Lambda Powertools Integration

<ItemGroup>
  <PackageReference Include="AWS.Lambda.Powertools.Logging" Version="1.5.0" />
  <PackageReference Include="AWS.Lambda.Powertools.Metrics" Version="1.5.0" />
  <PackageReference Include="AWS.Lambda.Powertools.Tracing" Version="1.5.0" />
</ItemGroup>

from aws_lambda_powertools import Logger, Tracer, Metrics
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.utilities.data_classes import event_source, SQSEvent
from aws_lambda_powertools.metrics import MetricUnit

# Initialize Powertools
logger = Logger()
tracer = Tracer()
metrics = Metrics()

@logger.inject_lambda_context(log_event=True)
@tracer.capture_lambda_handler
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
    """
    Process order events with full observability
    """

    # Structured logging with correlation IDs (automatic)
    logger.info("Processing order", extra={
        "order_id": event.get("orderId"),
        "customer_id": event.get("customerId"),
        "amount": event.get("amount")
    })

    try:
        # Your business logic
        order_id = process_order(event)

        # Add custom metrics (no CloudWatch API calls!)
        metrics.add_metric(name="OrderProcessed", unit=MetricUnit.Count, value=1)
        metrics.add_metric(name="OrderAmount", unit=MetricUnit.None, value=event.get("amount", 0))

        logger.info("Order processed successfully", extra={"order_id": order_id})

        return {"statusCode": 200, "orderId": order_id}

    except Exception as e:
        logger.exception("Failed to process order")
        metrics.add_metric(name="OrderFailed", unit=MetricUnit.Count, value=1)
        raise

@tracer.capture_method
def process_order(event: dict) -> str:
    """
    Process order with method-level tracing
    """
    # This method automatically creates an X-Ray subsegment
    order_id = event["orderId"]

    # Add annotations for X-Ray filtering
    tracer.put_annotation(key="OrderId", value=order_id)
    tracer.put_metadata(key="order_details", value=event)

    # Your order processing logic here
    validate_order(event)
    save_to_database(order_id)

    return order_id

@tracer.capture_method
def validate_order(event: dict):
    """Validate order details"""
    logger.debug("Validating order", extra={"order": event})
    # Validation logic...

@tracer.capture_method
def save_to_database(order_id: str):
    """Save order to database"""
    logger.info("Saving order to database", extra={"order_id": order_id})
    # Database logic...

from aws_lambda_powertools.utilities.data_classes import event_source, SQSEvent
from aws_lambda_powertools.utilities.batch import BatchProcessor, EventType

processor = BatchProcessor(event_type=EventType.SQS)

@logger.inject_lambda_context
@tracer.capture_lambda_handler
def lambda_handler(event, context):
    return processor.process(event=event, record_handler=process_record)

def process_record(record):
    """Process individual SQS message"""
    logger.info("Processing record", extra={"message_id": record.message_id})
    # Process message...

npm install @aws-lambda-powertools/logger \
            @aws-lambda-powertools/tracer \
            @aws-lambda-powertools/metrics

import { Logger } from '@aws-lambda-powertools/logger';
import { Tracer } from '@aws-lambda-powertools/tracer';
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics';
import { Context } from 'aws-lambda';

// Initialize Powertools
const logger = new Logger();
const tracer = new Tracer();
const metrics = new Metrics();

export const handler = async (event: any, context: Context) => {
    // Add context information
    logger.addContext(context);

    // Structured logging with correlation IDs
    logger.info('Processing order', {
        orderId: event.orderId,
        customerId: event.customerId,
        amount: event.amount
    });

    try {
        // Your business logic
        const orderId = await processOrder(event);

        // Add custom metrics
        metrics.addMetric('OrderProcessed', MetricUnits.Count, 1);
        metrics.addMetric('OrderAmount', MetricUnits.None, event.amount);

        logger.info('Order processed successfully', { orderId });

        return { statusCode: 200, orderId };

    } catch (error) {
        logger.error('Failed to process order', error as Error);
        metrics.addMetric('OrderFailed', MetricUnits.Count, 1);
        throw error;
    }
};

async function processOrder(event: any): Promise<string> {
    // Create manual segment for detailed tracing
    const segment = tracer.getSegment();
    const subsegment = segment?.addNewSubsegment('processOrder');

    try {
        const orderId = event.orderId;

        // Add annotations for X-Ray
        subsegment?.addAnnotation('OrderId', orderId);
        subsegment?.addMetadata('order_details', event);

        // Your order processing logic
        await validateOrder(event);
        await saveToDatabase(orderId);

        subsegment?.close();
        return orderId;

    } catch (error) {
        subsegment?.close(error as Error);
        throw error;
    }
}

async function validateOrder(event: any): Promise<void> {
    logger.debug('Validating order', { order: event });
    // Validation logic...
}

async function saveToDatabase(orderId: string): Promise<void> {
    logger.info('Saving order to database', { orderId });
    // Database logic...
}

<dependency>
    <groupId>software.amazon.lambda</groupId>
    <artifactId>powertools-logging</artifactId>
    <version>1.18.0</version>
</dependency>
<dependency>
    <groupId>software.amazon.lambda</groupId>
    <artifactId>powertools-metrics</artifactId>
    <version>1.18.0</version>
</dependency>
<dependency>
    <groupId>software.amazon.lambda</groupId>
    <artifactId>powertools-tracing</artifactId>
    <version>1.18.0</version>
</dependency>

package com.example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import software.amazon.lambda.powertools.logging.Logging;
import software.amazon.lambda.powertools.metrics.Metrics;
import software.amazon.lambda.powertools.tracing.Tracing;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class OrderHandler implements RequestHandler<OrderEvent, OrderResponse> {

    private static final Logger logger = LogManager.getLogger(OrderHandler.class);

    @Override
    @Logging(logEvent = true)
    @Metrics(namespace = "ECommerceApp", service = "order-processor")
    @Tracing
    public OrderResponse handleRequest(OrderEvent event, Context context) {

        logger.info("Processing order: " + event.getOrderId());

        try {
            String orderId = processOrder(event);

            // Metrics are automatically published
            MetricsUtils.putMetric("OrderProcessed", 1, Unit.COUNT);
            MetricsUtils.putMetric("OrderAmount", event.getAmount(), Unit.NONE);

            logger.info("Order processed successfully: " + orderId);

            return new OrderResponse(200, orderId);

        } catch (Exception e) {
            logger.error("Failed to process order", e);
            MetricsUtils.putMetric("OrderFailed", 1, Unit.COUNT);
            throw e;
        }
    }

    @Tracing
    private String processOrder(OrderEvent event) {
        // Automatically creates X-Ray subsegment
        validateOrder(event);
        saveToDatabase(event.getOrderId());
        return event.getOrderId();
    }

    private void validateOrder(OrderEvent event) {
        logger.debug("Validating order: " + event);
    }

    private void saveToDatabase(String orderId) {
        logger.info("Saving order to database: " + orderId);
    }
}

-- Find all errors for a specific order
fields @timestamp, level, message, order_id, error
| filter level = "ERROR" and order_id = "order-123"
| sort @timestamp desc

-- Calculate average processing time
fields @timestamp, function_request_id, function_cold_start, duration
| stats avg(duration), max(duration), count(