aws-powertools/powertools-lambda-python

Features

• Serverless Function Development - Provides a comprehensive utility framework for building production-ready Python functions on AWS Lambda.
• Python Framework Extensions - Offers a comprehensive utility framework for building production-ready Python functions on AWS Lambda.
• Exactly-Once Processing Semantics - Implements mechanisms to ensure each message in a stream or queue is processed exactly once.
• Agent-Integrated Functions - Exposes Python functions as tools for AI agents using OpenAPI schemas to perform actions during conversations.
• Cloud Service Event Models - Uses pre-defined models to structure and validate events coming from standard AWS cloud services.
• S3 Event Parsing - Extracts bucket and object metadata from object-level notifications and lambda requests.
• Serverless Telemetry - Offers a comprehensive suite for emitting structured JSON logs and custom metrics specifically for serverless functions.
• Base64 Encoding and Decoding - Deserializes JSON, decodes base64 data, and decompresses gzip content within event envelopes.
• Custom Format Validators - Extends JSON Schema validation with regex or custom functions to verify domain-specific data formats.
• Data Schema Validation - Provides schema-based validation for incoming event payloads and responses to ensure data integrity.
• Data Type Validation - Converts incoming event data into typed objects using data models to ensure structural correctness.
• Data Validation Schemas - Uses data models to automatically deserialize and validate the schema of records within a batch.
• Event-Driven Architectures - Parses and validates complex event payloads from S3, Kinesis, and SQS into typed Python objects.
• Event Envelope Extractions - Uses JMESPath expressions and built-in presets to isolate specific portions of events for validation.
• Request-Level Idempotency - Prevents duplicate processing by storing execution states and results in a database or cache.
• Serverless Idempotency - Prevents duplicate processing of serverless functions by tracking request state and managing batch failures.
• JSON Schema Validation - Validates inbound events and outbound responses against JSON schemas to ensure correct formats.
• Request Validation - Coerces and validates request bodies, query strings, and headers using data models.
• Request Validation and Routing Pipelines - Provides a pipeline to validate incoming requests and route them to appropriate handler functions.
• Serverless Event Handlers - Processes incoming requests from gateways, load balancers, and function URLs via a dedicated handler.
• Serverless Payload Parsers - Uses strongly-typed, self-describing classes to parse and validate incoming payloads from various services.
• Event Payload Parsing - Parses incoming event data from various cloud queues and streams into typed Python classes.
• Data Extraction - Uses JMESPath expressions and predefined envelopes to fetch and flatten nested data from event sources.
• Structured Logging - Injects execution metadata like request IDs and cold start status into machine-readable JSON logs.
• Structured Logging Frameworks - Implements a structured logging framework that enriches logs with execution context and provides log-level controls.
• Input Validation - Performs deep validation and parsing of input data using structured data models.
• API Request Handling - Parses incoming HTTP requests from various API gateways into typed objects for streamlined attribute access.
• Nested Payload Extractions - Isolates specific portions of complex JSON structures using envelopes to parse only relevant inner payloads.
• Response Validation - Verifies that outgoing responses match specified types and handles validation failure error codes.
• HTTP Routing - Directs incoming HTTP traffic to specific functions based on URL paths and HTTP methods.
• Decorator-Based Route Mappings - Maps incoming HTTP or GraphQL requests to specific handler functions using function decorators.
• Event Trigger Parsers - Parses inbound events from various API and application sources using specialized handlers and data classes.
• Serverless Gateway Routing - Processes incoming events from gateways, load balancers, and function URLs using dedicated handlers.
• AI Agent Tooling - Implements functions as tools for AI agents using OpenAPI schemas and manages conversation states.
• Custom Metric Emission - Creates asynchronous custom metrics using a standardized format to track overall application performance.
• Batch Handler Customization - Allows overriding success and failure handlers or implementing custom processors to control batch handling.
• Configuration Caching - Controls the memory lifespan of retrieved settings to balance access speed and data freshness.
• Log Formatters - Allows overriding default serialization logic to remap keys or redact sensitive information in structured logs.
• GraphQL Request Routing - Maps incoming GraphQL types and fields to specific handler functions using decorators.
• API Documentation Generators - Automatically generates interactive Swagger UI documentation based on defined API routes and validation models.
• Feature Flagging - Fetches all active feature flags based on the current input context in a single operation.
• Asynchronous Request Tracing - Provides hooks for asynchronous HTTP clients to ensure end-to-end visibility of non-blocking network calls.
• Feature Flags - Determines whether specific application features should be active based on a defined set of input rules.
• Serverless API Frameworks - Facilitates the creation of REST and GraphQL APIs using routing and OpenAPI schema generation.
• Asynchronous Event Loops - Manages non-blocking I/O operations using an event loop to process records or handlers concurrently.
• Cloud Secret Managers - Provides a utility for fetching and caching parameters and secrets from AWS cloud storage services.
• Data Masking - Redacts or encrypts sensitive information within logs and outputs to ensure data privacy.
• Secret Retrieval Interfaces - Fetches sensitive data from secret managers individually or in batches to optimize API calls.
• Secrets Management - Creates and updates sensitive values within secret managers for secure configuration handling.
• Application Configuration - Fetches the latest configuration versions for specific applications and environments to manage externalized settings.
• Configuration Providers - Retrieves and caches application settings and secrets from external stores using pluggable backend providers.
• Batch Event Processors - Handles multiple events for a channel as a single list to optimize downstream operations.
• Concurrent Execution Managers - Blocks simultaneous invocations with the same payload to prevent race conditions during execution.
• Custom Log Formatting - Controls log serialization, including timestamp formats and key ordering for non-serializable values.
• Parameter Store Management - Creates and updates values in parameter stores with the ability to overwrite existing entries.
• Parameter Store Retrieval - Fetches values from parameter stores with support for recursive path lookups and decryption.
• Event Logging - Records the full raw input event of a function invocation to facilitate debugging.
• Log Event Enrichment - Automatically injects request IDs, function ARNs, and cold start status into structured log records.
• Exception Logging - Captures exception names and stack traces in structured JSON format with support for custom notes.
• Partial Batch Failure Management - Manages partial failures in message batches to ensure successful records are not reprocessed during retries.
• Batch Record Idempotency - Applies idempotency logic to individual records within a batch to ensure each item is processed only once.
• Cache-Backed Idempotency Stores - Uses Redis-compatible caches to persist execution state and results for function idempotency.
• Database-Backed Idempotency Stores - Utilizes database tables to persist the state and results of function executions for idempotency tracking.
• Idempotency Key Extraction - Specifies which parts of an event payload serve as the unique idempotency identifier using JMESPath.
• Dependency Injection - Resolves and injects required dependencies into route handlers with support for caching and test overrides.
• Custom Middleware Implementations - Provides a decorator factory to execute custom logic before and after function invocations to manage cross-cutting concerns.
• Serverless Event Loops - Processes incoming events using async functions and an event loop to manage non-blocking operations.
• Request Interception Middleware - Executes a chain of registered functions to enrich or short-circuit requests before they reach the handler.
• Agentic Argument Validations - Enforces data formats for incoming agent requests and outgoing responses using type annotations or models.
• Cross-Instance Correlation Tracking - Extracts unique identifiers from events and propagates them across log messages to link related workflow instances.
• Agent Failure Tracking - Tracks and handles failure patterns in message batches to maintain processing consistency.
• AWS Lambda Integrations - Captures handler responses and exceptions in AWS Lambda, including tags for cold starts and service names.
• JMESPath Event Extraction - Uses JMESPath query expressions to isolate and flatten specific nested portions of complex event payloads.
• External API Instrumentation - Instruments third-party SDKs and libraries to automatically capture outbound requests and downstream dependencies.
• Custom Metric Recording - Tracks numerical data points with configurable units and resolutions for performance analysis.
• Batch Retry Mechanisms - Tracks failed records within a batch to prevent successful messages from being retried during reprocessing.
• Concurrent Record Handlers - Increases throughput by executing independent record handlers asynchronously using an event loop.
• Execution Tracing - Records the execution time and outcome of synchronous and asynchronous functions to identify bottlenecks.
• Asynchronous Metric Publishing - Sends application metrics asynchronously to avoid adding network latency to function execution.
• Serverless Cold Start Analysis - Detects and records specialized metrics specifically for serverless cold start events.
• API Routers - Implements a routing system for mapping HTTP and GraphQL requests to handler functions with schema validation.
• HTTP Response Handling - Provides a dedicated response object to control status codes, content types, custom headers, and cookies.
• GraphQL Resolver Organization - Organizes related GraphQL operations into separate modules to improve maintainability.
• Middleware - Implements reusable logic components that execute globally to standardize cross-cutting concerns across functions.
• Request Interception Middleware - Implements pipeline handlers to intercept, enrich, or short-circuit requests before they reach the handler.
• OpenAPI Specification Generators - Produces JSON-serialized OpenAPI specifications from decorated functions to configure AI agent behaviors.
• Async - Implements non-blocking concurrent I/O operations using asynchronous route handlers for improved performance.
• Schema Validation - Coerces and validates inbound event data and outbound responses against predefined JSON schemas.

Star history