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

# Google Cloud Redis

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