datadog_lambda 6.109.0__tar.gz → 6.111.0__tar.gz

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datadog_lambda
-Version: 6.109.0
+Version: 6.111.0
 Summary: The Datadog AWS Lambda Library
 Home-page: https://github.com/DataDog/datadog-lambda-python
 License: Apache-2.0
@@ -60,6 +60,7 @@ Besides the environment variables supported by dd-trace-py, the datadog-lambda-p
 | DD_COLD_START_TRACE_SKIP_LIB | optionally skip creating Cold Start Spans for a comma-separated list of libraries. Useful to limit depth or skip known libraries. | `ddtrace.internal.compat,ddtrace.filters` |
 | DD_CAPTURE_LAMBDA_PAYLOAD | [Captures incoming and outgoing AWS Lambda payloads][1] in the Datadog APM spans for Lambda invocations. | `false` |
 | DD_CAPTURE_LAMBDA_PAYLOAD_MAX_DEPTH | Determines the level of detail captured from AWS Lambda payloads, which are then assigned as tags for the `aws.lambda` span. It specifies the nesting depth of the JSON payload structure to process. Once the specified maximum depth is reached, the tag's value is set to the stringified value of any nested elements beyond this level.  <br> For example, given the input payload: <pre>{<br>  "lv1" : {<br>    "lv2": {<br>      "lv3": "val"<br>    }<br>  }<br>}</pre> If the depth is set to `2`, the resulting tag's key is set to `function.request.lv1.lv2` and the value is `{\"lv3\": \"val\"}`. <br> If the depth is set to `0`, the resulting tag's key is set to `function.request` and value is `{\"lv1\":{\"lv2\":{\"lv3\": \"val\"}}}` | `10` |
+| DD_EXCEPTION_REPLAY_ENABLED | When set to `true`, the Lambda will run with Error Tracking Exception Replay enabled, capturing local variables. | `false` |
 
 
 ## Opening Issues

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/README.md

@@ -29,6 +29,7 @@ Besides the environment variables supported by dd-trace-py, the datadog-lambda-p
 | DD_COLD_START_TRACE_SKIP_LIB | optionally skip creating Cold Start Spans for a comma-separated list of libraries. Useful to limit depth or skip known libraries. | `ddtrace.internal.compat,ddtrace.filters` |
 | DD_CAPTURE_LAMBDA_PAYLOAD | [Captures incoming and outgoing AWS Lambda payloads][1] in the Datadog APM spans for Lambda invocations. | `false` |
 | DD_CAPTURE_LAMBDA_PAYLOAD_MAX_DEPTH | Determines the level of detail captured from AWS Lambda payloads, which are then assigned as tags for the `aws.lambda` span. It specifies the nesting depth of the JSON payload structure to process. Once the specified maximum depth is reached, the tag's value is set to the stringified value of any nested elements beyond this level.  <br> For example, given the input payload: <pre>{<br>  "lv1" : {<br>    "lv2": {<br>      "lv3": "val"<br>    }<br>  }<br>}</pre> If the depth is set to `2`, the resulting tag's key is set to `function.request.lv1.lv2` and the value is `{\"lv3\": \"val\"}`. <br> If the depth is set to `0`, the resulting tag's key is set to `function.request` and value is `{\"lv1\":{\"lv2\":{\"lv3\": \"val\"}}}` | `10` |
+| DD_EXCEPTION_REPLAY_ENABLED | When set to `true`, the Lambda will run with Error Tracking Exception Replay enabled, capturing local variables. | `false` |
 
 
 ## Opening Issues

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/api.py

@@ -1,7 +1,7 @@
 import logging
 import os
 
-from datadog_lambda.fips import fips_mode_enabled
+from datadog_lambda.config import config
 
 logger = logging.getLogger(__name__)
 KMS_ENCRYPTION_CONTEXT_KEY = "LambdaFunctionName"
