---
title: AWS DMS
description: >-
  Simplifies migrating various data stores like relational databases, data
  warehouses, and NoSQL databases.
breadcrumbs: Docs > Integrations > AWS DMS
---

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

# AWS DMS
Integration version1.1.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 %}

AWS Database Migration Service (DMS) is a cloud service that makes it easy to migrate relational databases, data warehouses, NoSQL databases, and other types of data stores.

Enable this integration to see all your DMS metrics in Datadog.

## Setup{% #setup %}

### Installation{% #installation %}

If you haven't already, set up the [Amazon Web Services integration](https://docs.datadoghq.com/integrations/amazon_web_services.md) first.

### Metric collection{% #metric-collection %}

1. In the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `Database Migration Service` is enabled under the `Metric Collection` tab.
1. Install the [Datadog - AWS Database Migration Service (DMS) integration](https://app.datadoghq.com/integrations/amazon-dms).

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

#### Enable logging{% #enable-logging %}

Configure AWS Database Migration Service to send logs either to a S3 bucket or to CloudWatch.

**Note**: If you log to a S3 bucket, make sure that `amazon_dms` is set as *Target prefix*.

#### 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 Forwarder Lambda function](https://docs.datadoghq.com/logs/guide/forwarder.md).

1. Once the Lambda function is installed, manually add a trigger on the S3 bucket or CloudWatch log group that contains your AWS DMS logs in the AWS console:

   - [Add a manual trigger on the S3 bucket](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md#collecting-logs-from-s3-buckets)
   - [Add a manual trigger on the CloudWatch Log Group](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md#collecting-logs-from-cloudwatch-log-group)

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.dms.available_memory**(gauge)                         | An estimate of how much memory is available for starting new applications, without swapping.*Shown as byte*                                                                   |
| **aws.dms.capacity_utilization**(gauge)                     | The percentage of provisioned capacity in use by the replication.*Shown as percent*                                                                                           |
| **aws.dms.cdcchanges_disk_source**(gauge)                  | Amount of rows accumulating on disk and waiting to be committed from the source*Shown as row*                                                                                 |
| **aws.dms.cdcchanges_disk_target**(gauge)                  | Amount of rows accumulating on disk and waiting to be committed to the target*Shown as row*                                                                                   |
| **aws.dms.cdcchanges_memory_source**(gauge)                | Amount of rows accumulating in a memory and waiting to be committed from the source*Shown as row*                                                                             |
| **aws.dms.cdcchanges_memory_target**(gauge)                | Amount of rows accumulating in a memory and waiting to be committed to the target*Shown as row*                                                                               |
| **aws.dms.cdcincoming_changes**(gauge)                      | Total row count of changes for the task*Shown as row*                                                                                                                         |
| **aws.dms.cdclatency_source**(gauge)                        | Latency reading from source*Shown as second*                                                                                                                                  |
| **aws.dms.cdclatency_target**(gauge)                        | Latency writing to the target*Shown as second*                                                                                                                                |
| **aws.dms.cdcthroughput_bandwidth_source**(gauge)          | Incoming task network bandwidth from the source*Shown as kibibyte*                                                                                                            |
| **aws.dms.cdcthroughput_bandwidth_target**(gauge)          | Outgoing task network bandwidth for the target*Shown as kibibyte*                                                                                                             |
| **aws.dms.cdcthroughput_rows_source**(gauge)               | Incoming task changes from the source*Shown as row*                                                                                                                           |
| **aws.dms.cdcthroughput_rows_target**(gauge)               | Outgoing task changes for the target*Shown as row*                                                                                                                            |
| **aws.dms.cpuallocated**(gauge)                              | The maximum percentage of CPU allocated to the task (0 means no limit).*Shown as percent*                                                                                     |
| **aws.dms.cpuutilization**(gauge)                            | The amount of CPU used.*Shown as percent*                                                                                                                                     |
| **aws.dms.disk_queue_depth**(gauge)                        | The number of outstanding read and write requests (I/Os) waiting to access the disk.*Shown as request*                                                                        |
| **aws.dms.free_memory**(gauge)                              | The amount of physical memory available for use by applications, page cache, and for the kernel's own data structures.*Shown as byte*                                         |
| **aws.dms.free_storage_space**(gauge)                      | The amount of available storage space.*Shown as byte*                                                                                                                         |
| **aws.dms.freeable_memory**(gauge)                          | The amount of available random access memory.*Shown as byte*                                                                                                                  |
| **aws.dms.full_load_throughput_bandwidth_source**(gauge) | Incoming network bandwidth from a full load from the source*Shown as kibibyte*                                                                                                |
| **aws.dms.full_load_throughput_bandwidth_target**(gauge) | Outgoing network bandwidth from a full load for the target*Shown as kibibyte*                                                                                                 |
| **aws.dms.full_load_throughput_rows_source**(gauge)      | Incoming changes from a full load from the source in rows per second*Shown as row*                                                                                            |
| **aws.dms.full_load_throughput_rows_target**(gauge)      | Outgoing changes from a full load for the target*Shown as row*                                                                                                                |
| **aws.dms.memory_allocated**(gauge)                         | The maximum amount of memory allocated to the task (0 means no limit).*Shown as mebibyte*                                                                                     |
| **aws.dms.memory_allocated_bytes**(gauge)                  | The maximum amount of memory allocated to the task, in bytes (0 means no limit).*Shown as byte*                                                                               |
| **aws.dms.memory_usage**(gauge)                             | The memory consumed by a task within the control group (cgroup) allocated for that task, in megabytes.*Shown as megabyte*                                                     |
| **aws.dms.memory_usage_bytes**(gauge)                      | The memory consumed by a task within the control group (cgroup) allocated for that task, in bytes.*Shown as byte*                                                             |
| **aws.dms.network_receive_throughput**(gauge)              | The incoming (Receive) network traffic on the DB instance including both customer database traffic and Amazon RDS traffic used for monitoring and replication.*Shown as byte* |
| **aws.dms.network_transmit_throughput**(gauge)             | The outgoing (Transmit) network traffic on the DB instance including both customer database traffic and Amazon RDS traffic used for monitoring and replication*Shown as byte* |
| **aws.dms.read_iops**(gauge)                                | The average number of disk I/O operations per second.*Shown as operation*                                                                                                     |
| **aws.dms.read_latency**(gauge)                             | The average amount of time taken per read disk I/O operation*Shown as second*                                                                                                 |
| **aws.dms.read_throughput**(gauge)                          | The average number of bytes read from disk per second.*Shown as byte*                                                                                                         |
| **aws.dms.recovery_count**(gauge)                           | The number of times the task has recovered from an error or interruption.                                                                                                     |
| **aws.dms.replication_lag**(gauge)                          | The lag between the source and the target for a table in the task.                                                                                                            |
| **aws.dms.run_counter**(gauge)                              | The number of times the task has run.                                                                                                                                         |
| **aws.dms.service_cpuutilization**(gauge)                   | The percentage of CPU used by the AWS DMS service processes on the replication instance.*Shown as percent*                                                                    |
| **aws.dms.service_memory_usage**(gauge)                    | The amount of memory used by the AWS DMS service processes on the replication instance.                                                                                       |
| **aws.dms.swap_usage**(gauge)                               | The amount of swap space used on the DB Instance*Shown as byte*                                                                                                               |
| **aws.dms.task_status**(gauge)                              | The status of the replication task.                                                                                                                                           |
| **aws.dms.total_bytes_read**(gauge)                        | The total number of bytes read by the task.*Shown as byte*                                                                                                                    |
| **aws.dms.total_bytes_written**(gauge)                     | The total number of bytes written by the task.*Shown as byte*                                                                                                                 |
| **aws.dms.validation_attempted_record_count**(gauge)      | The number of rows for which validation was attempted, per minute.*Shown as row*                                                                                              |
| **aws.dms.validation_bulk_query_source_latency**(gauge)  | The latency required to read a bulk set of data from the source endpoint during data validation.*Shown as millisecond*                                                        |
| **aws.dms.validation_bulk_query_target_latency**(gauge)  | The latency required to read a bulk set of data from the target endpoint during data validation.*Shown as millisecond*                                                        |
| **aws.dms.validation_failed_overall_count**(gauge)        | The number of rows where validation failed.*Shown as row*                                                                                                                     |
| **aws.dms.validation_item_query_source_latency**(gauge)  | The latency in reading ongoing changes from the source endpoint during data validation.*Shown as millisecond*                                                                 |
| **aws.dms.validation_item_query_target_latency**(gauge)  | The latency in reading ongoing changes from the target endpoint during data validation.*Shown as millisecond*                                                                 |
| **aws.dms.validation_pending_overall_count**(gauge)       | The number of rows where validation is still pending.*Shown as row*                                                                                                           |
| **aws.dms.validation_succeeded_record_count**(gauge)      | The number of rows that AWS DMS validated, per minute.*Shown as row*                                                                                                          |
| **aws.dms.validation_suspended_overall_count**(gauge)     | The number of rows where validation was suspended.*Shown as row*                                                                                                              |
| **aws.dms.write_iops**(gauge)                               | The average number of disk I/O operations per second*Shown as operation*                                                                                                      |
| **aws.dms.write_latency**(gauge)                            | The average amount of time taken per write disk I/O operation*Shown as second*                                                                                                |
| **aws.dms.write_throughput**(gauge)                         | The average number of bytes written to disk per second.*Shown as byte*                                                                                                        |

### Events{% #events %}

The AWS Database Migration Service (DMS) integration does not include any events.

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

The AWS Database Migration Service (DMS) integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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