---
title: Google Cloud Redis
description: >-
  A managed in-memory data store service on scalable, secure, and highly
  available infrastructure.
breadcrumbs: Docs > Integrations > Google Cloud Redis
---

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

# Google Cloud Redis

{% 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 Memorystore for Redis provides a fully managed in-memory data store service built on scalable, secure, and highly available infrastructure.

Use the Datadog Google Cloud Platform integration to collect metrics from Google Cloud Memorystore for Redis.

## 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.

### Log collection{% #log-collection %}

Google Cloud Memorystore for Redis logs are collected with Google Cloud Logging and sent to a Dataflow job through a Cloud Pub/Sub topic. If you haven't already, [set up logging with the Datadog Dataflow template](https://docs.datadoghq.com/integrations/google-cloud-platform.md#log-collection).

Once this is done, export your Google Cloud Memorystore for Redis logs from Google Cloud Logging to the Pub/Sub topic:

1. Go to the [Google Cloud Logging page](https://console.cloud.google.com/logs/viewer) and filter the Google Cloud Memorystore for Redis logs.
1. Click **Create Export** and name the sink.
1. Choose "Cloud Pub/Sub" as the destination and select the Pub/Sub topic that was created for that purpose. **Note**: The Pub/Sub topic can be located in a different project.
1. Click **Create** and wait for the confirmation message to show up.

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

### Metrics{% #metrics %}

|  |
|  |
| **gcp.redis.clients.blocked**(gauge)                                                                   | Number of blocked clients.                                                                                                                                                              |
| **gcp.redis.clients.connected**(gauge)                                                                 | Number of client connections.*Shown as connection*                                                                                                                                      |
| **gcp.redis.cluster.clients.average_connected_clients**(gauge)                                       | Mean current number of client connections across the cluster.                                                                                                                           |
| **gcp.redis.cluster.clients.maximum_connected_clients**(gauge)                                       | Maximum current number of client connections across the cluster.                                                                                                                        |
| **gcp.redis.cluster.clients.total_connected_clients**(gauge)                                         | Current number of client connections to the cluster.                                                                                                                                    |
| **gcp.redis.cluster.commandstats.total_calls_count**(count)                                          | Count of Redis commands.                                                                                                                                                                |
| **gcp.redis.cluster.commandstats.total_usec_count**(count)                                           | The total time consumed per command.*Shown as microsecond*                                                                                                                              |
| **gcp.redis.cluster.cpu.average_utilization**(gauge)                                                  | Mean CPU utilization across the cluster from 0.0 to 1.0.                                                                                                                                |
| **gcp.redis.cluster.cpu.maximum_utilization**(gauge)                                                  | Maximum CPU utilization across the cluster from 0.0 to 1.0.                                                                                                                             |
| **gcp.redis.cluster.cross_cluster_replication.secondary_average_replication_offset_diff**(gauge) | Average replication offset difference between primary shards and secondary shards.*Shown as byte*                                                                                       |
| **gcp.redis.cluster.cross_cluster_replication.secondary_maximum_replication_offset_diff**(gauge) | Maximum replication offset difference between primary shards and secondary shards.*Shown as byte*                                                                                       |
| **gcp.redis.cluster.cross_cluster_replication.secondary_replication_links**(gauge)                 | Number of replication links between a primary cluster and a secondary cluster.                                                                                                          |
| **gcp.redis.cluster.keyspace.total_keys**(gauge)                                                      | Number of keys stored in the cluster instance.                                                                                                                                          |
| **gcp.redis.cluster.memory.average_utilization**(gauge)                                               | Mean memory utilization across the cluster from 0.0 to 1.0.                                                                                                                             |
| **gcp.redis.cluster.memory.maximum_utilization**(gauge)                                               | Maximum memory utilization across the cluster from 0.0 to 1.0.                                                                                                                          |
| **gcp.redis.cluster.memory.size**(gauge)                                                               | Memory size of the cluster.*Shown as byte*                                                                                                                                              |
| **gcp.redis.cluster.memory.total_used_memory**(gauge)                                                | Total memory usage of the cluster.*Shown as byte*                                                                                                                                       |
| **gcp.redis.cluster.node.clients.blocked_clients**(gauge)                                             | Number of client connections blocked by the cluster node.                                                                                                                               |
| **gcp.redis.cluster.node.clients.connected_clients**(gauge)                                           | Number of clients connected to the cluster node.                                                                                                                                        |
| **gcp.redis.cluster.node.commandstats.calls_count**(count)                                            | Total number of calls for this command on the cluster node in one minute.                                                                                                               |
| **gcp.redis.cluster.node.commandstats.usec_count**(count)                                             | The total time consumed per command in the cluster node.*Shown as microsecond*                                                                                                          |
| **gcp.redis.cluster.node.cpu.utilization**(gauge)                                                      | CPU utilization for the cluster node from 0.0 to 1.0.                                                                                                                                   |
| **gcp.redis.cluster.node.cross_cluster_replication.follower_replication_offset_diff**(gauge)      | Replication offset diff in bytes between a replicator node and its follower node, reported by the replicator node.*Shown as byte*                                                       |
| **gcp.redis.cluster.node.cross_cluster_replication.role**(gauge)                                     | Cross cluster replication role of the node.                                                                                                                                             |
| **gcp.redis.cluster.node.keyspace.total_keys**(gauge)                                                 | Number of keys stored in the cluster node.                                                                                                                                              |
| **gcp.redis.cluster.node.memory.usage**(gauge)                                                         | Total memory usage of the cluster node.*Shown as byte*                                                                                                                                  |
| **gcp.redis.cluster.node.memory.utilization**(gauge)                                                   | Memory utilization within the cluster node from 0.0 to 1.0.                                                                                                                             |
| **gcp.redis.cluster.node.persistence.aof_fsync_errors_count**(count)                                | Count of AOF fsync errors on the cluster node.                                                                                                                                          |
| **gcp.redis.cluster.node.persistence.aof_fsync_lag**(gauge)                                          | AOF lag between memory and persistent store on the cluster node.*Shown as second*                                                                                                       |
| **gcp.redis.cluster.node.persistence.aof_last_bgrewrite_status**(gauge)                             | Indicates the success of the last AOF bgrewrite operation on the cluster node.                                                                                                          |
| **gcp.redis.cluster.node.persistence.aof_last_write_status**(gauge)                                 | Indicates the success of the last AOF write operation on the cluster node.                                                                                                              |
| **gcp.redis.cluster.node.persistence.aof_rewrites_count**(count)                                     | AOF rewrites count on the cluster node.                                                                                                                                                 |
| **gcp.redis.cluster.node.persistence.auto_restore_count**(count)                                     | Count of restores from dumpfile on the cluster node.                                                                                                                                    |
| **gcp.redis.cluster.node.persistence.current_save_keys_total**(gauge)                               | Number of keys at the beginning of the current save operation.                                                                                                                          |
| **gcp.redis.cluster.node.persistence.rdb_bgsave_in_progress**(gauge)                                | Indicates if a RDB BGSAVE is currently in progress on the cluster node.                                                                                                                 |
| **gcp.redis.cluster.node.persistence.rdb_last_bgsave_status**(gauge)                                | Indicates the success of the last BGSAVE on the cluster node.                                                                                                                           |
| **gcp.redis.cluster.node.persistence.rdb_last_save_age**(gauge)                                     | Measures the time in seconds, since the last successful snapshot.*Shown as second*                                                                                                      |
| **gcp.redis.cluster.node.persistence.rdb_next_save_time_until**(gauge)                             | Measures the time in seconds, remaining until the next snapshot.*Shown as second*                                                                                                       |
| **gcp.redis.cluster.node.persistence.rdb_saves_count**(count)                                        | Count of RDB saves in the cluster node.                                                                                                                                                 |
| **gcp.redis.cluster.node.replication.offset**(gauge)                                                   | Measures the replication offset bytes of the cluster node.*Shown as byte*                                                                                                               |
| **gcp.redis.cluster.node.server.uptime**(gauge)                                                        | Measures the uptime of the cluster node.*Shown as second*                                                                                                                               |
| **gcp.redis.cluster.node.stats.connections_received_count**(count)                                   | Count of total client connections created in the last one minute on the cluster node.                                                                                                   |
| **gcp.redis.cluster.node.stats.evicted_keys_count**(count)                                           | Count of evicted keys by the cluster node.                                                                                                                                              |
| **gcp.redis.cluster.node.stats.expired_keys_count**(count)                                           | Count of key expiration events in the cluster node.                                                                                                                                     |
| **gcp.redis.cluster.node.stats.keyspace_hits_count**(count)                                          | Count of successful lookup of keys in the cluster node.                                                                                                                                 |
| **gcp.redis.cluster.node.stats.keyspace_misses_count**(count)                                        | Count of failed lookup of keys in the cluster node.                                                                                                                                     |
| **gcp.redis.cluster.node.stats.net_input_bytes_count**(count)                                       | Count of incoming network bytes received by the cluster node.*Shown as byte*                                                                                                            |
| **gcp.redis.cluster.node.stats.net_output_bytes_count**(count)                                      | Count of outgoing network bytes sent from the cluster node.*Shown as byte*                                                                                                              |
| **gcp.redis.cluster.node.stats.rejected_connections_count**(count)                                   | Number of connections rejected because of maxclients limit by the cluster node.                                                                                                         |
| **gcp.redis.cluster.persistence.aof_fsync_lags.avg**(gauge)                                          | The average distribution of AOF lag between memory and persistent store across the cluster.*Shown as second*                                                                            |
| **gcp.redis.cluster.persistence.aof_fsync_lags.samplecount**(gauge)                                  | The sample count for distribution of AOF lag between memory and persistent store across the cluster.*Shown as second*                                                                   |
| **gcp.redis.cluster.persistence.aof_fsync_lags.sumsqdev**(gauge)                                     | The sum of squared deviation for distribution of AOF lag between memory and persistent store across the cluster.*Shown as second*                                                       |
| **gcp.redis.cluster.persistence.aof_rewrite_count**(count)                                           | Count of AOF rewrites across the cluster.                                                                                                                                               |
| **gcp.redis.cluster.persistence.rdb_last_success_ages.avg**(gauge)                                  | The average age of RDB snapshots across cluster.*Shown as second*                                                                                                                       |
| **gcp.redis.cluster.persistence.rdb_last_success_ages.samplecount**(gauge)                          | The sample count for age of RDB snapshots across cluster.*Shown as second*                                                                                                              |
| **gcp.redis.cluster.persistence.rdb_last_success_ages.sumsqdev**(gauge)                             | The sum of squared deviation for age of RDB snapshots across cluster.*Shown as second*                                                                                                  |
| **gcp.redis.cluster.persistence.rdb_saves_count**(count)                                             | Count of RDB saves across the cluster.                                                                                                                                                  |
| **gcp.redis.cluster.replication.average_ack_lag**(gauge)                                             | Mean replication acknowledge lag (in seconds) of replica across the cluster.*Shown as second*                                                                                           |
| **gcp.redis.cluster.replication.average_offset_diff**(gauge)                                         | Mean replication offset diff (in bytes) across the cluster.*Shown as byte*                                                                                                              |
| **gcp.redis.cluster.replication.maximum_ack_lag**(gauge)                                             | Maximum replication acknowledge lag (in seconds) of replica across the cluster.*Shown as second*                                                                                        |
| **gcp.redis.cluster.replication.maximum_offset_diff**(gauge)                                         | Maximum replication offset diff (in bytes) across the cluster.*Shown as byte*                                                                                                           |
| **gcp.redis.cluster.stats.average_evicted_keys**(gauge)                                              | Mean number of evicted keys due to memory capacity.                                                                                                                                     |
| **gcp.redis.cluster.stats.average_expired_keys**(gauge)                                              | Mean number of key expiration events.                                                                                                                                                   |
| **gcp.redis.cluster.stats.average_keyspace_hits**(gauge)                                             | Mean number of successful lookup of keys across the cluster.                                                                                                                            |
| **gcp.redis.cluster.stats.average_keyspace_misses**(gauge)                                           | Mean number of failed lookup of keys across the cluster.                                                                                                                                |
| **gcp.redis.cluster.stats.maximum_evicted_keys**(gauge)                                              | Maximum number of evicted keys due to memory capacity.                                                                                                                                  |
| **gcp.redis.cluster.stats.maximum_expired_keys**(gauge)                                              | Maximum number of key expiration events.                                                                                                                                                |
| **gcp.redis.cluster.stats.maximum_keyspace_hits**(gauge)                                             | Maximum number of successful lookup of keys across the cluster.                                                                                                                         |
| **gcp.redis.cluster.stats.maximum_keyspace_misses**(gauge)                                           | Maximum number of failed lookup of keys across the cluster.                                                                                                                             |
| **gcp.redis.cluster.stats.total_connections_received_count**(count)                                 | Count of client connections created in the last one minute.                                                                                                                             |
| **gcp.redis.cluster.stats.total_evicted_keys_count**(count)                                         | Total number of evicted keys due to memory capacity.                                                                                                                                    |
| **gcp.redis.cluster.stats.total_expired_keys_count**(count)                                         | Total number of key expiration events.                                                                                                                                                  |
| **gcp.redis.cluster.stats.total_keyspace_hits_count**(count)                                        | Total number of successful lookup of keys across the cluster.                                                                                                                           |
| **gcp.redis.cluster.stats.total_keyspace_misses_count**(count)                                      | Total number of failed lookup of keys across the cluster.                                                                                                                               |
| **gcp.redis.cluster.stats.total_net_input_bytes_count**(count)                                     | Count of incoming network bytes received by the cluster.*Shown as byte*                                                                                                                 |
| **gcp.redis.cluster.stats.total_net_output_bytes_count**(count)                                    | Count of outgoing network bytes sent from the cluster.*Shown as byte*                                                                                                                   |
| **gcp.redis.cluster.stats.total_rejected_connections_count**(count)                                 | Count of client connections rejected because of maxclients limit.                                                                                                                       |
| **gcp.redis.commands.calls**(count)                                                                    | Total number of calls for this command.                                                                                                                                                 |
| **gcp.redis.commands.total_time**(gauge)                                                              | The amount of time in microseconds that this command took in the last second.*Shown as microsecond*                                                                                     |
| **gcp.redis.commands.usec_per_call**(gauge)                                                          | Average time per call over 1 minute by command.*Shown as second*                                                                                                                        |
| **gcp.redis.keyspace.avg_ttl**(gauge)                                                                 | Average TTL for keys in this database.*Shown as millisecond*                                                                                                                            |
| **gcp.redis.keyspace.keys**(gauge)                                                                     | Number of keys stored in this database.*Shown as key*                                                                                                                                   |
| **gcp.redis.keyspace.keys_with_expiration**(gauge)                                                   | Number of keys with an expiration in this database.*Shown as key*                                                                                                                       |
| **gcp.redis.persistence.rdb.bgsave_in_progress**(gauge)                                              | Flag indicating a RDB save is on-going.                                                                                                                                                 |
| **gcp.redis.rdb.enabled**(gauge)                                                                       | Indicates if the snapshot is in RDB mode.                                                                                                                                               |
| **gcp.redis.rdb.recovery.attempts_since_last_success**(gauge)                                       | Indicates number of recovery attempts since the last successful recovery attempt.                                                                                                       |
| **gcp.redis.rdb.recovery.elapsed_time**(gauge)                                                        | Indicates increasing time elapsed for an in-progress recovery from an RDB snapshot. 0 means the recovery is idle or completed.*Shown as second*                                         |
| **gcp.redis.rdb.recovery.estimated_recovery_time**(gauge)                                            | Indicates the expected recovery time when using the last successful snapshot for recovery.*Shown as second*                                                                             |
| **gcp.redis.rdb.recovery.estimated_remaining_time**(gauge)                                           | Indicates remaining time to finish recovery from an RDB snapshot. 0 means the recovery is idle or completed.*Shown as second*                                                           |
| **gcp.redis.rdb.recovery.in_progress**(gauge)                                                         | Indicates if recovery from an RDB snapshot is in progress. When the metric value is true, then a recovery is in progress.                                                               |
| **gcp.redis.rdb.recovery.last_duration**(gauge)                                                       | Indicates time it took to restore the last snapshot.*Shown as second*                                                                                                                   |
| **gcp.redis.rdb.recovery.last_status**(gauge)                                                         | Indicates status of the most recent recovery.                                                                                                                                           |
| **gcp.redis.rdb.recovery.loaded_bytes_count**(count)                                                 | During a recovery, indicates how many bytes have loaded. 0 if the recovery is not active.*Shown as byte*                                                                                |
| **gcp.redis.rdb.recovery.total_bytes_count**(count)                                                  | Indicates the size in bytes of the snapshot.*Shown as byte*                                                                                                                             |
| **gcp.redis.rdb.snapshot.attempt_count**(count)                                                       | Indicates number of snapshot attempts every minute.                                                                                                                                     |
| **gcp.redis.rdb.snapshot.elapsed_time**(gauge)                                                        | Indicates increasing time elapsed while creating the current snapshot.*Shown as second*                                                                                                 |
| **gcp.redis.rdb.snapshot.in_progress**(gauge)                                                         | Indicates if RDB snapshot is in progress. When the metric value is true, then an RDB snapshot is in progress.                                                                           |
| **gcp.redis.rdb.snapshot.last_status**(gauge)                                                         | Indicates status of the most recent snapshot attempt.                                                                                                                                   |
| **gcp.redis.rdb.snapshot.last_success_age**(gauge)                                                   | Indicates time elapsed since the start of the last successful snapshot.*Shown as second*                                                                                                |
| **gcp.redis.rdb.snapshot.last_success_duration**(gauge)                                              | Indicates the total time required to write the last successful snapshot, not including failed attempts.*Shown as second*                                                                |
| **gcp.redis.rdb.snapshot.time_until_next_run**(gauge)                                               | Seconds until the next scheduled snapshot.*Shown as second*                                                                                                                             |
| **gcp.redis.replication.master.slaves.lag**(gauge)                                                     | The number of seconds that replica is lagging behind primary.*Shown as second*                                                                                                          |
| **gcp.redis.replication.master.slaves.offset**(gauge)                                                  | The number of bytes that have been acknowledged by replicas.*Shown as byte*                                                                                                             |
| **gcp.redis.replication.master_repl_offset**(gauge)                                                  | The number of bytes that master has produced and sent to replicas. To be compared with replication byte offset of replica.*Shown as byte*                                               |
| **gcp.redis.replication.offset_diff**(gauge)                                                          | The number of bytes that have not been replicated to the replica. This is the difference between replication byte offset (master) and replication byte offset (replica).*Shown as byte* |
| **gcp.redis.replication.role**(gauge)                                                                  | Returns a value indicating the node role. 1 indicates master and 0 indicates replica.                                                                                                   |
| **gcp.redis.search.attributes**(gauge)                                                                 | Indicates the number of attributes in vector search.                                                                                                                                    |
| **gcp.redis.search.background_indexing_in_progress**(gauge)                                         | Indicates if the background indexing is in progress. When the metric value is true, then the background indexing is in progress.                                                        |
| **gcp.redis.search.indexed_hash_keys**(gauge)                                                        | Indicates the number of indexed hash keys in vector search.                                                                                                                             |
| **gcp.redis.search.indexes**(gauge)                                                                    | Indicates the number of indexes in vector search.                                                                                                                                       |
| **gcp.redis.search.query_requests_count**(count)                                                     | Indicates the number of query requests count.                                                                                                                                           |
| **gcp.redis.search.used_memory_bytes**(gauge)                                                        | Indicates the used memory in bytes in vector search.*Shown as byte*                                                                                                                     |
| **gcp.redis.server.uptime**(gauge)                                                                     | Uptime in seconds.*Shown as second*                                                                                                                                                     |
| **gcp.redis.stats.cache_hit_ratio**(gauge)                                                           | Cache Hit ratio as a fraction.                                                                                                                                                          |
| **gcp.redis.stats.connections.total**(gauge)                                                           | Total number of connections accepted by the server.*Shown as connection*                                                                                                                |
| **gcp.redis.stats.cpu_utilization**(gauge)                                                            | CPU, in seconds of utilization, consumed by the Redis server broken down by System/User and Parent/Child relationship.*Shown as second*                                                 |
| **gcp.redis.stats.cpu_utilization_main_thread**(count)                                              | CPU-seconds consumed by the Redis server main thread, broken down by system/user space and parent/child relationship.*Shown as second*                                                  |
| **gcp.redis.stats.evicted_keys**(count)                                                               | Number of evicted keys due to maxmemory limit.*Shown as key*                                                                                                                            |
| **gcp.redis.stats.expired_keys**(count)                                                               | Total number of key expiration events.*Shown as key*                                                                                                                                    |
| **gcp.redis.stats.keyspace_hits**(count)                                                              | Number of successful lookup of keys in the main dictionary.*Shown as key*                                                                                                               |
| **gcp.redis.stats.keyspace_misses**(count)                                                            | Number of failed lookup of keys in the main dictionary.*Shown as key*                                                                                                                   |
| **gcp.redis.stats.memory.maxmemory**(gauge)                                                            | Maximum amount of memory Redis can consume.*Shown as byte*                                                                                                                              |
| **gcp.redis.stats.memory.system_memory_overload_duration**(count)                                   | The amount of time in microseconds the instance is in system memory overload mode.*Shown as microsecond*                                                                                |
| **gcp.redis.stats.memory.system_memory_usage_ratio**(gauge)                                         | Memory usage as a ratio of maximum system memory.*Shown as fraction*                                                                                                                    |
| **gcp.redis.stats.memory.usage**(gauge)                                                                | Total number of bytes allocated by Redis.*Shown as byte*                                                                                                                                |
| **gcp.redis.stats.memory.usage_ratio**(gauge)                                                         | Memory usage as a ratio of maximum memory.*Shown as fraction*                                                                                                                           |
| **gcp.redis.stats.network_traffic**(count)                                                            | Total number of bytes sent to or from redis (includes bytes from commands themselves, payload data, and delimiters).*Shown as byte*                                                     |
| **gcp.redis.stats.pubsub.channels**(gauge)                                                             | Global number of Pub/Sub channels with client subscriptions.                                                                                                                            |
| **gcp.redis.stats.pubsub.patterns**(gauge)                                                             | Global number of Pub/Sub patterns with client subscriptions.                                                                                                                            |
| **gcp.redis.stats.reject_connections_count**(count)                                                  | Number of connections rejected because of maxclients limit.                                                                                                                             |

### Events{% #events %}

The Google Cloud Memorystore for Redis integration does not include any events.

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

The Google Cloud Memorystore for Redis integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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