AWS Cloudwatch Investigation

GitHubOfficialFirst committed by starlightretailceoDistributed by GitHub

Skill
Guidelines
Cloud and DevOps
MIT
No issues found

From the author

Reusable investigation patterns for AWS CloudWatch: Logs Insights query templates, alarm-to-deployment correlation, blast-radius narrowing decision tree, and PromQL-style metric query patterns for structured incident triage.

— the description by starlightretailceo

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive set of reusable patterns for incident triage within AWS CloudWatch. It includes specific query templates for Logs Insights, methods for correlating alarms with deployment events, a systematic decision tree for narrowing the blast radius of an incident, and metric math patterns for advanced signal analysis. The skill is designed to help engineers move from initial alarm notification to root cause identification through a standardized, repeatable process.

What it does

Provides pre-built Logs Insights queries for error, latency, cold start, OOM, and timeout detection.
Defines a process for correlating alarm state transitions with recent deployment events via CloudTrail.
Offers a step-by-step decision tree to isolate incidents by account, region, service, operation, and resource.
Includes metric math templates for calculating error rates, latency anomalies, and throttling pressure.
Outlines a methodology for reconstructing incident timelines by merging data from multiple AWS sources.
Highlights common pitfalls in timestamp interpretation and data latency across AWS services.

When to use it

During active production incident triage to quickly identify the scope and cause of an issue.
When investigating performance regressions or error spikes in AWS Lambda or ECS environments.
To verify if a recent deployment or configuration change triggered an alarm.
When building custom dashboards to monitor service health and dependency pressure.
To standardize the incident response process across engineering teams.

Advantages

Reduces mean time to resolution (MTTR) by providing ready-to-use diagnostic queries.
Promotes a consistent, logical approach to incident investigation.
Helps distinguish between service-level issues and specific resource failures.
Enables advanced monitoring through composite metric signals.
Provides clear guidance on handling common data skew and delay issues in AWS logs.

Usage examples

“I have a Lambda function failing with timeouts. How can I find the specific invocations?”: The agent provides a Logs Insights query template specifically designed to filter for 'Task timed out' messages or durations exceeding 28 seconds, grouped by log stream.
“How do I check if a deployment caused my current CloudWatch alarm?”: The agent guides you through a CloudTrail query to identify deployment events within the 30-minute window preceding the alarm and provides criteria to determine if the correlation is strong.
“My service is showing high error rates. How do I narrow down the blast radius?”: The agent walks you through a 5-step decision tree, starting from account and region level down to specific resource instances, to systematically isolate the failure point.
“Can you help me create a metric that shows combined throttling pressure?”: The agent provides a MetricDataQuery template that sums Lambda throttles, API Gateway 4XX errors, and DynamoDB throttled requests into a single 'throttle_pressure' signal.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/github/aws-cloudwatch-investigation/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip aws-cloudwatch-investigation.zip -d .agents/skills

Documentation by starlightretailceo

AWS CloudWatch Investigation Skill

Reusable patterns for investigating production incidents using CloudWatch Logs, Metrics, and Alarms. These patterns are designed to be composed together during incident triage.

Pattern 1: Logs Insights Query Templates

Error Spike Detection

Find the top errors in a time window, grouped by error type:

fields @timestamp, @message, @logStream
| filter @message like /(?i)(error|exception|fatal|critical)/
| stats count(*) as errorCount by bin(5m), @logStream
| sort errorCount desc
| limit 20

P99 Latency Breakdown by Operation

Identify which operations are driving latency spikes:

fields @timestamp, @duration, operation
| filter ispresent(@duration)
| stats avg(@duration) as avgMs,
        pct(@duration, 50) as p50Ms,
        pct(@duration, 95) as p95Ms,
        pct(@duration, 99) as p99Ms,
        count(*) as invocations
  by operation
| sort p99Ms desc
| limit 15

Lambda Cold Start Detection

Quantify cold start impact during an incident:

fields @timestamp, @duration, @initDuration, @memorySize, @maxMemoryUsed
| filter ispresent(@initDuration)
| stats count(*) as coldStarts,
        avg(@initDuration) as avgInitMs,
        max(@initDuration) as maxInitMs,
        avg(@duration) as avgDurationMs
  by bin(5m)
| sort @timestamp desc

Out-of-Memory (OOM) Detection

Find Lambda functions or containers killed by memory pressure:

fields @timestamp, @message, @logStream, @memorySize, @maxMemoryUsed
| filter @message like /Runtime exited|out of memory|OOMKilled|Cannot allocate memory|MemoryError/
| stats count(*) as oomEvents by @logStream, bin(10m)
| sort oomEvents desc
| limit 10

For memory utilization trending before OOM:

fields @timestamp, @maxMemoryUsed, @memorySize
| filter ispresent(@maxMemoryUsed)
| stats max(@maxMemoryUsed / @memorySize * 100) as peakMemPct,
        avg(@maxMemoryUsed / @memorySize * 100) as avgMemPct
  by bin(5m)