@@ -29,7 +29,6 @@ def decrypt_kms_api_key(kms_client, ciphertext):
     is added. We need to try decrypting the API key both with and without the encryption context.
     """
     # Try without encryption context, in case API key was encrypted using the AWS CLI
-    function_name = os.environ.get("AWS_LAMBDA_FUNCTION_NAME")
     try:
         plaintext = kms_client.decrypt(CiphertextBlob=decoded_bytes)[
             "Plaintext"
@@ -43,7 +42,7 @@ def decrypt_kms_api_key(kms_client, ciphertext):
         plaintext = kms_client.decrypt(
             CiphertextBlob=decoded_bytes,
             EncryptionContext={
-                KMS_ENCRYPTION_CONTEXT_KEY: function_name,
+                KMS_ENCRYPTION_CONTEXT_KEY: config.function_name,
             },
         )["Plaintext"].decode("utf-8")
 
@@ -66,7 +65,7 @@ def get_api_key() -> str:
     DD_API_KEY = os.environ.get("DD_API_KEY", os.environ.get("DATADOG_API_KEY", ""))
 
     LAMBDA_REGION = os.environ.get("AWS_REGION", "")
-    if fips_mode_enabled:
+    if config.fips_mode_enabled:
         logger.debug(
             "FIPS mode is enabled, using FIPS endpoints for secrets management."
         )
@@ -82,7 +81,7 @@ def get_api_key() -> str:
             return ""
         endpoint_url = (
             f"https://secretsmanager-fips.{secrets_region}.amazonaws.com"
-            if fips_mode_enabled
+            if config.fips_mode_enabled
             else None
         )
         secrets_manager_client = _boto3_client(
@@ -95,7 +94,7 @@ def get_api_key() -> str:
         # SSM endpoints: https://docs.aws.amazon.com/general/latest/gr/ssm.html
         fips_endpoint = (
             f"https://ssm-fips.{LAMBDA_REGION}.amazonaws.com"
-            if fips_mode_enabled
+            if config.fips_mode_enabled
             else None
         )
         ssm_client = _boto3_client("ssm", endpoint_url=fips_endpoint)
@@ -106,7 +105,7 @@ def get_api_key() -> str:
         # KMS endpoints: https://docs.aws.amazon.com/general/latest/gr/kms.html
         fips_endpoint = (
             f"https://kms-fips.{LAMBDA_REGION}.amazonaws.com"
-            if fips_mode_enabled
+            if config.fips_mode_enabled
             else None
         )
         kms_client = _boto3_client("kms", endpoint_url=fips_endpoint)
@@ -118,7 +117,7 @@ def get_api_key() -> str:
 
 
 def init_api():
-    if not os.environ.get("DD_FLUSH_TO_LOG", "").lower() == "true":
+    if not config.flush_to_log:
         # Make sure that this package would always be lazy-loaded/outside from the critical path
         # since underlying packages are quite heavy to load
         # and useless with the extension unless sending metrics with timestamps

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/cold_start.py

@@ -1,8 +1,9 @@
 import time
-import os
 from typing import List, Hashable
 import logging
 
+from datadog_lambda.config import config
+
 logger = logging.getLogger(__name__)
 
 _cold_start = True
@@ -86,14 +87,12 @@ def reset_node_stacks():
 
 def push_node(module_name, file_path):
     node = ImportNode(module_name, file_path, time.time_ns())
-    global import_stack
     if import_stack:
         import_stack[-1].children.append(node)
     import_stack.append(node)
 
 
 def pop_node(module_name):
-    global import_stack
     if not import_stack:
         return
     node = import_stack.pop()
@@ -102,7 +101,6 @@ def pop_node(module_name):
     end_time_ns = time.time_ns()
     node.end_time_ns = end_time_ns
     if not import_stack:  # import_stack empty, a root node has been found
-        global root_nodes
         root_nodes.append(node)
 
 
@@ -147,11 +145,7 @@ def wrap_find_spec(original_find_spec):
 
 
 def initialize_cold_start_tracing():
-    if (
-        is_new_sandbox()
-        and os.environ.get("DD_TRACE_ENABLED", "true").lower() == "true"
-        and os.environ.get("DD_COLD_START_TRACING", "true").lower() == "true"
-    ):
+    if is_new_sandbox() and config.cold_start_tracing:
         from sys import meta_path
 
         for importer in meta_path:

datadog_lambda-6.111.0/datadog_lambda/config.py

@@ -0,0 +1,145 @@
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache License Version 2.0.
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2019 Datadog, Inc.
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def _get_env(key, default=None, cast=None, depends_on_tracing=False):
+    @property
+    def _getter(self):
+        if not hasattr(self, prop_key):
+            val = self._resolve_env(key, default, cast, depends_on_tracing)
+            setattr(self, prop_key, val)
+        return getattr(self, prop_key)
+
+    prop_key = f"_config_{key}"
+    return _getter
+
+
+def as_bool(val):
+    return val.lower() == "true" or val == "1"
+
+
+def as_list(val):
+    return [val.strip() for val in val.split(",") if val.strip()]
+
+
+class Config:
+    def _resolve_env(self, key, default=None, cast=None, depends_on_tracing=False):
+        if depends_on_tracing and not self.trace_enabled:
+            return False
+        val = os.environ.get(key, default)
+        if cast is not None:
+            try:
+                val = cast(val)
+            except (ValueError, TypeError):
+                msg = (
+                    "Failed to cast environment variable '%s' with "
+                    "value '%s' to type %s. Using default value '%s'."
+                )
+                logger.warning(msg, key, val, cast.__name__, default)
+                val = default
+        return val
+
+    service = _get_env("DD_SERVICE")
+    env = _get_env("DD_ENV")
+
+    cold_start_tracing = _get_env(
+        "DD_COLD_START_TRACING", "true", as_bool, depends_on_tracing=True
+    )
+    min_cold_start_trace_duration = _get_env("DD_MIN_COLD_START_DURATION", 3, int)
+    cold_start_trace_skip_lib = _get_env(
+        "DD_COLD_START_TRACE_SKIP_LIB",
+        "ddtrace.internal.compat,ddtrace.filters",
+        as_list,
+    )
+
+    capture_payload_max_depth = _get_env("DD_CAPTURE_LAMBDA_PAYLOAD_MAX_DEPTH", 10, int)
+    capture_payload_enabled = _get_env("DD_CAPTURE_LAMBDA_PAYLOAD", "false", as_bool)
+
+    trace_enabled = _get_env("DD_TRACE_ENABLED", "true", as_bool)
+    make_inferred_span = _get_env(
+        "DD_TRACE_MANAGED_SERVICES", "true", as_bool, depends_on_tracing=True
+    )
+    encode_authorizer_context = _get_env(
+        "DD_ENCODE_AUTHORIZER_CONTEXT", "true", as_bool, depends_on_tracing=True
+    )
+    decode_authorizer_context = _get_env(
+        "DD_DECODE_AUTHORIZER_CONTEXT", "true", as_bool, depends_on_tracing=True
+    )
+    add_span_pointers = _get_env("DD_BOTOCORE_ADD_SPAN_POINTERS", "true", as_bool)
+    trace_extractor = _get_env("DD_TRACE_EXTRACTOR")
+
+    enhanced_metrics_enabled = _get_env("DD_ENHANCED_METRICS", "true", as_bool)
+
+    flush_in_thread = _get_env("DD_FLUSH_IN_THREAD", "false", as_bool)
+    flush_to_log = _get_env("DD_FLUSH_TO_LOG", "false", as_bool)
+    logs_injection = _get_env("DD_LOGS_INJECTION", "true", as_bool)
+    merge_xray_traces = _get_env("DD_MERGE_XRAY_TRACES", "false", as_bool)
+
+    telemetry_enabled = _get_env(
+        "DD_INSTRUMENTATION_TELEMETRY_ENABLED",
+        "false",
+        as_bool,
+        depends_on_tracing=True,
+    )
+    otel_enabled = _get_env("DD_TRACE_OTEL_ENABLED", "false", as_bool)
+    profiling_enabled = _get_env("DD_PROFILING_ENABLED", "false", as_bool)
+    llmobs_enabled = _get_env("DD_LLMOBS_ENABLED", "false", as_bool)
+    exception_replay_enabled = _get_env("DD_EXCEPTION_REPLAY_ENABLED", "false", as_bool)
+    data_streams_enabled = _get_env(
+        "DD_DATA_STREAMS_ENABLED", "false", as_bool, depends_on_tracing=True
+    )
+
+    is_gov_region = _get_env("AWS_REGION", "", lambda x: x.startswith("us-gov-"))
+
+    local_test = _get_env("DD_LOCAL_TEST", "false", as_bool)
+    integration_test = _get_env("DD_INTEGRATION_TEST", "false", as_bool)
+
+    aws_lambda_function_name = _get_env("AWS_LAMBDA_FUNCTION_NAME")
+
+    @property
+    def function_name(self):
+        if not hasattr(self, "_config_function_name"):
+            if self.aws_lambda_function_name is None:
+                self._config_function_name = "function"
+            else:
+                self._config_function_name = self.aws_lambda_function_name
+        return self._config_function_name
+
+    @property
+    def is_lambda_context(self):
+        if not hasattr(self, "_config_is_lambda_context"):
+            self._config_is_lambda_context = bool(self.aws_lambda_function_name)
+        return self._config_is_lambda_context
+
+    @property
+    def fips_mode_enabled(self):
+        if not hasattr(self, "_config_fips_mode_enabled"):
+            self._config_fips_mode_enabled = (
+                os.environ.get(
+                    "DD_LAMBDA_FIPS_MODE",
+                    "true" if self.is_gov_region else "false",
+                ).lower()
+                == "true"
+            )
+        return self._config_fips_mode_enabled
+
+    def _reset(self):
+        for attr in dir(self):
+            if attr.startswith("_config_"):
+                delattr(self, attr)
+
+
+config = Config()
+
+if config.is_gov_region or config.fips_mode_enabled:
+    logger.debug(
+        "Python Lambda Layer FIPS mode is %s.",
+        "enabled" if config.fips_mode_enabled else "not enabled",
+    )

datadog_lambda-6.111.0/datadog_lambda/dsm.py

@@ -0,0 +1,38 @@
+from datadog_lambda import logger
+from datadog_lambda.trigger import EventTypes
+
+
+def set_dsm_context(event, event_source):
+
+    if event_source.equals(EventTypes.SQS):
+        _dsm_set_sqs_context(event)
+
+
+def _dsm_set_sqs_context(event):
+    from datadog_lambda.wrapper import format_err_with_traceback
+    from ddtrace.internal.datastreams import data_streams_processor
+    from ddtrace.internal.datastreams.processor import DsmPathwayCodec
+    from ddtrace.internal.datastreams.botocore import (
+        get_datastreams_context,
+        calculate_sqs_payload_size,
+    )
+
+    records = event.get("Records")
+    if records is None:
+        return
+    processor = data_streams_processor()
+
+    for record in records:
+        try:
+            queue_arn = record.get("eventSourceARN", "")
+
+            contextjson = get_datastreams_context(record)
+            payload_size = calculate_sqs_payload_size(record)
+
+            ctx = DsmPathwayCodec.decode(contextjson, processor)
+            ctx.set_checkpoint(
+                ["direction:in", f"topic:{queue_arn}", "type:sqs"],
+                payload_size=payload_size,
+            )
+        except Exception as e:
+            logger.error(format_err_with_traceback(e))

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/metric.py

@@ -5,14 +5,13 @@
 
 import enum
 import logging
-import os
 import time
 from datetime import datetime, timedelta
 
 import ujson as json
 
+from datadog_lambda.config import config
 from datadog_lambda.extension import should_use_extension
-from datadog_lambda.fips import fips_mode_enabled
 from datadog_lambda.tags import dd_lambda_layer_tag, get_enhanced_metrics_tags
 
 logger = logging.getLogger(__name__)
@@ -28,10 +27,10 @@ class MetricsHandler(enum.Enum):
 def _select_metrics_handler():
     if should_use_extension:
         return MetricsHandler.EXTENSION
-    if os.environ.get("DD_FLUSH_TO_LOG", "").lower() == "true":
+    if config.flush_to_log:
         return MetricsHandler.FORWARDER
 
-    if fips_mode_enabled:
+    if config.fips_mode_enabled:
         logger.debug(
             "With FIPS mode enabled, the Datadog API metrics handler is unavailable."
         )
@@ -58,14 +57,8 @@ elif metrics_handler == MetricsHandler.DATADOG_API:
     from datadog_lambda.api import init_api
     from datadog_lambda.thread_stats_writer import ThreadStatsWriter
 
-    flush_in_thread = os.environ.get("DD_FLUSH_IN_THREAD", "").lower() == "true"
     init_api()
-    lambda_stats = ThreadStatsWriter(flush_in_thread)
-
-
-enhanced_metrics_enabled = (
-    os.environ.get("DD_ENHANCED_METRICS", "true").lower() == "true"
-)
+    lambda_stats = ThreadStatsWriter(config.flush_in_thread)
 
 
 def lambda_metric(metric_name, value, timestamp=None, tags=None, force_async=False):
@@ -191,7 +184,7 @@ def submit_enhanced_metric(metric_name, lambda_context):
         metric_name (str): metric name w/o enhanced prefix i.e. "invocations" or "errors"
         lambda_context (object): Lambda context dict passed to the function by AWS
     """
