Skip to content

itsmostafa/aws-agent-skills / skills/lambda

lambda

Verified

AWS Lambda serverless functions for event-driven compute. Use when creating functions, configuring triggers, debugging invocations, optimizing cold starts, setting up event source mappings, or managing layers.

FileKindSize
SKILL.mdskill md8.4 KB
debugging.mdmarkdown8.5 KB
deployment.mdmarkdown7.1 KB

debugging.md

View on GitHub
# Lambda Debugging Guide

Techniques for debugging and troubleshooting Lambda functions.

## CloudWatch Logs

### View Logs

```bash
# Get log group
aws logs describe-log-groups \
  --log-group-name-prefix /aws/lambda/MyFunction

# Get recent log streams
aws logs describe-log-streams \
  --log-group-name /aws/lambda/MyFunction \
  --order-by LastEventTime \
  --descending \
  --limit 5

# View log events
aws logs get-log-events \
  --log-group-name /aws/lambda/MyFunction \
  --log-stream-name '2024/01/15/[$LATEST]abc123' \
  --limit 100
```

### Filter Logs

```bash
# Find errors
aws logs filter-log-events \
  --log-group-name /aws/lambda/MyFunction \
  --filter-pattern "ERROR" \
  --start-time $(date -d '1 hour ago' +%s000)

# Find specific request
aws logs filter-log-events \
  --log-group-name /aws/lambda/MyFunction \
  --filter-pattern "request-id-12345"
```

### CloudWatch Logs Insights

```bash
# Query for errors with context
aws logs start-query \
  --log-group-name /aws/lambda/MyFunction \
  --start-time $(date -d '1 hour ago' +%s) \
  --end-time $(date +%s) \
  --query-string '
    fields @timestamp, @message, @requestId
    | filter @message like /ERROR/
    | sort @timestamp desc
    | limit 50
  '
```

Common queries:

```sql
-- Cold starts
fields @timestamp, @duration, @billedDuration
| filter @type = "REPORT"
| filter @initDuration > 0
| sort @timestamp desc
| limit 50

-- Slow invocations
fields @timestamp, @requestId, @duration
| filter @type = "REPORT"
| filter @duration > 1000
| sort @duration desc
| limit 20

-- Memory usage
fields @timestamp, @requestId, @maxMemoryUsed, @memorySize
| filter @type = "REPORT"
| stats avg(@maxMemoryUsed), max(@maxMemoryUsed), avg(@memorySize) by bin(1h)

-- Error rate
fields @timestamp
| filter @type = "REPORT"
| stats count(*) as total,
        sum(strcontains(@message, "Error")) as errors,
        sum(strcontains(@message, "Error")) * 100.0 / count(*) as errorRate
  by bin(5m)
```

## X-Ray Tracing

### Enable X-Ray

```bash
aws lambda update-function-configuration \
  --function-name MyFunction \
  --tracing-config Mode=Active
```

### Instrument Code

```python
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all

# Patch AWS SDK calls
patch_all()

def handler(event, context):
    # Create custom subsegment
    with xray_recorder.in_subsegment('process_data') as subsegment:
        subsegment.put_annotation('user_id', event.get('user_id'))
        result = process_data(event)

    return result
```

### Query Traces

```bash
# Get trace summaries
aws xray get-trace-summaries \
  --start-time $(date -d '1 hour ago' -u +%Y-%m-%dT%H:%M:%SZ) \
  --end-time $(date -u +%Y-%m-%dT%H:%M:%SZ) \
  --filter-expression 'service(id(name: "MyFunction")) AND responsetime > 1'
```

## Local Testing

### SAM Local

```bash
# Invoke locally
sam local invoke MyFunction --event event.json

# Start local API
sam local start-api

# Debug with IDE
sam local invoke MyFunction --event event.json --debug-port 5678
```

### Docker Lambda Runtime

```bash
# Run function locally
docker run --rm \
  -v $(pwd):/var/task \
  -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID \
  -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY \
  public.ecr.aws/lambda/python:3.12 \
  lambda_function.handler '{"key": "value"}'
```

### Unit Testing

```python
import json
import pytest
from unittest.mock import patch, MagicMock

# Import handler
from lambda_function import handler

class TestHandler:
    def test_successful_request(self):
        event = {"body": json.dumps({"name": "test"})}
        context = MagicMock()

        result = handler(event, context)

        assert result["statusCode"] == 200

    @patch('lambda_function.dynamodb')
    def test_dynamo_error(self, mock_dynamo):
        mock_dynamo.Table.return_value.get_item.side_effect = Exception("DB Error")

        event = {"id": "123"}
        context = MagicMock()

        result = handler(event, context)

        assert result["statusCode"] == 500
```

