Unlocking deeper insights with enhanced monitoring in AWS AppSync

In today’s digital landscape, how well your APIs work is important for a good user experience. Monitoring your APIs isn’t just smart—it’s needed to keep your apps running well.

AWS AppSync, a managed GraphQL service, is a popular choice for developers building scalable, real-time applications. With the introduction of Enhanced Monitoring, AppSync now provides deeper insights and more detailed metrics. In this blog post, we’ll show how this feature can help you monitor and optimise your APIs more effectively. We’ll also compare it to current monitoring tools, guide you through a sample API implementation, and break down the associated costs.

AWS AppSync overview

AWS AppSync simplifies the process of building and deploying secure, high-performance APIs. It’s a managed service for GraphQL and Pub/Sub APIs that abstracts away the complexities of infrastructure, allowing you to focus on what matters—building innovative applications.

With AppSync, you can create a unified data graph that brings together data from multiple sources. Whether you’re synchronizing real-time data, enabling offline access, or managing conflict resolution, AppSync provides the tools to make it happen. Its built-in security features and serverless architecture mean you can deploy APIs that are both robust and secure, without worrying about the underlying infrastructure.

The importance of monitoring in API management

Monitoring is a critical aspect of API management. It ensures that APIs are performing optimally, meeting service level objectives, and maintaining security standards. By regularly keeping a close eye on key metrics, you ensure that your APIs meet your service-level objectives (SLOs) and comply with security standards, ensuring a smooth and reliable experience. When you monitor metrics like latency, error rates, and request counts, you can detect anomalies early, troubleshoot root causes, and prevent small issues from escalating into user-facing problems. This approach of using telemetry from metrics to take proactive action aligns with best practices like OPS09-BP03 and is essential for the long-term reliability and scalability of your APIs.

Understanding existing monitoring in AWS AppSync

Basic monitoring with AWS CloudWatch

AWS AppSync integrates with Amazon CloudWatch, providing essential metrics that offer a high-level overview of your API’s performance. These include request latency, counts and error rates and more.

AppSync’s real-time subscriptions are a powerful feature, enabling push notifications and live updates. To monitor these, Amazon CloudWatch offers metrics such as the number of active real-time subscriptions, number of messages sent via subscription and more.

Check the full list of built-in metrics to identify overall trends and spikes at a glance.

Introducing enhanced monitoring in AWS AppSync

As applications become more complex and user demands grow, there is a growing need for more granular insights. Developers increasingly require additional metrics to pinpoint the precise stages of request processing that might contribute to latency or errors.

For instance, understanding the performance at the resolver level or tracking how individual data sources perform under load can be critical for fine-tuning and optimizing API operations. These detailed metrics empower developers to not only detect issues but also to understand the root causes, enabling more targeted and effective optimizations.

On February 12, 2024, AWS announced Enhanced Monitoring for AWS AppSync, Enhanced Monitoring in AWS AppSync gives developers access to a more detailed view of their API’s performance. This feature provides real-time insights and granular metrics, allowing you to drill down into specific operations, resolvers, and data sources.

Key features of enhanced monitoring

• Resolver-Level Metrics: Track the performance of individual resolvers to pinpoint latency and errors. This allows for targeted optimizations, ensuring your API performs efficiently at every stage.
• Data Source Monitoring: Gain detailed insights into how your data sources—whether Amazon DynamoDB, Amazon RDS, or AWS Lambda—are performing. Identifying performance bottlenecks at the source level becomes easier, allowing you to take corrective action quickly.
• Operational metrics: Get detailed metrics on GraphQL operation-level (Mutations & Queries) metrics.

In total, 10 new CloudWatch metrics were added under the “Enhanced metrics” section of the official documentation.

Sample API implementation with enhanced monitoring

To demonstrate the power of Enhanced Monitoring, let’s walk through a sample AWS AppSync API implementation. This API will include three queries and two mutations, connected to four different data sources: Amazon DynamoDB, AWS Lambda, and Amazon OpenSearch Service.

We will create an API that supports the following operations:

Queries:

• getUser: Retrieve user details by ID.
• listUsers: List all users.
• searchUsers: Search users by a specific attribute.

Mutations:

• createUser: Add a new user.
• updateUser: Update existing user details.

Data Sources:

• DynamoDB: To store user data.
• AWS Lambda: For complex business logic processing (used for createUser and updateUser mutations).
• Amazon OpenSearch Service: To enable search functionality.

Step-by-step setup

Prerequisites:

• An active AWS account: If you don’t have one, you can create an AWS account to get started.
• Valid AWS credentials: You need an IAM user with permissions to manage AWS AppSync APIs (create, update, delete, view) and to view related CloudWatch metrics and alarms. This can be granted by attaching the AWS managed policies AWSAppSyncAdministrator and CloudWatchReadOnlyAccess, or equivalent custom permissions. You will use these credentials to sign in to AWS Management Console.

Here’s how you can enable enhanced monitoring in AWS AppSync using different methods:

Method 1: Enabling enhanced monitoring via the AWS Management Console:

