aws.memorydb.active_defrag_hits
(count) | The number of value reallocations per minute performed by the active defragmentation process. |
aws.memorydb.authentication_failures
(count) | The total number of failed attempts to authenticate to Redis using the AUTH command. |
aws.memorydb.bytes_read_from_disk
(count) | The total number of bytes read from disk per minute. Supported only for clusters using data tiering.
Shown as byte |
aws.memorydb.bytes_used_for_memory_db
(gauge) | The total number of bytes allocated by MemoryDB for all purposes.
Shown as byte |
aws.memorydb.bytes_written_to_disk
(count) | The total number of bytes written to disk per minute. Supported only for clusters using data tiering.
Shown as byte |
aws.memorydb.channel_authorization_failures
(count) | The total number of failed attempts by users to access channels they do not have permission to access. |
aws.memorydb.command_authorization_failures
(count) | The total number of failed attempts by users to run commands they don't have permission to call. |
aws.memorydb.cpuutilization
(gauge) | The average percentage of CPU utilization for the entire host.
Shown as percent |
aws.memorydb.curr_connections
(gauge) | The number of client connections, excluding connections from read replicas. MemoryDB uses two to four of the connections to monitor the cluster in each case.
Shown as connection |
aws.memorydb.curr_items
(gauge) | The number of items in the cache. |
aws.memorydb.database_memory_usage_percentage
(gauge) | Percentage of the memory available for the cluster that is in use.
Shown as percent |
aws.memorydb.db0_average_ttl
(gauge) | The average TTL of keys with an expiration set in DB0. Only applicable for primary nodes.
Shown as millisecond |
aws.memorydb.engine_cpuutilization
(gauge) | Provides CPU utilization of the Redis engine thread. Because Redis is single-threaded, you can use this metric to analyze the load of the Redis process itself.
Shown as percent |
aws.memorydb.eval_based_cmds
(count) | The total number of commands for eval-based commands. This is derived from the Redis commandstats statistics by summing eval, evalsha. |
aws.memorydb.evictions
(count) | The number of keys that have been evicted due to the maxmemory limit. |
aws.memorydb.freeable_memory
(gauge) | The amount of free memory available on the host.
Shown as byte |
aws.memorydb.geo_spatial_based_cmds
(count) | The total number of commands for geospatial-based commands. This is derived from the Redis commandstats statistics, by summing all of the geo type of commands: geoadd, geodist, geohash, geopos, georadius, and georadiusbymember. |
aws.memorydb.get_type_cmds
(count) | The total number of read-only type commands. This is derived from the Redis commandstats statistics by summing all of the read-only type commands (get, hget, scard, lrange, and so on). |
aws.memorydb.hash_based_cmds
(count) | The total number of commands that are hash-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more hashes (hget, hkeys, hvals, hdel, and so on). |
aws.memorydb.hyper_log_log_based_cmds
(count) | The total number of HyperLogLog-based commands. This is derived from the Redis commandstats statistics by summing all of the pf type of commands (pfadd, pfcount, pfmerge, and so on). |
aws.memorydb.iam_authentication_expirations
(count) | The total number of expired IAM-authenticated Redis connections. |
aws.memorydb.iam_authentication_throttling
(count) | The total number of throttled IAM-authenticated Redis AUTH or HELLO requests. |
aws.memorydb.is_primary
(gauge) | Indicates whether the node is primary node of current shard. The metric can be either 0 (not primary) or 1 (primary). |
aws.memorydb.json_based_cmds
(count) | The total number of commands that are JSON-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more JSON document objects. |
aws.memorydb.json_based_get_cmds
(count) | The total number of JSON read-only commands. This is derived from the Redis commandstats statistics by summing all JSON read commands that act upon JSON keys. |
aws.memorydb.json_based_set_cmds
(count) | The total number of JSON write commands. This is derived from the Redis commandstats statistics by summing all JSON write commands that act upon JSON keys. |
aws.memorydb.key_authorization_failures
(count) | The total number of failed attempts by users to access keys they don't have permission to access. |
aws.memorydb.key_based_cmds
(count) | The total number of commands that are key-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more keys across multiple data structures (del, expire, rename, and so on). |
aws.memorydb.keys_tracked
(count) | The number of keys being tracked by Redis key tracking. This is limited by the parameter tracking-table-max-keys. |
aws.memorydb.keyspace_hits
(count) | The number of successful read-only key lookups in the main dictionary. |
aws.memorydb.keyspace_misses
(count) | The number of unsuccessful read-only key lookups in the main dictionary. |
aws.memorydb.list_based_cmds
(count) | The total number of commands that are list-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more lists (lindex, lrange, lpush, ltrim, and so on). |
aws.memorydb.max_replication_throughput
(gauge) | The maximum observed replication throughput during the last measurement cycle.
Shown as byte |
aws.memorydb.memory_fragmentation_ratio
(gauge) | The ratio between Redis's resident set size and the amount of allocated memory. A ratio less than 1.0 indicates swap usage, which makes Redis slower. This is calculated from the mem_fragmentation_ratio statistic of Redis INFO. |
aws.memorydb.network_bandwidth_in_allowance_exceeded
(count) | The number of packets shaped because the inbound aggregate bandwidth exceeded the maximum for the instance.
Shown as packet |
aws.memorydb.network_bandwidth_out_allowance_exceeded
(count) | The number of packets shaped because the outbound aggregate bandwidth exceeded the maximum for the instance.
Shown as packet |
aws.memorydb.network_bytes_in
(count) | The number of bytes the host has read from the network.
Shown as byte |
aws.memorydb.network_bytes_out
(count) | The number of bytes sent out on all network interfaces by the instance.
Shown as byte |
aws.memorydb.network_conntrack_allowance_exceeded
(count) | The number of packets shaped because connection tracking exceeded the maximum for the instance and new connections could not be established.
Shown as packet |
aws.memorydb.network_packets_in
(count) | The number of packets received on all network interfaces by the instance.
Shown as packet |
aws.memorydb.network_packets_out
(count) | The number of packets sent out on all network interfaces by the instance.
Shown as packet |
aws.memorydb.network_packets_per_second_allowance_exceeded
(count) | The number of packets shaped because the bidirectional packets per second exceeded the maximum for the instance.
Shown as packet |
aws.memorydb.new_connections
(count) | The total number of connections that have been accepted by the server during this period.
Shown as connection |
aws.memorydb.non_key_type_cmds
(count) | The total number of commands that are not key-based. This is derived from the Redis commandstats statistics by summing all of the commands that do not act upon a key, for example, acl, dbsize, or info. |
aws.memorydb.num_items_read_from_disk
(count) | The total number of items retrieved from disk per minute. Supported only for clusters using data tiering. |
aws.memorydb.num_items_written_to_disk
(count) | The total number of items written to disk per minute. Supported only for clusters using data tiering. |
aws.memorydb.primary_link_health_status
(gauge) | This status has two values: 0 or 1. The value 0 indicates that data in the MemoryDB primary node is not in sync with Redis on EC2. The value of 1 indicates that the data is in sync. |
aws.memorydb.pub_sub_based_cmds
(count) | The total number of commands for pub/sub functionality. This is derived from the Redis commandstats statistics by summing all of the commands used for pub/sub functionality: psubscribe, publish, pubsub, punsubscribe, subscribe, and unsubscribe. |
aws.memorydb.reclaimed
(count) | The total number of key expiration events. |
aws.memorydb.replication_bytes
(count) | The number of bytes that the primary is sending to all of its replicas.
Shown as byte |
aws.memorydb.replication_delayed_write_commands
(count) | Number of commands that were delayed due to exceeding the maximum replication throughput. |
aws.memorydb.replication_lag
(gauge) | The amount of delay, in seconds, between applying changes to the primary node and applying changes to a read replica. Only applicable for a node running as a read replica.
Shown as second |
aws.memorydb.set_based_cmds
(count) | The total number of commands that are set-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more sets (scard, sdiff, sadd, sunion, and so on). |
aws.memorydb.set_type_cmds
(count) | The total number of write-type commands. This is derived from the Redis commandstats statistics by summing all of the mutative types of commands that operate on data (set, hset, sadd, lpop, and so on). |
aws.memorydb.sorted_set_based_cmds
(count) | The total number of commands that are sorted set-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more sorted sets (zcount, zrange, zrank, zadd, and so on). |
aws.memorydb.stream_based_cmds
(count) | The total number of commands that are stream-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more streams data types (xrange, xlen, xadd, xdel, and so on). |
aws.memorydb.string_based_cmds
(count) | The total number of commands that are string-based. This is derived from the Redis commandstats statistics by summing all of the commands that act upon one or more strings (strlen, setex, setrange, and so on). |
aws.memorydb.swap_usage
(gauge) | The amount of swap used on the host.
Shown as byte |