| sort @timestamp desc

Timeout Detection

Find invocations that hit the configured timeout:

fields @timestamp, @duration, @logStream, @requestId
| filter @message like /Task timed out/ or @duration > 28000
| stats count(*) as timeouts by @logStream, bin(5m)
| sort timeouts desc

Pattern 2: Alarm History to Deploy-Event Correlation

Process

Get alarm transition time — note the exact timestamp when the alarm entered ALARM state.
Query CloudTrail for deployment-related events in a window of [alarm_time - 30min, alarm_time]:

# CloudTrail Lake query for deployment events
SELECT eventTime, eventName, userIdentity.arn, requestParameters
FROM <event-data-store-id>
WHERE eventTime > '<alarm_time_minus_30m>'
  AND eventTime < '<alarm_time>'
  AND eventName IN (
    'UpdateFunctionCode', 'UpdateFunctionConfiguration',
    'UpdateService', 'CreateDeployment', 'RegisterTaskDefinition',
    'CreateChangeSet', 'ExecuteChangeSet',
    'StartPipelineExecution', 'PutImage'
  )
ORDER BY eventTime DESC

Correlation criteria — a deploy is "correlated" if:
- It targets the same service/resource as the alarm
- It completed within 15 minutes before the alarm transition
- The deployer identity matches a CI/CD role (not a human applying a hotfix)
Strengthening the correlation:
- Check if the same alarm was healthy in the previous deployment cycle
- Verify no other environmental changes (scaling events, config changes) in the same window
- Look for canary/synthetic monitor failures that started at the same time

Output Format

Deploy Correlation:
  Event: UpdateFunctionCode
  Time: 2024-03-15T14:23:07Z (12 min before alarm)
  Actor: arn:aws:sts::123456789012:assumed-role/github-actions-deploy/session
  Resource: arn:aws:lambda:us-east-1:123456789012:function:payment-processor
  Correlation: STRONG — same resource, CI/CD actor, alarm was OK prior cycle

Pattern 3: Narrow the Blast Radius Decision Tree

Use this tree to systematically scope an incident from broadest to most specific:

START
  |
  v
[1] ACCOUNT — Which account(s) show the alarm?
  |  - Check: Are alarms firing in multiple accounts?
  |  - If yes → suspect shared service (SSO, networking, shared deployment pipeline)
  |  - If no → proceed to Region
  v
[2] REGION — Which region(s) are affected?
  |  - Check: Same alarm in other regions?
  |  - If multi-region → suspect global service (IAM, Route53, S3 global)
  |  - If single-region → proceed to Service
  v
[3] SERVICE — Which service namespace shows degradation?
  |  - Check CloudWatch namespace: AWS/Lambda, AWS/ECS, AWS/ApiGateway, etc.
  |  - If multiple services → suspect shared dependency (VPC, NAT, DNS, IAM)
  |  - If single service → proceed to Operation
  v
[4] OPERATION — Which API action or function is failing?
  |  - For Lambda: which function name?
  |  - For ECS: which service/task definition?
  |  - For API GW: which stage/resource/method?
  |  - If all operations → suspect service-level issue (throttling, quota)
  |  - If specific operation → proceed to Resource
  v
[5] RESOURCE — Which specific resource instance?
     - Function ARN, Task ID, DB instance identifier
     - This is your investigation target
     - Proceed to log and trace analysis scoped to this resource

Shared Dependency Investigation

When blast radius spans multiple services, investigate in this order:

VPC/Networking — NAT Gateway ErrorPortAllocation, packet drops, DNS resolution failures
IAM/STS — ThrottlingException on AssumeRole, token vending latency
Downstream dependency — shared database, cache, or external API
Deployment pipeline — simultaneous deploys across services from same pipeline run
AWS service event — check AWS Health Dashboard and Service Health for the region

Pattern 4: PromQL-Style Metric Query Patterns

These patterns use CloudWatch metric math and GetMetricData to build composite signals. Express them as metric queries for dashboards or programmatic retrieval.

Error Rate as Percentage

MetricDataQueries:
  - Id: errors
    MetricStat:
      Metric:
        Namespace: AWS/Lambda
        MetricName: Errors
        Dimensions: [{Name: FunctionName, Value: TARGET}]
      Period: 60
      Stat: Sum
  - Id: invocations
    MetricStat:
      Metric:
        Namespace: AWS/Lambda
        MetricName: Invocations
        Dimensions: [{Name: FunctionName, Value: TARGET}]
      Period: 60
      Stat: Sum
  - Id: error_rate
    Expression: "errors / invocations * 100"
    Label: "Error Rate %"

Latency Anomaly Detection (Compare to Baseline)