1. Navigate to the AppSync Console:
   1. Sign in to the AWS Management Console.
   2. Navigate to the AppSync service by searching for “AppSync” in the AWS services search bar.
2. Select Your GraphQL API:
   1. In the AppSync console, click on the API for which you want to enable enhanced monitoring.
3. Go to the Settings:
   1. Select “Settings” from the left-hand menu.
4. Enable Enhanced Monitoring:
   

   Figure 1: AWS AppSync Console ‘Settings’ tab showing the toggles for Enhanced Monitoring

   1. In the API Configuration section, you’ll see an option to enable Enhanced Monitoring.
   2. Here you can either enable metrics for all resolvers and data sources or can choose to manually select them by choosing “PER_RESOLVER_METRICS” and “PER_DATA_SOURCE_METRICS”, respectively, as stated in the documentation.
   3. For per-resolver and per-data source metrics, metrics need to be enabled individually on each resolver and data source.

Method 2: Enabling enhanced monitoring via the AWS CLI

aws appsync update-graphql-api \
--api-id <API_ID> \
--name "<API_NAME>" \
--authentication-type API_KEY \
--enhanced-metrics-config resolverLevelMetricsBehavior=FULL_REQUEST_RESOLVER_METRICS,dataSourceLevelMetricsBehavior=FULL_REQUEST_DATA_SOURCE_METRICS,operationLevelMetricsConfig=ENABLE

Method 3: Enabling enhanced monitoring via Terraform

Following the AWS Provider documentation, adding the block enhanced_metrics_configto an existing resource will enable enhanced monitoring, eg:

resource "aws_appsync_graphql_api" "api" {
  authentication_type = "API_KEY"
  name                = "<API_NAME>"
  enhanced_metrics_config {
    resolver_level_metrics_behavior     = "FULL_REQUEST_RESOLVER_METRICS"
    data_source_level_metrics_behavior  = "FULL_REQUEST_DATA_SOURCE_METRICS"
    operation_level_metrics_config      = "ENABLED"
  }
}

Metrics dashboard

With Enhanced Monitoring enabled, you can now observe detailed metrics in the Amazon CloudWatch dashboard. For example, if the SearchUsers query is experiencing high latency, you can quickly identify whether the issue lies with the Amazon OpenSearch Service data source or the Lambda resolver. The Amazon CloudWatch dashboard will display metrics such as resolver execution time and data source response time, allowing you to pinpoint the exact cause of any performance issues.

Additional API metrics in Amazon CloudWatch metrics

Useful dimensions and metrics include:

• DataSource, GraphQLAPIId
• API Metrics by Operation
• GraphQLAPIId, Resolver

Figure 2: A screenshot of AWS AppSync API Metrics in Amazon CloudWatch

API Metrics per resolver

Figure 3: AWS AppSync API Metrics by Resolver

API Metrics per DataSource

Figure 4: AWS AppSync API Metrics by Datasource

API Metrics per Operation

Figure 5: AWS AppSync API Metrics by Operation

API metrics custom dashboard with enhanced metrics

With AWS AppSync’s enhanced monitoring metrics, you can create a custom CloudWatch dashboard to get a real-time view of your API’s performance and display key KPIs like resolver latency, error rates, throttling, and data source performance. This helps quickly identify bottlenecks, track usage patterns, and optimise API efficiency.

For example, you can set up widgets on your Amazon CloudWatch dashboard to monitor:

• Resolver Request Count: This will provide insights into usage patterns, guiding the team to optimise the most frequently used data sources and resolvers.
• Resolver Latency: Track the time taken by each resolver to process requests, helping you pinpoint areas that may require optimisation.
• Data Source Performance: Visualise the interaction between your API and its data sources, such as DynamoDB or Lambda, to ensure they are performing within acceptable thresholds.
• Error Rates: Display the number of errors encountered by each resolver or data source, enabling you to identify and address issues before they impact users.

By aggregating these metrics into a single dashboard, you gain a holistic view of your API’s health, enabling proactive management and optimisation to deliver a seamless user experience.

Figure 6: Custom Amazon CloudWatch dashboard to show API Metrics

SELECT
line_item_operation,
SUM(CAST(line_item_unblended_cost AS decimal(16,8))) AS TotalSpend
FROM ''
WHERE
product_product_name = 'AmazonCloudWatch'
AND line_item_usage_account_id = ''
AND product_region = ''
AND line_item_operation in ('MetricStorage:AWS/AppSync', 'GetMetricData', 'ListMetrics', 'GetMetricStatistics', 'PutMetricData')
AND line_item_line_item_type NOT IN ('Tax','Credit','Refund','EdpDiscount','Fee','RIFee')
AND line_item_usage_start_date > DATE('2024-07-20')
AND line_item_usage_end_date < DATE('2024-07-30')
GROUP BY line_item_operation
ORDER BY TotalSpend DESC;

# line_item_operation TotalSpend
1 GetMetricData 59.11682000
2 MetricStorage:AWS/AppSync 0.56626344
3 PutMetricData 0.42279000
4 ListMetrics 0.00248000
5 GetMetricStatistics 0.00028000