-    if not enhanced_metrics_enabled:
+    if not config.enhanced_metrics_enabled:
         logger.debug(
             "Not submitting enhanced metric %s because enhanced metrics are disabled",
             metric_name,

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/patch.py

@@ -3,7 +3,6 @@
 # This product includes software developed at Datadog (https://www.datadoghq.com/).
 # Copyright 2019 Datadog, Inc.
 
-import os
 import sys
 import logging
 import zlib
@@ -13,10 +12,8 @@ from wrapt import wrap_function_wrapper as wrap
 from wrapt.importer import when_imported
 from ddtrace import patch_all as patch_all_dd
 
-from datadog_lambda.tracing import (
-    get_dd_trace_context,
-    dd_tracing_enabled,
-)
+from datadog_lambda.config import config
+from datadog_lambda.tracing import get_dd_trace_context
 from collections.abc import MutableMapping
 
 logger = logging.getLogger(__name__)
@@ -32,7 +29,7 @@ def patch_all():
     """
     _patch_for_integration_tests()
 
-    if dd_tracing_enabled:
+    if config.trace_enabled:
         patch_all_dd()
     else:
         _patch_http()
@@ -44,8 +41,7 @@ def _patch_for_integration_tests():
     Patch `requests` to log the outgoing requests for integration tests.
     """
     global _integration_tests_patched
-    is_in_tests = os.environ.get("DD_INTEGRATION_TEST", "false").lower() == "true"
-    if not _integration_tests_patched and is_in_tests:
+    if not _integration_tests_patched and config.integration_test:
         wrap("requests", "Session.send", _log_request)
         _integration_tests_patched = True
 

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/span_pointers.py

@@ -1,12 +1,12 @@
 from itertools import chain
 import logging
-import os
 from typing import List
 from typing import Optional
 
 from ddtrace._trace._span_pointer import _SpanPointerDirection
 from ddtrace._trace._span_pointer import _SpanPointerDescription
 
+from datadog_lambda.config import config
 from datadog_lambda.metric import submit_dynamodb_stream_type_metric
 from datadog_lambda.trigger import EventTypes
 
@@ -14,15 +14,10 @@ from datadog_lambda.trigger import EventTypes
 logger = logging.getLogger(__name__)
 
 
-dd_botocore_add_span_pointers = os.environ.get(
-    "DD_BOTOCORE_ADD_SPAN_POINTERS", "true"
-).lower() in ("true", "1")
-
-
 def calculate_span_pointers(
     event_source,
     event,
-    botocore_add_span_pointers=dd_botocore_add_span_pointers,
+    botocore_add_span_pointers=config.add_span_pointers,
 ) -> List[_SpanPointerDescription]:
     try:
         if botocore_add_span_pointers:

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/tag_object.py

@@ -4,18 +4,17 @@
 # Copyright 2021 Datadog, Inc.
 
 from decimal import Decimal
-import logging
 import ujson as json
 
+from datadog_lambda.config import config
+
 redactable_keys = ["authorization", "x-authorization", "password", "token"]
-max_depth = 10
-logger = logging.getLogger(__name__)
 
 
 def tag_object(span, key, obj, depth=0):
     if obj is None:
         return span.set_tag(key, obj)
-    if depth >= max_depth:
+    if depth >= config.capture_payload_max_depth:
         return span.set_tag(key, _redact_val(key, str(obj)[0:5000]))
     depth += 1
     if _should_try_string(obj):

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/tracing.py

@@ -32,6 +32,8 @@ from ddtrace import patch
 from ddtrace import __version__ as ddtrace_version
 from ddtrace.propagation.http import HTTPPropagator
 from ddtrace.trace import Context, Span, tracer
+
+from datadog_lambda.config import config
 from datadog_lambda import __version__ as datadog_lambda_version
 from datadog_lambda.trigger import (
     _EventSource,
@@ -42,10 +44,7 @@ from datadog_lambda.trigger import (
     EventSubtypes,
 )
 
-dd_trace_otel_enabled = (
-    os.environ.get("DD_TRACE_OTEL_ENABLED", "false").lower() == "true"
-)
-if dd_trace_otel_enabled:
+if config.otel_enabled:
     from opentelemetry.trace import set_tracer_provider
     from ddtrace.opentelemetry import TracerProvider
 
@@ -55,18 +54,11 @@ if dd_trace_otel_enabled:
 logger = logging.getLogger(__name__)
 
 dd_trace_context = None
-dd_tracing_enabled = os.environ.get("DD_TRACE_ENABLED", "false").lower() == "true"
-if dd_tracing_enabled:
+if config.telemetry_enabled:
     # Enable the telemetry client if the user has opted in
-    if (
-        os.environ.get("DD_INSTRUMENTATION_TELEMETRY_ENABLED", "false").lower()
-        == "true"
-    ):
-        from ddtrace.internal.telemetry import telemetry_writer
-
-        telemetry_writer.enable()
+    from ddtrace.internal.telemetry import telemetry_writer
 
-is_lambda_context = os.environ.get(XrayDaemon.FUNCTION_NAME_HEADER_NAME) != ""
+    telemetry_writer.enable()
 
 propagator = HTTPPropagator()
 
@@ -97,7 +89,7 @@ def _convert_xray_sampling(xray_sampled):
 
 
 def _get_xray_trace_context():
-    if not is_lambda_context:
+    if not config.is_lambda_context:
         return None
 
     xray_trace_entity = parse_xray_header(
@@ -639,13 +631,11 @@ def get_dd_trace_context_obj():
     automatically, but this function can be used to manually inject the trace
     context to an outgoing request.
     """
-    if dd_tracing_enabled:
+    if config.trace_enabled:
         dd_trace_py_context = _get_dd_trace_py_context()
         if _is_context_complete(dd_trace_py_context):
             return dd_trace_py_context
 
-    global dd_trace_context
-
     try:
         xray_context = _get_xray_trace_context()  # xray (sub)segment
     except Exception as e:
@@ -690,10 +680,10 @@ def set_correlation_ids():
 
     TODO: Remove me when Datadog tracer is natively supported in Lambda.
     """
-    if not is_lambda_context:
+    if not config.is_lambda_context:
         logger.debug("set_correlation_ids is only supported in LambdaContext")
         return
-    if dd_tracing_enabled:
+    if config.trace_enabled:
         logger.debug("using ddtrace implementation for spans")
         return
 
@@ -850,13 +840,14 @@ def create_inferred_span_from_lambda_function_url_event(event, context):
     http = request_context.get("http")
     method = http.get("method") if http else None
     path = http.get("path") if http else None
+    http_url = f"https://{domain}{path}"
     resource = f"{method} {path}"
     tags = {
         "operation_name": "aws.lambda.url",
-        "http.url": domain + path,
+        "http.url": http_url,
         "endpoint": path,
         "http.method": method,
-        "resource_names": domain + path,
+        "resource_names": resource,
         "request_id": context.aws_request_id,
     }
     request_time_epoch = request_context.get("timeEpoch")
@@ -948,6 +939,7 @@ def create_inferred_span_from_api_gateway_websocket_event(
     request_context = event.get("requestContext")
     domain = request_context.get("domainName")
     endpoint = request_context.get("routeKey")
+    http_url = f"https://{domain}{endpoint}"
     api_id = request_context.get("apiId")
 
     service_name = determine_service_name(
@@ -955,7 +947,7 @@ def create_inferred_span_from_api_gateway_websocket_event(
     )
     tags = {
         "operation_name": "aws.apigateway.websocket",
-        "http.url": domain + endpoint,
+        "http.url": http_url,
         "endpoint": endpoint,
         "resource_names": endpoint,
         "apiid": api_id,
@@ -1007,11 +999,12 @@ def create_inferred_span_from_api_gateway_event(
     )
     method = event.get("httpMethod")
     path = event.get("path")
+    http_url = f"https://{domain}{path}"
     resource_path = _get_resource_path(event, request_context)
     resource = f"{method} {resource_path}"
     tags = {
         "operation_name": "aws.apigateway.rest",
-        "http.url": domain + path,
+        "http.url": http_url,
         "endpoint": path,
         "http.method": method,
         "resource_names": resource,
@@ -1073,12 +1066,13 @@ def create_inferred_span_from_http_api_event(
     http = request_context.get("http") or {}
     method = http.get("method")
     path = event.get("rawPath")
+    http_url = f"https://{domain}{path}"
     resource_path = _get_resource_path(event, request_context)
     resource = f"{method} {resource_path}"
     tags = {
         "operation_name": "aws.httpapi",
         "endpoint": path,
-        "http.url": domain + path,
+        "http.url": http_url,
         "http.method": http.get("method"),
         "http.protocol": http.get("protocol"),
         "http.source_ip": http.get("sourceIp"),
@@ -1476,7 +1470,7 @@ def emit_telemetry_on_exception_outside_of_handler(
     Emit an enhanced error metric and create a span for exceptions occurring outside the handler
     """
     submit_errors_metric(None)
-    if dd_tracing_enabled:
+    if config.trace_enabled:
         span = tracer.trace(
             "aws.lambda",
             service="aws.lambda",

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/trigger.py

@@ -114,10 +114,14 @@ def parse_event_source(event: dict) -> _EventSource:
 
     event_source = None
 
+    # Get requestContext safely and ensure it's a dictionary
     request_context = event.get("requestContext")
+    if not isinstance(request_context, dict):
+        request_context = None
+
     if request_context and request_context.get("stage"):
         if "domainName" in request_context and detect_lambda_function_url_domain(
-            request_context.get("domainName")
+            request_context.get("domainName", "")
         ):
             return _EventSource(EventTypes.LAMBDA_FUNCTION_URL)
         event_source = _EventSource(EventTypes.API_GATEWAY)
@@ -149,7 +153,7 @@ def parse_event_source(event: dict) -> _EventSource:
         event_source = _EventSource(EventTypes.STEPFUNCTIONS)
 
     event_record = get_first_record(event)
-    if event_record:
+    if event_record and isinstance(event_record, dict):
         aws_event_source = event_record.get("eventSource") or event_record.get(
             "EventSource"
         )
@@ -171,6 +175,8 @@ def parse_event_source(event: dict) -> _EventSource:
 
 def detect_lambda_function_url_domain(domain: str) -> bool:
     #  e.g. "etsn5fibjr.lambda-url.eu-south-1.amazonaws.com"
+    if not isinstance(domain, str):
+        return False
     domain_parts = domain.split(".")
     if len(domain_parts) < 2:
         return False
@@ -283,17 +289,28 @@ def extract_http_tags(event):
     Extracts HTTP facet tags from the triggering event
     """
     http_tags = {}
+
+    # Safely get request_context and ensure it's a dictionary
     request_context = event.get("requestContext")
+    if not isinstance(request_context, dict):
+        request_context = None
+
     path = event.get("path")
     method = event.get("httpMethod")
+
     if request_context and request_context.get("stage"):
-        if request_context.get("domainName"):
-            http_tags["http.url"] = request_context.get("domainName")
+        domain_name = request_context.get("domainName")
+        if domain_name:
+            http_tags["http.url"] = f"https://{domain_name}"
 
         path = request_context.get("path")
         method = request_context.get("httpMethod")
+
         # Version 2.0 HTTP API Gateway
-        apigateway_v2_http = request_context.get("http")
+        apigateway_v2_http = request_context.get("http", {})
+        if not isinstance(apigateway_v2_http, dict):
+            apigateway_v2_http = {}
+
         if event.get("version") == "2.0" and apigateway_v2_http:
             path = apigateway_v2_http.get("path")
             method = apigateway_v2_http.get("method")
@@ -303,15 +320,23 @@ def extract_http_tags(event):
     if method:
         http_tags["http.method"] = method
 
-    headers = event.get("headers")
+    # Safely get headers
+    headers = event.get("headers", {})
+    if not isinstance(headers, dict):
+        headers = {}
+
     if headers and headers.get("Referer"):
         http_tags["http.referer"] = headers.get("Referer")
 
     # Try to get `routeKey` from API GW v2; otherwise try to get `resource` from API GW v1
     route = event.get("routeKey") or event.get("resource")
-    if route:
-        # "GET /my/endpoint" = > "/my/endpoint"
-        http_tags["http.route"] = route.split(" ")[-1]
+    if route and isinstance(route, str):
+        try:
+            # "GET /my/endpoint" = > "/my/endpoint"
+            http_tags["http.route"] = route.split(" ")[-1]
+        except Exception:
+            # If splitting fails, use the route as is
+            http_tags["http.route"] = route
 
     return http_tags
 

datadog_lambda-6.111.0/datadog_lambda/version.py

@@ -0,0 +1 @@
+__version__ = "6.111.0"

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/datadog_lambda/wrapper.py

@@ -9,6 +9,7 @@ import ujson as json
 from importlib import import_module
 from time import time_ns
 
+from datadog_lambda.dsm import set_dsm_context
 from datadog_lambda.extension import should_use_extension, flush_extension
 from datadog_lambda.cold_start import (
     set_cold_start,
@@ -17,6 +18,7 @@ from datadog_lambda.cold_start import (
     is_new_sandbox,
     ColdStartTracer,
 )
+from datadog_lambda.config import config
 from datadog_lambda.constants import (
     TraceContextSource,
     XraySubsegment,
@@ -25,11 +27,11 @@ from datadog_lambda.constants import (
 from datadog_lambda.module_name import modify_module_name
 from datadog_lambda.patch import patch_all
 from datadog_lambda.span_pointers import calculate_span_pointers
+from datadog_lambda.tag_object import tag_object
 from datadog_lambda.tracing import (
     extract_dd_trace_context,
     create_dd_dummy_metadata_subsegment,
     inject_correlation_ids,
-    dd_tracing_enabled,
     mark_trace_as_error_for_5xx_responses,
     set_correlation_ids,
     set_dd_trace_py_root,
@@ -45,57 +47,20 @@ from datadog_lambda.trigger import (
     extract_http_status_code_tag,
 )
 
-profiling_env_var = os.environ.get("DD_PROFILING_ENABLED", "false").lower() == "true"
-if profiling_env_var:
+if config.profiling_enabled:
     from ddtrace.profiling import profiler
 
-llmobs_env_var = os.environ.get("DD_LLMOBS_ENABLED", "false").lower() in ("true", "1")
-if llmobs_env_var:
+if config.llmobs_enabled:
     from ddtrace.llmobs import LLMObs
 
+if config.exception_replay_enabled:
+    from ddtrace.debugging._exception.replay import SpanExceptionHandler
+    from ddtrace.debugging._uploader import LogsIntakeUploaderV1
+
 logger = logging.getLogger(__name__)
 
-DD_FLUSH_TO_LOG = "DD_FLUSH_TO_LOG"
-DD_LOGS_INJECTION = "DD_LOGS_INJECTION"
-DD_MERGE_XRAY_TRACES = "DD_MERGE_XRAY_TRACES"
-AWS_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME"
-DD_LOCAL_TEST = "DD_LOCAL_TEST"
-DD_TRACE_EXTRACTOR = "DD_TRACE_EXTRACTOR"
-DD_TRACE_MANAGED_SERVICES = "DD_TRACE_MANAGED_SERVICES"
-DD_ENCODE_AUTHORIZER_CONTEXT = "DD_ENCODE_AUTHORIZER_CONTEXT"
-DD_DECODE_AUTHORIZER_CONTEXT = "DD_DECODE_AUTHORIZER_CONTEXT"
-DD_COLD_START_TRACING = "DD_COLD_START_TRACING"
-DD_MIN_COLD_START_DURATION = "DD_MIN_COLD_START_DURATION"
-DD_COLD_START_TRACE_SKIP_LIB = "DD_COLD_START_TRACE_SKIP_LIB"
-DD_CAPTURE_LAMBDA_PAYLOAD = "DD_CAPTURE_LAMBDA_PAYLOAD"
-DD_CAPTURE_LAMBDA_PAYLOAD_MAX_DEPTH = "DD_CAPTURE_LAMBDA_PAYLOAD_MAX_DEPTH"
 DD_REQUESTS_SERVICE_NAME = "DD_REQUESTS_SERVICE_NAME"
 DD_SERVICE = "DD_SERVICE"
-DD_ENV = "DD_ENV"
-
-
-def get_env_as_int(env_key, default_value: int) -> int:
-    try:
-        return int(os.environ.get(env_key, default_value))
-    except Exception as e:
-        logger.warn(
-            f"Failed to parse {env_key} as int. Using default value: {default_value}. Error: {e}"
-        )
-        return default_value
-
-
-dd_capture_lambda_payload_enabled = (
-    os.environ.get(DD_CAPTURE_LAMBDA_PAYLOAD, "false").lower() == "true"
-)
-
-if dd_capture_lambda_payload_enabled:
-    import datadog_lambda.tag_object as tag_object
-
-    tag_object.max_depth = get_env_as_int(
-        DD_CAPTURE_LAMBDA_PAYLOAD_MAX_DEPTH, tag_object.max_depth
-    )
-
-env_env_var = os.environ.get(DD_ENV, None)
 
 init_timestamp_ns = time_ns()
 
@@ -152,56 +117,16 @@ class _LambdaDecorator(object):
         """Executes when the wrapped function gets wrapped"""
         try:
             self.func = func
-            self.flush_to_log = os.environ.get(DD_FLUSH_TO_LOG, "").lower() == "true"
-            self.logs_injection = (
-                os.environ.get(DD_LOGS_INJECTION, "true").lower() == "true"
-            )
-            self.merge_xray_traces = (
-                os.environ.get(DD_MERGE_XRAY_TRACES, "false").lower() == "true"
-            )
-            self.function_name = os.environ.get(AWS_LAMBDA_FUNCTION_NAME, "function")
-            self.service = os.environ.get(DD_SERVICE, None)
-            self.extractor_env = os.environ.get(DD_TRACE_EXTRACTOR, None)
             self.trace_extractor = None
             self.span = None
             self.inferred_span = None
-            depends_on_dd_tracing_enabled = (
-                lambda original_boolean: dd_tracing_enabled and original_boolean
-            )
-            self.make_inferred_span = depends_on_dd_tracing_enabled(
-                os.environ.get(DD_TRACE_MANAGED_SERVICES, "true").lower() == "true"
-            )
-            self.encode_authorizer_context = depends_on_dd_tracing_enabled(
-                os.environ.get(DD_ENCODE_AUTHORIZER_CONTEXT, "true").lower() == "true"
-            )
-            self.decode_authorizer_context = depends_on_dd_tracing_enabled(
-                os.environ.get(DD_DECODE_AUTHORIZER_CONTEXT, "true").lower() == "true"
-            )
-            self.cold_start_tracing = depends_on_dd_tracing_enabled(
-                os.environ.get(DD_COLD_START_TRACING, "true").lower() == "true"
-            )
-            self.min_cold_start_trace_duration = get_env_as_int(
-                DD_MIN_COLD_START_DURATION, 3
-            )
-            self.local_testing_mode = os.environ.get(
-                DD_LOCAL_TEST, "false"
-            ).lower() in ("true", "1")
-            self.cold_start_trace_skip_lib = [
-                "ddtrace.internal.compat",
-                "ddtrace.filters",
-            ]
-            if DD_COLD_START_TRACE_SKIP_LIB in os.environ:
-                try:
-                    self.cold_start_trace_skip_lib = os.environ[
-                        DD_COLD_START_TRACE_SKIP_LIB
-                    ].split(",")
-                except Exception:
-                    logger.debug(f"Malformatted for env {DD_COLD_START_TRACE_SKIP_LIB}")
             self.response = None
-            if profiling_env_var:
-                self.prof = profiler.Profiler(env=env_env_var, service=self.service)
-            if self.extractor_env:
-                extractor_parts = self.extractor_env.rsplit(".", 1)
+
+            if config.profiling_enabled:
+                self.prof = profiler.Profiler(env=config.env, service=config.service)
+
+            if config.trace_extractor:
+                extractor_parts = config.trace_extractor.rsplit(".", 1)
                 if len(extractor_parts) == 2:
                     (mod_name, extractor_name) = extractor_parts
                     modified_extractor_name = modify_module_name(mod_name)
@@ -209,7 +134,7 @@ class _LambdaDecorator(object):
                     self.trace_extractor = getattr(extractor_module, extractor_name)
 
             # Inject trace correlation ids to logs
-            if self.logs_injection:
+            if config.logs_injection:
                 inject_correlation_ids()
 
             # This prevents a breaking change in ddtrace v0.49 regarding the service name
@@ -221,9 +146,14 @@ class _LambdaDecorator(object):
             patch_all()
 
             # Enable LLM Observability
-            if llmobs_env_var:
+            if config.llmobs_enabled:
                 LLMObs.enable()
 
+            # Enable Exception Replay
+            if config.exception_replay_enabled:
+                logger.debug("Enabling exception replay")
+                SpanExceptionHandler.enable()
+
             logger.debug("datadog_lambda_wrapper initialized")
         except Exception as e:
             logger.error(format_err_with_traceback(e))
@@ -290,7 +220,7 @@ class _LambdaDecorator(object):
                 event,
                 context,
                 extractor=self.trace_extractor,
-                decode_authorizer_context=self.decode_authorizer_context,
+                decode_authorizer_context=config.decode_authorizer_context,
             )
             self.event_source = event_source
             # Create a Datadog X-Ray subsegment with the trace context
@@ -304,26 +234,28 @@ class _LambdaDecorator(object):
                     XraySubsegment.TRACE_KEY,
                 )
 
-            if dd_tracing_enabled:
-                set_dd_trace_py_root(trace_context_source, self.merge_xray_traces)
-                if self.make_inferred_span:
+            if config.trace_enabled:
+                set_dd_trace_py_root(trace_context_source, config.merge_xray_traces)
+                if config.make_inferred_span:
                     self.inferred_span = create_inferred_span(
-                        event, context, event_source, self.decode_authorizer_context
+                        event, context, event_source, config.decode_authorizer_context
                     )
+                if config.data_streams_enabled:
+                    set_dsm_context(event, event_source)
                 self.span = create_function_execution_span(
                     context=context,
-                    function_name=self.function_name,
+                    function_name=config.function_name,
                     is_cold_start=is_cold_start(),
                     is_proactive_init=is_proactive_init(),
                     trace_context_source=trace_context_source,
-                    merge_xray_traces=self.merge_xray_traces,
+                    merge_xray_traces=config.merge_xray_traces,
                     trigger_tags=self.trigger_tags,
                     parent_span=self.inferred_span,
                     span_pointers=calculate_span_pointers(event_source, event),
                 )
             else:
                 set_correlation_ids()
-            if profiling_env_var and is_new_sandbox():
+            if config.profiling_enabled and is_new_sandbox():
                 self.prof.start(stop_on_exit=False, profile_children=True)
             logger.debug("datadog_lambda_wrapper _before() done")
         except Exception as e:
@@ -342,14 +274,14 @@ class _LambdaDecorator(object):
                 create_dd_dummy_metadata_subsegment(
                     self.trigger_tags, XraySubsegment.LAMBDA_FUNCTION_TAGS_KEY
                 )
-            should_trace_cold_start = self.cold_start_tracing and is_new_sandbox()
+            should_trace_cold_start = config.cold_start_tracing and is_new_sandbox()
             if should_trace_cold_start:
                 trace_ctx = tracer.current_trace_context()
 
             if self.span:
-                if dd_capture_lambda_payload_enabled:
-                    tag_object.tag_object(self.span, "function.request", event)
-                    tag_object.tag_object(self.span, "function.response", self.response)
+                if config.capture_payload_enabled:
+                    tag_object(self.span, "function.request", event)
+                    tag_object(self.span, "function.response", self.response)
 
                 if status_code:
                     self.span.set_tag("http.status_code", status_code)
@@ -359,8 +291,8 @@ class _LambdaDecorator(object):
                 if status_code:
                     self.inferred_span.set_tag("http.status_code", status_code)
 
-                if self.service:
-                    self.inferred_span.set_tag("peer.service", self.service)
+                if config.service:
+                    self.inferred_span.set_tag("peer.service", config.service)
 
                 if InferredSpanInfo.is_async(self.inferred_span) and self.span:
                     self.inferred_span.finish(finish_time=self.span.start)
@@ -372,29 +304,35 @@ class _LambdaDecorator(object):
                     following_span = self.span or self.inferred_span
                     ColdStartTracer(
                         tracer,
-                        self.function_name,
+                        config.function_name,
                         following_span.start_ns,
                         trace_ctx,
-                        self.min_cold_start_trace_duration,
-                        self.cold_start_trace_skip_lib,
+                        config.min_cold_start_trace_duration,
+                        config.cold_start_trace_skip_lib,
                     ).trace()
                 except Exception as e:
                     logger.debug("Failed to create cold start spans. %s", e)
 
-            if not self.flush_to_log or should_use_extension:
+            if not config.flush_to_log or should_use_extension:
                 from datadog_lambda.metric import flush_stats
 
                 flush_stats(context)
-            if should_use_extension and self.local_testing_mode:
+            if should_use_extension and config.local_test:
                 # when testing locally, the extension does not know when an
                 # invocation completes because it does not have access to the
                 # logs api
                 flush_extension()
 
-            if llmobs_env_var:
+            if config.llmobs_enabled:
                 LLMObs.flush()
 
-            if self.encode_authorizer_context and is_authorizer_response(self.response):
+            # Flush exception replay
+            if config.exception_replay_enabled:
+                LogsIntakeUploaderV1._instance.periodic()
+
+            if config.encode_authorizer_context and is_authorizer_response(
+                self.response
+            ):
                 self._inject_authorizer_span_headers(
                     event.get("requestContext", {}).get("requestId")
                 )

{datadog_lambda-6.109.0 → datadog_lambda-6.111.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "datadog_lambda"
-version = "6.109.0"
+version = "6.111.0"
 description = "The Datadog AWS Lambda Library"
 authors = ["Datadog, Inc. <dev@datadoghq.com>"]
 license = "Apache-2.0"

datadog_lambda-6.109.0/datadog_lambda/fips.py

@@ -1,19 +0,0 @@
-import logging
-import os
-
-is_gov_region = os.environ.get("AWS_REGION", "").startswith("us-gov-")
-
-fips_mode_enabled = (
-    os.environ.get(
-        "DD_LAMBDA_FIPS_MODE",
-        "true" if is_gov_region else "false",
-    ).lower()
-    == "true"
-)
-
-if is_gov_region or fips_mode_enabled:
-    logger = logging.getLogger(__name__)
-    logger.debug(
-        "Python Lambda Layer FIPS mode is %s.",
-        "enabled" if fips_mode_enabled else "not enabled",
-    )

datadog_lambda-6.109.0/datadog_lambda/version.py

@@ -1 +0,0 @@
-__version__ = "6.109.0"