---
title: Google Cloud Apigee X
description: >-
  Track API traffic, latency, error rates, and overall performance across your
  Apigee X APIs.
breadcrumbs: Docs > Integrations > Google Cloud Apigee X
---

# Google Cloud Apigee X

{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}

## Overview{% #overview %}

Apigee X is Google Cloud's API management platform for building, securing, and scaling APIs. The Google Cloud Apigee X integration provides visibility into API traffic, latency, error rates, and overall performance across your Apigee X APIs.

Enable this integration to see all of your Apigee X metrics in Datadog.

## Setup{% #setup %}

### Metric collection{% #metric-collection %}

#### Installation{% #installation %}

Set up the [Google Cloud Platform integration](https://docs.datadoghq.com/integrations/google_cloud_platform.md) to begin collect Apigee X metrics. After the GCP integration is configured, Apigee X metrics under the `gcp.apigee.*` namespace are collected automatically.

For more information about the metrics emitted by Apigee X, see the [Apigee documentation](https://cloud.google.com/apigee/docs).

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **gcp.apigee.apihub.security.score**(gauge)                         | Current security score of an API Hub deployment based on an API Hub Security Profile. Sampled every 300 seconds. After sampling, data is not visible for up to 120 seconds.                                                                                                                                                                                                                                              |
| **gcp.apigee.cassandra.clientrequest\_latency**(gauge)              | Average read request latency in the 75th percentile range in microseconds for Apigee Cassandra. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                |
| **gcp.apigee.cassandra.compaction\_pendingtasks**(gauge)            | Number of pending compaction tasks for Apigee Cassandra. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                       |
| **gcp.apigee.cassandra.jvm\_memory\_bytes\_committed**(gauge)       | Number of bytes committed for Apigee Cassandra JVM heap. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                        |
| **gcp.apigee.cassandra.jvm\_memory\_bytes\_init**(gauge)            | Initial memory usage in bytes for Apigee Cassandra JVM heap. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                    |
| **gcp.apigee.cassandra.jvm\_memory\_bytes\_max**(gauge)             | Maximum memory usage in bytes for Apigee Cassandra JVM heap. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                    |
| **gcp.apigee.cassandra.jvm\_memory\_bytes\_used**(gauge)            | Memory usage in bytes for Apigee Cassandra JVM heap. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                            |
| **gcp.apigee.cassandra.jvm\_memory\_pool\_bytes\_committed**(gauge) | Memory usage in bytes committed per Apigee Cassandra JVM pool. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                  |
| **gcp.apigee.cassandra.jvm\_memory\_pool\_bytes\_init**(gauge)      | Initial memory usage in bytes for Apigee Cassandra JVM pool. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                    |
| **gcp.apigee.cassandra.jvm\_memory\_pool\_bytes\_max**(gauge)       | Maximum memory usage in bytes for Apigee Cassandra JVM pool. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                    |
| **gcp.apigee.cassandra.jvm\_memory\_pool\_bytes\_used**(gauge)      | Memory usage in bytes per Apigee Cassandra JVM pool. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                            |
| **gcp.apigee.cassandra.process\_cpu\_seconds\_total**(count)        | User and system CPU time spent in seconds for Apigee Cassandra. Sampled every 60 seconds.*Shown as second*                                                                                                                                                                                                                                                                                                               |
| **gcp.apigee.cassandra.process\_max\_fds**(gauge)                   | Maximum number of open file descriptors for Apigee Cassandra. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                  |
| **gcp.apigee.cassandra.process\_open\_fds**(gauge)                  | Number of open file descriptors for Apigee Cassandra. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                          |
| **gcp.apigee.cassandra.tablerequests\_latency**(gauge)              | Read and Write Request latency for all the tables in Apigee Cassandra. Sampled every 60 seconds.*Shown as microsecond*                                                                                                                                                                                                                                                                                                   |
| **gcp.apigee.cassandra.tablerequests\_rate**(gauge)                 | Read and Write Request rate for all the tables in Apigee Cassandra. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                            |
| **gcp.apigee.connectagent.completed\_rpcs\_count**(count)           | Count of RPCs completed by Apigee Connect Agent. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                               |
| **gcp.apigee.connectagent.dropped\_requests**(count)                | Distribution of dropped requests by Apigee Connect Agent per RPC. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                              |
| **gcp.apigee.connectagent.dropped\_responses**(count)               | Distribution of dropped responses by Apigee Connect Agent per RPC. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                             |
| **gcp.apigee.connectagent.received\_bytes**(count)                  | Distribution of bytes received by Apigee Connect Agent per RPC. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                 |
| **gcp.apigee.connectagent.received\_messages**(count)               | Distribution of messages received by Apigee Connect Agent per RPC. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                             |
| **gcp.apigee.connectagent.sent\_bytes**(count)                      | Distribution of bytes sent by Apigee Connect Agent per RPC. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                                     |
| **gcp.apigee.connectagent.sent\_messages**(count)                   | Distribution of messages sent by Apigee Connect Agent per RPC. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                 |
| **gcp.apigee.connectagent.stream\_liveness\_time**(count)           | Distribution of stream liveness time by Apigee Connect Agent per RPC. Sampled every 60 seconds.*Shown as millisecond*                                                                                                                                                                                                                                                                                                    |
| **gcp.apigee.environment.active**(gauge)                            | Number of current environments attached to Apigee instance. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds.                                                                                                                                                                                                                                                                         |
| **gcp.apigee.environment.anomaly\_count**(count)                    | Total number of anomalies observed in the Apigee environment. Sampled every 60 seconds. After sampling, data is not visible for up to 120 seconds.                                                                                                                                                                                                                                                                       |
| **gcp.apigee.environment.api\_call\_count**(count)                  | Number of API calls processed by an Apigee environment since the last sample was recorded. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                     |
| **gcp.apigee.environment.instance.gateway\_nodes**(gauge)           | Number of Apigee gateway nodes in an environment attached to an instance. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                      |
| **gcp.apigee.envoy.redis.commands.evalsha.error**(count)            | Total number of error evalsha commands to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                  |
| **gcp.apigee.envoy.redis.commands.evalsha.latency**(count)          | Total amount of time in microseconds for execution of evalsha command. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                         |
| **gcp.apigee.envoy.redis.commands.evalsha.success**(count)          | Total number of successful evalsha commands to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                             |
| **gcp.apigee.envoy.redis.commands.evalsha.total**(count)            | Total number of evalsha commands to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                        |
| **gcp.apigee.envoy.redis.commands.get.error**(count)                | Total number of error get commands to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                      |
| **gcp.apigee.envoy.redis.commands.get.latency**(count)              | Total amount of time in microseconds for execution of get command. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                             |
| **gcp.apigee.envoy.redis.commands.get.success**(count)              | Total number of successful get commands to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                 |
| **gcp.apigee.envoy.redis.commands.get.total**(count)                | Total number of get commands to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                            |
| **gcp.apigee.envoy.redis.downstream\_cx\_active**(gauge)            | Total number of current active connections to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                              |
| **gcp.apigee.envoy.redis.downstream\_cx\_total**(count)             | Total number of connections to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                             |
| **gcp.apigee.envoy.redis.downstream\_rq\_active**(gauge)            | Total number of current active requests to Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                 |
| **gcp.apigee.envoy.redis.downstream\_rq\_total**(count)             | Total number of requests received by Apigee Redis Envoy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                       |
| **gcp.apigee.mint.latencies\_percentile**(gauge)                    | Percentile of all Monetized response latencies to a request. Sampled every 60 seconds.*Shown as millisecond*                                                                                                                                                                                                                                                                                                             |
| **gcp.apigee.mint.request\_count**(count)                           | Total number of requests received by the Monetized Api Proxy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                  |
| **gcp.apigee.mint.response\_count**(count)                          | Total number of complete Monetized requests processed by API proxy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                            |
| **gcp.apigee.policyv2.latencies\_percentile**(gauge)                | Percentile of all API policy response to a request. Sampled every 60 seconds.*Shown as millisecond*                                                                                                                                                                                                                                                                                                                      |
| **gcp.apigee.proxy.details**(gauge)                                 | Details relevant to the proxy that is deployed to an Apigee environment. Sampled every 60 seconds. After sampling, data is not visible for up to 181 seconds.                                                                                                                                                                                                                                                            |
| **gcp.apigee.proxy.latencies**(count)                               | A distribution of the latency calculated from when the request was received by the Apigee proxy until the response sent from the Apigee proxy to the client. Time includes the Apigee proxy overhead and the target server time. Sampled every 60 seconds. After sampling, data is not visible for up to 181 seconds.*Shown as millisecond*                                                                              |
| **gcp.apigee.proxy.request\_count**(count)                          | Number of requests sent to the Apigee proxy since the last sample was recorded. Sampled every 60 seconds. After sampling, data is not visible for up to 181 seconds.                                                                                                                                                                                                                                                     |
| **gcp.apigee.proxy.response\_count**(count)                         | Number of responses sent by the Apigee API proxy since the last sample was recorded. Sampled every 60 seconds. After sampling, data is not visible for up to 181 seconds.                                                                                                                                                                                                                                                |
| **gcp.apigee.proxyv2.details**(gauge)                               | Apigee proxy details deployed to an Apigee environment. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                        |
| **gcp.apigee.proxyv2.latencies\_percentile**(gauge)                 | Percentile of all API proxy response to a request. Sampled every 60 seconds.*Shown as millisecond*                                                                                                                                                                                                                                                                                                                       |
| **gcp.apigee.proxyv2.request\_count**(count)                        | Total number of requests received by the Apigee API proxy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                     |
| **gcp.apigee.proxyv2.response\_count**(count)                       | Total number of responses sent by the Apigee API proxy. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                        |
| **gcp.apigee.security.detected\_request\_count**(count)             | Number of API requests detected by Apigee Advanced API Security abuse detection, since the last sample. Sampled every 300 seconds. After sampling, data is not visible for up to 120 seconds.                                                                                                                                                                                                                            |
| **gcp.apigee.security.detected\_request\_count\_by\_rule**(count)   | Number of API requests detected by Apigee Advanced API Security abuse detection and grouped by detection rule, since the last sample. Note: Sum of request count across detection_rule label does not produce total detected request count, instead to get the total number of detected requests use apigee.googleapis.com/security/detected_request_count. Sampled every 300 seconds. After sampling, data…             |
| **gcp.apigee.security.environment\_score**(gauge)                   | Current security score of Apigee environment based on Advanced API Security assessment. This value is measured at least once every 3 hours. There might be a delay after measuring before the value becomes available in Cloud Monitoring. Once available, the value is repeated at each sampling interval until the next measurement. For this metric, the sampling period is a reporting period, not a…                |
| **gcp.apigee.security.incident\_request\_count**(count)             | Total Number of API requests detected to be a part of an Apigee API Security incident. This value is measured once every hour. There might be a delay after measuring before the value becomes available in Cloud Monitoring. Once available, the value is repeated at each sampling interval throughout the hour. For this metric, the sampling period is a reporting period, not a measurement period…                 |
| **gcp.apigee.security.incident\_request\_count\_by\_rule**(count)   | Total number of API requests detected to be a part of an Apigee API Security incident grouped by detection rule. This value is measured once every hour. There might be a delay after measuring before the value becomes available in Cloud Monitoring. Once available, the value is repeated at each sampling interval throughout the hour. For this metric, the sampling period is a reporting period, not…            |
| **gcp.apigee.security.proxy\_score**(gauge)                         | Current security score of Apigee API proxy based on Advanced API Security proxy assessment. This value is measured at least once every 3 hours. There might be a delay after measuring before the value becomes available in Cloud Monitoring. Once available, the value is repeated at each sampling interval until the next measurement. For this metric, the sampling period is a reporting period, not a…            |
| **gcp.apigee.security.request\_count**(count)                       | Number of API requests processed by Apigee Advanced API Security, since the last sample. Sampled every 300 seconds. After sampling, data is not visible for up to 120 seconds.                                                                                                                                                                                                                                           |
| **gcp.apigee.security.score**(gauge)                                | Current security score of a deployed resource based on an Apigee Risk Assessment V2 Security profile. Sampled every 300 seconds. After sampling, data is not visible for up to 120 seconds.                                                                                                                                                                                                                              |
| **gcp.apigee.security.source\_score**(gauge)                        | Current security score of Apigee environment based on Advanced API Security source assessment. This value is measured at least once every 3 hours. There might be a delay after measuring before the value becomes available in Cloud Monitoring. Once available, the value is repeated at each sampling interval until the next measurement. For this metric, the sampling period is a reporting period…                |
| **gcp.apigee.security.target\_score**(gauge)                        | Current security score of Apigee target server based on Advanced API Security target assessment. This value is measured at least once every 3 hours. There might be a delay after measuring before the value becomes available in Cloud Monitoring. Once available, the value is repeated at each sampling interval until the next measurement. For this metric, the sampling period is a reporting period…              |
| **gcp.apigee.server.fault\_count**(count)                           | Total number of faults returned by the Apigee server application. For example, the apigee-runtime, apigee–synchronizer, or apigee-udca server application. Sampled every 60 seconds.                                                                                                                                                                                                                                     |
| **gcp.apigee.server.latencies**(count)                              | Total amount of time in milliseconds for the Apigee application server to process the requests and responses. For example, the apigee-runtime, apigee-synchronizer, or apigee-udca server application. Sampled every 60 seconds.*Shown as millisecond*                                                                                                                                                                   |
| **gcp.apigee.server.nio**(gauge)                                    | Number of open sockets. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                                                        |
| **gcp.apigee.server.num\_threads**(gauge)                           | Number of active non-daemon threads in the Apigee server. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                      |
| **gcp.apigee.server.request\_count**(count)                         | Total number of requests received by the Apigee server application. For example, the apigee-runtime, apigee-synchronizer, or apigee-udca server application. Sampled every 60 seconds.                                                                                                                                                                                                                                   |
| **gcp.apigee.server.response\_count**(count)                        | Total number of responses sent by the Apigee server application. For example, the apigee-runtime, apigee-synchronizer, or apigee-udca server application. Sampled every 60 seconds.                                                                                                                                                                                                                                      |
| **gcp.apigee.target.latencies**(count)                              | A distribution of the latency calculated from when the request was sent to the Apigee target until the response was received by the Apigee proxy. Time does not include the Apigee API proxy overhead. Sampled every 60 seconds. After sampling, data is not visible for up to 181 seconds.*Shown as millisecond*                                                                                                        |
| **gcp.apigee.target.request\_count**(count)                         | Number of requests sent to the Apigee target since the last sample was recorded. Sampled every 60 seconds. After sampling, data is not visible for up to 181 seconds.                                                                                                                                                                                                                                                    |
| **gcp.apigee.target.response\_count**(count)                        | Number of responses received from the Apigee target since the last sample was recorded. Sampled every 60 seconds. After sampling, data is not visible for up to 181 seconds.                                                                                                                                                                                                                                             |
| **gcp.apigee.targetv2.latencies\_percentile**(gauge)                | Percentile of all API proxy target response to a request. Sampled every 60 seconds.*Shown as millisecond*                                                                                                                                                                                                                                                                                                                |
| **gcp.apigee.targetv2.request\_count**(count)                       | Total number of requests received by the Apigee API proxy target. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                              |
| **gcp.apigee.targetv2.response\_count**(count)                      | Total number of responses sent by the Apigee API proxy target. Sampled every 60 seconds.                                                                                                                                                                                                                                                                                                                                 |
| **gcp.apigee.udca.disk.used\_bytes**(gauge)                         | Amount of bytes used by the data files on the data collection pod's disk. Sampled every 60 seconds.*Shown as byte*                                                                                                                                                                                                                                                                                                       |
| **gcp.apigee.udca.server.local\_file\_count**(gauge)                | Number of files on disk in the data collection pod. Ideally, the value will be close to 0. A consistently high value indicates that files are not being uploaded or that the Apigee Universal Data Collection Agent (UDCA) server application is not able to upload them fast enough. This value is computed every 60 seconds and does not reflect the state of the Apigee UDCA server application in real…              |
| **gcp.apigee.udca.server.local\_file\_latest\_ts**(gauge)           | Apigee Universal Data Collection Agent (UDCA) server timestamp difference between current time and latest file. Sampled every 60 seconds.*Shown as second*                                                                                                                                                                                                                                                               |
| **gcp.apigee.udca.server.local\_file\_oldest\_ts**(gauge)           | Time that the oldest file in the dataset was created in seconds since epoch. If the Apigee Universal Data Collection Agent (UDCA) server application is up to date and there are no files waiting to be uploaded when this metric is computed, then this value will be 0. If this value increases, it indicates that old files are still on disk. The metric is computed every 60 seconds and does not…*Shown as second* |
| **gcp.apigee.udca.server.pruned\_file\_count**(count)               | Total number of files that have been deleted because their Time To Life (TTL) was beyond a set threshold. The dataset can include API, trace, and others, and state can be UPLOADED, FAILED, or DISCARDED. Sampled every 60 seconds.                                                                                                                                                                                     |
| **gcp.apigee.udca.server.retry\_cache\_size**(gauge)                | Number of files, by dataset, that the Apigee Universal Data Collection Agent (UDCA) server application is retrying to upload. After 3 retries per file, the UDCA moves the file to the /failed subdirectory and removes it from this cache. An increase in this value over time implies that the cache is not being cleared. Sampled every 60 seconds.                                                                   |
| **gcp.apigee.udca.server.total\_latencies**(count)                  | Total amount of time in seconds for a data file to be created and uploaded successfully by the Apigee Universal Data Collection Agent (UDCA) server application. Buckets will be 100 ms, 250 ms, 500 ms, 1 s, 2 s, 4 s, 8 s, 16 s, 32 s, and 64 s. The metrics will display a histogram for total latency from file creation time to successful upload time. Sampled every 60 seconds.*Shown as second*                  |
| **gcp.apigee.udca.server.upload\_latencies**(count)                 | Total amount of time in seconds that the Apigee Universal Data Collection Agent (UDCA) server application required to upload a data file. Buckets will be 100 ms, 250 ms, 500 ms, 1 s, 2 s, 4 s, 8 s, 16 s, 32 s, and 64 s. The metrics will display a histogram for total latency from file creation time to successful upload time. Sampled every 60 seconds.*Shown as second*                                         |
| **gcp.apigee.udca.upstream.http\_error\_count**(count)              | Total number of HTTP errors encountered by the Apigee Universal Data Collection Agent (UDCA) server application. This metric is useful to help determine in which part of the UDCA external dependencies are failing and for what reason. These errors can arise for various services (such as getDataLocation, Cloud storage, token generator) and for various datasets (such as API and trace) with…                   |
| **gcp.apigee.udca.upstream.http\_latencies**(count)                 | Total amount of time in seconds required for upstream services. Buckets will be 100 ms, 250 ms, 500 ms, 1 s, 2 s, 4 s, 8 s, 16 s, 32 s, and 64 s. The metrics will display a histogram for latency from upstream services. Sampled every 60 seconds.*Shown as second*                                                                                                                                                    |
| **gcp.apigee.udca.upstream.uploaded\_file\_count**(count)           | Total number of files being uploaded to the Apigee Universal Data Collection Agent (UDCA) server application. Note that the event dataset value should keep growing, the API dataset value should keep growing if the organization and environment have constant traffic, and the trace dataset value should increase when you use the Apigee trace tools to debug or inspect your requests. Sampled every…              |
| **gcp.apigee.udca.upstream.uploaded\_file\_sizes**(count)           | Total file size in bytes uploaded to the Apigee Universal Data Collection Agent (UDCA) server application. Buckets will be 1 KB, 10 KB, 100 KB, 1 MB, 10 MB, 100 MB, and 1 GB. The metrics will display a histogram for file size by dataset, organization, and environment. Sampled every 60 seconds.*Shown as byte*                                                                                                    |
| **gcp.apigee.upstream.latencies**(count)                            | Total amount of time in milliseconds incurred by the upstream Apigee server application. For apigee-synchronizer this metric indicates the latency from the control plane. Sampled every 60 seconds.*Shown as millisecond*                                                                                                                                                                                               |
| **gcp.apigee.upstream.request\_count**(count)                       | Total number of requests sent by the Apigee server application to its upstream application. For example, for the apigee-synchronizer the control plane is upstream. Sampled every 60 seconds.                                                                                                                                                                                                                            |
| **gcp.apigee.upstream.response\_count**(count)                      | Total number of responses received by the Apigee server application from its upstream application. For example, for the apigee-synchronizer the control plane is upstream. Sampled every 60 seconds.                                                                                                                                                                                                                     |

### Events{% #events %}

The Google Cloud Apigee X integration does not include any events.

### Service Checks{% #service-checks %}

The Google Cloud Apigee X integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).

## Further Reading{% #further-reading %}

- [Google Cloud Platform](https://docs.datadoghq.com/integrations/google_cloud_platform.md)
