---
title: Google Cloud Media CDN
description: >-
  Monitor cache performance, latency, and client experience for Google Cloud
  Media CDN.
breadcrumbs: Docs > Integrations > Google Cloud Media CDN
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Google Cloud Media CDN
Integration version1.0.0
{% 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 %}

[Google Cloud Media CDN](https://docs.cloud.google.com/media-cdn/docs/overview) is a media delivery service that complements Cloud CDN for high-throughput egress workloads, such as streaming video and large file downloads. Media CDN uses Google's global edge network to cache content close to your users, reducing latency and origin load, with support for flexible per-route caching rules, signed URLs and cookies, and origin authentication for private Cloud Storage buckets.

Use the Datadog Google Cloud Platform integration to collect metrics about your Media CDN route rules, including cache performance, latency, and client experience data such as buffer starvation and encoded bitrates.

## Setup{% #setup %}

### Installation{% #installation %}

If you haven't already, set up the [Google Cloud Platform integration](https://docs.datadoghq.com/integrations/google-cloud-platform.md) first. There are no other installation steps.

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

### Metrics{% #metrics %}

|  |
|  |
| **gcp.edgecache.edge_cache_route_rule.cmcd.buffer_lengths.avg**(gauge)                                        | A distribution of the client's buffer length.*Shown as millisecond*                                                                                                                                                                                  |
| **gcp.edgecache.edge_cache_route_rule.cmcd.buffer_lengths.samplecount**(count)                                | A distribution of the client's buffer length (sample count).                                                                                                                                                                                         |
| **gcp.edgecache.edge_cache_route_rule.cmcd.buffer_lengths.sumsqdev**(count)                                   | A distribution of the client's buffer length (sum of squared deviations).                                                                                                                                                                            |
| **gcp.edgecache.edge_cache_route_rule.cmcd.buffer_starvation_count**(count)                                  | Count of the client's buffer starvations.                                                                                                                                                                                                            |
| **gcp.edgecache.edge_cache_route_rule.cmcd.encoded_bitrates.avg**(gauge)                                      | A distribution of the client's encoded bitrate.*Shown as kilobit*                                                                                                                                                                                    |
| **gcp.edgecache.edge_cache_route_rule.cmcd.encoded_bitrates.samplecount**(count)                              | A distribution of the client's encoded bitrate (sample count).                                                                                                                                                                                       |
| **gcp.edgecache.edge_cache_route_rule.cmcd.encoded_bitrates.sumsqdev**(count)                                 | A distribution of the client's encoded bitrate (sum of squared deviations).                                                                                                                                                                          |
| **gcp.edgecache.edge_cache_route_rule.cmcd.encoded_bitrates_over_measured_throughputs.avg**(gauge)         | A distribution of the client's encoded bitrate divided by its measured throughput.                                                                                                                                                                   |
| **gcp.edgecache.edge_cache_route_rule.cmcd.encoded_bitrates_over_measured_throughputs.samplecount**(count) | A distribution of the client's encoded bitrate divided by its measured throughput (sample count).                                                                                                                                                    |
| **gcp.edgecache.edge_cache_route_rule.cmcd.encoded_bitrates_over_measured_throughputs.sumsqdev**(count)    | A distribution of the client's encoded bitrate divided by its measured throughput (sum of squared deviations).                                                                                                                                       |
| **gcp.edgecache.edge_cache_route_rule.cmcd.measured_throughputs.avg**(gauge)                                  | A distribution of the client's measured throughput.*Shown as kilobit*                                                                                                                                                                                |
| **gcp.edgecache.edge_cache_route_rule.cmcd.measured_throughputs.samplecount**(count)                          | A distribution of the client's measured throughput (sample count).                                                                                                                                                                                   |
| **gcp.edgecache.edge_cache_route_rule.cmcd.measured_throughputs.sumsqdev**(count)                             | A distribution of the client's measured throughput (sum of squared deviations).                                                                                                                                                                      |
| **gcp.edgecache.edge_cache_route_rule.cmcd.playback_time_count**(count)                                      | Count of playback time.                                                                                                                                                                                                                              |
| **gcp.edgecache.edge_cache_route_rule.cmcd.request_count**(count)                                             | Count of requests with CMCD.                                                                                                                                                                                                                         |
| **gcp.edgecache.edge_cache_route_rule.frontend_rtt_by_client.avg**(gauge)                                   | Round trip times from the end user to the proxy terminating the request.*Shown as millisecond*                                                                                                                                                       |
| **gcp.edgecache.edge_cache_route_rule.frontend_rtt_by_client.samplecount**(count)                           | Round trip times from the end user to the proxy terminating the request (sample count).                                                                                                                                                              |
| **gcp.edgecache.edge_cache_route_rule.frontend_rtt_by_client.sumsqdev**(count)                              | Round trip times from the end user to the proxy terminating the request (sum of squared deviations).                                                                                                                                                 |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb.avg**(gauge)                                                  | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received).*Shown as millisecond*                                                                            |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb.samplecount**(count)                                          | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received) (sample count).                                                                                   |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb.sumsqdev**(count)                                             | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received) (sum of squared deviations).                                                                      |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client.avg**(gauge)                                      | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received) with client location information.*Shown as millisecond*                                           |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client.samplecount**(count)                              | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received) with client location information (sample count).                                                  |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client.sumsqdev**(count)                                 | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received) with client location information (sum of squared deviations).                                     |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client_asn.avg**(gauge)                                 | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received). Broken down by client ASN.*Shown as millisecond*                                                 |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client_asn.samplecount**(count)                         | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received). Broken down by client ASN (sample count).                                                        |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client_asn.sumsqdev**(count)                            | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received). Broken down by client ASN (sum of squared deviations).                                           |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client_device.avg**(gauge)                              | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received). Broken down by client device.*Shown as millisecond*                                              |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client_device.samplecount**(count)                      | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received). Broken down by client device (sample count).                                                     |
| **gcp.edgecache.edge_cache_route_rule.http_ttfb_by_client_device.sumsqdev**(count)                         | A distribution of latencies calculated from when the request was received by the proxy until the first byte of the response is sent (not received). Broken down by client device (sum of squared deviations).                                        |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb.avg**(gauge)                                                  | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received).*Shown as millisecond*                                                                             |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb.samplecount**(count)                                          | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received) (sample count).                                                                                    |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb.sumsqdev**(count)                                             | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received) (sum of squared deviations).                                                                       |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client.avg**(gauge)                                      | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received) with client location information.*Shown as millisecond*                                            |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client.samplecount**(count)                              | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received) with client location information (sample count).                                                   |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client.sumsqdev**(count)                                 | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received) with client location information (sum of squared deviations).                                      |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client_asn.avg**(gauge)                                 | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received). Broken down by client ASN.*Shown as millisecond*                                                  |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client_asn.samplecount**(count)                         | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received). Broken down by client ASN (sample count).                                                         |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client_asn.sumsqdev**(count)                            | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received). Broken down by client ASN (sum of squared deviations).                                            |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client_device.avg**(gauge)                              | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received). Broken down by client device.*Shown as millisecond*                                               |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client_device.samplecount**(count)                      | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received). Broken down by client device (sample count).                                                      |
| **gcp.edgecache.edge_cache_route_rule.http_ttlb_by_client_device.sumsqdev**(count)                         | A distribution of latencies calculated from when the request was received by the proxy until the last byte of the response is sent (not received). Broken down by client device (sum of squared deviations).                                         |
| **gcp.edgecache.edge_cache_route_rule.origin_http_ttfb.avg**(gauge)                                          | A distribution of latencies calculated from when the request was sent by the proxy until the response headers are received from the origin.*Shown as millisecond*                                                                                    |
| **gcp.edgecache.edge_cache_route_rule.origin_http_ttfb.samplecount**(count)                                  | A distribution of latencies calculated from when the request was sent by the proxy until the response headers are received from the origin (sample count).                                                                                           |
| **gcp.edgecache.edge_cache_route_rule.origin_http_ttfb.sumsqdev**(count)                                     | A distribution of latencies calculated from when the request was sent by the proxy until the response headers are received from the origin (sum of squared deviations).                                                                              |
| **gcp.edgecache.edge_cache_route_rule.origin_http_ttlb.avg**(gauge)                                          | A distribution of latencies calculated from when the request was sent by the proxy to the origin until the last byte of the response is received from the origin.*Shown as millisecond*                                                              |
| **gcp.edgecache.edge_cache_route_rule.origin_http_ttlb.samplecount**(count)                                  | A distribution of latencies calculated from when the request was sent by the proxy to the origin until the last byte of the response is received from the origin (sample count).                                                                     |
| **gcp.edgecache.edge_cache_route_rule.origin_http_ttlb.sumsqdev**(count)                                     | A distribution of latencies calculated from when the request was sent by the proxy to the origin until the last byte of the response is received from the origin (sum of squared deviations).                                                        |
| **gcp.edgecache.edge_cache_route_rule.origin_request_count**(count)                                          | Count of requests to an origin.*Shown as request*                                                                                                                                                                                                    |
| **gcp.edgecache.edge_cache_route_rule.origin_response_bytes_count**(count)                                  | Count of response bytes from an origin.*Shown as byte*                                                                                                                                                                                               |
| **gcp.edgecache.edge_cache_route_rule.request_bytes_count**(count)                                           | Count of request bytes (body and headers).*Shown as byte*                                                                                                                                                                                            |
| **gcp.edgecache.edge_cache_route_rule.request_bytes_count_by_client**(count)                               | Count of request bytes (body and headers) with client location information.*Shown as byte*                                                                                                                                                           |
| **gcp.edgecache.edge_cache_route_rule.request_count**(count)                                                  | Count of requests.*Shown as request*                                                                                                                                                                                                                 |
| **gcp.edgecache.edge_cache_route_rule.request_count5xx_by_client_asn**(count)                              | Count of requests with HTTP 5xx responses, broken down by client ASN.                                                                                                                                                                                |
| **gcp.edgecache.edge_cache_route_rule.request_count_by_blocked**(count)                                     | Count of requests with client location information and Cloud Armor action.                                                                                                                                                                           |
| **gcp.edgecache.edge_cache_route_rule.request_count_by_client**(count)                                      | Count of requests with client location information.                                                                                                                                                                                                  |
| **gcp.edgecache.edge_cache_route_rule.response_bytes_count**(count)                                          | Count of response bytes.*Shown as byte*                                                                                                                                                                                                              |
| **gcp.edgecache.edge_cache_route_rule.response_bytes_count_by_client**(count)                              | Count of response bytes (body and headers) with client location information.*Shown as byte*                                                                                                                                                          |
| **gcp.edgecache.edge_cache_route_rule.total_latencies.avg**(gauge)                                            | A distribution of latencies calculated from when the request was received by the proxy until the proxy receives an acknowledgment (ACK) from the client for the last response byte.*Shown as millisecond*                                            |
| **gcp.edgecache.edge_cache_route_rule.total_latencies.samplecount**(count)                                    | A distribution of latencies calculated from when the request was received by the proxy until the proxy receives an acknowledgment (ACK) from the client for the last response byte (sample count).                                                   |
| **gcp.edgecache.edge_cache_route_rule.total_latencies.sumsqdev**(count)                                       | A distribution of latencies calculated from when the request was received by the proxy until the proxy receives an acknowledgment (ACK) from the client for the last response byte (sum of squared deviations).                                      |
| **gcp.edgecache.edge_cache_route_rule.total_latencies_by_proxy.avg**(gauge)                                 | A distribution of latencies calculated from when the request was received by the proxy until the proxy receives an acknowledgment (ACK) from the client for the last response byte. Includes proxy location information.*Shown as millisecond*       |
| **gcp.edgecache.edge_cache_route_rule.total_latencies_by_proxy.samplecount**(count)                         | A distribution of latencies calculated from when the request was received by the proxy until the proxy receives an acknowledgment (ACK) from the client for the last response byte. Includes proxy location information (sample count).              |
| **gcp.edgecache.edge_cache_route_rule.total_latencies_by_proxy.sumsqdev**(count)                            | A distribution of latencies calculated from when the request was received by the proxy until the proxy receives an acknowledgment (ACK) from the client for the last response byte. Includes proxy location information (sum of squared deviations). |

### Events{% #events %}

The Google Cloud Media CDN integration does not include any events.

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

The Google Cloud Media CDN integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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