## Common Issues

### Timeout Debugging

```python
import time
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def handler(event, context):
    start = time.time()

    # Log remaining time periodically
    def check_time(operation):
        elapsed = time.time() - start
        remaining = context.get_remaining_time_in_millis() / 1000
        logger.info(f"{operation}: elapsed={elapsed:.2f}s, remaining={remaining:.2f}s")

    check_time("start")

    result1 = step1()
    check_time("after step1")

    result2 = step2()
    check_time("after step2")

    return {"statusCode": 200}
```

### Memory Issues

```python
import sys
import tracemalloc

def handler(event, context):
    tracemalloc.start()

    # Your code here
    result = process(event)

    current, peak = tracemalloc.get_traced_memory()
    print(f"Current memory: {current / 1024 / 1024:.2f} MB")
    print(f"Peak memory: {peak / 1024 / 1024:.2f} MB")
    tracemalloc.stop()

    return result
```

### Connection Issues

```python
import socket
import urllib.request

def handler(event, context):
    # Test DNS resolution
    try:
        ip = socket.gethostbyname('example.com')
        print(f"DNS resolved: example.com -> {ip}")
    except socket.gaierror as e:
        print(f"DNS failed: {e}")

    # Test HTTP connectivity
    try:
        response = urllib.request.urlopen('https://example.com', timeout=5)
        print(f"HTTP status: {response.status}")
    except Exception as e:
        print(f"HTTP failed: {e}")

    return {"statusCode": 200}
```

## Structured Logging

### AWS Lambda Powertools

```python
from aws_lambda_powertools import Logger
from aws_lambda_powertools.logging import correlation_paths

logger = Logger(service="my-service")

@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
def handler(event, context):
    logger.info("Processing request", extra={
        "user_id": event.get("user_id"),
        "action": "process"
    })

    try:
        result = process(event)
        logger.info("Success", extra={"result": result})
        return {"statusCode": 200, "body": json.dumps(result)}
    except Exception as e:
        logger.exception("Failed to process")
        return {"statusCode": 500}
```

### JSON Logging

```python
import json
import logging

class JsonFormatter(logging.Formatter):
    def format(self, record):
        log_data = {
            "timestamp": self.formatTime(record),
            "level": record.levelname,
            "message": record.getMessage(),
            "function": record.funcName,
        }
        if hasattr(record, 'request_id'):
            log_data['request_id'] = record.request_id
        if record.exc_info:
            log_data['exception'] = self.formatException(record.exc_info)
        return json.dumps(log_data)

logger = logging.getLogger()
handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())
logger.addHandler(handler)
logger.setLevel(logging.INFO)
```

## Debugging Event Sources

### SQS Events

```python
def handler(event, context):
    for record in event['Records']:
        message_id = record['messageId']
        body = record['body']

        print(f"Processing message {message_id}")
        print(f"Body: {body}")
        print(f"Attributes: {record.get('messageAttributes', {})}")

        try:
            process_message(body)
        except Exception as e:
            print(f"Failed to process {message_id}: {e}")
            raise  # Message goes to DLQ
```

### API Gateway Events

```python
def handler(event, context):
    print(f"HTTP Method: {event['httpMethod']}")
    print(f"Path: {event['path']}")
    print(f"Headers: {json.dumps(event.get('headers', {}))}")
    print(f"Query: {json.dumps(event.get('queryStringParameters', {}))}")
    print(f"Body: {event.get('body', '')}")

    return {
        "statusCode": 200,
        "body": json.dumps({"message": "Debug info logged"})
    }
```

## Error Handling

```python
import json
from aws_lambda_powertools import Logger

logger = Logger()

class ProcessingError(Exception):
    """Custom application error"""
    pass

def handler(event, context):
    try:
        result = process(event)
        return {
            "statusCode": 200,
            "body": json.dumps(result)
        }
    except ProcessingError as e:
        logger.warning(f"Processing error: {e}")
        return {
            "statusCode": 400,
            "body": json.dumps({"error": str(e)})
        }
    except Exception as e:
        logger.exception("Unexpected error")
        return {
            "statusCode": 500,
            "body": json.dumps({"error": "Internal server error"})
        }
```
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 318kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 117kUpdated Claude CodeCodexVerifiedInstall