---
title: Google Cloud Datastream
description: >-
  Monitor throughput, latency, and event volume for your Google Cloud Datastream
  replication streams.
breadcrumbs: Docs > Integrations > Google Cloud Datastream
---

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

# Google Cloud Datastream
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 Datastream](https://cloud.google.com/datastream/docs/overview) is a serverless, easy-to-use change data capture (CDC) and replication service that synchronizes data streams across heterogeneous databases and applications reliably, with minimal latency and downtime.

Use the Datadog Google Cloud Platform integration to monitor the throughput, latency, and event volume of your Datastream streams.

## Setup{% #setup %}

### Installation{% #installation %}

The Google Cloud Datastream check requires the [Google Cloud Platform integration](https://docs.datadoghq.com/integrations/google-cloud-platform.md) to be configured. No additional installation is needed once the Google Cloud Platform integration is set up.

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

### Metrics{% #metrics %}

|  |
|  |
| **gcp.datastream.stream.bytes_count**(count)                    | The stream bytes count.*Shown as byte*                                                                                                                                                                                                                                                     |
| **gcp.datastream.stream.event_count**(count)                    | The stream event count.                                                                                                                                                                                                                                                                    |
| **gcp.datastream.stream.freshness**(gauge)                       | Indicates how far behind Datastream is compared to the source. This is calculated as the time difference between when the change occurred in the source database, until it is read by Datastream. If no new changes are available to read then the freshness is set to 0.*Shown as second* |
| **gcp.datastream.stream.latencies.avg**(gauge)                   | The stream latencies.*Shown as second*                                                                                                                                                                                                                                                     |
| **gcp.datastream.stream.latencies.samplecount**(count)           | The stream latencies.                                                                                                                                                                                                                                                                      |
| **gcp.datastream.stream.latencies.sumsqdev**(count)              | The stream latencies.                                                                                                                                                                                                                                                                      |
| **gcp.datastream.stream.system_latencies.avg**(gauge)           | A distribution of the latency calculated from when the event was read from the source until it was written to the destination.*Shown as second*                                                                                                                                            |
| **gcp.datastream.stream.system_latencies.samplecount**(count)   | A distribution of the latency calculated from when the event was read from the source until it was written to the destination.                                                                                                                                                             |
| **gcp.datastream.stream.system_latencies.sumsqdev**(count)      | A distribution of the latency calculated from when the event was read from the source until it was written to the destination.                                                                                                                                                             |
| **gcp.datastream.stream.total_latencies.avg**(gauge)            | A distribution of the latency calculated from when the event was created at the source until it was written to the destination.*Shown as second*                                                                                                                                           |
| **gcp.datastream.stream.total_latencies.samplecount**(count)    | A distribution of the latency calculated from when the event was created at the source until it was written to the destination.                                                                                                                                                            |
| **gcp.datastream.stream.total_latencies.sumsqdev**(count)       | A distribution of the latency calculated from when the event was created at the source until it was written to the destination.                                                                                                                                                            |
| **gcp.datastream.stream.unsupported_event_count**(count)       | The stream unsupported event count.                                                                                                                                                                                                                                                        |
| **gcp.datastream.streamobject.bytes_count**(count)              | The bytes count per stream object.*Shown as byte*                                                                                                                                                                                                                                          |
| **gcp.datastream.streamobject.event_count**(count)              | The event count per stream object.                                                                                                                                                                                                                                                         |
| **gcp.datastream.streamobject.unsupported_event_count**(count) | The unsupported event count per stream object.                                                                                                                                                                                                                                             |

### Events{% #events %}

The Google Cloud Datastream integration does not include any events.

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

The Google Cloud Datastream integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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