---
title: Amazon AppStream
description: >-
  A secure and fully-managed service for streaming desktop apps from AWS to a
  web browser.
breadcrumbs: Docs > Integrations > Amazon AppStream
---

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

# Amazon AppStream
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 %}

Amazon AppStream is a fully managed, secure application streaming service that allows you to stream desktop applications from AWS to a web browser.

Enable this integration to see all your AppStream 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 `AppStream` is enabled under the `Metric Collection` tab.
1. Install the [Datadog - Amazon AppStream integration](https://app.datadoghq.com/integrations/amazon-appstream).

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

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

Configure Amazon AppStream to send logs either to a S3 bucket or to CloudWatch.

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

#### Send logs to Datadog{% #send-logs-to-datadog %}

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 Amazon AppStream 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.appstream.active_user_session_capacity**(gauge)              | The number of user sessions being used for streaming sessions on multi-session fleets.*Shown as session*                                                                                                                                                                     |
| **aws.appstream.actual_capacity**(count)                             | The average number of instances that are available for streaming or are currently streaming                                                                                                                                                                                  |
| **aws.appstream.actual_capacity.maximum**(count)                     | The maximum number of instances that are available for streaming or are currently streaming                                                                                                                                                                                  |
| **aws.appstream.actual_capacity.minimum**(count)                     | The minimum number of instances that are available for streaming or are currently streaming                                                                                                                                                                                  |
| **aws.appstream.actual_user_session_capacity**(gauge)              | The total number of session slots that are available for streaming or in use for streaming.*Shown as session*                                                                                                                                                                |
| **aws.appstream.available_capacity**(count)                          | The average number of idle instances currently available for user sessions                                                                                                                                                                                                   |
| **aws.appstream.available_capacity.maximum**(count)                  | The maximum number of idle instances currently available for user sessions                                                                                                                                                                                                   |
| **aws.appstream.available_capacity.minimum**(count)                  | The minimum number of idle instances currently available for user sessions                                                                                                                                                                                                   |
| **aws.appstream.available_user_session_capacity**(gauge)           | The number of idle session slots available for user sessions.*Shown as session*                                                                                                                                                                                              |
| **aws.appstream.bandwidth**(gauge)                                    | The rate of data transferred from the gateway to the client (outbound).*Shown as kilobit*                                                                                                                                                                                    |
| **aws.appstream.bandwidth_inbound**(gauge)                           | The rate of data transferred from the client to the gateway (inbound).*Shown as kilobit*                                                                                                                                                                                     |
| **aws.appstream.capacity_utilization**(count)                        | The average percentage of instances in a fleet that are being used*Shown as percent*                                                                                                                                                                                         |
| **aws.appstream.capacity_utilization.maximum**(count)                | The maximum percentage of instances in a fleet that are being used*Shown as percent*                                                                                                                                                                                         |
| **aws.appstream.capacity_utilization.minimum**(count)                | The minimum percentage of instances in a fleet that are being used*Shown as percent*                                                                                                                                                                                         |
| **aws.appstream.congestion_window**(gauge)                           | The size of the congestion window at the gateway for traffic flowing to the client.*Shown as byte*                                                                                                                                                                           |
| **aws.appstream.connection_duration**(gauge)                         | The duration of the streaming connection.*Shown as second*                                                                                                                                                                                                                   |
| **aws.appstream.cpu_queue_length**(gauge)                           | The number of threads waiting for CPU time on the instance.*Shown as thread*                                                                                                                                                                                                 |
| **aws.appstream.cpu_utilization_instance**(gauge)                   | The percentage of allocated compute units in use on the instance.*Shown as percent*                                                                                                                                                                                          |
| **aws.appstream.cpu_utilization_session**(gauge)                    | The percentage of allocated compute units in use by the session.*Shown as percent*                                                                                                                                                                                           |
| **aws.appstream.desired_capacity**(count)                            | The average number of instances that are either running or pending. This represents the total number of concurrent streaming sessions your fleet can support in a steady state                                                                                               |
| **aws.appstream.desired_capacity.maximum**(count)                    | The maximum number of instances that are either running or pending. This represents the total number of concurrent streaming sessions your fleet can support in a steady state                                                                                               |
| **aws.appstream.desired_capacity.minimum**(count)                    | The minimum number of instances that are either running or pending. This represents the total number of concurrent streaming sessions your fleet can support in a steady state                                                                                               |
| **aws.appstream.desired_user_session_capacity**(gauge)             | The total number of session slots that are either running or pending. This represents the total number of concurrent streaming sessions your fleet can support in a steady state.*Shown as session*                                                                          |
| **aws.appstream.disk_io_queue_length**(gauge)                      | The number of pending I/O requests waiting to be processed by the disk on the instance.*Shown as request*                                                                                                                                                                    |
| **aws.appstream.disk_read_operations**(count)                       | The number of disk read operations per instance.*Shown as operation*                                                                                                                                                                                                         |
| **aws.appstream.disk_utilization_instance**(gauge)                  | The percentage of the instance's available disk storage capacity in use.*Shown as percent*                                                                                                                                                                                   |
| **aws.appstream.disk_write_operations**(count)                      | The number of disk write operations per instance.*Shown as operation*                                                                                                                                                                                                        |
| **aws.appstream.drain_mode_active_user_session_capacity**(gauge) | The number of active user sessions on instances in Drain Mode.*Shown as session*                                                                                                                                                                                             |
| **aws.appstream.drain_mode_unused_user_session_capacity**(gauge) | The number of unused session slots on instances in Drain Mode that cannot be used for user session provisioning.*Shown as session*                                                                                                                                           |
| **aws.appstream.draining_capacity**(gauge)                           | The number of instances in Drain Mode.*Shown as instance*                                                                                                                                                                                                                    |
| **aws.appstream.frames_per_second**(gauge)                          | The number of frames sent per second from the instance to the client.*Shown as frame*                                                                                                                                                                                        |
| **aws.appstream.gpu_utilization_instance**(gauge)                   | The percentage of the GPU resource used on the instance.*Shown as percent*                                                                                                                                                                                                   |
| **aws.appstream.in_session_latency**(gauge)                         | The round-trip time between the client and the instance.*Shown as millisecond*                                                                                                                                                                                               |
| **aws.appstream.in_use_capacity**(count)                            | The average number of instances currently being used for streaming sessions                                                                                                                                                                                                  |
| **aws.appstream.in_use_capacity.maximum**(count)                    | The maximum number of instances currently being used for streaming sessions                                                                                                                                                                                                  |
| **aws.appstream.in_use_capacity.minimum**(count)                    | The minimum number of instances currently being used for streaming sessions                                                                                                                                                                                                  |
| **aws.appstream.insufficient_capacity_error**(count)                | The average number of session requests rejected due to lack of capacity                                                                                                                                                                                                      |
| **aws.appstream.insufficient_capacity_error.maximum**(count)        | The maximum number of session requests rejected due to lack of capacity                                                                                                                                                                                                      |
| **aws.appstream.insufficient_capacity_error.minimum**(count)        | The minimum number of session requests rejected due to lack of capacity                                                                                                                                                                                                      |
| **aws.appstream.insufficient_capacity_error.sum**(count)            | The sum of the number of session requests rejected due to lack of capacity                                                                                                                                                                                                   |
| **aws.appstream.insufficient_concurrency_limit_error**(count)      | The number of session requests to Elastic fleets that were rejected because the fleet reached its maximum concurrent streaming capacity.                                                                                                                                     |
| **aws.appstream.memory_page_hard_faults**(gauge)                   | The rate of hard page faults on the instance.*Shown as fault*                                                                                                                                                                                                                |
| **aws.appstream.memory_utilization_instance**(gauge)                | The percentage of allocated physical memory units in use on the instance.*Shown as percent*                                                                                                                                                                                  |
| **aws.appstream.memory_utilization_session**(gauge)                 | The percentage of allocated physical memory units in use by the session.*Shown as percent*                                                                                                                                                                                   |
| **aws.appstream.metadata_no_token**(count)                          | The number of times the instance metadata service was accessed without a token (IMDSv1). This metric helps identify workloads that have not yet migrated to IMDSv2.*Shown as request*                                                                                        |
| **aws.appstream.metadata_no_token_rejected**(count)                | The number of times an IMDSv1 request to the instance metadata service was rejected. This metric is available when the instance is configured to require IMDSv2.*Shown as request*                                                                                           |
| **aws.appstream.paging_file_utilization_instance**(gauge)          | The percentage of the paging file in use to extend the memory (RAM) capacity.*Shown as percent*                                                                                                                                                                              |
| **aws.appstream.pending_capacity**(count)                            | The average number of instances being provisioned by AppStream. Represents the additional number of streaming sessions the fleet can support after provisioning is complete                                                                                                  |
| **aws.appstream.pending_capacity.maximum**(count)                    | The maximum number of instances being provisioned by AppStream. Represents the additional number of streaming sessions the fleet can support after provisioning is complete                                                                                                  |
| **aws.appstream.pending_capacity.minimum**(count)                    | The minimum number of instances being provisioned by AppStream. Represents the additional number of streaming sessions the fleet can support after provisioning is complete                                                                                                  |
| **aws.appstream.pending_user_session_capacity**(gauge)             | The number of session slots being provisioned by AppStream. This represents the additional number of streaming sessions the fleet can support after provisioning is complete.*Shown as session*                                                                              |
| **aws.appstream.running_capacity**(count)                            | The average number of instances currently running. Represents the number of concurrent streaming sessions that can be supported by the fleet in its current state                                                                                                            |
| **aws.appstream.running_capacity.maximum**(count)                    | The maximum number of instances currently running. Represents the number of concurrent streaming sessions that can be supported by the fleet in its current state                                                                                                            |
| **aws.appstream.running_capacity.minimum**(count)                    | The minimum number of instances currently running. Represents the number of concurrent streaming sessions that can be supported by the fleet in its current state                                                                                                            |
| **aws.appstream.running_user_session_capacity**(gauge)             | The total number of session slots available for streaming or in use for streaming. This represents the number of concurrent streaming sessions that can be supported by the fleet in its current state. This metric is provided for Always-On fleets only.*Shown as session* |
| **aws.appstream.tcp_retransmission_rate**(gauge)                    | The percentage of TCP segments that were retransmitted from the gateway to the client.*Shown as percent*                                                                                                                                                                     |
| **aws.appstream.udp_packet_loss_rate**(gauge)                      | The percentage of UDP packets lost in traffic from the gateway to the client.*Shown as percent*                                                                                                                                                                              |

### Events{% #events %}

The Amazon AppStream integration does not include any events.

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

The Amazon AppStream integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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