---
title: AWS AppSync
description: >-
  Simplify app development with AppSync's flexible, secure API for accessing and
  combining data from various sources.
breadcrumbs: Docs > Integrations > AWS AppSync
---

# AWS AppSync
Integration version1.0.0
## Overview{% #overview %}

AWS AppSync simplifies application development by letting you create a flexible API to securely access, manipulate, and combine data from one or more data sources.

Enable this integration to see all your AppSync 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/) first.

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

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

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

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

Configure AWS AppSync to send logs either to a S3 bucket or to CloudWatch.

**Note**: If you log to a S3 bucket, make sure that `amazon_appsync` 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/?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/#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/).

1. Once the Lambda function is installed, manually add a trigger on the S3 bucket or CloudWatch log group that contains your AWS AppSync 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/#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/#collecting-logs-from-cloudwatch-log-group)

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.appsync.4xxerror**(count)                              | The number of errors captured as a result of invalid requests due to incorrect client configuration.*Shown as error*                                                                                                                                 |
| **aws.appsync.5xxerror**(count)                              | Errors encountered during the execution of a GraphQL query.*Shown as error*                                                                                                                                                                          |
| **aws.appsync.active\_connections**(count)                   | The number of concurrent WebSocket connections from clients to AWS AppSync in 1 minute.                                                                                                                                                              |
| **aws.appsync.active\_subscriptions**(count)                 | The number of concurrent subscriptions from clients in 1 minute.                                                                                                                                                                                     |
| **aws.appsync.broadcast\_delayed\_events**(count)            | The number of delayed broadcast events.*Shown as event*                                                                                                                                                                                              |
| **aws.appsync.broadcast\_dropped\_events**(count)            | The number of dropped broadcast events.*Shown as event*                                                                                                                                                                                              |
| **aws.appsync.broadcast\_event\_client\_error**(count)       | The number of events that failed to broadcast because of client-side errors.*Shown as event*                                                                                                                                                         |
| **aws.appsync.broadcast\_event\_server\_error**(count)       | The number of errors that originated from AWS AppSync while broadcasting events.*Shown as error*                                                                                                                                                     |
| **aws.appsync.broadcast\_event\_size**(count)                | The size of events broadcast.*Shown as byte*                                                                                                                                                                                                         |
| **aws.appsync.broadcast\_event\_success**(count)             | The number of events that were successfully broadcast to subscribers.*Shown as event*                                                                                                                                                                |
| **aws.appsync.cache\_hit**(count)                            | The total number of cache hits during a requests. This will only be emitted if a cache is used. Cache hits are recorded on a per-resolver basis.*Shown as hit*                                                                                       |
| **aws.appsync.cache\_miss**(count)                           | The total number of cache misses during requests. This will only be emitted if a cache is used. Cache misses are recorded on a per-resolver basis.*Shown as miss*                                                                                    |
| **aws.appsync.connect\_client\_error**(count)                | The number of WebSocket connections that were rejected by AWS AppSync because of client-side errors. This could imply that the service is throttled or the Authorization settings are misconfigured.*Shown as error*                                 |
| **aws.appsync.connect\_requests**(count)                     | The number of WebSocket connection requests made to AWS AppSync, including both successful and unsuccessful attempts.*Shown as request*                                                                                                              |
| **aws.appsync.connect\_server\_error**(count)                | The number of errors that originated from AWS AppSync while processing connections. This is known to happen when an unexpected server-side issue occurs.*Shown as error*                                                                             |
| **aws.appsync.connect\_success**(count)                      | The number of successful WebSocket connections to AWS AppSync. It is possible to have connections without subscriptions.*Shown as success*                                                                                                           |
| **aws.appsync.connection\_duration**(count)                  | The amount of time that the connection stays open.*Shown as millisecond*                                                                                                                                                                             |
| **aws.appsync.disconnect\_client\_error**(count)             | The number of client errors that originated from AWS AppSync while disconnecting WebSocket connections.*Shown as error*                                                                                                                              |
| **aws.appsync.disconnect\_server\_error**(count)             | The number of server errors that originated from AWS AppSync while disconnecting WebSocket connections.*Shown as error*                                                                                                                              |
| **aws.appsync.disconnect\_success**(count)                   | The number of successful WebSocket disconnections from AWS AppSync.*Shown as success*                                                                                                                                                                |
| **aws.appsync.dropped\_events**(count)                       | The count of input events filtered by a OnPublish handler.*Shown as event*                                                                                                                                                                           |
| **aws.appsync.failed\_events**(count)                        | The count of input events that encountered error during processing.*Shown as event*                                                                                                                                                                  |
| **aws.appsync.graphql\_error**(count)                        | The number of GraphQL errors that occurred.*Shown as error*                                                                                                                                                                                          |
| **aws.appsync.inbound\_messages**(count)                     | The number of inbound metered events.*Shown as message*                                                                                                                                                                                              |
| **aws.appsync.inbound\_message\_delayed**(count)             | The number of delayed inbound messages. Inbound messages can be delayed when either the inbound message rate quota or outbound message rate quota is breached.*Shown as message*                                                                     |
| **aws.appsync.inbound\_message\_dropped**(count)             | The number of dropped inbound messages. Inbound messages can be dropped when either the inbound message rate quota or outbound message rate quota is breached.*Shown as message*                                                                     |
| **aws.appsync.inbound\_message\_error**(count)               | The number of inbound messages that failed processing due to invalid API requests, such as exceeding the 240 kB subscription payload size limit.*Shown as message*                                                                                   |
| **aws.appsync.inbound\_message\_failure**(count)             | The number of inbound messages that failed processing due to errors from AWS AppSync.*Shown as message*                                                                                                                                              |
| **aws.appsync.inbound\_message\_success**(count)             | The number of inbound messages successfully processed. Each subscription type invoked by a mutation generates one inbound message.*Shown as message*                                                                                                 |
| **aws.appsync.invalidation\_request\_dropped**(count)        | The number of invalidation requests dropped when the invalidation request quota was exceeded.*Shown as request*                                                                                                                                      |
| **aws.appsync.invalidation\_request\_error**(count)          | The number of invalidation requests that failed processing due to invalid API requests.*Shown as request*                                                                                                                                            |
| **aws.appsync.invalidation\_request\_failure**(count)        | The number of invalidation requests that failed processing due to errors from AWS AppSync.*Shown as request*                                                                                                                                         |
| **aws.appsync.invalidation\_request\_success**(count)        | The number of invalidation requests successfully processed.*Shown as request*                                                                                                                                                                        |
| **aws.appsync.invalidation\_success**(count)                 | The number of subscriptions successfully invalidated (unsubscribed).                                                                                                                                                                                 |
| **aws.appsync.latency**(gauge)                               | The average time between when AWS AppSync receives a request from a client and when it returns a response to the client. This doesn't include the network latency encountered for a response to reach the end devices.*Shown as millisecond*         |
| **aws.appsync.latency.maximum**(gauge)                       | The maximum time between when AWS AppSync receives a request from a client and when it returns a response to the client. This doesn't include the network latency encountered for a response to reach the end devices.*Shown as millisecond*         |
| **aws.appsync.latency.p90**(gauge)                           | The 90th percentile time between when AWS AppSync receives a request from a client and when it returns a response to the client. This doesn't include the network latency encountered for a response to reach the end devices.*Shown as millisecond* |
| **aws.appsync.outbound\_messages**(count)                    | The number of metered messages successfully published.*Shown as message*                                                                                                                                                                             |
| **aws.appsync.publish\_data\_message\_client\_error**(count) | The number of subscription event messages that failed to publish because of client-side errors.*Shown as error*                                                                                                                                      |
| **aws.appsync.publish\_data\_message\_server\_error**(count) | The number of errors that originated from AWS AppSync while publishing subscription event messages. This is known to happen when an unexpected server-side issue occurs.*Shown as error*                                                             |
| **aws.appsync.publish\_data\_message\_size**(gauge)          | The size of subscription event messages published.*Shown as byte*                                                                                                                                                                                    |
| **aws.appsync.publish\_data\_message\_success**(count)       | The number of subscription event messages that were successfully published.*Shown as success*                                                                                                                                                        |
| **aws.appsync.publish\_handler\_invocations**(count)         | The number of OnPublish handler invocations.                                                                                                                                                                                                         |
| **aws.appsync.requests**(count)                              | The number of requests (queries + mutations) that all APIs in your account have processed.*Shown as request*                                                                                                                                         |
| **aws.appsync.subscribe\_client\_error**(count)              | The number of subscriptions that were rejected by AWS AppSync because of client-side errors. This can occur when a JSON payload is incorrect, the service is throttled, or the Authorization settings are misconfigured.*Shown as error*             |
| **aws.appsync.subscribe\_handler\_invocations**(count)       | The number of Subscribe handlers invoked.                                                                                                                                                                                                            |
| **aws.appsync.subscribe\_server\_error**(count)              | The number of errors that originated from AWS AppSync while processing subscriptions. This is known to happen when an unexpected server-side issue occurs.*Shown as error*                                                                           |
| **aws.appsync.subscribe\_success**(count)                    | The number of subscriptions that were successfully registered to AWS AppSync through WebSocket. It is possible to have connections without subscriptions, but it isn't possible to have subscriptions without connections.*Shown as success*         |
| **aws.appsync.successful\_events**(count)                    | The count of input events that were processed successfully and submitted for broadcast in the OnPublish handler.*Shown as event*                                                                                                                     |
| **aws.appsync.tokens\_consumed**(count)                      | The number of tokens allocated to processed requests.*Shown as token*                                                                                                                                                                                |
| **aws.appsync.unsubscribe\_client\_error**(count)            | The number of unsubscriptions that were rejected by AWS AppSync because of client-side errors.*Shown as error*                                                                                                                                       |
| **aws.appsync.unsubscribe\_server\_error**(count)            | The number of errors that originated from AWS AppSync while processing unsubscriptions. This is known to happen when an unexpected server-side issue occurs.*Shown as error*                                                                         |
| **aws.appsync.unsubscribe\_success**(count)                  | The number of unsubscriptions that were successfully processed from AWS AppSync.*Shown as success*                                                                                                                                                   |

### Events{% #events %}

The AWS AppSync integration does not include any events.

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

The AWS AppSync integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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