---
title: Amazon ECS Data Collection
description: >-
  Reference guide for metrics, logs, and events collected by the Datadog Agent
  on Amazon ECS
breadcrumbs: Docs > Containers > Amazon ECS > Amazon ECS Data Collection
---

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

# Amazon ECS Data Collection

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

### Metrics{% #metrics %}

Amazon ECS on EC2 is a container management service for Docker containers running on EC2 instances.

The following table lists metrics collected by the Agent or API crawler for Amazon ECS:

|  |
|  |
| **aws.ecs.cpureservation**(gauge)                      | The percentage of CPU units that are reserved by running tasks in the cluster.*Shown as percent*                                                                                               |
| **aws.ecs.cpureservation.maximum**(gauge)              | The maximum percentage of CPU units that are reserved by running tasks in the cluster.*Shown as percent*                                                                                       |
| **aws.ecs.cpureservation.minimum**(gauge)              | The minimum percentage of CPU units that are reserved by running tasks in the cluster.*Shown as percent*                                                                                       |
| **aws.ecs.cpureservation.samplecount**(count)          | The sample count of CPU units that are reserved by running tasks in the cluster.                                                                                                               |
| **aws.ecs.cluster.cpureservation**(gauge)              | The percentage of CPU units that are reserved by running tasks in the cluster.*Shown as percent*                                                                                               |
| **aws.ecs.cluster.cpureservation.maximum**(gauge)      | The maximum percentage of CPU units that are reserved by running tasks in the cluster.*Shown as percent*                                                                                       |
| **aws.ecs.cluster.cpureservation.minimum**(gauge)      | The minimum percentage of CPU units that are reserved by running tasks in the cluster.*Shown as percent*                                                                                       |
| **aws.ecs.cluster.cpureservation.samplecount**(count)  | The sample count of CPU units that are reserved by running tasks in the cluster.                                                                                                               |
| **aws.ecs.cpuutilization**(gauge)                      | The percentage of CPU units that are used in the cluster or service filtered by ClusterName and ServiceName.*Shown as percent*                                                                 |
| **aws.ecs.cpuutilization.maximum**(gauge)              | The maximum percentage of CPU units that are used in the cluster or service.*Shown as percent*                                                                                                 |
| **aws.ecs.cpuutilization.minimum**(gauge)              | The minimum percentage of CPU units that are used in the cluster or service.*Shown as percent*                                                                                                 |
| **aws.ecs.cpuutilization.samplecount**(count)          | The sample count of CPU units that are used in the cluster or service.                                                                                                                         |
| **aws.ecs.cluster.cpuutilization**(gauge)              | The percentage of CPU units that are used in the cluster or service filtered by ClusterName.*Shown as percent*                                                                                 |
| **aws.ecs.cluster.cpuutilization.maximum**(gauge)      | The maximum percentage of CPU units that are used in the cluster or service.*Shown as percent*                                                                                                 |
| **aws.ecs.cluster.cpuutilization.minimum**(gauge)      | The minimum percentage of CPU units that are used in the cluster or service.*Shown as percent*                                                                                                 |
| **aws.ecs.service.cpuutilization**(gauge)              | Average percentage of CPU units that are used in the service.*Shown as percent*                                                                                                                |
| **aws.ecs.service.cpuutilization.maximum**(gauge)      | Maximum percentage of CPU units that are used in the service.*Shown as percent*                                                                                                                |
| **aws.ecs.service.cpuutilization.minimum**(gauge)      | Minimum percentage of CPU units that are used in the service.*Shown as percent*                                                                                                                |
| **aws.ecs.cluster.cpuutilization.samplecount**(count)  | The sample count of CPU units that are used in the cluster.                                                                                                                                    |
| **aws.ecs.service.cpuutilization.samplecount**(count)  | The sample count of CPU units that are used in the service.                                                                                                                                    |
| **aws.ecs.memory_reservation**(gauge)                 | The percentage of memory that is reserved by running tasks in the cluster.*Shown as percent*                                                                                                   |
| **aws.ecs.memory_reservation.maximum**(gauge)         | The maximum percentage of memory that is reserved by running tasks in the cluster.*Shown as percent*                                                                                           |
| **aws.ecs.memory_reservation.minimum**(gauge)         | The minimum percentage of memory that is reserved by running tasks in the cluster.*Shown as percent*                                                                                           |
| **aws.ecs.cluster.memory_reservation**(gauge)         | The percentage of memory that is reserved by running tasks in the cluster.*Shown as percent*                                                                                                   |
| **aws.ecs.cluster.memory_reservation.maximum**(gauge) | The maximum percentage of memory that is reserved by running tasks in the cluster.*Shown as percent*                                                                                           |
| **aws.ecs.cluster.memory_reservation.minimum**(gauge) | The minimum percentage of memory that is reserved by running tasks in the cluster.*Shown as percent*                                                                                           |
| **aws.ecs.memory_utilization**(gauge)                 | The percentage of memory that is used in the cluster or service.*Shown as percent*                                                                                                             |
| **aws.ecs.memory_utilization.maximum**(gauge)         | The maximum percentage of memory that is used in the cluster or service.*Shown as percent*                                                                                                     |
| **aws.ecs.memory_utilization.minimum**(gauge)         | The minimum percentage of memory that is used in the cluster or service.*Shown as percent*                                                                                                     |
| **aws.ecs.cluster.memory_utilization**(gauge)         | The percentage of memory that is used in the cluster or service.*Shown as percent*                                                                                                             |
| **aws.ecs.cluster.memory_utilization.maximum**(gauge) | The maximum percentage of memory that is used in the cluster or service.*Shown as percent*                                                                                                     |
| **aws.ecs.cluster.memory_utilization.minimum**(gauge) | The minimum percentage of memory that is used in the cluster or service.*Shown as percent*                                                                                                     |
| **aws.ecs.service.memory_utilization**(gauge)         | Average percentage of memory that is used in the service.*Shown as percent*                                                                                                                    |
| **aws.ecs.service.memory_utilization.maximum**(gauge) | Maximum percentage of memory that is used in the service.*Shown as percent*                                                                                                                    |
| **aws.ecs.service.memory_utilization.minimum**(gauge) | Minimum percentage of memory that is used in the service.*Shown as percent*                                                                                                                    |
| **aws.ecs.live_task_count**(gauge)                   | The number of tasks in the ACTIVATING, RUNNING, and DEACTIVATING lifecycle states for the cluster or service.*Shown as task*                                                                   |
| **aws.ecs.service.live_task_count**(gauge)           | The number of tasks in the ACTIVATING, RUNNING, and DEACTIVATING lifecycle states for the service.*Shown as task*                                                                              |
| **aws.ecs.active_connection_count**(gauge)           | The average number of concurrent connections active from clients to the Service Connect proxies that run in tasks that share the selected discovery name.*Shown as connection*                 |
| **aws.ecs.service.active_connection_count**(gauge)   | The average number of concurrent connections active from clients to the Service Connect proxies that run in tasks that share the selected discovery name for the service.*Shown as connection* |
| **aws.ecs.console_status**(gauge)                     | The average console status reported.                                                                                                                                                           |
| **aws.ecs.service.console_status**(gauge)             | The average console status reported for the service.                                                                                                                                           |
| **aws.ecs.ebsfilesystem_utilization**(gauge)          | The average percentage of the Amazon EBS filesystem that is used by tasks.*Shown as percent*                                                                                                   |
| **aws.ecs.service.ebsfilesystem_utilization**(gauge)  | The average percentage of the Amazon EBS filesystem that is used by tasks for the service.*Shown as percent*                                                                                   |
| **aws.ecs.gpureservation**(gauge)                      | The average percentage of total available GPUs that are reserved by running tasks.*Shown as percent*                                                                                           |
| **aws.ecs.cluster.gpureservation**(gauge)              | The average percentage of total available GPUs that are reserved by running tasks in the cluster.*Shown as percent*                                                                            |
| **aws.ecs.grpc_request_count**(gauge)                | The average number of gRPC inbound traffic requests processed by the Service Connect proxies.*Shown as request*                                                                                |
| **aws.ecs.service.grpc_request_count**(gauge)        | The average number of gRPC inbound traffic requests processed by the Service Connect proxies for the service.*Shown as request*                                                                |
| **aws.ecs.httpcode_target_2xxcount**(gauge)          | The average number of HTTP response codes with numbers 200 to 299 generated by the applications in the target tasks.*Shown as response*                                                        |
| **aws.ecs.service.httpcode_target_2xxcount**(gauge)  | The average number of HTTP response codes with numbers 200 to 299 generated by the applications in the target tasks for the service.*Shown as response*                                        |
| **aws.ecs.httpcode_target_3xxcount**(gauge)          | The average number of HTTP response codes with numbers 300 to 399 generated by the applications in the target tasks.*Shown as response*                                                        |
| **aws.ecs.service.httpcode_target_3xxcount**(gauge)  | The average number of HTTP response codes with numbers 300 to 399 generated by the applications in the target tasks for the service.*Shown as response*                                        |
| **aws.ecs.httpcode_target_4xxcount**(gauge)          | The average number of HTTP response codes with numbers 400 to 499 generated by the applications in the target tasks.*Shown as response*                                                        |
| **aws.ecs.service.httpcode_target_4xxcount**(gauge)  | The average number of HTTP response codes with numbers 400 to 499 generated by the applications in the target tasks for the service.*Shown as response*                                        |
| **aws.ecs.httpcode_target_5xxcount**(gauge)          | The average number of HTTP response codes with numbers 500 to 599 generated by the applications in the target tasks.*Shown as response*                                                        |
| **aws.ecs.service.httpcode_target_5xxcount**(gauge)  | The average number of HTTP response codes with numbers 500 to 599 generated by the applications in the target tasks for the service.*Shown as response*                                        |
| **aws.ecs.new_connection_count**(gauge)              | The average number of new connections established from clients to the Service Connect proxies that run in tasks that share the selected discovery name.*Shown as connection*                   |
| **aws.ecs.service.new_connection_count**(gauge)      | The average number of new connections established from clients to the Service Connect proxies that run in tasks that share the selected discovery name for the service.*Shown as connection*   |
| **aws.ecs.processed_bytes**(gauge)                    | The average number of bytes of inbound traffic processed by the Service Connect proxies.*Shown as byte*                                                                                        |
| **aws.ecs.service.processed_bytes**(gauge)            | The average number of bytes of inbound traffic processed by the Service Connect proxies for the service.*Shown as byte*                                                                        |
| **aws.ecs.request_count**(gauge)                      | The average number of inbound traffic requests processed by the Service Connect proxies.*Shown as request*                                                                                     |
| **aws.ecs.service.request_count**(gauge)              | The average number of inbound traffic requests processed by the Service Connect proxies for the service.*Shown as request*                                                                     |
| **aws.ecs.request_count_per_target**(gauge)         | The average number of requests received by each target that share the selected discovery name.*Shown as request*                                                                               |
| **aws.ecs.service.request_count_per_target**(gauge) | The average number of requests received by each target that share the selected discovery name for the service.*Shown as request*                                                               |
| **aws.ecs.schedulable_containers**(gauge)             | The average number of containers that can be scheduled.*Shown as container*                                                                                                                    |
| **aws.ecs.cluster.schedulable_containers**(gauge)     | The average number of containers that can be scheduled in the cluster.*Shown as container*                                                                                                     |
| **aws.ecs.target_processed_bytes**(gauge)            | The average number of bytes processed by the Service Connect proxies for the target tasks.*Shown as byte*                                                                                      |
| **aws.ecs.service.target_processed_bytes**(gauge)    | The average number of bytes processed by the Service Connect proxies for the target tasks for the service.*Shown as byte*                                                                      |
| **aws.ecs.target_response_time**(gauge)              | The average latency of the application request processing between the Service Connect proxy in the target task and the target application.*Shown as millisecond*                               |
| **aws.ecs.service.target_response_time**(gauge)      | The average latency of the application request processing between the Service Connect proxy in the target task and the target application for the service.*Shown as millisecond*               |
| **aws.ecs.pending_tasks_count**(gauge)               | The number of tasks on the container instance that are in the PENDING status.*Shown as task*                                                                                                   |
| **aws.ecs.registered_cpu**(gauge)                     | The number of CPU units registered on the container instance                                                                                                                                   |
| **aws.ecs.registered_memory**(gauge)                  | The number of Memory units registered on the container instance                                                                                                                                |
| **aws.ecs.remaining_cpu**(gauge)                      | The number of CPU units remaining on the container instance                                                                                                                                    |
| **aws.ecs.remaining_memory**(gauge)                   | The number of Memory units remaining on the container instance                                                                                                                                 |
| **aws.ecs.running_tasks_count**(gauge)               | The number of tasks on the container instance that are in the RUNNING status.*Shown as task*                                                                                                   |
| **aws.ecs.service.desired**(gauge)                     | The number of tasks in the cluster that are in the desired state                                                                                                                               |
| **aws.ecs.service.pending**(gauge)                     | The number of tasks in the cluster that are in the pending state*Shown as task*                                                                                                                |
| **aws.ecs.service.running**(gauge)                     | The number of tasks in the cluster that are in the running state*Shown as task*                                                                                                                |
| **aws.ecs.services**(gauge)                            | The number of services running per cluster                                                                                                                                                     |

