--- title: Amazon ElastiCache description: >- Amazon ElastiCache is a web service that makes it easy to deploy, operate, and scale an in-memory cache in the cloud. breadcrumbs: Docs > Integrations > Amazon ElastiCache --- > For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt). # Amazon ElastiCache 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 %} See [Monitoring ElastiCache performance metrics with Redis or Memcached](https://www.datadoghq.com/blog/monitoring-elasticache-performance-metrics-with-redis-or-memcached) to learn about key performance metrics, how to collect them, and how [Coursera](https://www.coursera.org) monitors ElastiCache using Datadog. ## Setup{% #setup %} If you haven't already, set up the [Amazon Web Services integration](https://docs.datadoghq.com/integrations/amazon_web_services.md) first. ### Installation without Datadog Agent{% #installation-without-datadog-agent %} 1. In the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `ElastiCache` is enabled under the `Metric Collection` tab. 1. Add the following permissions to your [Datadog IAM policy](https://docs.datadoghq.com/integrations/amazon_web_services.md#installation) in order to collect Amazon ElastiCache metrics. For more information, see the [ElastiCache policies](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.html) on the AWS website. | AWS Permission | Description | | ----------------------------------- | --------------------------------------------------------------------- | | `elasticache:DescribeCacheClusters` | List and describe Cache clusters, to add tags and additional metrics. | | `elasticache:ListTagsForResource` | List custom tags of a cluster, to add custom tags. | | `elasticache:DescribeEvents` | Add events about snapshots and maintenances. | 1. Install the [Datadog - Amazon ElastiCache integration](https://app.datadoghq.com/integrations/amazon-elasticache). ### Installation with Datadog Agent (recommended){% #installation-with-datadog-agent-recommended %} #### Collecting native metrics with the Agent{% #collecting-native-metrics-with-the-agent %} The following diagram shows how Datadog collects metrics directly from CloudWatch with the native ElastiCache integration, and how it can additionally collect native metrics directly from the backend technology: Redis or Memcached. By collecting from the backend directly, you have access to a greater number of important metrics, and at a higher resolution. #### How this works{% #how-this-works %} Because the Agent metrics are tied to the EC2 instance where the agent is running and not to the actual ElastiCache instance, you need to use the `cacheclusterid` tag to connect all metrics together. Once the agent is configured with the same tags as the ElastiCache instance, combining Redis/Memcached metrics with ElastiCache metrics is straightforward. #### Step-by-step{% #step-by-step %} Since the Agent is not running on an actual ElastiCache instance, but on a remote machine, the key to setting up this integration correctly is telling the Agent where to collect the metrics from. **Note**: The IAM role used by the [Amazon Web Services integration](https://docs.datadoghq.com/integrations/amazon_web_services.md) has permissions to perform CloudWatch metric collection (`aws.elasticache.*`) only, it cannot collect the data returned by the Redis check. For native `redis.*` metrics, use Redis-level username and password authentication instead. ##### Gather connection details for your ElastiCache instance{% #gather-connection-details-for-your-elasticache-instance %} First navigate to the AWS Console, open the ElastiCache section and then the Cache Clusters tab to find the cluster you want to monitor. It should look like: Then click on the "node" link to access its endpoint URL: Write down the endpoint URL (for example: **replica-001.xxxx.use1.cache.amazonaws.com**) and the `cacheclusterid` (for example: **replica-001**). You need these values to configure the agent and to create graphs and dashboards. ##### Configure the Agent{% #configure-the-agent %} The Redis/Memcached integrations support the tagging of individual cache instances. Originally designed to allow the monitoring of multiple instances on the same machine, these tags can be used to filter and group metrics. Here is an example of a configuration for ElastiCache with Redis using `redisdb.yaml`. For information about where this file is stored based on your platform, see the [Agent configuration directory](https://docs.datadoghq.com/agent/guide/agent-configuration-files.md#agent-configuration-directory). ```yaml init_config: instances: # Endpoint URL from AWS console - host: replica-001.xxxx.use1.cache.amazonaws.com port: 6379 # Cache Cluster ID from AWS console tags: - cacheclusterid:replica-001 ``` Then restart the agent: `sudo /etc/init.d/datadog-agent restart` (on linux). ##### Visualize metrics together{% #visualize-metrics-together %} After a few minutes, ElastiCache metrics and Redis or Memcached metrics can be accessed in Datadog for graphing, monitoring, etc. Here's an example of setting up a graph to combine cache hit metrics from ElastiCache with native latency metrics from Redis using the same `cacheclusterid` tag **replica-001**. ## Data Collected{% #data-collected %} ### Metrics{% #metrics %} | | | | | **aws.elasticache.cpuutilization**(gauge) | The percentage of CPU utilization for the server.*Shown as percent* | | **aws.elasticache.cpucredit_balance**(gauge) | The number of earned CPU credits that an instance has accrued since it was launched or started.*Shown as unit* | | **aws.elasticache.cpucredit_usage**(gauge) | The number of CPU credits spent by the instance for CPU utilization.*Shown as unit* | | **aws.elasticache.freeable_memory**(gauge) | The amount of free memory available on the host.*Shown as byte* | | **aws.elasticache.network_bytes_in**(count) | The number of bytes the host has read from the network.*Shown as byte* | | **aws.elasticache.network_bytes_out**(count) | The number of bytes the host has written to the network.*Shown as byte* | | **aws.elasticache.network_packets_in**(count) | The number of packets received on all network interfaces by the instance.*Shown as packet* | | **aws.elasticache.network_packets_out**(count) | The number of packets sent out on all network interfaces by the instance.*Shown as packet* | | **aws.elasticache.network_bandwidth_in_allowance_exceeded**(count) | The number of packets queued or dropped because the inbound aggregate bandwidth exceeded the maximum for the instance.*Shown as packet* | | **aws.elasticache.network_bandwidth_out_allowance_exceeded**(count) | The number of packets queued or dropped because the outbound aggregate bandwidth exceeded the maximum for the instance.*Shown as packet* | | **aws.elasticache.network_conntrack_allowance_exceeded**(count) | The number of packets dropped because connection tracking exceeded the maximum for the instance and new connections could not be established.*Shown as packet* | | **aws.elasticache.network_packets_per_second_allowance_exceeded**(count) | The number of packets queued or dropped because the bidirectional packets per second exceeded the maximum for the instance.*Shown as packet* | | **aws.elasticache.network_max_bytes_in**(gauge) | The maximum per second burst of received bytes within each minute.*Shown as byte* | | **aws.elasticache.network_max_bytes_out**(gauge) | The maximum per second burst of transmitted bytes within each minute.*Shown as byte* | | **aws.elasticache.network_max_packets_in**(gauge) | The maximum per second burst of received packets within each minute.*Shown as packet* | | **aws.elasticache.network_max_packets_out**(gauge) | The maximum per second burst of transmitted packets within each minute.*Shown as packet* | | **aws.elasticache.swap_usage**(gauge) | The amount of swap used on the host.*Shown as byte* | | **aws.elasticache.major_page_faults**(count) | The number of major page faults incurred by the engine process. High values indicate that the engine is actively swapping and experiencing memory pressure that can degrade performance.*Shown as fault* | | **aws.elasticache.network_baseline_usage_in_percentage**(gauge) | The average inbound network bandwidth utilization as a percentage of the baseline bandwidth for the instance type.*Shown as percent* | | **aws.elasticache.network_baseline_usage_out_percentage**(gauge) | The average outbound network bandwidth utilization as a percentage of the baseline bandwidth for the instance type.*Shown as percent* | | **aws.elasticache.network_baseline_max_usage_in_percentage**(gauge) | The maximum per-second inbound network bandwidth utilization as a percentage of the baseline bandwidth for the instance type. This metric captures microbursts that averaged metrics can hide.*Shown as percent* | | **aws.elasticache.network_baseline_max_usage_out_percentage**(gauge) | The maximum per-second outbound network bandwidth utilization as a percentage of the baseline bandwidth for the instance type. This metric captures microbursts that averaged metrics can hide.*Shown as percent* | | **aws.elasticache.active_defrag_hits**(gauge) | Redis - The number of value reallocations per minute performed by the active defragmentation process. | | **aws.elasticache.authentication_failures**(count) | Redis - The total number of failed attempts to authenticate to Redis using the AUTH command.*Shown as error* | | **aws.elasticache.database_authorization_failures**(count) | Redis - The total number of failed attempts by users to access databases they don't have permission to access.*Shown as error* | | **aws.elasticache.bytes_used_for_cache**(gauge) | Redis - The total number of bytes allocated by Redis.*Shown as byte* | | **aws.elasticache.bytes_read_from_disk**(count) | Redis - The total number of bytes read from disk per minute. Supported only for clusters using data tiering.*Shown as byte* | | **aws.elasticache.bytes_written_to_disk**(count) | Redis - The total number of bytes written to disk per minute. Supported only for clusters using data tiering.*Shown as byte* | | **aws.elasticache.cache_hits**(count) | Redis - The number of successful key lookups.*Shown as hit* | | **aws.elasticache.cache_misses**(count) | Redis - The number of unsuccessful key lookups.*Shown as miss* | | **aws.elasticache.command_authorization_failures**(count) | Redis - The total number of failed attempts by users to run commands they don't have permission to call.*Shown as error* | | **aws.elasticache.cache_hit_rate**(gauge) | Redis - Indicates the usage efficiency of the Redis instance.*Shown as percent* | | **aws.elasticache.channel_authorization_failures**(count) | Redis - The total number of failed attempts by users to access channels they do not have permission to access.*Shown as error* | | **aws.elasticache.curr_connections**(gauge) | Redis - The number of client connections, excluding connections from read replicas. Memcached - A count of the number of connections connected to the cache at an instant in time.*Shown as connection* | | **aws.elasticache.curr_items**(gauge) | Redis - The number of items in the cache. This is derived from the Redis keyspace statistic, summing all of the keys in the entire keyspace. Memcached - A count of the number of items currently stored in the cache.*Shown as item* | | **aws.elasticache.curr_volatile_items**(gauge) | Redis - The total number of keys in all databases that have a ttl set. This is derived from the expires statistic, summing all of the keys with a ttl set in the entire keyspace.*Shown as item* | | **aws.elasticache.curr_items_with_volatile_fields**(gauge) | Redis - The number of keys that contain hash fields with expiration set.*Shown as item* | | **aws.elasticache.reclaimed_fields**(count) | Redis - The number of expired hash fields reclaimed by the active expiration process. | | **aws.elasticache.database_capacity_usage_percentage**(gauge) | Redis - The percentage of the total data capacity for the cluster that is in use.*Shown as percent* | | **aws.elasticache.database_capacity_usage_counted_for_evict_percentage**(gauge) | Redis - The percentage of the total data capacity for the cluster that is in use, excluding the memory used for overhead and copy-on-write buffers.*Shown as percent* | | **aws.elasticache.database_memory_usage_percentage**(gauge) | Redis - The percentage of the memory available for the cluster that is in use.*Shown as percent* | | **aws.elasticache.database_memory_usage_counted_for_evict_percentage**(gauge) | Redis - The percentage of the memory for the cluster that is in use, excluding memory used for overhead and copy-on-write buffers.*Shown as percent* | | **aws.elasticache.database_memory_usage_percentage.maximum**(gauge) | Redis - The maximum percentage of the memory available for the cluster that is in use.*Shown as percent* | | **aws.elasticache.db_0average_ttl**(gauge) | Redis - Exposes avg_ttl of DB0 from the keyspace statistic of the Redis INFO command.*Shown as millisecond* | | **aws.elasticache.engine_cpuutilization**(gauge) | The percentage of CPU utilization for the Redis process.*Shown as percent* | | **aws.elasticache.engine_cpuutilization.maximum**(gauge) | The maximum percentage of CPU utilization for the Redis process.*Shown as percent* | | **aws.elasticache.evictions**(count) | Redis - The number of keys that have been evicted due to the maxmemory limit. Memcached - The number of non-expired items the cache evicted to allow space for new writes.*Shown as eviction* | | **aws.elasticache.global_datastore_replication_lag**(gauge) | Redis - The lag between the secondary region's primary node and the primary region's primary node. For cluster mode enabled Redis, the lag indicates the maximum delay among the shards.*Shown as second* | | **aws.elasticache.iam_authentication_expirations**(count) | Redis - The total number of expired IAM-authenticated Redis connections.*Shown as connection* | | **aws.elasticache.iam_authentication_throttling**(count) | Redis - The total number of throttled IAM-authenticated Redis AUTH or HELLO requests.*Shown as throttle* | | **aws.elasticache.is_master**(gauge) | Redis - Returns 1 if the node is master, 0 otherwise. | | **aws.elasticache.key_authorization_failures**(count) | Redis - The total number of failed attempts by users to access keys they don't have permission to access.*Shown as error* | | **aws.elasticache.keys_tracked**(gauge) | Redis - The number of keys being tracked by Redis key tracking.*Shown as key* | | **aws.elasticache.memory_fragmentation_ratio**(gauge) | Redis - Indicates the efficiency in the allocation of memory of the Redis engine. | | **aws.elasticache.master_link_health_status**(gauge) | Redis - A value of 0 indicates that data in the Elasticache primary node is not in sync with Redis on EC2. A value of 1 indicates that the data is in sync. | | **aws.elasticache.new_connections**(count) | Redis - The total number of connections that have been accepted by the server during this period. Memcached - The number of new connections the cache has received. This is derived from the memcached total_connections statistic by recording the change in total_connections across a period of time. This will always be at least 1, due to a connection reserved for a ElastiCache.*Shown as connection* | | **aws.elasticache.num_items_read_from_disk**(count) | Redis - The total number of items retrieved from disk per minute. Supported only for clusters using data tiering.*Shown as item* | | **aws.elasticache.num_items_written_to_disk**(count) | Redis - The total number of items written to disk per minute. Supported only for clusters using data tiering.*Shown as item* | | **aws.elasticache.reclaimed**(count) | Redis - The total number of key expiration events. Memcached - The number of expired items the cache evicted to allow space for new writes. | | **aws.elasticache.replication_bytes**(count) | Redis - For primaries with attached replicas, ReplicationBytes reports the number of bytes that the primary is sending to all of its replicas. This metric is representative of the write load on the replication group. For replicas and standalone primaries, ReplicationBytes is always 0.*Shown as byte* | | **aws.elasticache.replication_lag**(gauge) | Redis - This metric is only applicable for a cache node running as a read replica. It represents how far behind, in seconds, the replica is in applying changes from the primary cache cluster.*Shown as second* | | **aws.elasticache.save_in_progress**(gauge) | Redis - This binary metric returns 1 whenever a background save (forked or forkless) is in progress, and 0 otherwise. A background save process is typically used during snapshots and syncs. These operations can cause degraded performance. Using the SaveInProgress metric, you can diagnose whether or not degraded performance was caused by a background save process. | | **aws.elasticache.traffic_management_active**(gauge) | Redis - Indicates whether ElastiCache for Redis is actively managing traffic by adjusting traffic allocated to incoming commands, monitoring, or replication. A value of 1 may indicate that the node is underscaled for the workload being provided. | | **aws.elasticache.successful_write_request_latency**(gauge) | Redis - The latency of successful write requests. The sample count includes only the commands that were successfully executed.*Shown as microsecond* | | **aws.elasticache.successful_write_request_latency.maximum**(gauge) | Redis - The maximum latency of successful write requests.*Shown as microsecond* | | **aws.elasticache.successful_read_request_latency**(gauge) | Redis - The latency of successful read requests. The sample count includes only the commands that were successfully executed.*Shown as microsecond* | | **aws.elasticache.successful_read_request_latency.maximum**(gauge) | Redis - The maximum latency of successful read requests.*Shown as microsecond* | | **aws.elasticache.error_count**(count) | Redis - The total number of failed commands during the specified time period.*Shown as error* | | **aws.elasticache.search_number_of_indexes**(gauge) | Redis - The number of created search indexes.*Shown as index* | | **aws.elasticache.search_total_indexed_documents**(gauge) | Redis - The total number of keys in all search indexes.*Shown as document* | | **aws.elasticache.search_used_memory_bytes**(gauge) | Redis - The number of bytes of memory consumed by all search data structures.*Shown as byte* | | **aws.elasticache.blocked_connections**(gauge) | Redis - The number of clients currently in a blocked state, waiting on blocking commands such as BLPOP.*Shown as connection* | | **aws.elasticache.rejected_connections**(count) | Redis - The number of connections that the engine has rejected, primarily when the number of connected clients has reached the maxclients limit.*Shown as connection* | | **aws.elasticache.pub_sub_channels**(gauge) | Redis - The number of active pub/sub channels on this node that have at least one subscriber. This count does not include sharded pub/sub channels. | | **aws.elasticache.pub_sub_shard_channels**(gauge) | Redis - The number of active sharded pub/sub channels on this node that have at least one subscriber. | | **aws.elasticache.used_memory_dataset**(gauge) | Redis - An estimate of memory in bytes used by actual user data (keys and values), excluding overhead such as replication buffers, client output buffers, and internal metadata.*Shown as byte* | | **aws.elasticache.allocator_fragmentation_bytes**(gauge) | Redis - The amount of memory in bytes wasted due to allocator fragmentation.*Shown as byte* | | **aws.elasticache.allocator_fragmentation_ratio**(gauge) | Redis - The ratio of allocator fragmentation relative to total allocated memory. Values above 1.0 represent fragmentation. | | **aws.elasticache.processed_commands**(count) | Redis - The total number of commands processed by the engine. Commands rejected before execution are not counted.*Shown as command* | | **aws.elasticache.durability_lag**(gauge) | Redis - The age of the oldest write acknowledged to the client but not yet persisted to the Multi-AZ transactional log. Only for durability-enabled clusters.*Shown as millisecond* | | **aws.elasticache.durability_buffer_exceeded_error_count**(count) | Redis - The number of write commands rejected due to exceeding the 10-second durability window. Only for async writes.*Shown as error* | | **aws.elasticache.max_replication_throughput**(gauge) | Redis - The maximum observed replication throughput during the last measurement cycle.*Shown as byte* | | **aws.elasticache.elasti_cache_processing_units**(count) | Redis - The number of ElastiCache Processing Units consumed by the requests against a serverless cache. | | **aws.elasticache.total_cmds_count**(count) | Redis - The total number of commands processed by a serverless cache.*Shown as command* | | **aws.elasticache.throttled_cmds**(count) | Redis - The number of commands that have been throttled because the data or request rate exceeded the throughput available to a serverless cache.*Shown as command* | | **aws.elasticache.search_write_cpuutilization**(gauge) | Redis - The current CPU utilization of the search module's writer threads.*Shown as percent* | | **aws.elasticache.search_write_throttle_active**(gauge) | Redis - Indicates whether search write throttling is currently active. A value of 1 indicates active, 0 indicates inactive. | | **aws.elasticache.search_write_throttle_clients_count**(gauge) | Redis - The number of client connections currently being throttled.*Shown as connection* | | **aws.elasticache.search_write_throttle_events**(count) | Redis - The number of search write throttle events within the reporting interval.*Shown as throttle* | | **aws.elasticache.bloom_filter_based_cmds**(count) | Redis - The total number of Bloom filter commands, including both read and write commands.*Shown as command* | | **aws.elasticache.bloom_filter_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by all Bloom filter commands, including both read and write commands. | | **aws.elasticache.bloom_filter_based_cmds_latency**(gauge) | Redis - The latency of all Bloom filter commands, including both read and write commands.*Shown as microsecond* | | **aws.elasticache.cluster_based_cmds**(count) | Redis - The total number of commands that are cluster-based. This is derived from the commandstats statistic by summing all of the commands that act upon a cluster (cluster slot, cluster info, and so on).*Shown as command* | | **aws.elasticache.cluster_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by cluster-based commands. | | **aws.elasticache.cluster_based_cmds_latency**(gauge) | Redis - The latency of cluster-based commands.*Shown as microsecond* | | **aws.elasticache.eval_based_cmds**(count) | Redis - The total number of commands for eval-based commands.*Shown as command* | | **aws.elasticache.eval_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by eval based commands. | | **aws.elasticache.eval_based_cmds_latency**(gauge) | Redis - The latency of eval-based commands.*Shown as microsecond* | | **aws.elasticache.geo_spatial_based_cmds**(count) | Redis - The total number of geo spatial based commands.*Shown as command* | | **aws.elasticache.geo_spatial_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by geospatial based commands. | | **aws.elasticache.geo_spatial_based_cmds_latency**(gauge) | Redis - The latency of geospatial-based commands.*Shown as microsecond* | | **aws.elasticache.get_type_cmds**(count) | Redis - The total number of read-only type commands. This is derived from the Redis OSS commandstats statistic by summing all of the read-only type commands (get, hget, scard, lrange, and so on.)*Shown as command* | | **aws.elasticache.get_type_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by get type commands. | | **aws.elasticache.get_type_cmds_latency**(gauge) | Redis - The latency of read commands.*Shown as microsecond* | | **aws.elasticache.hash_based_cmds**(count) | Redis - The total number of commands that are hash-based. This is derived from the Redis commandstats statistic by summing all of the commands that act upon one or more hashes.*Shown as command* | | **aws.elasticache.hash_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by hash based commands. | | **aws.elasticache.hash_based_cmds_latency**(gauge) | Redis - The latency of hash-based commands.*Shown as microsecond* | | **aws.elasticache.hyper_log_log_based_cmds**(count) | Redis - The total number of HyperLogLog based commands. This is derived from the Redis commandstats statistic by summing all of the pf type of commands (pfadd, pfcount, pfmerge).*Shown as command* | | **aws.elasticache.hyper_log_log_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by HyperLogLog based commands. | | **aws.elasticache.hyper_log_log_based_cmds_latency**(gauge) | Redis - The latency of HyperLogLog-based commands.*Shown as microsecond* | | **aws.elasticache.json_based_cmds**(count) | Redis - The total number of JSON commands, including both read and write commands. This is derived from the commandstats statistic by summing all JSON commands that act upon JSON keys.*Shown as command* | | **aws.elasticache.json_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by JSON based commands. | | **aws.elasticache.json_based_cmds_latency**(gauge) | Redis - The latency of all JSON commands, including both read and write commands.*Shown as microsecond* | | **aws.elasticache.json_based_get_cmds**(count) | Redis - The total number of JSON read-only commands. This is derived from the commandstats statistic by summing all JSON read commands that act upon JSON keys.*Shown as command* | | **aws.elasticache.json_based_get_cmds_latency**(gauge) | Redis - The latency of JSON read-only commands.*Shown as microsecond* | | **aws.elasticache.json_based_set_cmds**(count) | Redis - The total number of JSON write commands. This is derived from the commandstats statistic by summing all JSON write commands that act upon JSON keys.*Shown as command* | | **aws.elasticache.json_based_set_cmds_latency**(gauge) | Redis - The latency of JSON write commands.*Shown as microsecond* | | **aws.elasticache.key_based_cmds**(count) | Redis - The total number of commands that are key-based. This is derived from the Redis commandstats statistic by summing all of the commands that act upon one or more keys.*Shown as command* | | **aws.elasticache.key_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by key based commands. | | **aws.elasticache.key_based_cmds_latency**(gauge) | Redis - The latency of key-based commands.*Shown as microsecond* | | **aws.elasticache.list_based_cmds**(count) | Redis - The total number of commands that are list-based. This is derived from the Redis commandstats statistic by summing all of the commands that act upon one or more lists.*Shown as command* | | **aws.elasticache.list_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by list based commands. | | **aws.elasticache.list_based_cmds_latency**(gauge) | Redis - The latency of list-based commands.*Shown as microsecond* | | **aws.elasticache.non_key_type_cmds**(count) | Redis - The total number of commands that are not key-based. This is derived from the commandstats statistic by summing all of the commands that do not act upon a key, for example, acl, dbsize, or info.*Shown as command* | | **aws.elasticache.non_key_type_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by non-key type commands. | | **aws.elasticache.non_key_type_cmds_latency**(gauge) | Redis - The latency of non-key-based commands.*Shown as microsecond* | | **aws.elasticache.pub_sub_based_cmds**(count) | Redis - The total number of commands for pub/sub functionality. This is derived from the commandstats statistic by summing all of the commands used for pub/sub functionality (psubscribe, publish, pubsub, punsubscribe, ssubscribe, sunsubscribe, spublish, subscribe, and unsubscribe).*Shown as command* | | **aws.elasticache.pub_sub_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by pub/sub based commands. | | **aws.elasticache.pub_sub_based_cmds_latency**(gauge) | Redis - The latency of pub/sub-based commands.*Shown as microsecond* | | **aws.elasticache.set_based_cmds**(count) | Redis - The total number of commands that are set-based. This is derived from the Redis commandstats statistic by summing all of the commands that act upon one or more sets.*Shown as command* | | **aws.elasticache.set_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by set based commands. | | **aws.elasticache.set_based_cmds_latency**(gauge) | Redis - The latency of set-based commands.*Shown as microsecond* | | **aws.elasticache.set_type_cmds**(count) | Redis - The total number of write types of commands. This is derived from the Redis OSS commandstats statistic by summing all of the mutative types of commands that operate on data (set, hset, sadd, lpop, and so on.)*Shown as command* | | **aws.elasticache.set_type_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by set type commands. | | **aws.elasticache.set_type_cmds_latency**(gauge) | Redis - The latency of write commands.*Shown as microsecond* | | **aws.elasticache.sorted_set_based_cmds**(count) | Redis - The total number of commands that are sorted set-based. This is derived from the Redis commandstats statistic by summing all of the commands that act upon one or more sorted sets.*Shown as command* | | **aws.elasticache.sorted_set_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by sorted set based commands. | | **aws.elasticache.sorted_set_based_cmds_latency**(gauge) | Redis - The latency of sorted-based commands.*Shown as microsecond* | | **aws.elasticache.stream_based_cmds**(count) | Redis - The total number of commands that are stream-based.*Shown as command* | | **aws.elasticache.stream_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by stream based commands. | | **aws.elasticache.stream_based_cmds_latency**(gauge) | Redis - The latency of stream-based commands.*Shown as microsecond* | | **aws.elasticache.string_based_cmds**(count) | Redis - The total number of commands that are string-based. This is derived from the Redis commandstats statistic by summing all of the commands that act upon one or more strings.*Shown as command* | | **aws.elasticache.string_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by string based commands. | | **aws.elasticache.string_based_cmds_latency**(gauge) | Redis - The latency of string-based commands.*Shown as microsecond* | | **aws.elasticache.search_based_cmds**(count) | Redis - The total number of search commands, including both read and write commands. This is derived from the commandstats statistic by summing all search commands.*Shown as command* | | **aws.elasticache.search_based_cmds_ecpus**(count) | Redis - The number of ElastiCache Processing Units consumed by all search commands, including both read and write commands. | | **aws.elasticache.search_based_cmds_latency**(gauge) | Redis - The latency of all search commands, including both read and write commands.*Shown as microsecond* | | **aws.elasticache.search_based_get_cmds**(count) | Redis - The total number of search read-only commands. This is derived from the commandstats statistic by summing all search read commands.*Shown as command* | | **aws.elasticache.search_based_get_cmds_latency**(gauge) | Redis - The latency of search read-only commands.*Shown as microsecond* | | **aws.elasticache.search_based_set_cmds**(count) | Redis - The total number of search write commands. This is derived from the commandstats statistic by summing all search write commands.*Shown as command* | | **aws.elasticache.search_based_set_cmds_latency**(gauge) | Redis - The latency of search write commands.*Shown as microsecond* | | **aws.elasticache.bytes_read_into_memcached**(count) | Memcached - The number of bytes that have been read from the network by the cache node.*Shown as byte* | | **aws.elasticache.bytes_used_for_cache_items**(gauge) | Memcached - The number of bytes used to store cache items.*Shown as byte* | | **aws.elasticache.bytes_used_for_hash**(gauge) | Memcached - The number of bytes currently used by hash tables.*Shown as byte* | | **aws.elasticache.bytes_written_out_from_memcached**(count) | Memcached - The number of bytes that have been written to the network by the cache node.*Shown as byte* | | **aws.elasticache.cas_badval**(count) | Memcached - The number of CAS (check and set) requests the cache has received where the Cas value did not match the Cas value stored.*Shown as request* | | **aws.elasticache.cas_hits**(count) | Memcached - The number of CAS requests the cache has received where the requested key was found and the Cas value matched.*Shown as hit* | | **aws.elasticache.cas_misses**(count) | Memcached - The number of CAS requests the cache has received where the key requested was not found.*Shown as miss* | | **aws.elasticache.cmd_config_get**(count) | Memcached - The cumulative number of config get requests.*Shown as get* | | **aws.elasticache.cmd_config_set**(count) | Memcached - The cumulative number of config set requests.*Shown as set* | | **aws.elasticache.cmd_flush**(count) | Memcached - The number of flush commands the cache has received.*Shown as flush* | | **aws.elasticache.cmd_get**(count) | Memcached - The number of get commands the cache has received.*Shown as get* | | **aws.elasticache.cmd_set**(count) | Memcached - The number of set commands the cache has received.*Shown as set* | | **aws.elasticache.cmd_touch**(count) | Memcached - The cumulative number of touch requests.*Shown as request* | | **aws.elasticache.crawler_items_checked**(count) | Memcached - The number of items checked by the LRU crawler.*Shown as item* | | **aws.elasticache.curr_config**(gauge) | Memcached - The current number of configurations stored. | | **aws.elasticache.decr_hits**(count) | Memcached - The number of decrement requests the cache has received where the requested key was found.*Shown as hit* | | **aws.elasticache.decr_misses**(count) | Memcached - The number of decrement requests the cache has received where the requested key was not found.*Shown as miss* | | **aws.elasticache.delete_hits**(count) | Memcached - The number of delete requests the cache has received where the requested key was found.*Shown as hit* | | **aws.elasticache.delete_misses**(count) | Memcached - The number of delete requests the cache has received where the requested key was not found.*Shown as miss* | | **aws.elasticache.evicted_unfetched**(count) | Memcached - The number of valid items evicted from the least recently used cache (LRU) which were never touched after being set.*Shown as item* | | **aws.elasticache.expired_unfetched**(count) | Memcached - The number of expired items reclaimed from the LRU which were never touched after being set.*Shown as item* | | **aws.elasticache.get_hits**(count) | Memcached - The number of get requests the cache has received where the key requested was found.*Shown as hit* | | **aws.elasticache.get_misses**(count) | Memcached - The number of get requests the cache has received where the key requested was not found.*Shown as miss* | | **aws.elasticache.incr_hits**(count) | Memcached - The number of increment requests the cache has received where the key requested was found.*Shown as hit* | | **aws.elasticache.incr_misses**(count) | Memcached - The number of increment requests the cache has received where the key requested was not found.*Shown as miss* | | **aws.elasticache.new_items**(count) | Memcached - The number of new items the cache has stored. This is derived from the memcached total_items statistic by recording the change in total_items across a period of time.*Shown as item* | | **aws.elasticache.slabs_moved**(count) | Memcached - The total number of slab pages that have been moved.*Shown as page* | | **aws.elasticache.touch_hits**(count) | Memcached - The number of keys that have been touched and were given a new expiration time.*Shown as hit* | | **aws.elasticache.touch_misses**(count) | Memcached - The number of items that have been touched, but were not found.*Shown as miss* | | **aws.elasticache.unused_memory**(gauge) | Memcached - The amount of unused memory the cache can use to store items. This is derived from the memcached statistics limit_maxbytes and bytes by subtracting bytes from limit_maxbytes.*Shown as byte* | | **aws.elasticache.search_bytes_used_for_cache**(gauge) | Redis - The total number of bytes allocated for search indexes by a serverless cache.*Shown as byte* | | **aws.elasticache.total_operations**(count) | The total operations recorded for a cache.*Shown as command* | | **aws.elasticache.cluster_count**(count) | The number of Elasticache clusters. | | **aws.elasticache.node_count**(count) | The number of Elasticache nodes.*Shown as node* | Each of the metrics retrieved from AWS is assigned the same tags that appear in the AWS console, including but not limited to host name, security-groups, and more. **Note**: Metrics for ElastiCache Serverless deployments are reported under the same `aws.elasticache` namespace. These metrics can be distinguished by tags: - The existing ElastiCache metrics for self-designed caches use the tag cacheclusterid to identify an individual cache - The serverless cache metrics use the tag clusterid to identify individual caches ### Events{% #events %} The Amazon ElastiCache integration includes events for cluster, cache security groups, and cache parameter groups. See example events below: ### Service Checks{% #service-checks %} The Amazon ElastiCache integration does not include any service checks. ## Troubleshooting{% #troubleshooting %} Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).