aws-lambda-powertools 2.35.0__tar.gz → 2.36.0__tar.gz

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-lambda-powertools
-Version: 2.35.0
+Version: 2.36.0
 Summary: Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverless best practices and increase developer velocity.
 Home-page: https://github.com/aws-powertools/powertools-lambda-python
 License: MIT

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/event_handler/api_gateway.py

@@ -503,6 +503,18 @@ class Route:
             if request_body_oai:
                 operation["requestBody"] = request_body_oai
 
+        # Validation failure response (422) will always be part of the schema
+        operation_responses: Dict[int, OpenAPIResponse] = {
+            422: {
+                "description": "Validation Error",
+                "content": {
+                    "application/json": {
+                        "schema": {"$ref": COMPONENT_REF_PREFIX + "HTTPValidationError"},
+                    },
+                },
+            },
+        }
+
         # Add the response to the OpenAPI operation
         if self.responses:
             for status_code in list(self.responses):
@@ -549,45 +561,34 @@ class Route:
 
                         response["content"][content_type] = new_payload
 
-            operation["responses"] = self.responses
+                # Merge the user provided response with the default responses
+                operation_responses[status_code] = response
         else:
             # Set the default 200 response
-            responses = operation.setdefault("responses", {})
-            success_response = responses.setdefault(200, {})
-            success_response["description"] = self.response_description or _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION
-            success_response["content"] = {"application/json": {"schema": {}}}
-            json_response = success_response["content"].setdefault("application/json", {})
-
-            # Add the response schema to the OpenAPI 200 response
-            json_response.update(
-                self._openapi_operation_return(
-                    param=dependant.return_param,
-                    model_name_map=model_name_map,
-                    field_mapping=field_mapping,
-                ),
+            response_schema = self._openapi_operation_return(
+                param=dependant.return_param,
+                model_name_map=model_name_map,
+                field_mapping=field_mapping,
             )
 
-            # Add validation failure response (422)
-            operation["responses"][422] = {
-                "description": "Validation Error",
-                "content": {
-                    "application/json": {
-                        "schema": {"$ref": COMPONENT_REF_PREFIX + "HTTPValidationError"},
-                    },
-                },
+            # Add the response schema to the OpenAPI 200 response
+            operation_responses[200] = {
+                "description": self.response_description or _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION,
+                "content": {"application/json": response_schema},
             }
 
-            # Add the validation error schema to the definitions, but only if it hasn't been added yet
-            if "ValidationError" not in definitions:
-                definitions.update(
-                    {
-                        "ValidationError": validation_error_definition,
-                        "HTTPValidationError": validation_error_response_definition,
-                    },
-                )
-
+        operation["responses"] = operation_responses
         path[self.method.lower()] = operation
 
+        # Add the validation error schema to the definitions, but only if it hasn't been added yet
+        if "ValidationError" not in definitions:
+            definitions.update(
+                {
+                    "ValidationError": validation_error_definition,
+                    "HTTPValidationError": validation_error_response_definition,
+                },
+            )
+
         # Generate the response schema
         return path, definitions
 
@@ -1401,7 +1402,9 @@ class ApiGatewayResolver(BaseRouter):
         if self._enable_validation:
             from aws_lambda_powertools.event_handler.middlewares.openapi_validation import OpenAPIValidationMiddleware
 
-            self.use([OpenAPIValidationMiddleware()])
+            # Note the serializer argument: only use custom serializer if provided by the caller
+            # Otherwise, fully rely on the internal Pydantic based mechanism to serialize responses for validation.
+            self.use([OpenAPIValidationMiddleware(validation_serializer=serializer)])
 
     def get_openapi_schema(
         self,
@@ -1621,6 +1624,7 @@ class ApiGatewayResolver(BaseRouter):
         license_info: Optional["License"] = None,
         swagger_base_url: Optional[str] = None,
         middlewares: Optional[List[Callable[..., Response]]] = None,
+        compress: bool = False,
     ):
         """
         Returns the OpenAPI schema as a JSON serializable dict
@@ -1653,11 +1657,13 @@ class ApiGatewayResolver(BaseRouter):
             The base url for the swagger UI. If not provided, we will serve a recent version of the Swagger UI.
         middlewares: List[Callable[..., Response]], optional
             List of middlewares to be used for the swagger route.
+        compress: bool, default = False
+            Whether or not to enable gzip compression swagger route.
         """
         from aws_lambda_powertools.event_handler.openapi.compat import model_json
         from aws_lambda_powertools.event_handler.openapi.models import Server
 
-        @self.get(path, middlewares=middlewares, include_in_schema=False)
+        @self.get(path, middlewares=middlewares, include_in_schema=False, compress=compress)
         def swagger_handler():
             base_path = self._get_base_path()
 
@@ -2128,6 +2134,9 @@ class ApiGatewayResolver(BaseRouter):
         logger.debug("Appending Router middlewares into App middlewares.")
         self._router_middlewares = self._router_middlewares + router._router_middlewares
 
+        logger.debug("Appending Router exception_handler into App exception_handler.")
+        self._exception_handlers.update(router._exception_handlers)
+
         # use pointer to allow context clearance after event is processed e.g., resolve(evt, ctx)
         router.context = self.context
 
@@ -2193,6 +2202,7 @@ class Router(BaseRouter):
         self._routes_with_middleware: Dict[tuple, List[Callable]] = {}
         self.api_resolver: Optional[BaseRouter] = None
         self.context = {}  # early init as customers might add context before event resolution
+        self._exception_handlers: Dict[Type, Callable] = {}
 
     def route(
         self,
@@ -2247,6 +2257,17 @@ class Router(BaseRouter):
 
         return register_route
 
+    def exception_handler(self, exc_class: Union[Type[Exception], List[Type[Exception]]]):
+        def register_exception_handler(func: Callable):
+            if isinstance(exc_class, list):
+                for exp in exc_class:
+                    self._exception_handlers[exp] = func
+            else:
+                self._exception_handlers[exc_class] = func
+            return func
+
+        return register_exception_handler
+
 
 class APIGatewayRestResolver(ApiGatewayResolver):
     current_event: APIGatewayProxyEvent

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/event_handler/middlewares/openapi_validation.py

@@ -2,7 +2,7 @@ import dataclasses
 import json
 import logging
 from copy import deepcopy
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple
 
 from pydantic import BaseModel
 
@@ -55,6 +55,18 @@ class OpenAPIValidationMiddleware(BaseMiddlewareHandler):
     ```
     """
 
+    def __init__(self, validation_serializer: Optional[Callable[[Any], str]] = None):
+        """
+        Initialize the OpenAPIValidationMiddleware.
+
+        Parameters
+        ----------
+        validation_serializer : Callable, optional
+            Optional serializer to use when serializing the response for validation.
+            Use it when you have a custom type that cannot be serialized by the default jsonable_encoder.
+        """
+        self._validation_serializer = validation_serializer
+
     def handler(self, app: EventHandlerInstance, next_middleware: NextMiddleware) -> Response:
         logger.debug("OpenAPIValidationMiddleware handler")
 
@@ -181,10 +193,11 @@ class OpenAPIValidationMiddleware(BaseMiddlewareHandler):
                 exclude_unset=exclude_unset,
                 exclude_defaults=exclude_defaults,
                 exclude_none=exclude_none,
+                custom_serializer=self._validation_serializer,
             )
         else:
             # Just serialize the response content returned from the handler
-            return jsonable_encoder(response_content)
+            return jsonable_encoder(response_content, custom_serializer=self._validation_serializer)
 
     def _prepare_response_content(
         self,

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/event_handler/openapi/encoders.py

@@ -29,6 +29,7 @@ def jsonable_encoder(  # noqa: PLR0911
     exclude_unset: bool = False,
     exclude_defaults: bool = False,
     exclude_none: bool = False,
+    custom_serializer: Optional[Callable[[Any], str]] = None,
 ) -> Any:
     """
     JSON encodes an arbitrary Python object into JSON serializable data types.
@@ -55,6 +56,8 @@ def jsonable_encoder(  # noqa: PLR0911
         by default False
     exclude_none : bool, optional
         Whether fields that are equal to None should be excluded, by default False
+    custom_serializer : Callable, optional
+        A custom serializer to use for encoding the object, when everything else fails.
 
     Returns
     -------
@@ -134,6 +137,10 @@ def jsonable_encoder(  # noqa: PLR0911
         if isinstance(obj, classes_tuple):
             return encoder(obj)
 
+    # Use custom serializer if present
+    if custom_serializer:
+        return custom_serializer(obj)
+
     # Default
     return _dump_other(
         obj=obj,
@@ -259,7 +266,7 @@ def _dump_other(
     exclude_defaults: bool = False,
 ) -> Any:
     """
-    Dump an object to ah hashable object, using the same parameters as jsonable_encoder
+    Dump an object to a hashable object, using the same parameters as jsonable_encoder
     """
     try:
         data = dict(obj)

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/event_handler/openapi/types.py

@@ -28,7 +28,7 @@ validation_error_definition = {
             "type": "array",
             "items": {"anyOf": [{"type": "string"}, {"type": "integer"}]},
         },
-        "msg": {"title": "Message", "type": "string"},
+        # For security reasons, we hide **msg** details (don't leak Python, Pydantic or filenames)
         "type": {"title": "Error Type", "type": "string"},
     },
     "required": ["loc", "msg", "type"],

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/logging/logger.py

@@ -580,7 +580,7 @@ class Logger:
             extra=extra,
         )
 
-    def append_keys(self, **additional_keys) -> None:
+    def append_keys(self, **additional_keys: object) -> None:
         self.registered_formatter.append_keys(**additional_keys)
 
     def remove_keys(self, keys: Iterable[str]) -> None:

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/metrics/base.py

@@ -17,6 +17,7 @@ from aws_lambda_powertools.metrics.exceptions import (
     MetricValueError,
     SchemaValidationError,
 )
+from aws_lambda_powertools.metrics.functions import convert_timestamp_to_emf_format, validate_emf_timestamp
 from aws_lambda_powertools.metrics.provider import cold_start
 from aws_lambda_powertools.metrics.provider.cloudwatch_emf.constants import MAX_DIMENSIONS, MAX_METRICS
 from aws_lambda_powertools.metrics.provider.cloudwatch_emf.metric_properties import MetricResolution, MetricUnit
@@ -76,6 +77,8 @@ class MetricManager:
         self.namespace = resolve_env_var_choice(choice=namespace, env=os.getenv(constants.METRICS_NAMESPACE_ENV))
         self.service = resolve_env_var_choice(choice=service, env=os.getenv(constants.SERVICE_NAME_ENV))
         self.metadata_set = metadata_set if metadata_set is not None else {}
+        self.timestamp: int | None = None
+
         self._metric_units = [unit.value for unit in MetricUnit]
         self._metric_unit_valid_options = list(MetricUnit.__members__)
         self._metric_resolutions = [resolution.value for resolution in MetricResolution]
@@ -224,7 +227,7 @@ class MetricManager:
 
         return {
             "_aws": {
-                "Timestamp": int(datetime.datetime.now().timestamp() * 1000),  # epoch
+                "Timestamp": self.timestamp or int(datetime.datetime.now().timestamp() * 1000),  # epoch
                 "CloudWatchMetrics": [
                     {
                         "Namespace": self.namespace,  # "test_namespace"
@@ -296,6 +299,31 @@ class MetricManager:
         else:
             self.metadata_set[str(key)] = value
 
+    def set_timestamp(self, timestamp: int | datetime.datetime):
+        """
+        Set the timestamp for the metric.
+
+        Parameters:
+        -----------
+        timestamp: int | datetime.datetime
+            The timestamp to create the metric.
+            If an integer is provided, it is assumed to be the epoch time in milliseconds.
+            If a datetime object is provided, it will be converted to epoch time in milliseconds.
+        """
+        # The timestamp must be a Datetime object or an integer representing an epoch time.
+        # This should not exceed 14 days in the past or be more than 2 hours in the future.
+        # Any metrics failing to meet this criteria will be skipped by Amazon CloudWatch.
+        # See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Specification.html
+        # See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html
+        if not validate_emf_timestamp(timestamp):
+            warnings.warn(
+                "This metric doesn't meet the requirements and will be skipped by Amazon CloudWatch. "
+                "Ensure the timestamp is within 14 days past or 2 hours future.",
+                stacklevel=2,
+            )
+
+        self.timestamp = convert_timestamp_to_emf_format(timestamp)
+
     def clear_metrics(self) -> None:
         logger.debug("Clearing out existing metric set from memory")
         self.metric_set.clear()
@@ -576,6 +604,9 @@ def single_metric(
         Metric value
     namespace: str
         Namespace for metrics
+    default_dimensions: Dict[str, str], optional
+        Metric dimensions as key=value that will always be present
+
 
     Yields
     -------

aws_lambda_powertools-2.36.0/aws_lambda_powertools/metrics/functions.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from aws_lambda_powertools.metrics.provider.cloudwatch_emf.exceptions import (
+    MetricResolutionError,
+    MetricUnitError,
+)
+from aws_lambda_powertools.metrics.provider.cloudwatch_emf.metric_properties import MetricResolution, MetricUnit
+from aws_lambda_powertools.shared import constants
+from aws_lambda_powertools.shared.types import List
+
+
+def extract_cloudwatch_metric_resolution_value(metric_resolutions: List, resolution: int | MetricResolution) -> int:
+    """Return metric value from CloudWatch metric unit whether that's str or MetricResolution enum
+
+    Parameters
+    ----------
+    unit : Union[int, MetricResolution]
+        Metric resolution
+
+    Returns
+    -------
+    int
+        Metric resolution value must be 1 or 60
+
+    Raises
+    ------
+    MetricResolutionError
+        When metric resolution is not supported by CloudWatch
+    """
+    if isinstance(resolution, MetricResolution):
+        return resolution.value
+
+    if isinstance(resolution, int) and resolution in metric_resolutions:
+        return resolution
+
+    raise MetricResolutionError(
+        f"Invalid metric resolution '{resolution}', expected either option: {metric_resolutions}",  # noqa: E501
+    )
+
+
+def extract_cloudwatch_metric_unit_value(metric_units: List, metric_valid_options: List, unit: str | MetricUnit) -> str:
+    """Return metric value from CloudWatch metric unit whether that's str or MetricUnit enum
+
+    Parameters
+    ----------
+    unit : Union[str, MetricUnit]
+        Metric unit
+
+    Returns
+    -------
+    str
+        Metric unit value (e.g. "Seconds", "Count/Second")
+
+    Raises
+    ------
+    MetricUnitError
+        When metric unit is not supported by CloudWatch
+    """
+
+    if isinstance(unit, str):
+        if unit in metric_valid_options:
+            unit = MetricUnit[unit].value
+
+        if unit not in metric_units:
+            raise MetricUnitError(
+                f"Invalid metric unit '{unit}', expected either option: {metric_valid_options}",
+            )
+
+    if isinstance(unit, MetricUnit):
+        unit = unit.value
+
+    return unit
+
+
+def validate_emf_timestamp(timestamp: int | datetime) -> bool:
+    """
+    Validates a given timestamp based on CloudWatch Timestamp guidelines.
+
+    Timestamp must meet CloudWatch requirements, otherwise an InvalidTimestampError will be raised.
+    See [Timestamps](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#about_timestamp)
+    for valid values.
+
+    Parameters:
+    ----------
+    timestamp: int | datetime
+        Datetime object or epoch time in milliseconds representing the timestamp to validate.
+
+    Returns
+    -------
+    bool
+        Valid or not timestamp values
+    """
+
+    if not isinstance(timestamp, (int, datetime)):
+        return False
+
+    if isinstance(timestamp, datetime):
+        # Converting timestamp to epoch time in milliseconds
+        timestamp = int(timestamp.timestamp() * 1000)
+
+    # Consider current timezone when working with date and time
+    current_timezone = datetime.now().astimezone().tzinfo
+
+    current_time = int(datetime.now(current_timezone).timestamp() * 1000)
+    min_valid_timestamp = current_time - constants.EMF_MAX_TIMESTAMP_PAST_AGE
+    max_valid_timestamp = current_time + constants.EMF_MAX_TIMESTAMP_FUTURE_AGE
+
+    return min_valid_timestamp <= timestamp <= max_valid_timestamp
+
+
+def convert_timestamp_to_emf_format(timestamp: int | datetime) -> int:
+    """
+    Converts a timestamp to EMF compatible format.
+
+    Parameters
+    ----------
+    timestamp: int | datetime
+        The timestamp to convert. If already in epoch milliseconds format, returns it as is.
+        If datetime object, converts it to milliseconds since Unix epoch.
+
+    Returns:
+    --------
+    int
+        The timestamp converted to EMF compatible format (milliseconds since Unix epoch).
+    """
+    if isinstance(timestamp, int):
+        return timestamp
+
+    try:
+        return int(round(timestamp.timestamp() * 1000))
+    except AttributeError:
+        # If this point is reached, it indicates timestamp is not a datetime object
+        # Returning zero represents the initial date of epoch time,
+        # which will be skipped by Amazon CloudWatch.
+        return 0

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/metrics/metrics.py

@@ -125,6 +125,19 @@ class Metrics:
     def add_metadata(self, key: str, value: Any) -> None:
         self.provider.add_metadata(key=key, value=value)
 
+    def set_timestamp(self, timestamp: int):
+        """
+        Set the timestamp for the metric.
+
+        Parameters:
+        -----------
+        timestamp: int | datetime.datetime
+            The timestamp to create the metric.
+            If an integer is provided, it is assumed to be the epoch time in milliseconds.
+            If a datetime object is provided, it will be converted to epoch time in milliseconds.
+        """
+        self.provider.set_timestamp(timestamp=timestamp)
+
     def flush_metrics(self, raise_on_empty_metrics: bool = False) -> None:
         self.provider.flush_metrics(raise_on_empty_metrics=raise_on_empty_metrics)
 

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/metrics/provider/cloudwatch_emf/cloudwatch.py

@@ -12,8 +12,10 @@ from typing import Any, Dict, List
 from aws_lambda_powertools.metrics.base import single_metric
 from aws_lambda_powertools.metrics.exceptions import MetricValueError, SchemaValidationError
 from aws_lambda_powertools.metrics.functions import (
+    convert_timestamp_to_emf_format,
     extract_cloudwatch_metric_resolution_value,
     extract_cloudwatch_metric_unit_value,
+    validate_emf_timestamp,
 )
 from aws_lambda_powertools.metrics.provider.base import BaseProvider
 from aws_lambda_powertools.metrics.provider.cloudwatch_emf.constants import MAX_DIMENSIONS, MAX_METRICS
@@ -73,6 +75,7 @@ class AmazonCloudWatchEMFProvider(BaseProvider):
         self.namespace = resolve_env_var_choice(choice=namespace, env=os.getenv(constants.METRICS_NAMESPACE_ENV))
         self.service = resolve_env_var_choice(choice=service, env=os.getenv(constants.SERVICE_NAME_ENV))
         self.metadata_set = metadata_set if metadata_set is not None else {}
+        self.timestamp: int | None = None
 
         self._metric_units = [unit.value for unit in MetricUnit]
         self._metric_unit_valid_options = list(MetricUnit.__members__)
@@ -231,7 +234,7 @@ class AmazonCloudWatchEMFProvider(BaseProvider):
 
         return {
             "_aws": {
-                "Timestamp": int(datetime.datetime.now().timestamp() * 1000),  # epoch
+                "Timestamp": self.timestamp or int(datetime.datetime.now().timestamp() * 1000),  # epoch
                 "CloudWatchMetrics": [
                     {
                         "Namespace": self.namespace,  # "test_namespace"
@@ -304,6 +307,31 @@ class AmazonCloudWatchEMFProvider(BaseProvider):
         else:
             self.metadata_set[str(key)] = value
 
+    def set_timestamp(self, timestamp: int | datetime.datetime):
+        """
+        Set the timestamp for the metric.
+
+        Parameters:
+        -----------
+        timestamp: int | datetime.datetime
+            The timestamp to create the metric.
+            If an integer is provided, it is assumed to be the epoch time in milliseconds.
+            If a datetime object is provided, it will be converted to epoch time in milliseconds.
+        """
+        # The timestamp must be a Datetime object or an integer representing an epoch time.
+        # This should not exceed 14 days in the past or be more than 2 hours in the future.
+        # Any metrics failing to meet this criteria will be skipped by Amazon CloudWatch.
+        # See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Specification.html
+        # See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html
+        if not validate_emf_timestamp(timestamp):
+            warnings.warn(
+                "This metric doesn't meet the requirements and will be skipped by Amazon CloudWatch. "
+                "Ensure the timestamp is within 14 days past or 2 hours future.",
+                stacklevel=2,
+            )
+
+        self.timestamp = convert_timestamp_to_emf_format(timestamp)
+
     def clear_metrics(self) -> None:
         logger.debug("Clearing out existing metric set from memory")
         self.metric_set.clear()

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/shared/constants.py

@@ -1,32 +1,17 @@
+# Tracer constants
 TRACER_CAPTURE_RESPONSE_ENV: str = "POWERTOOLS_TRACER_CAPTURE_RESPONSE"
 TRACER_CAPTURE_ERROR_ENV: str = "POWERTOOLS_TRACER_CAPTURE_ERROR"
 TRACER_DISABLED_ENV: str = "POWERTOOLS_TRACE_DISABLED"
+XRAY_SDK_MODULE: str = "aws_xray_sdk"
+XRAY_SDK_CORE_MODULE: str = "aws_xray_sdk.core"
+XRAY_TRACE_ID_ENV: str = "_X_AMZN_TRACE_ID"
+MIDDLEWARE_FACTORY_TRACE_ENV: str = "POWERTOOLS_TRACE_MIDDLEWARES"
+INVALID_XRAY_NAME_CHARACTERS = r"[?;*()!$~^<>]"
 
+# Logger constants
 LOGGER_LOG_SAMPLING_RATE: str = "POWERTOOLS_LOGGER_SAMPLE_RATE"
 LOGGER_LOG_EVENT_ENV: str = "POWERTOOLS_LOGGER_LOG_EVENT"
 LOGGER_LOG_DEDUPLICATION_ENV: str = "POWERTOOLS_LOG_DEDUPLICATION_DISABLED"
-
-MIDDLEWARE_FACTORY_TRACE_ENV: str = "POWERTOOLS_TRACE_MIDDLEWARES"
-
-METRICS_NAMESPACE_ENV: str = "POWERTOOLS_METRICS_NAMESPACE"
-
-DATADOG_FLUSH_TO_LOG: str = "DD_FLUSH_TO_LOG"
-
-SERVICE_NAME_ENV: str = "POWERTOOLS_SERVICE_NAME"
-XRAY_TRACE_ID_ENV: str = "_X_AMZN_TRACE_ID"
-LAMBDA_TASK_ROOT_ENV: str = "LAMBDA_TASK_ROOT"
-
-
-LAMBDA_FUNCTION_NAME_ENV: str = "AWS_LAMBDA_FUNCTION_NAME"
-
-XRAY_SDK_MODULE: str = "aws_xray_sdk"
-XRAY_SDK_CORE_MODULE: str = "aws_xray_sdk.core"
-
-IDEMPOTENCY_DISABLED_ENV: str = "POWERTOOLS_IDEMPOTENCY_DISABLED"
-
-PARAMETERS_SSM_DECRYPT_ENV: str = "POWERTOOLS_PARAMETERS_SSM_DECRYPT"
-PARAMETERS_MAX_AGE_ENV: str = "POWERTOOLS_PARAMETERS_MAX_AGE"
-
 LOGGER_LAMBDA_CONTEXT_KEYS = [
     "function_arn",
     "function_memory_size",
@@ -35,17 +20,6 @@ LOGGER_LAMBDA_CONTEXT_KEYS = [
     "cold_start",
     "xray_trace_id",
 ]
-
-# JSON indentation level
-PRETTY_INDENT: int = 4
-COMPACT_INDENT = None
-
-POWERTOOLS_DEV_ENV: str = "POWERTOOLS_DEV"
-POWERTOOLS_DEBUG_ENV: str = "POWERTOOLS_DEBUG"
-POWERTOOLS_LOG_LEVEL_ENV: str = "POWERTOOLS_LOG_LEVEL"
-POWERTOOLS_LOG_LEVEL_LEGACY_ENV: str = "LOG_LEVEL"
-LAMBDA_LOG_LEVEL_ENV: str = "AWS_LAMBDA_LOG_LEVEL"
-
 # Mapping of Lambda log levels to Python logging levels
 # https://docs.aws.amazon.com/lambda/latest/dg/configuration-logging.html#configuration-logging-log-levels
 LAMBDA_ADVANCED_LOGGING_LEVELS = {
@@ -57,3 +31,37 @@ LAMBDA_ADVANCED_LOGGING_LEVELS = {
     "ERROR": "ERROR",
     "FATAL": "CRITICAL",
 }
+POWERTOOLS_LOG_LEVEL_ENV: str = "POWERTOOLS_LOG_LEVEL"
+POWERTOOLS_LOG_LEVEL_LEGACY_ENV: str = "LOG_LEVEL"
+LAMBDA_LOG_LEVEL_ENV: str = "AWS_LAMBDA_LOG_LEVEL"
+
+# Metrics constants
+METRICS_NAMESPACE_ENV: str = "POWERTOOLS_METRICS_NAMESPACE"
+DATADOG_FLUSH_TO_LOG: str = "DD_FLUSH_TO_LOG"
+SERVICE_NAME_ENV: str = "POWERTOOLS_SERVICE_NAME"
+# If the timestamp of log event is more than 2 hours in future, the log event is skipped.
+# If the timestamp of log event is more than 14 days in past, the log event is skipped.
+# See https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AgentReference.html
+EMF_MAX_TIMESTAMP_PAST_AGE = 14 * 24 * 60 * 60 * 1000  # 14 days
+EMF_MAX_TIMESTAMP_FUTURE_AGE = 2 * 60 * 60 * 1000  # 2 hours
+
+# Parameters constants
+PARAMETERS_SSM_DECRYPT_ENV: str = "POWERTOOLS_PARAMETERS_SSM_DECRYPT"
+PARAMETERS_MAX_AGE_ENV: str = "POWERTOOLS_PARAMETERS_MAX_AGE"
+
+# Runtime and environment constants
+LAMBDA_TASK_ROOT_ENV: str = "LAMBDA_TASK_ROOT"
+SAM_LOCAL_ENV: str = "AWS_SAM_LOCAL"
+CHALICE_LOCAL_ENV: str = "AWS_CHALICE_CLI_MODE"
+LAMBDA_FUNCTION_NAME_ENV: str = "AWS_LAMBDA_FUNCTION_NAME"
+
+# Debug constants
+POWERTOOLS_DEV_ENV: str = "POWERTOOLS_DEV"
+POWERTOOLS_DEBUG_ENV: str = "POWERTOOLS_DEBUG"
+
+# JSON constants
+PRETTY_INDENT: int = 4
+COMPACT_INDENT = None
+
+# Idempotency constants
+IDEMPOTENCY_DISABLED_ENV: str = "POWERTOOLS_IDEMPOTENCY_DISABLED"

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/shared/functions.py

@@ -4,6 +4,7 @@ import base64
 import itertools
 import logging
 import os
+import re
 import warnings
 from binascii import Error as BinAsciiError
 from pathlib import Path
@@ -275,13 +276,10 @@ def abs_lambda_path(relative_path: str = "") -> str:
         If the path is empty, it will return the current working directory.
     """
     # Retrieve the LAMBDA_TASK_ROOT environment variable or default to an empty string
-    current_working_directory = os.environ.get("LAMBDA_TASK_ROOT", "")
+    current_working_directory = os.environ.get("LAMBDA_TASK_ROOT", "") or str(Path.cwd())
 
-    # If LAMBDA_TASK_ROOT is not set, use the current working directory
-    if not current_working_directory:
-        current_working_directory = str(Path.cwd())
+    return str(Path(current_working_directory, relative_path))
 
-    # Combine the current working directory and the relative path to get the absolute path
-    absolute_path = str(Path(current_working_directory, relative_path))
 
-    return absolute_path
+def sanitize_xray_segment_name(name: str) -> str:
+    return re.sub(constants.INVALID_XRAY_NAME_CHARACTERS, "", name)

{aws_lambda_powertools-2.35.0 → aws_lambda_powertools-2.36.0}/aws_lambda_powertools/shared/version.py

@@ -1,3 +1,3 @@
 """Exposes version constant to avoid circular dependencies."""
 
-VERSION = "2.35.0"
+VERSION = "2.36.0"