Each of the metrics retrieved from AWS is assigned the same tags that appear in the AWS console, including but not limited to hostname, security-groups, and more.

**Note**: Metrics prefixed with `ecs.containerinsights.*` are provided by the [Amazon ECS Container Insights](https://app.datadoghq.com/integrations/amazon-ecs-container-insights) integration.

Metrics collected by the Agent when deployed in a Docker container also include the same metrics collected by the Docker integration. See the [Docker integration metrics](https://docs.datadoghq.com/agent/docker/data_collected.md#metrics) for a complete list of metrics.

Metrics prefixed with `ecs.containerinsights.*` can be collected by enabling **collect custom metrics** under the Metric Collection tab of the AWS Integration.

**Note**: Docker metrics are tagged accordingly with the following tags: `container_name`, `task_arn`, `task_family`, `task_name`, `task_version`. No further configuration is required.

### Events{% #events %}

To reduce noise, the Amazon ECS integration is automatically set up to include only events that contain the following words: `drain`, `error`, `fail`, `insufficient memory`, `pending`, `reboot`, `terminate`. See example events below:

{% image
   source="https://docs.dd-static.net/images/integrations/amazon_ecs/aws_ecs_events.87ba0979448661b1eecfc157287b77f8.png?auto=format&fit=max&w=850 1x, https://docs.dd-static.net/images/integrations/amazon_ecs/aws_ecs_events.87ba0979448661b1eecfc157287b77f8.png?auto=format&fit=max&w=850&dpr=2 2x"
   alt="Amazon ECS Events" /%}

To remove this include list and receive all events from your Datadog Amazon ECS integration, reach out to [Datadog support](https://docs.datadoghq.com/help/).

## Further reading{% #further-reading %}

Additional helpful documentation, links, and articles:

- [Collect your application logs](https://docs.datadoghq.com/agent/amazon_ecs/logs.md)
- [Collect your application traces](https://docs.datadoghq.com/agent/amazon_ecs/apm.md)
- [Collect ECS metrics](https://docs.datadoghq.com/agent/amazon_ecs/data_collected.md#metrics)
