--- title: Amazon RDS description: Set up, operate, and scale relational databases in the cloud. breadcrumbs: Docs > Integrations > Amazon RDS --- > For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt). # Amazon RDS Integration version1.2.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 %} Amazon Relational Database Service (RDS) is a web service used to setup, operate, and scale a relational database in the cloud. Enable this integration to see all your RDS metrics in Datadog. **Note**: Ensure the environment variable `DD_SITE` is set to your region outside of the code, , or set the variable in the code as follows: `DD_SITE = os.getenv("DD_SITE", default=" ")` There are three options for monitoring RDS instances: Standard, Enhanced, and Native. **Review the full list of metrics before choosing a configuration** as each metric is labeled with its corresponding configuration. In addition, review the information below to learn more about each configuration's requirements and preset dashboard: Additionally, [Performance Insights](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_PerfInsights.html) database load metrics (`aws.rds.dbload*`) are available if Performance Insights is enabled on the RDS instance in AWS. {% tab title="Standard" %} The standard integration requires enabling RDS under the `Metric Collection` tab of the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services). This allows you to receive metrics about your instance as often as your CloudWatch integration allows. All RDS Engine types are supported. The preset dashboard for this integration includes the following metric information: connection, replication lag, read operations and latency, computer, RAM, write operations and latency, and disk metrics. {% /tab %} {% tab title="Enhanced" %} The enhanced integration requires additional configuration and is available for MySQL, Aurora, MariaDB, SQL Server, Oracle, and PostgreSQL engines. Additional metrics are available but an AWS Lambda is required to submit the metrics to Datadog. The higher granularity and additional required services may result in additional AWS charges. The preset dashboard for this integration includes the following metric information: loads, uptime, CPU Utilization, tasks, memory, SWAP, network receive, network transmit, CPU used per process, memory used per process, disk ops, filesystem used (pct), tasks running, and system CPU utilization. {% /tab %} {% tab title="Native" %} The native database integration is optional and available for MySQL, Aurora, MariaDB, SQL Server, and PostgreSQL engine types. To get the metrics from RDS and the ones from the native integration to match up, use the `dbinstanceidentifier` tag on the native integration based on the identifier you assign to the RDS instance. The RDS instances are automatically assigned the tag. There are 3 preset dashboards available for this configuration: MySQL, Aurora, and PostgreSQL. Each dashboard includes the following metric information: query volume, disk I/O, connections, replication, and AWS resource metrics. **Note**: These dashboards display metrics both from AWS CloudWatch and from the individual database engine itself. Enable one of the integrations, [MySQL](https://docs.datadoghq.com/integrations/mysql.md), [Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_SettingUp_Aurora.html), or [PostgreSQL](https://docs.datadoghq.com/integrations/postgres.md), for all integration metrics. {% /tab %} ## Setup{% #setup %} ### Installation{% #installation %} {% tab title="Standard" %} For the standard RDS integration, set up the [Amazon Web Services integration](https://app.datadoghq.com/integrations/amazon-web-services) first. {% /tab %} {% tab title="Enhanced" %} Enable enhanced monitoring for your RDS instance during instance creation or afterwards by choosing **Modify** under **Instance Actions**. It is recommended to choose `15` for Monitoring Granularity. The following instructions use KMS and the Lambda Management Console to create an encrypted version of your Datadog API key which can only be used with the RDS Enhanced Monitoring Lambda function. If you already have an encrypted API key from another Lambda such as the [Log Forwarder](https://docs.datadoghq.com/serverless/forwarder.md), see [the Lambda function's README](https://github.com/DataDog/datadog-serverless-functions/tree/master/aws/rds_enhanced_monitoring#setup) for other options. #### Create your KMS key{% #create-your-kms-key %} 1. Open the KMS home at [https://console.aws.amazon.com/kms/home](https://console.aws.amazon.com/kms/home). 1. Go into **Customer managed keys**. 1. Choose **Create Key**. 1. Enter an Alias for the key, such as `lambda-datadog-key`. *Note: An alias cannot begin with aws. Aliases that begin with aws are reserved by Amazon Web Services to represent AWS-managed CMKs in your account.* 1. Add the appropriate administrators to determine who can administer this key. 1. No roles need to be added. 1. Save your KMS key. #### Create your Lambda application{% #create-your-lambda-application %} 1. From the [Lambda management console](https://console.aws.amazon.com/lambda/), create a new Lambda application. **Note**: Your Lambda application must be in the same region as the KMS key you created. 1. Choose the **Serverless application** tab. 1. Search for and select `Datadog-RDS-Enhanced`. 1. Give the application a unique name. 1. In the **KMSKeyId** field, paste the ID of the key created in the previous section. 1. Click **Deploy**. #### Configure encryption with KMS{% #configure-encryption-with-kms %} 1. After the application is deployed, click its **Logical ID** value in the **Resources** section to open the Lambda function. 1. Choose the **Configuration** tab. 1. Click the **Environment variables** option from the menu on the left. 1. Click **Edit**. 1. For the `kmsEncryptedKeys` environment variable, add your [Datadog API key](https://app.datadoghq.com/organization-settings/api-keys) value in the **Value** field, in JSON format: `{"api_key":""}`. 1. Select **Enable helpers for encryption in transit**. 1. Ensure that **Use a customer master key** is selected, and the ARN of the KMS key created earlier is entered in the **Customer master key** field. 1. Click **Encrypt** next to the `kmsEncryptedKeys` environment variable value. 1. In the popup, select the same KMS key created earlier. 1. Click **Encrypt**. 1. Click **Save**. #### Add a trigger to your CloudWatch log group{% #add-a-trigger-to-your-cloudwatch-log-group %} 1. On the page of the created Lambda function, click **Add trigger**. 1. Under **Trigger configuration**, select **CloudWatch Logs**. 1. Under **Log group**, select the `RDSOSMetrics` CloudWatch log group. 1. Give the filter a name, and optionally specify a filter pattern. 1. Click **Add**. **Note**: You can't create test events under the **Test** tab with this setup. {% /tab %} {% tab title="Native" %} 1. Navigate to the AWS Console and open the RDS section to find the instance you want to monitor. 1. Make note of the endpoint URL, for example: **mysqlrds.blah.us-east1.rds.amazonaws.com:3306**, which is used to configure the Agent. Also make a note of the `DB Instance identifier`, for example: **mysqlrds**, which is used to create graphs and dashboards. {% /tab %} ### Configuration{% #configuration %} {% tab title="Standard" %} 1. In the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `RDS` 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 RDS metrics. For more information, see the [RDS policies](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/security_iam_service-with-iam.html) on the AWS website. | AWS Permission | Description | | ------------------------- | ------------------------------------ | | `rds:DescribeDBInstances` | Describe RDS instances to add tags. | | `rds:ListTagsForResource` | Add custom tags on RDS instances. | | `rds:DescribeEvents` | Add events related to RDS databases. | 1. Install the [Datadog - Amazon RDS integration](https://app.datadoghq.com/integrations/amazon-rds). {% /tab %} {% tab title="Enhanced" %} 1. In the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `RDS` 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 RDS metrics. For more information, see the [RDS policies](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/security_iam_service-with-iam.html) on the AWS website. | AWS Permission | Description | | ------------------------- | ------------------------------------ | | `rds:DescribeDBInstances` | Describe RDS instances to add tags. | | `rds:ListTagsForResource` | Add custom tags on RDS instances. | | `rds:DescribeEvents` | Add events related to RDS databases. | 1. Install the [Datadog - Amazon RDS integration](https://app.datadoghq.com/integrations/amazon-rds). {% /tab %} {% tab title="Native" %} Configure an Agent and connect to your RDS instance by editing the appropriate yaml file in your conf.d directory and then restart your Agent: For RDS Aurora, edit the YAML file of the database flavor you are using. If you are using MySQL or MariaDB, then edit `mysql.yaml`: ```yaml init_config: instances: # The endpoint URL from the AWS console - server: 'mysqlrds.blah.us-east-1.rds.amazonaws.com' user: '' pass: '' port: 3306 tags: - 'dbinstanceidentifier:' ``` If you are using PostgreSQL, then edit `postgres.yaml`: ```yaml init_config: instances: - host: 'postgresqlrds.blah.us-east-1.rds.amazonaws.com' port: 5432 username: '' password: '' dbname: '' tags: - 'dbinstanceidentifier:' ``` If you are using Microsoft SQL Server, then edit `sqlserver.yaml`: ```yaml init_config: instances: - host: 'sqlserverrds.blah.us-east-1.rds.amazonaws.com,1433' username: '' password: '' tags: - 'dbinstanceidentifier:' ``` ### Validation{% #validation %} [Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands.md#agent-information) and look for something like this under the Checks section: ```shell Checks ====== [...] mysql ----- - instance #0 [OK] - Collected 8 metrics & 0 events ``` {% /tab %} ### Usage{% #usage %} After a few minutes, RDS metrics and [metrics from MySQL, Aurora, MariaDB, SQL Server, Oracle, or PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Aurora.Monitoring.html) are accessible in Datadog from the metrics explorer, [dashboards](https://docs.datadoghq.com/dashboards.md), and [alerts](https://docs.datadoghq.com/monitors.md). Here's an example of an Aurora dashboard displaying several metrics from both RDS and the MySQL integration. Metrics from both integrations on the instance `quicktestrds` are unified using the `dbinstanceidentifier` tag. ### Log collection{% #log-collection %} #### Enable logging{% #enable-logging %} It is possible to forward MySQL, MariaDB, and Postgres logs to Amazon CloudWatch. Follow instructions in [Monitor Amazon Aurora MySQL, Amazon RDS for MySQL and MariaDB logs with Amazon CloudWatch](https://aws.amazon.com/blogs/database/monitor-amazon-rds-for-mysql-and-mariadb-logs-with-amazon-cloudwatch) to start sending your RDS logs to CloudWatch. #### Send logs to Datadog{% #send-logs-to-datadog %} **Note**: Datadog's [automatic trigger setup](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md?tab=awsconsole#automatically-set-up-triggers) is available for CloudWatch log groups only. For S3 buckets, use the [manual trigger setup](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md#collecting-logs-from-s3-buckets). 1. If you haven't already, set up the [Datadog log collection AWS Lambda function](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md). 1. Once the Lambda function is installed, manually add a trigger on the CloudWatch log group that contains your RDS logs. Select the corresponding CloudWatch log group, add a filter name (optional), and add the trigger. Once done, go in your [Datadog Log section](https://app.datadoghq.com/logs) to explore your logs. ## Data Collected{% #data-collected %} In addition to the [metrics collected from the database engines](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Aurora.Monitoring.html), you also receive the following RDS metrics. ### Metrics{% #metrics %} | | | | | **aws.rds.backup_retention_period_storage_used**(gauge) | The amount of backup storage used for storing continuous backups at the current time. Only available for Aurora DBs.*Shown as byte* | | **aws.rds.burst_balance**(gauge) | The percent of General Purpose SSD (gp2) burst-bucket I/O credits available. Only available for non-Aurora DBs.*Shown as percent* | | **aws.rds.cpucredit_balance**(gauge) | [T2 instances] Number of CPU credits that an instance has accumulated. Available for Aurora DBs. | | **aws.rds.cpucredit_usage**(gauge) | [T2 instances] Number of CPU credits consumed. Available for Aurora DBs. | | **aws.rds.cpusurplus_credit_balance**(gauge) | The number of surplus credits that have been spent by an unlimited instance when its CPUCreditBalance value is zero. | | **aws.rds.cpusurplus_credits_charged**(gauge) | The number of spent surplus credits that are not paid down by earned CPU credits, and which thus incur an additional charge. | | **aws.rds.cpuutilization**(gauge) | Percentage of CPU utilization. Recommended metric for standard monitoring. Available for Aurora DBs.*Shown as percent* | | **aws.rds.cpuutilization.maximum**(gauge) | Maximum percentage of CPU utilization.*Shown as percent* | | **aws.rds.data_volume_iopsexceeded_check**(gauge) | Indicates whether the IOPS of the data volume reached its limit during the period. A value of 1 means the limit was reached. | | **aws.rds.data_volume_throughput_exceeded_check**(gauge) | Indicates whether the throughput of the data volume reached its limit during the period. A value of 1 means the limit was reached. | | **aws.rds.database_connections**(gauge) | Number of database connections in use. Available for Aurora DBs.*Shown as connection* | | **aws.rds.disk_queue_depth**(gauge) | Number of outstanding IOs (read/write requests) waiting to access the disk. Available for Aurora DBs.*Shown as request* | | **aws.rds.disk_queue_depth_log_volume**(gauge) | The number of outstanding I/Os (read and write requests) waiting to access the log volume disk.*Shown as request* | | **aws.rds.ebsbyte_balance**(gauge) | The percentage of throughput credits remaining in the burst bucket of the RDS database. Available for basic monitoring only. The value is based on the throughput of all volumes, including the root volume.*Shown as percent* | | **aws.rds.ebsiobalance**(gauge) | The percentage of I/O credits remaining in the burst bucket of the RDS database. Available for basic monitoring only. The value is based on the IOPS of all volumes, including the root volume. This metric is different from BurstBalance.*Shown as percent* | | **aws.rds.engine_uptime**(gauge) | The amount of time that the DB instance has been active. Only available for Aurora DBs.*Shown as second* | | **aws.rds.free_ephemeral_storage**(gauge) | The amount of available ephemeral NVMe storage.*Shown as byte* | | **aws.rds.free_storage_space**(gauge) | Amount of available storage space.*Shown as byte* | | **aws.rds.free_storage_space_log_volume**(gauge) | The amount of available storage space on the log volume.*Shown as byte* | | **aws.rds.freeable_memory**(gauge) | Amount of available random access memory.*Shown as byte* | | **aws.rds.iam_db_auth_connection_failure**(gauge) | The number of failed connection requests using AWS Identity and Access Management (IAM) authentication to the DB instance.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure.sum**(count) | The number of failed connection requests using AWS Identity and Access Management (IAM) authentication to the DB instance.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_insufficient_permissions**(gauge) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of insufficient permissions.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_insufficient_permissions.sum**(count) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of insufficient permissions.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_invalid_token**(gauge) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of an invalid token.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_invalid_token.sum**(count) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of an invalid token.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_server_error**(gauge) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of a server error.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_server_error.sum**(count) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of a server error.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_throttling**(gauge) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of throttling.*Shown as connection* | | **aws.rds.iam_db_auth_connection_failure_throttling.sum**(count) | The number of connection requests using AWS Identity and Access Management (IAM) authentication that failed because of throttling.*Shown as connection* | | **aws.rds.iam_db_auth_connection_requests**(gauge) | The number of connection requests using AWS Identity and Access Management (IAM) authentication to the DB instance.*Shown as connection* | | **aws.rds.iam_db_auth_connection_requests.sum**(count) | The number of connection requests using AWS Identity and Access Management (IAM) authentication to the DB instance.*Shown as connection* | | **aws.rds.iam_db_auth_connection_success**(gauge) | The number of successful connection requests using AWS Identity and Access Management (IAM) authentication to the DB instance.*Shown as connection* | | **aws.rds.iam_db_auth_connection_success.sum**(count) | The number of successful connection requests using AWS Identity and Access Management (IAM) authentication to the DB instance.*Shown as connection* | | **aws.rds.instance_ebsiopsexceeded_check**(gauge) | Indicates whether the Amazon Elastic Block Store (EBS) IOPS limit of the DB instance was reached during the period. A value of 1 means the limit was reached. | | **aws.rds.instance_ebsthroughput_exceeded_check**(gauge) | Indicates whether the Amazon Elastic Block Store (EBS) throughput limit of the DB instance was reached during the period. A value of 1 means the limit was reached. | | **aws.rds.lvmread_iops**(gauge) | The number of read I/O operations per second on the logical volume.*Shown as operation* | | **aws.rds.lvmwrite_iops**(gauge) | The number of write I/O operations per second on the logical volume.*Shown as operation* | | **aws.rds.network_receive_throughput**(rate) | Incoming (Receive) network traffic on the DB instance. Available for Aurora DBs.*Shown as byte* | | **aws.rds.network_throughput**(rate) | The rate of network throughput sent and received from clients by each instance in the DB cluster. Only available for Aurora DBs.*Shown as byte* | | **aws.rds.network_transmit_throughput**(rate) | Outgoing (Transmit) network traffic on the DB instance. Available for Aurora DBs.*Shown as byte* | | **aws.rds.read_iops**(rate) | Average number of disk read I/O operations.*Shown as operation* | | **aws.rds.read_iopsephemeral_storage**(gauge) | The average number of disk read I/O operations per second to ephemeral NVMe storage.*Shown as operation* | | **aws.rds.read_iopslocal_storage**(gauge) | The average number of disk read I/O operations per second to local storage. Applies only to DB instance classes with NVMe SSD instance store volumes.*Shown as operation* | | **aws.rds.read_iopslog_volume**(gauge) | The average number of disk read I/O operations per second for the log volume.*Shown as operation* | | **aws.rds.read_latency**(gauge) | Average amount of time taken per disk read I/O operation.*Shown as second* | | **aws.rds.read_latency_ephemeral_storage**(gauge) | The average amount of time taken per disk read I/O operation for ephemeral NVMe storage.*Shown as second* | | **aws.rds.read_latency_local_storage**(gauge) | The average amount of time taken per disk I/O operation for local storage. Applies only to DB instance classes with NVMe SSD instance store volumes.*Shown as second* | | **aws.rds.read_latency_log_volume**(gauge) | The average amount of time taken per disk I/O operation for the log volume.*Shown as second* | | **aws.rds.read_throughput**(rate) | Average number of bytes read from disk.*Shown as byte* | | **aws.rds.read_throughput_ephemeral_storage**(gauge) | The average number of bytes read from disk per second for ephemeral NVMe storage.*Shown as byte* | | **aws.rds.read_throughput_local_storage**(gauge) | The average number of bytes read from disk per second for local storage. Applies only to DB instance classes with NVMe SSD instance store volumes.*Shown as byte* | | **aws.rds.read_throughput_log_volume**(gauge) | The average number of bytes read from disk per second for the log volume.*Shown as byte* | | **aws.rds.snapshot_storage_used**(gauge) | The amount of backup storage used for storing manual snapshots beyond the backup retention period. Only available for Aurora DBs.*Shown as byte* | | **aws.rds.total_backup_storage_billed**(gauge) | The sum of BackupRetentionPeriodStorageUsed and SnapshotStorageUsed minus an amount of free backup storage which equals the size of the cluster volume for one day. Only available for Aurora DBs.*Shown as byte* | | **aws.rds.v_cpucount**(gauge) | The number of virtual CPUs of the DB instance.*Shown as cpu* | | **aws.rds.write_iops**(rate) | Average number of disk write I/O operations per second.*Shown as operation* | | **aws.rds.write_iopsephemeral_storage**(gauge) | The average number of disk write I/O operations per second to ephemeral NVMe storage.*Shown as operation* | | **aws.rds.write_iopslocal_storage**(gauge) | The average number of disk write I/O operations per second on local storage. Applies only to DB instance classes with NVMe SSD instance store volumes.*Shown as operation* | | **aws.rds.write_iopslog_volume**(gauge) | The average number of disk write I/O operations per second for the log volume.*Shown as operation* | | **aws.rds.write_latency**(gauge) | Average amount of time taken per disk write I/O operation.*Shown as second* | | **aws.rds.write_latency_ephemeral_storage**(gauge) | The average amount of time taken per disk write I/O operation for ephemeral NVMe storage.*Shown as second* | | **aws.rds.write_latency_local_storage**(gauge) | The average amount of time taken per disk I/O operation on local storage. Applies only to DB instance classes with NVMe SSD instance store volumes.*Shown as second* | | **aws.rds.write_latency_log_volume**(gauge) | The average amount of time taken per disk I/O operation for the log volume.*Shown as second* | | **aws.rds.write_throughput**(rate) | Average number of bytes written.*Shown as byte* | | **aws.rds.write_throughput_ephemeral_storage**(gauge) | The average number of bytes written to disk per second for ephemeral NVMe storage.*Shown as byte* | | **aws.rds.write_throughput_local_storage**(gauge) | The average number of bytes written to disk per second for local storage. Applies only to DB instance classes with NVMe SSD instance store volumes.*Shown as byte* | | **aws.rds.write_throughput_log_volume**(gauge) | The average number of bytes written to disk per second for the log volume.*Shown as byte* | | **aws.rds.active_transactions**(gauge) | The average rate of current transactions executing on a DB instance. Only available for Aurora MySQL DBs.*Shown as transaction* | | **aws.rds.acuconfigured_max**(gauge) | The maximum Aurora capacity unit (ACU) value configured for the Aurora Serverless DB cluster. | | **aws.rds.acuconfigured_min**(gauge) | The minimum Aurora capacity unit (ACU) value configured for the Aurora Serverless DB cluster. | | **aws.rds.acuutilization**(gauge) | The percentage of the maximum ACU value of the DB cluster that is in use, calculated as ServerlessDatabaseCapacity divided by the maximum ACU value. Applies only to Aurora Serverless.*Shown as percent* | | **aws.rds.acuutilization.maximum**(gauge) | The highest percentage of the maximum Aurora capacity unit (ACU) value of the DB cluster that is in use during the period. Applies only to Aurora Serverless.*Shown as percent* | | **aws.rds.aurora_analytics_active_threads**(gauge) | The number of active threads used by Aurora analytics queries.*Shown as thread* | | **aws.rds.aurora_analytics_cache_hit**(gauge) | The cache hits of Aurora analytics queries. | | **aws.rds.aurora_analytics_cache_size**(gauge) | The size of the Aurora analytics cache. | | **aws.rds.aurora_analytics_disk_spill_size**(gauge) | The amount of data that Aurora analytics queries spilled to disk. | | **aws.rds.aurora_analytics_memory_usage**(gauge) | The memory used by Aurora analytics queries. | | **aws.rds.aurora_analytics_remote_read**(gauge) | The reads that Aurora analytics queries performed from remote storage. | | **aws.rds.aurora_analytics_s_3get_request**(count) | The number of Amazon S3 GET requests made by Aurora analytics queries.*Shown as request* | | **aws.rds.aurora_analytics_s_3head_request**(count) | The number of Amazon S3 HEAD requests made by Aurora analytics queries.*Shown as request* | | **aws.rds.aurora_binlog_replica_lag**(gauge) | The amount of time a replica DB cluster running on Aurora with MySQL compatibility lags behind the source DB cluster. Only available for Aurora MySQL DBs.*Shown as second* | | **aws.rds.aurora_dmlrejected_master_full**(count) | The number of forwarded queries rejected because the session is full on the writer DB instance. Applies to Aurora MySQL version 2.*Shown as query* | | **aws.rds.aurora_dmlrejected_writer_full**(count) | The number of forwarded queries rejected because the session is full on the writer DB instance. Applies to Aurora MySQL version 3.*Shown as query* | | **aws.rds.aurora_estimated_shared_memory_bytes**(gauge) | The estimated amount of shared buffer or buffer pool memory actively used during the last configured polling interval. Applies to Aurora PostgreSQL.*Shown as byte* | | **aws.rds.aurora_memory_health_state**(gauge) | The memory health state. 0 means healthy (no memory pressure), 5 means moderate memory pressure, and 10 means critical memory pressure. | | **aws.rds.aurora_memory_num_declined_sql_total**(gauge) | The number of queries declined as part of out-of-memory (OOM) avoidance.*Shown as query* | | **aws.rds.aurora_memory_num_kill_conn_total**(gauge) | The number of connections closed as part of OOM avoidance.*Shown as connection* | | **aws.rds.aurora_memory_num_kill_query_total**(gauge) | The number of queries terminated as part of OOM avoidance.*Shown as query* | | **aws.rds.aurora_milliseconds_spent_in_oom_recovery**(gauge) | The amount of time since memory health dropped below the normal state.*Shown as millisecond* | | **aws.rds.aurora_num_oom_recovery_successful**(gauge) | The number of times memory health was restored to the normal state. | | **aws.rds.aurora_num_oom_recovery_triggered**(gauge) | The number of times memory health dropped below the normal state. | | **aws.rds.aurora_optimized_reads_cache_hit_ratio**(gauge) | The percentage of requests served by the Optimized Reads cache, calculated as orcache_blks_hit / (orcache_blks_hit + storage_blks_read). Applies to the primary instance of Aurora PostgreSQL.*Shown as percent* | | **aws.rds.aurora_replica_lag**(gauge) | The average lag when replicating updates from the primary instance. Only available for Aurora DBs.*Shown as millisecond* | | **aws.rds.aurora_replica_lag_maximum**(gauge) | The maximum amount of lag between the primary instance and each Aurora instance in the DB cluster. Only available for Aurora DBs.*Shown as millisecond* | | **aws.rds.aurora_replica_lag_minimum**(gauge) | The minimum amount of lag between the primary instance and each Aurora instance in the DB cluster. Only available for Aurora DBs.*Shown as millisecond* | | **aws.rds.aurora_slow_connection_handle_count**(gauge) | The number of connections that waited 2 seconds or longer to start the handshake. Applies to Aurora MySQL version 3.*Shown as connection* | | **aws.rds.aurora_slow_connection_handle_count.sum**(count) | The number of connections that waited two seconds or longer to start the handshake. Applies to Aurora MySQL version 3.*Shown as connection* | | **aws.rds.aurora_slow_handshake_count**(gauge) | The number of connections that took 50 milliseconds or longer to finish the handshake. Applies to Aurora MySQL version 3.*Shown as connection* | | **aws.rds.aurora_slow_handshake_count.sum**(count) | The number of connections that took 50 milliseconds or longer to finish the handshake. Applies to Aurora MySQL version 3.*Shown as connection* | | **aws.rds.aurora_temp_table_volume_total_bytes**(gauge) | The total size of the temporary table volume.*Shown as byte* | | **aws.rds.aurora_volume_bytes_left_total**(gauge) | The remaining available space for the cluster volume. As the cluster volume grows, this value decreases. If it reaches zero, the cluster reports an out-of-space error.*Shown as byte* | | **aws.rds.average_data_throughput**(gauge) | The average data throughput of the Aurora change-log streaming task. | | **aws.rds.average_request_throughput**(gauge) | The average request throughput of the Aurora change-log streaming task. | | **aws.rds.backtrack_change_records_creation_rate**(gauge) | The number of backtrack change records created over 5 minutes for the DB cluster.*Shown as record* | | **aws.rds.backtrack_change_records_stored**(gauge) | The number of backtrack change records used by the DB cluster.*Shown as record* | | **aws.rds.backtrack_window_actual**(gauge) | The difference between the target backtrack window and the actual backtrack window.*Shown as minute* | | **aws.rds.backtrack_window_alert**(count) | The number of times the actual backtrack window was smaller than the target backtrack window for a given period of time. | | **aws.rds.bin_log_disk_usage**(gauge) | Amount of disk space occupied by binary logs on the master. Only available for non-Aurora DBs.*Shown as byte* | | **aws.rds.blocked_transactions**(count) | The average rate of transactions in the database that are blocked. Only available for Aurora MySQL DBs.*Shown as transaction* | | **aws.rds.buffer_cache_hit_ratio**(gauge) | The percentage of requests that are served by the Buffer cache. Only available for Aurora DBs.*Shown as percent* | | **aws.rds.change_log_bytes_used**(gauge) | The amount of storage used by the cluster change log.*Shown as byte* | | **aws.rds.change_log_read_iops**(count) | The number of read I/O operations on the cluster change log, reported at 5-minute intervals.*Shown as operation* | | **aws.rds.change_log_write_iops**(count) | The number of write I/O operations on the cluster change log, reported at 5-minute intervals.*Shown as operation* | | **aws.rds.changelog_bytes_read**(count) | The number of bytes read from the change log by the streaming task.*Shown as byte* | | **aws.rds.commit_latency**(gauge) | The amount of latency for committed transactions. Only available for Aurora DBs.*Shown as millisecond* | | **aws.rds.commit_throughput**(rate) | The average rate of committed transactions. Only available for Aurora DBs.*Shown as transaction* | | **aws.rds.dbaurora_blocks_read_times**(gauge) | The time spent reading blocks from Aurora storage. | | **aws.rds.dbaurora_optimized_reads_block_read_time**(gauge) | The time spent reading blocks from the Optimized Reads cache. | | **aws.rds.dbaurora_optimized_reads_cache_hits**(gauge) | The number of blocks served from the Optimized Reads cache.*Shown as block* | | **aws.rds.dbaurora_storage_blocks_read**(gauge) | The number of blocks read from Aurora storage.*Shown as block* | | **aws.rds.ddllatency**(gauge) | The amount of latency for DDL requests (create/alter/drop). Only available for Aurora MySQL DBs.*Shown as millisecond* | | **aws.rds.ddlthroughput**(rate) | The average rate of DDL requests per second. Only available for Aurora MySQL DBs.*Shown as request* | | **aws.rds.deadlocks**(count) | The average number of deadlocks in the database per second. Only available for Aurora DBs.*Shown as lock* | | **aws.rds.delete_latency**(gauge) | The average latency for delete queries. Only available for Aurora MySQL DBs.*Shown as millisecond* | | **aws.rds.delete_throughput**(rate) | The average rate of delete queries. Only available for Aurora MySQL DBs.*Shown as query* | | **aws.rds.dmllatency**(gauge) | The average latency for inserts and updates and deletes. Only available for Aurora MySQL DBs.*Shown as millisecond* | | **aws.rds.dmlthroughput**(rate) | The average rate of inserts and updates and deletes. Only available for Aurora MySQL DBs.*Shown as operation* | | **aws.rds.failed_streaming_requests**(count) | The number of failed requests of the change-log streaming task.*Shown as request* | | **aws.rds.free_local_storage**(gauge) | The amount of local storage that is free on an instance. Only available for Aurora DBs.*Shown as byte* | | **aws.rds.free_local_storage_percent**(gauge) | The percentage of available local storage space. Applies only to DB instance classes with NVMe SSD instance store volumes.*Shown as percent* | | **aws.rds.insert_latency**(gauge) | The amount of latency for insert queries. Only available for Aurora MySQL DBs.*Shown as millisecond* | | **aws.rds.insert_throughput**(rate) | The average rate of insert queries. Only available for Aurora MySQL DBs.*Shown as query* | | **aws.rds.login_failures**(count) | The average number of failed login attempts per second. Only available for Aurora MySQL DBs.*Shown as operation* | | **aws.rds.num_active_transactions**(gauge) | The number of active transactions.*Shown as transaction* | | **aws.rds.num_binary_log_files**(gauge) | The number of binlog files generated.*Shown as file* | | **aws.rds.num_undo_row_operations**(gauge) | The total number of rows modified in current active transactions. Applies to Aurora MySQL version 3.08 and higher.*Shown as row* | | **aws.rds.out_of_memory_kill_count**(count) | The number of out-of-memory (OOM) kills that happened over the last collection interval. | | **aws.rds.purge_boundary**(gauge) | The transaction number up to which InnoDB purging is allowed. If this metric doesn't advance for extended periods, long-running transactions are likely blocking InnoDB purging. | | **aws.rds.purge_finished_point**(gauge) | The transaction number up to which InnoDB purging is performed. Use it to examine how fast InnoDB purging is progressing. | | **aws.rds.queries**(rate) | The average rate of queries. Only available for Aurora MySQL DBs.*Shown as query* | | **aws.rds.rdsto_aurora_postgre_sqlreplica_lag**(gauge) | The amount of lag in seconds when replicating updates from the primary RDS PostgreSQL instance to other nodes in the cluster. Only available for Aurora PostgreSQL DBs.*Shown as second* | | **aws.rds.replica_lag**(gauge) | Amount of time a Read Replica DB Instance lags behind the source DB Instance.*Shown as second* | | **aws.rds.replica_transport_lag**(gauge) | The lag of the replica transport from the source DB instance. | | **aws.rds.result_set_cache_hit_ratio**(gauge) | The percentage of requests that are served by the Resultset cache. Only available for Aurora MySQL DBs.*Shown as percent* | | **aws.rds.rollback_segment_history_list_length**(gauge) | The length of the undo logs that record committed transactions with delete-marked records, which are scheduled to be processed by the InnoDB purge operation. | | **aws.rds.row_lock_time**(gauge) | The total time spent acquiring row locks for InnoDB tables.*Shown as millisecond* | | **aws.rds.select_latency**(gauge) | The average latency for select queries. Only available for Aurora MySQL DBs.*Shown as millisecond* | | **aws.rds.select_throughput**(rate) | The average rate of select queries. Only available for Aurora MySQL DBs.*Shown as query* | | **aws.rds.serverless_database_capacity**(gauge) | The current capacity of an Aurora Serverless DB cluster. | | **aws.rds.storage_network_receive_throughput**(rate) | The amount of network throughput received from the Aurora storage subsystem by each instance in the DB cluster.*Shown as byte* | | **aws.rds.storage_network_throughput**(rate) | The amount of network throughput received from and sent to the Aurora storage subsystem by each instance in the DB cluster.*Shown as byte* | | **aws.rds.storage_network_transmit_throughput**(rate) | The amount of network throughput sent to the Aurora storage subsystem by each instance in the DB cluster.*Shown as byte* | | **aws.rds.streamed_bytes**(count) | The number of bytes streamed by the change-log streaming task.*Shown as byte* | | **aws.rds.streaming_request_latency**(gauge) | The latency of the requests of the change-log streaming task. | | **aws.rds.sum_binary_log_size**(gauge) | The total size of the binlog files.*Shown as byte* | | **aws.rds.temp_storage_iops**(rate) | The number of IOPS for both reads and writes on local storage attached to the DB instance, measured once per second. Applies only to Aurora Serverless.*Shown as operation* | | **aws.rds.temp_storage_throughput**(rate) | The amount of data transferred to and from local storage associated with the DB instance, measured once per second. Applies only to Aurora Serverless.*Shown as byte* | | **aws.rds.time_lag**(gauge) | The time lag of the change-log streaming task. | | **aws.rds.transaction_age_maximum**(gauge) | The age of the oldest active running transaction. Applies to Aurora MySQL version 3.08 and higher.*Shown as second* | | **aws.rds.transaction_age_maximum.maximum**(gauge) | The maximum age of the oldest active running transaction. Applies to Aurora MySQL version 3.08 and higher.*Shown as second* | | **aws.rds.truncate_finished_point**(gauge) | The transaction identifier up to which undo truncation is performed. | | **aws.rds.trx_rseg_history_len**(gauge) | The length of the list of undo log pages for committed transactions that the InnoDB transaction system maintains to run purge operations. | | **aws.rds.update_latency**(gauge) | The average latency for update queries. Only available for Aurora MySQL DBs.*Shown as millisecond* | | **aws.rds.update_throughput**(rate) | The average rate of update queries. Only available for Aurora MySQL DBs.*Shown as query* | | **aws.rds.volume_bytes_used**(gauge) | The amount of storage in bytes used by your Aurora database. Only available for Aurora DBs.*Shown as byte* | | **aws.rds.volume_read_iops**(count) | The number of billed read I/O operations from a cluster volume, reported at 5-minute intervals. Only available for Aurora DBs.*Shown as operation* | | **aws.rds.volume_write_iops**(count) | The average number of write disk I/O operations to the cluster volume reported at 5-minute intervals. Only available for Aurora DBs.*Shown as operation* | | **aws.rds.aurora_forwarding_replica_commit_throughput**(rate) | The number of commits in sessions forwarded by this replica each second.*Shown as transaction* | | **aws.rds.aurora_forwarding_replica_dmllatency**(gauge) | The average response time of forwarded DML statements on the replica.*Shown as millisecond* | | **aws.rds.aurora_forwarding_replica_dmlthroughput**(rate) | The number of forwarded DML statements processed on this replica each second.*Shown as operation* | | **aws.rds.aurora_forwarding_replica_error_sessions_limit**(count) | The number of sessions rejected by the primary cluster because the limit for maximum connections or maximum write-forwarding connections was reached.*Shown as session* | | **aws.rds.aurora_forwarding_replica_open_sessions**(gauge) | The number of sessions using write forwarding on a replica instance.*Shown as session* | | **aws.rds.aurora_forwarding_replica_read_wait_latency**(gauge) | The average time the replica waits to be consistent with the log sequence number (LSN) of the primary cluster.*Shown as millisecond* | | **aws.rds.aurora_forwarding_writer_dmlthroughput**(rate) | The number of forwarded DML statements processed each second by this writer DB instance.*Shown as operation* | | **aws.rds.aurora_forwarding_writer_open_sessions**(gauge) | The number of open sessions on this writer DB instance processing forwarded queries.*Shown as session* | | **aws.rds.aurora_forwarding_writer_total_sessions**(gauge) | The total number of forwarded sessions on this writer DB instance.*Shown as session* | | **aws.rds.aurora_global_dbdata_transfer_bytes**(gauge) | The amount of redo log data transferred from the source AWS Region to a secondary AWS Region in an Aurora global database. Available only in secondary AWS Regions.*Shown as byte* | | **aws.rds.aurora_global_dbdata_transfer_bytes.sum**(count) | The amount of redo log data transferred from the source AWS Region to a secondary AWS Region in an Aurora global database. Available only in secondary AWS Regions.*Shown as byte* | | **aws.rds.aurora_global_dbprogress_lag**(gauge) | The amount of time the storage volume of the secondary cluster is behind the storage volume of the primary cluster for user and system transactions in an Aurora global database. Available only in secondary AWS Regions.*Shown as millisecond* | | **aws.rds.aurora_global_dbreplicated_write_io**(gauge) | The number of write I/O operations replicated from the primary AWS Region to the cluster volume in a secondary AWS Region of an Aurora global database.*Shown as operation* | | **aws.rds.aurora_global_dbreplicated_write_io.sum**(count) | The number of write I/O operations replicated from the primary AWS Region to the cluster volume in a secondary AWS Region of an Aurora global database.*Shown as operation* | | **aws.rds.aurora_global_dbreplication_lag**(gauge) | The average time elapsed replicating updates between the replication server of the primary cluster and the replication server of the secondary cluster in an Aurora global database. Available only in secondary AWS Regions.*Shown as millisecond* | | **aws.rds.aurora_global_dbrpolag**(gauge) | The recovery point objective (RPO) lag of an Aurora global database, which measures how far the secondary cluster is behind the primary cluster for user transactions. Available only in secondary AWS Regions.*Shown as millisecond* | | **aws.rds.aurora_local_forwarding_writer_dmlthroughput**(rate) | The number of local forwarded DML statements processed each second by this writer DB instance.*Shown as operation* | | **aws.rds.aurora_local_forwarding_writer_open_sessions**(gauge) | The number of open local forwarded sessions on this writer DB instance.*Shown as session* | | **aws.rds.aurora_local_forwarding_writer_total_sessions**(gauge) | The total number of local forwarded sessions on this writer DB instance.*Shown as session* | | **aws.rds.forwarding_master_dmllatency**(gauge) | The average time to process each forwarded DML statement on the writer DB instance, excluding the time to forward the write request and to replicate changes back to the secondary cluster. Applies to Aurora MySQL version 2.*Shown as millisecond* | | **aws.rds.forwarding_master_dmlthroughput**(rate) | The number of forwarded DML statements processed each second by this writer DB instance. Applies to Aurora MySQL version 2.*Shown as operation* | | **aws.rds.forwarding_master_open_sessions**(gauge) | The number of forwarded sessions on the writer DB instance. Applies to Aurora MySQL version 2.*Shown as session* | | **aws.rds.forwarding_replica_dmllatency**(gauge) | The average response time of forwarded DML statements on the reader DB instance.*Shown as millisecond* | | **aws.rds.forwarding_replica_dmlthroughput**(rate) | The number of forwarded DML statements processed each second.*Shown as operation* | | **aws.rds.forwarding_replica_open_sessions**(gauge) | The number of sessions using write forwarding on a reader DB instance.*Shown as session* | | **aws.rds.forwarding_replica_read_wait_latency**(gauge) | The average time a SELECT statement on a reader DB instance waits to catch up to the primary cluster.*Shown as millisecond* | | **aws.rds.forwarding_replica_read_wait_throughput**(rate) | The total number of SELECT statements processed each second in all sessions that are forwarding writes.*Shown as query* | | **aws.rds.forwarding_replica_select_latency**(gauge) | The average latency of forwarded SELECT statements within the monitoring period.*Shown as millisecond* | | **aws.rds.forwarding_replica_select_throughput**(rate) | The average number of forwarded SELECT statements processed each second within the monitoring period.*Shown as query* | | **aws.rds.forwarding_writer_dmllatency**(gauge) | The average time to process each forwarded DML statement on the writer DB instance, excluding the time to forward the write request and to replicate changes back to the secondary cluster. Applies to Aurora MySQL version 3.*Shown as millisecond* | | **aws.rds.forwarding_writer_dmlthroughput**(rate) | The number of forwarded DML statements processed each second by this writer DB instance. Applies to Aurora MySQL version 3.*Shown as operation* | | **aws.rds.forwarding_writer_open_sessions**(gauge) | The number of forwarded sessions on the writer DB instance. Applies to Aurora MySQL version 3.*Shown as session* | | **aws.rds.aurorapqrequestattempted**(count) | The number of parallel query sessions requested.*Shown as session* | | **aws.rds.aurorapqrequestchosenpkrangescan**(count) | The number of times parallel query was chosen for a primary key range scan.*Shown as request* | | **aws.rds.aurorapqrequestexecuted**(count) | The number of parallel query sessions run successfully.*Shown as session* | | **aws.rds.aurorapqrequestfailed**(count) | The number of parallel query sessions that returned an error to the client.*Shown as session* | | **aws.rds.aurorapqrequestinprogress**(gauge) | The number of parallel query sessions currently in progress.*Shown as session* | | **aws.rds.aurorapqrequestnotchosen**(count) | The number of times parallel query wasn't chosen to satisfy a query.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenbelowminrows**(count) | The number of times parallel query wasn't chosen due to the number of rows in the table.*Shown as request* | | **aws.rds.aurorapqrequestnotchosencolumnbit**(count) | The number of parallel query requests that use the nonparallel query processing path because of an unsupported data type in the list of projected columns.*Shown as request* | | **aws.rds.aurorapqrequestnotchosencolumngeometry**(count) | The number of parallel query requests that use the nonparallel query processing path because the table has columns with the GEOMETRY data type.*Shown as request* | | **aws.rds.aurorapqrequestnotchosencolumnlob**(count) | The number of parallel query requests that use the nonparallel query processing path because the table has columns with a LOB data type, or VARCHAR columns that are stored externally due to the declared length.*Shown as request* | | **aws.rds.aurorapqrequestnotchosencolumnvirtual**(count) | The number of parallel query requests that use the nonparallel query processing path because the table contains a virtual column.*Shown as request* | | **aws.rds.aurorapqrequestnotchosencustomcharset**(count) | The number of parallel query requests that use the nonparallel query processing path because the table has columns with a custom character set.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenfastddl**(count) | The number of parallel query requests that use the nonparallel query processing path because the table is currently being altered by a fast DDL ALTER statement.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenfewpagesoutsidebufferpool**(count) | The number of times parallel query wasn't chosen, even though less than 95 percent of the table data was in the buffer pool, because there wasn't enough unbuffered table data to make parallel query worthwhile.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenfulltextindex**(count) | The number of parallel query requests that use the nonparallel query processing path because the table has full-text indexes.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenhighbufferpoolpct**(count) | The number of times parallel query wasn't chosen because a high percentage of the table data (greater than 95 percent) was already in the buffer pool.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenindexhint**(count) | The number of parallel query requests that use the nonparallel query processing path because the query includes an index hint.*Shown as request* | | **aws.rds.aurorapqrequestnotchoseninnodbtableformat**(count) | The number of parallel query requests that use the nonparallel query processing path because the table uses an unsupported InnoDB row format.*Shown as request* | | **aws.rds.aurorapqrequestnotchoseninstantddl**(count) | The number of parallel query requests that use the nonparallel query processing path because the table is being altered by an instant DDL ALTER statement.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenlongtrx**(count) | The number of parallel query requests that used the nonparallel query processing path becuase the query started inside a long-running transaction.*Shown as request* | | **aws.rds.aurorapqrequestnotchosennowhereclause**(count) | The number of parallel query requests that use the nonparallel query processing path because the query doesn't include any WHERE clause.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenrangescan**(count) | The number of parallel query requests that use the nonparallel query processing path because the query uses a range scan on an index.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenrowlengthtoolong**(count) | The number of parallel query requests that use the nonparallel query processing path because the total combined length of all the columns is too long.*Shown as request* | | **aws.rds.aurorapqrequestnotchosensmalltable**(count) | The number of times parallel query wasn't chosen due to the overall size of the table, as determined by number of rows and average row length.*Shown as request* | | **aws.rds.aurorapqrequestnotchosentemporarytable**(count) | The number of parallel query requests that use the nonparallel query processing path because the query refers to temporary tables that use the unsupported MyISAM or memory table types.*Shown as request* | | **aws.rds.aurorapqrequestnotchosentxisolation**(count) | The number of parallel query requests that use the nonparallel query processing path because the query uses an unsupported transaction isolation level.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenunsupportedaccess**(count) | The number of parallel query requests that use the nonparallel query processing path because the WHERE clause doesn't meet the criteria for parallel query.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenunsupportedstoragetype**(count) | The number of parallel query requests that use the nonparallel query processing path because the Aurora MySQL DB cluster isn't using a supported Aurora cluster storage configuration.*Shown as request* | | **aws.rds.aurorapqrequestnotchosenupdatedeletestmts**(count) | The number of parallel query requests that use the nonparallel query processing path because the query is part of an UPDATE or DELETE statement.*Shown as request* | | **aws.rds.aurorapqrequestthrottled**(count) | The number of times parallel query wasn't chosen due to the maximum number of concurrent parallel queries already running on a particular Aurora DB instance.*Shown as request* | | **aws.rds.proxy.availability_percentage**(gauge) | The percentage of time for which the target group was available in its role.*Shown as percent* | | **aws.rds.proxy.client_connections**(gauge) | The current number of client connections.*Shown as connection* | | **aws.rds.proxy.client_connections_closed**(gauge) | The number of client connections closed.*Shown as connection* | | **aws.rds.proxy.client_connections_in_setup**(gauge) | The current number of client connections that are open but have not completed setup.*Shown as connection* | | **aws.rds.proxy.client_connections_in_setup.sum**(gauge) | The current number of client connections that are open but have not completed setup.*Shown as connection* | | **aws.rds.proxy.client_connections_no_tls**(gauge) | The current number of client connections without Transport Layer Security (TLS).*Shown as connection* | | **aws.rds.proxy.client_connections_received**(gauge) | The number of client connection requests received.*Shown as connection* | | **aws.rds.proxy.client_connections_setup_failed_auth**(gauge) | The number of client connection attempts that failed.*Shown as connection* | | **aws.rds.proxy.client_connections_setup_succeeded**(gauge) | The number of client connections successfully established.*Shown as connection* | | **aws.rds.proxy.client_connections_tls**(gauge) | The current cumber of client connections with TLS.*Shown as connection* | | **aws.rds.proxy.database_connection_requests**(gauge) | The number of requests to create a DB connection.*Shown as request* | | **aws.rds.proxy.database_connection_requests_with_tls**(gauge) | The number of requests to create a DB connection with TLS.*Shown as request* | | **aws.rds.proxy.database_connections_borrow_latency**(gauge) | The time in microseconds that it takes for the proxy to get a DB connection.*Shown as microsecond* | | **aws.rds.proxy.database_connections_borrow_requests**(gauge) | The number of requests to borrow a database connection from the pool.*Shown as request* | | **aws.rds.proxy.database_connections_borrow_requests.sum**(gauge) | The number of requests to borrow a database connection from the pool.*Shown as request* | | **aws.rds.proxy.database_connections_borrow_requests_aborted**(gauge) | The number of borrow requests aborted because the client connection was closed before a database connection could be obtained.*Shown as request* | | **aws.rds.proxy.database_connections_borrow_requests_aborted.sum**(gauge) | The number of borrow requests aborted because the client connection was closed before a database connection could be obtained.*Shown as request* | | **aws.rds.proxy.database_connections_currently_borrowed**(gauge) | The current number of database connections in the borrow state.*Shown as connection* | | **aws.rds.proxy.database_connections_currently_in_transaction**(gauge) | The current number of database connections in a transaction.*Shown as connection* | | **aws.rds.proxy.database_connections_currently_session_pinned**(gauge) | The current number of database connections currently pinned.*Shown as connection* | | **aws.rds.proxy.database_connections_setup_failed**(gauge) | The number of database connection requests that failed.*Shown as connection* | | **aws.rds.proxy.database_connections_setup_succeeded**(gauge) | The number of database connections successfully established.*Shown as connection* | | **aws.rds.proxy.database_connections_with_tls**(gauge) | The current number of database connections with TLS.*Shown as connection* | | **aws.rds.proxy.max_database_connections_allowed**(gauge) | The maximum number of database connections allowed.*Shown as connection* | | **aws.rds.proxy.query_database_response_latency**(gauge) | The time in microseconds that the database took to respond to the query.*Shown as microsecond* | | **aws.rds.proxy.query_requests**(gauge) | The number of queries received (a query including multiple statements is counted as one query).*Shown as request* | | **aws.rds.proxy.query_requests_no_tls**(gauge) | The number of queries received from non-TLS connections.*Shown as request* | | **aws.rds.proxy.query_requests_tls**(gauge) | The number of queries received from TLS connections.*Shown as request* | | **aws.rds.proxy.query_response_latency**(gauge) | The time in microseconds between getting a query request and the proxy responding to it.*Shown as microsecond* | | **aws.rds.dbload**(gauge) | The number of active sessions for the DB engine (Performance Insights must be enabled).*Shown as session* | | **aws.rds.dbload_cpu**(gauge) | The number of active sessions where the wait event type is CPU (Performance Insights must be enabled).*Shown as session* | | **aws.rds.dbload_non_cpu**(gauge) | The number of active sessions where the wait event type is not CPU (Performance Insights must be enabled).*Shown as session* | | **aws.rds.dbload_relative_to_num_vcpus**(gauge) | The ratio of the DB load to the number of virtual CPUs for the database.*Shown as unit* | | **aws.rds.swap_usage**(gauge) | Amount of swap space used on the DB instance.*Shown as byte* | | **aws.rds.maximum_used_transaction_ids**(count) | The maximum transaction ID that has been used. Only available for Aurora PostgreSQL DBs. | | **aws.rds.oldest_replication_slot_lag**(gauge) | The lagging size of the replica lagging the most in terms of WAL data received. Only available for Aurora PostgreSQL DBs.*Shown as byte* | | **aws.rds.replication_slot_disk_usage**(gauge) | The disk space used by replication slot files. Available for Aurora PostgreSQL DBs.*Shown as byte* | | **aws.rds.transaction_logs_disk_usage**(gauge) | Amount of disk space occupied by transaction logs. Only available for Aurora PostgreSQL DBs.*Shown as byte* | | **aws.rds.transaction_logs_generation**(gauge) | The size of transaction logs generated per second.*Shown as byte* | | **aws.rds.failed_sqlserver_agent_jobs_count**(count) | The number of failed SQL Server Agent jobs during the last minute.*Shown as job* | | **aws.rds.proxy.available**(gauge) | This metric has a value of 1 for proxies which are available, and a value of 0 for proxies which have any other status (e.g. suspended). | | **aws.rds.total_storage_space**(gauge) | Total amount of storage available on an instance.*Shown as byte* | | **aws.rds.vcpu.count**(gauge) | The number of vCPUs of the DB instance.*Shown as cpu* | | **aws.rds.proxy.database_connections**(gauge) | The current number of database connections.*Shown as connection* | | **aws.rds.cpuutilization.guest**(gauge) | The percentage of CPU in use by guest programs. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.idle**(gauge) | The percentage of CPU that is idle. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.irq**(gauge) | The percentage of CPU in use by software interrupts. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.kern**(gauge) | The percentage of CPU in use by the kernel. (Enhanced, SQL Server Only)*Shown as percent* | | **aws.rds.cpuutilization.nice**(gauge) | The percentage of CPU in use by programs running at lowest priority. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.steal**(gauge) | The percentage of CPU in use by other virtual machines. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.system**(gauge) | The percentage of CPU in use by the kernel. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.total**(gauge) | The total percentage of the CPU in use. This value excludes the nice value. Recommended metric for enhanced monitoring. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.user**(gauge) | The percentage of CPU in use by user programs. (Enhanced)*Shown as percent* | | **aws.rds.cpuutilization.wait**(gauge) | The percentage of CPU unused while waiting for I/O access. (Enhanced)*Shown as percent* | | **aws.rds.diskio.avgQueueLen**(gauge) | The number of requests waiting in the I/O device's queue. This metric is not available for Amazon Aurora. (Enhanced)*Shown as request* | | **aws.rds.diskio.avgReqSz**(gauge) | The average request size. This metric is not available for Amazon Aurora. (Enhanced)*Shown as kibibyte* | | **aws.rds.diskio.await**(gauge) | The number of milliseconds required to respond to requests including queue time and service time. This metric is not available for Amazon Aurora. (Enhanced)*Shown as millisecond* | | **aws.rds.diskio.readIOsPS**(rate) | The rate of read operations. (Enhanced)*Shown as operation* | | **aws.rds.diskio.readKb**(gauge) | The total amount of data read. This metric is not available for Amazon Aurora. (Enhanced)*Shown as kibibyte* | | **aws.rds.diskio.readKbPS**(rate) | The rate that data is read. This metric is not available for Amazon Aurora. (Enhanced)*Shown as kibibyte* | | **aws.rds.diskio.readLatency**(gauge) | The elapsed time between the submission of a read I/O request and its completion, in milliseconds. (Enhanced, Aurora Only)*Shown as millisecond* | | **aws.rds.diskio.readThroughput**(rate) | The amount of network throughput used by requests to the DB cluster, in bytes per second. (Enhanced, Aurora Only)*Shown as byte* | | **aws.rds.diskio.rrqmPS**(rate) | The rate of merged read requests queue. This metric is not available for Amazon Aurora. (Enhanced)*Shown as request* | | **aws.rds.diskio.tps**(rate) | The rate of I/O transactions. This metric is not available for Amazon Aurora. (Enhanced)*Shown as transaction* | | **aws.rds.diskio.util**(gauge) | The percentage of CPU time during which requests were issued. The percentage of CPU time during which requests were issued. (Enhanced)*Shown as percent* | | **aws.rds.diskio.writeIOsPS**(rate) | The rate of write operations. (Enhanced)*Shown as operation* | | **aws.rds.diskio.writeKb**(gauge) | The total amount of data written. This metric is not available for Amazon Aurora. (Enhanced)*Shown as kibibyte* | | **aws.rds.diskio.writeKbPS**(rate) | The rate that data is written. This metric is not available for Amazon Aurora. (Enhanced)*Shown as kibibyte* | | **aws.rds.diskio.writeLatency**(gauge) | The average elapsed time between the submission of a write I/O request and its completion, in milliseconds. (Enhanced, Aurora Only)*Shown as millisecond* | | **aws.rds.diskio.writeThroughput**(rate) | The amount of network throughput used by responses from the DB cluster, in bytes per second. (Enhanced, Aurora Only)*Shown as byte* | | **aws.rds.diskio.wrqmPS**(rate) | The rate of merged write requests queue. This metric is not available for Amazon Aurora. (Enhanced)*Shown as request* | | **aws.rds.disks.availKb**(gauge) | The space available on the disk. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.disks.availPc**(gauge) | The percentage of space available on the disk. (Enhanced, SQL Server Only)*Shown as percent* | | **aws.rds.disks.rdBytesPS**(rate) | The number of bytes read per second. (Enhanced, SQL Server Only)*Shown as byte* | | **aws.rds.disks.rdCountPS**(rate) | The number of read operations per second. (Enhanced, SQL Server Only)*Shown as operation* | | **aws.rds.disks.totalKb**(gauge) | The total space of the disk. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.disks.usedKb**(gauge) | The amount of space used on the disk. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.disks.usedPc**(gauge) | The percentage of space used on the disk. (Enhanced, SQL Server Only)*Shown as percent* | | **aws.rds.disks.wrBytesPS**(rate) | The number of bytes written per second. (Enhanced, SQL Server Only)*Shown as byte* | | **aws.rds.disks.wrCountPS**(rate) | The number of write operations per second. (Enhanced, SQL Server Only)*Shown as operation* | | **aws.rds.filesystem.maxFiles**(gauge) | The maximum number of files that can be created for the file system. (Enhanced)*Shown as file* | | **aws.rds.filesystem.total**(gauge) | The total amount of disk space available for the file system. (Enhanced)*Shown as kibibyte* | | **aws.rds.filesystem.used**(gauge) | The amount of disk space used by files in the file system. (Enhanced)*Shown as kibibyte* | | **aws.rds.filesystem.usedFilePercent**(gauge) | The percentage of available files in use. (Enhanced)*Shown as percent* | | **aws.rds.filesystem.usedFiles**(gauge) | The number of files in the file system. (Enhanced)*Shown as file* | | **aws.rds.filesystem.usedPercent**(gauge) | The percentage of the file-system disk space in use. (Enhanced)*Shown as percent* | | **aws.rds.load.1**(gauge) | The number of processes requesting CPU time over the last minute. (Enhanced)*Shown as process* | | **aws.rds.load.15**(gauge) | The number of processes requesting CPU time over the last 15 minutes. (Enhanced)*Shown as process* | | **aws.rds.load.5**(gauge) | The number of processes requesting CPU time over the last 5 minutes. (Enhanced)*Shown as process* | | **aws.rds.memory.active**(gauge) | The amount of assigned memory. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.buffers**(gauge) | The amount of memory used for buffering I/O requests prior to writing to the storage device. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.cached**(gauge) | The amount of memory used for caching file system-based I/O. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.commitLimitKb**(gauge) | The maximum possible value for the commitTotKb metric. This value is the sum of the current pagefile size plus the physical memory available for pageable contents–excluding RAM that is assigned to non-pageable areas. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.commitPeakKb**(gauge) | The largest value of the commitTotKb metric since the operating system was last started. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.commitTotKb**(gauge) | The amount of pagefile-backed virtual address space in use, that is, the current commit charge. This value is composed of main memory (RAM) and disk (pagefiles). (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.dirty**(gauge) | The amount of memory pages in RAM that have been modified but not written to their related data block in storage. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.free**(gauge) | The amount of unassigned memory. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.hugePagesFree**(gauge) | The number of free huge pages. (Enhanced)*Shown as page* | | **aws.rds.memory.hugePagesRsvd**(gauge) | The number of committed huge pages. (Enhanced)*Shown as page* | | **aws.rds.memory.hugePagesSize**(gauge) | The size for each huge pages unit. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.hugePagesSurp**(gauge) | The number of available surplus huge pages over the total. (Enhanced)*Shown as page* | | **aws.rds.memory.hugePagesTotal**(gauge) | The total number of huge pages for the system. (Enhanced)*Shown as page* | | **aws.rds.memory.inactive**(gauge) | The amount of inactive memory (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.kernNonpagedKb**(gauge) | The amount of memory in the non-paged kernel pool. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.kernPagedKb**(gauge) | The amount of memory in the paged kernel pool. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.kernTotKb**(gauge) | The sum of the memory in the paged and non-paged kernel pools. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.mapped**(gauge) | The total amount of file-system contents that is memory mapped inside a process address space. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.pageSize**(gauge) | The size of a page. (Enhanced, SQL Server Only)*Shown as byte* | | **aws.rds.memory.pageTables**(gauge) | The amount of memory used by page tables. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.physAvailKb**(gauge) | The amount of available physical memory. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.physTotKb**(gauge) | The amount of physical memory. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.slab**(gauge) | The amount of reusable kernel data structures. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.sqlServerTotKb**(gauge) | The amount of memory committed to Microsoft SQL Server. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.sysCacheKb**(gauge) | The amount of system cache memory. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.memory.total**(gauge) | The total amount of memory. (Enhanced)*Shown as kibibyte* | | **aws.rds.memory.writeback**(gauge) | The amount of dirty pages in RAM that are still being written to the backing storage. (Enhanced)*Shown as kibibyte* | | **aws.rds.network.rdBytesPS**(gauge) | The number of bytes received per second. (Enhanced, SQL Server Only)*Shown as byte* | | **aws.rds.network.rx**(gauge) | The number of packets received. (Enhanced)*Shown as packet* | | **aws.rds.network.tx**(gauge) | The number of packets uploaded. (Enhanced)*Shown as packet* | | **aws.rds.network.wrBytesPS**(gauge) | The number of bytes sent per second. (Enhanced, SQL Server Only)*Shown as byte* | | **aws.rds.physicaldeviceio.avgQueueLen**(gauge) | The number of requests waiting in the I/O device's queue. (Enhanced)*Shown as request* | | **aws.rds.physicaldeviceio.avgReqSz**(gauge) | The average request size on physical devices. (Enhanced)*Shown as kibibyte* | | **aws.rds.physicaldeviceio.await**(gauge) | The number of milliseconds required to respond to requests on physical devices, including queue time and service time. (Enhanced)*Shown as millisecond* | | **aws.rds.physicaldeviceio.readIOsPS**(rate) | The number of read operations per second on physical devices. (Enhanced)*Shown as operation* | | **aws.rds.physicaldeviceio.readKb**(gauge) | The total amount of data read on physical devices. (Enhanced)*Shown as kibibyte* | | **aws.rds.physicaldeviceio.readKbPS**(rate) | The number of kilobytes read per second on physical devices. (Enhanced)*Shown as kibibyte* | | **aws.rds.physicaldeviceio.rrqmPS**(rate) | The number of merged read requests queued per second on physical devices. (Enhanced)*Shown as request* | | **aws.rds.physicaldeviceio.tps**(rate) | The number of I/O transactions per second on physical devices. (Enhanced)*Shown as transaction* | | **aws.rds.physicaldeviceio.util**(gauge) | The percentage of CPU time during which requests were issued on physical devices. (Enhanced)*Shown as percent* | | **aws.rds.physicaldeviceio.writeIOsPS**(rate) | The number of write operations per second on physical devices. (Enhanced)*Shown as operation* | | **aws.rds.physicaldeviceio.writeKb**(gauge) | The total amount of data written on physical devices. (Enhanced)*Shown as kibibyte* | | **aws.rds.physicaldeviceio.writeKbPS**(rate) | The number of kilobytes written per second on physical devices. (Enhanced)*Shown as kibibyte* | | **aws.rds.physicaldeviceio.wrqmPS**(rate) | The number of merged write requests queued per second on physical devices. (Enhanced)*Shown as request* | | **aws.rds.process.cpuUsedPc**(gauge) | The percentage of CPU used by the process. (Enhanced)*Shown as percent* | | **aws.rds.process.memUsedPc**(gauge) | The percentage of total memory used by the process. (Enhanced, SQL Server Only)*Shown as percent* | | **aws.rds.process.memoryUsedPc**(gauge) | The percentage of memory used by the process. (Enhanced)*Shown as percent* | | **aws.rds.process.parentID**(gauge) | The process identifier for the parent proces of the process. (Enhanced) | | **aws.rds.process.pid**(gauge) | The identifier of the process. This value is not present for processes that are owned by Amazon RDS. (Enhanced, SQL Server Only) | | **aws.rds.process.ppid**(gauge) | The process identifier for the parent of this process. This value is only present for child processes. (Enhanced, SQL Server Only) | | **aws.rds.process.rss**(gauge) | The amount of RAM allocated to the process. (Enhanced)*Shown as kibibyte* | | **aws.rds.process.tgid**(gauge) | The thread group identifier which is a number representing the process ID to which a thread belongs. This identifier is used to group threads from the same process. (Enhanced) | | **aws.rds.process.tid**(gauge) | The thread identifier. This value is only present for threads. The owning process can be identified by using the pid value. (Enhanced, SQL Server Only) | | **aws.rds.process.virtKb**(gauge) | The amount of virtual address space the process is using. Use of virtual address space does not necessarily imply corresponding use of either disk or main memory pages. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.process.vss**(gauge) | The amount of virtual memory allocated to the process. (Enhanced)*Shown as kibibyte* | | **aws.rds.process.workingSetKb**(gauge) | The amount of memory in the private working set plus the amount of memory that is in use by the process and can be shared with other processes. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.process.workingSetPrivKb**(gauge) | The amount of memory that is in use by a process, but can't be shared with other processes. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.process.workingSetShareableKb**(gauge) | The amount of memory that is in use by a process and can be shared with other processes. (Enhanced, SQL Server Only)*Shown as kibibyte* | | **aws.rds.swap.cached**(gauge) | The amount of swap memory used as cache memory. (Enhanced)*Shown as kibibyte* | | **aws.rds.swap.free**(gauge) | The total amount of swap memory free. (Enhanced)*Shown as kibibyte* | | **aws.rds.swap.in**(gauge) | The amount of memory swapped in from disk. (Enhanced)*Shown as kibibyte* | | **aws.rds.swap.out**(gauge) | The amount of memory swapped out from disk. (Enhanced)*Shown as kibibyte* | | **aws.rds.swap.total**(gauge) | The total amount of swap memory available. (Enhanced)*Shown as kibibyte* | | **aws.rds.system.handles**(gauge) | The number of handles that the system is using. (Enhanced, SQL Server Only) | | **aws.rds.system.processes**(gauge) | The number of processes running on the system. (Enhanced, SQL Server Only)*Shown as process* | | **aws.rds.system.threads**(gauge) | The number of threads running on the system. (Enhanced, SQL Server Only)*Shown as thread* | | **aws.rds.tasks.blocked**(gauge) | The number of tasks that are blocked. (Enhanced)*Shown as task* | | **aws.rds.tasks.running**(gauge) | The number of tasks that are running. (Enhanced)*Shown as task* | | **aws.rds.tasks.sleeping**(gauge) | The number of tasks that are sleeping. (Enhanced)*Shown as task* | | **aws.rds.tasks.stopped**(gauge) | The number of tasks that are stopped. (Enhanced)*Shown as task* | | **aws.rds.tasks.total**(gauge) | The total number of tasks. (Enhanced)*Shown as task* | | **aws.rds.tasks.zombie**(gauge) | The number of child tasks that are inactive with an active parent task. (Enhanced)*Shown as task* | | **aws.rds.uptime**(gauge) | RDS instance uptime. (Enhanced)*Shown as second* | | **aws.rds.virtual_cpus**(gauge) | The number of virtual CPUs for the DB instance. (Enhanced)*Shown as cpu* | 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. ### Events{% #events %} The Amazon RDS integration includes events related to DB instances, security groups, snapshots, and parameter groups. See example events below: ### Service Checks{% #service-checks %} **aws.rds.read_replica_status** Monitors the [read replication](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html#USER_ReadRepl.Monitoring) status. This check returns one of the following statuses: - OK - replicating or connecting - CRITICAL - error or terminated - WARNING - stopped - UNKNOWN - other ## Out-of-the-box monitoring{% #out-of-the-box-monitoring %} The Amazon RDS integration provides ready-to-use monitoring capabilities to monitor and optimize performance. - Amazon RDS Dashboard: Gain a comprehensive overview of your RDS instances using the out-of-the-box [Amazon RDS dashboard](https://app.datadoghq.com/dash/integration/aws_rds). - Recommended Monitors: Enable [Recommended Amazon RDS monitors](https://app.datadoghq.com/monitors/recommended) to proactively detect issues and receive timely alerts. ## Troubleshooting{% #troubleshooting %} Need help? Contact [Datadog support](https://docs.datadoghq.com/help/). ## Further Reading{% #further-reading %} Additional helpful documentation, links, and articles: - [Monitoring RDS MySQL performance metrics](https://www.datadoghq.com/blog/monitoring-rds-mysql-performance-metrics/) - [Key metrics for Amazon RDS PostgreSQL monitoring](https://www.datadoghq.com/blog/aws-rds-postgresql-monitoring/) - [Monitoring Amazon Aurora performance metrics](https://www.datadoghq.com/blog/monitoring-amazon-aurora-performance-metrics/)