MetricDataQueries:
  - Id: current_p99
    MetricStat:
      Metric:
        Namespace: AWS/Lambda
        MetricName: Duration
        Dimensions: [{Name: FunctionName, Value: TARGET}]
      Period: 300
      Stat: p99
  - Id: baseline_p99
    MetricStat:
      Metric:
        Namespace: AWS/Lambda
        MetricName: Duration
        Dimensions: [{Name: FunctionName, Value: TARGET}]
      Period: 300
      Stat: p99
    # Use StartTime/EndTime set to same window last week
  - Id: anomaly_ratio
    Expression: "current_p99 / baseline_p99"
    Label: "Latency vs Baseline (ratio > 2 = anomaly)"

Throttling Pressure Score

Combine multiple throttling signals into a single pressure metric:

MetricDataQueries:
  - Id: lambda_throttles
    MetricStat:
      Metric: {Namespace: AWS/Lambda, MetricName: Throttles}
      Period: 60
      Stat: Sum
  - Id: api_gw_429s
    MetricStat:
      Metric: {Namespace: AWS/ApiGateway, MetricName: 4XXError, Dimensions: [{Name: ApiName, Value: TARGET}]}
      Period: 60
      Stat: Sum
  - Id: dynamo_throttles
    MetricStat:
      Metric: {Namespace: AWS/DynamoDB, MetricName: ThrottledRequests, Dimensions: [{Name: TableName, Value: TARGET}]}
      Period: 60
      Stat: Sum
  - Id: throttle_pressure
    Expression: "lambda_throttles + api_gw_429s + dynamo_throttles"
    Label: "Combined Throttle Pressure"

Concurrent Execution Headroom

MetricDataQueries:
  - Id: concurrent
    MetricStat:
      Metric: {Namespace: AWS/Lambda, MetricName: ConcurrentExecutions}
      Period: 60
      Stat: Maximum
  - Id: headroom
    Expression: "1000 - concurrent"
    Label: "Remaining Concurrency (account limit 1000)"

Pattern 5: Incident Timeline Reconstruction

Process

Reconstruct a precise timeline by merging data from multiple sources:

Collect timestamps:

Source	Query	Yields
CloudWatch Alarms	Alarm history API	State transition times
CloudWatch Metrics	GetMetricData with 1-min period	First anomaly point
CloudWatch Logs	Logs Insights with `earliest(@timestamp)`	First error occurrence
CloudTrail	LookupEvents filtered by time	Deployment/change events
AWS Health	DescribeEvents	AWS-side incidents

Build the timeline:

fields @timestamp, @message
| filter @message like /ERROR|WARN|timeout|refused|denied/
| stats earliest(@timestamp) as firstSeen, latest(@timestamp) as lastSeen, count(*) as occurrences
  by @message
| sort firstSeen asc
| limit 20

Identify the sequence:

Timeline:
  T-15m: CloudTrail — UpdateFunctionCode by CI/CD role
  T-12m: Logs — first error "Connection refused to payments-api.internal"
  T-10m: Metrics — Error count crosses 5/min threshold
  T-8m:  Alarm — PaymentProcessorErrors enters ALARM
  T-5m:  Metrics — p99 latency spikes to 28s (timeout)
  T-0:   Current — error rate at 45%, alarm still firing

Determine root event — the earliest change that preceded all symptoms. Walk backward from the first symptom to the most recent mutation (deploy, config change, scaling event, or external dependency shift).

Gotchas

CloudWatch metric timestamps are end-of-period. A 1-minute datapoint at 14:05 covers 14:04-14:05.
CloudTrail events can have up to 15-minute delivery delay. Use eventTime, not ingestion time.
Log group timestamps depend on the agent/SDK flush interval. Allow for 30-60s of clock skew.
Alarm state changes have a built-in evaluation delay (periods x evaluation periods). The actual anomaly started earlier.

Files

ATTRIBUTION.mdAdded by AutoGineer909 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md10.3 KiB

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by

starlightretailceo

Publisher

GitHub (Official)

Distributed by

GitHub

Source

github/awesome-copilot · skills/aws-cloudwatch-investigation · commit 797337f

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

Contributors

starlightretailceo, sukanth

AutoGineer is not affiliated with or endorsed by starlightretailceo or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download aws-cloudwatch-investigation.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by starlightretailceo

AWS CloudWatch Investigation Skill

Pattern 1: Logs Insights Query Templates

Error Spike Detection

P99 Latency Breakdown by Operation

Lambda Cold Start Detection

Out-of-Memory (OOM) Detection

Timeout Detection

Pattern 2: Alarm History to Deploy-Event Correlation

Process

Output Format

Pattern 3: Narrow the Blast Radius Decision Tree

Shared Dependency Investigation

Pattern 4: PromQL-Style Metric Query Patterns

Error Rate as Percentage

Latency Anomaly Detection (Compare to Baseline)

Throttling Pressure Score

Concurrent Execution Headroom

Pattern 5: Incident Timeline Reconstruction

Process

Gotchas

Files

Requirements and compatibility

Security

Attribution and licence

Related skills

Spark Memory Thermal Ops

Observability And Instrumentation

Gke Alert Configuration

Application Performance Observability Engineer

Distributed Debugging Devops Troubleshooter

Distributed Tracing

Download ZIP