datadog_lambda 8.125.0__tar.gz → 8.127.0__tar.gz

{datadog_lambda-8.125.0 → datadog_lambda-8.127.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datadog_lambda
-Version: 8.125.0
+Version: 8.127.0
 Summary: The Datadog AWS Lambda Library
 Home-page: https://github.com/DataDog/datadog-lambda-python
 License: Apache-2.0

{datadog_lambda-8.125.0 → datadog_lambda-8.127.0}/datadog_lambda/durable.py

@@ -4,9 +4,12 @@
 # Copyright 2019 Datadog, Inc.
 import logging
 import re
+import ujson as json
 
 logger = logging.getLogger(__name__)
 
+_TRACE_CHECKPOINT_PREFIX = "_datadog_"
+
 
 def _parse_durable_execution_arn(arn):
     """
@@ -47,17 +50,71 @@ def extract_durable_function_tags(event):
     operations = event.get("InitialExecutionState", {}).get("Operations", [])
     is_first_invocation = len(operations) == 1
     return {
-        "aws_lambda.durable_function.execution_name": execution_name,
-        "aws_lambda.durable_function.execution_id": execution_id,
-        "aws_lambda.durable_function.first_invocation": str(
-            is_first_invocation
-        ).lower(),
+        "aws.durable.execution_name": execution_name,
+        "aws.durable.execution_id": execution_id,
+        "aws.durable.first_invocation": str(is_first_invocation).lower(),
     }
 
 
 VALID_DURABLE_STATUSES = {"SUCCEEDED", "FAILED", "PENDING"}
 
 
+def _extract_context_from_durable_checkpoint(operation):
+    # Checkpoint data is written by the dd-trace-py in Datadog style
+    # (x-datadog-* headers). Extraction goes through the standard
+    # propagator.extract path, which honors DD_TRACE_PROPAGATION_STYLE_EXTRACT.
+    # The default extract list (datadog, tracecontext, baggage) already
+    # includes datadog. Customers who override the extract list MUST keep
+    # datadog in it.
+    if not isinstance(operation, dict):
+        return None
+
+    step_details = operation.get("StepDetails")
+    if not isinstance(step_details, dict):
+        return None
+
+    result = step_details.get("Result")
+    if isinstance(result, str):
+        try:
+            result = json.loads(result)
+        except Exception:
+            return None
+
+    if not isinstance(result, dict):
+        return None
+
+    from datadog_lambda.tracing import propagator
+
+    return propagator.extract(result)
+
+
+def extract_context_from_durable_execution(event):
+    operations = event.get("InitialExecutionState", {}).get("Operations")
+    if isinstance(operations, dict):
+        operations = list(operations.values())
+    if not isinstance(operations, list) or not operations:
+        return None
+
+    highest = -1
+    best_operation = None
+    for operation in operations:
+        if not isinstance(operation, dict):
+            continue
+        name = operation.get("Name")
+        if not isinstance(name, str) or not name.startswith(_TRACE_CHECKPOINT_PREFIX):
+            continue
+        suffix = name[len(_TRACE_CHECKPOINT_PREFIX) :]
+        try:
+            number = int(suffix)
+        except (TypeError, ValueError):
+            continue
+        if number > highest:
+            highest = number
+            best_operation = operation
+
+    return _extract_context_from_durable_checkpoint(best_operation)
+
+
 def extract_durable_execution_status(response, event):
     if not isinstance(event, dict) or "DurableExecutionArn" not in event:
         return None

{datadog_lambda-8.125.0 → datadog_lambda-8.127.0}/datadog_lambda/tracing.py

@@ -43,7 +43,9 @@ from datadog_lambda.trigger import (
     is_step_function_event,
     EventTypes,
     EventSubtypes,
+    resolve_multivalue_headers,
 )
+from datadog_lambda.durable import extract_context_from_durable_execution
 
 if config.otel_enabled:
     from opentelemetry.trace import set_tracer_provider
@@ -195,7 +197,7 @@ def extract_context_from_http_event_or_context(
         if _is_context_complete(context):
             return context
 
-    headers = event.get("headers")
+    headers = resolve_multivalue_headers(event)
     context = propagator.extract(headers)
 
     if not _is_context_complete(context):
@@ -481,6 +483,21 @@ def _generate_sfn_parent_id(context: dict) -> int:
     )
 
 
+def _extract_dd_trace_id_from_dd_data(dd_data, meta):
+    """
+    Read native Datadog trace headers from a `_datadog` dict.
+    Returns the 64-bit trace_id and populates meta["_dd.p.tid"] when present.
+    Returns None if no usable trace id is found.
+    """
+    if not dd_data or "x-datadog-trace-id" not in dd_data:
+        return None
+    trace_id = int(dd_data.get("x-datadog-trace-id"))
+    high_64_bit_trace_id = _parse_high_64_bits(dd_data.get("x-datadog-tags"))
+    if high_64_bit_trace_id:
+        meta["_dd.p.tid"] = high_64_bit_trace_id
+    return trace_id
+
+
 def _generate_sfn_trace_id(execution_id: str, part: str):
     """
     Take the SHA-256 hash of the execution_id to calculate the trace ID. If the high 64 bits are
@@ -516,10 +533,7 @@ def extract_context_from_step_functions(event, lambda_context):
 
         if event.get("serverless-version") == "v1":
             if "x-datadog-trace-id" in event:  # lambda root
-                trace_id = int(event.get("x-datadog-trace-id"))
-                high_64_bit_trace_id = _parse_high_64_bits(event.get("x-datadog-tags"))
-                if high_64_bit_trace_id:
-                    meta["_dd.p.tid"] = high_64_bit_trace_id
+                trace_id = _extract_dd_trace_id_from_dd_data(event, meta)
             else:  # sfn root
                 root_execution_id = event.get("RootExecutionId")
                 trace_id = _generate_sfn_trace_id(root_execution_id, LOWER_64_BITS)
@@ -529,9 +543,13 @@ def extract_context_from_step_functions(event, lambda_context):
 
             parent_id = _generate_sfn_parent_id(event)
         else:
-            execution_id = event.get("Execution").get("Id")
-            trace_id = _generate_sfn_trace_id(execution_id, LOWER_64_BITS)
-            meta["_dd.p.tid"] = _generate_sfn_trace_id(execution_id, HIGHER_64_BITS)
+            execution = event.get("Execution", {})
+            dd_input = execution.get("Input", {}).get("_datadog")
+            trace_id = _extract_dd_trace_id_from_dd_data(dd_input, meta)
+            if trace_id is None:
+                execution_id = execution.get("Id")
+                trace_id = _generate_sfn_trace_id(execution_id, LOWER_64_BITS)
+                meta["_dd.p.tid"] = _generate_sfn_trace_id(execution_id, HIGHER_64_BITS)
             parent_id = _generate_sfn_parent_id(event)
 
         sampling_priority = SamplingPriority.AUTO_KEEP
@@ -633,6 +651,7 @@ def extract_dd_trace_context(
     global dd_trace_context
     trace_context_source = None
     event_source = parse_event_source(event)
+    context = None
 
     if extractor is not None:
         context = extract_context_custom_extractor(extractor, event, lambda_context)
@@ -640,7 +659,9 @@ def extract_dd_trace_context(
         context = extract_context_from_request_header_or_context(
             event, lambda_context, event_source
         )
-    elif isinstance(event, (set, dict)) and "headers" in event:
+    elif isinstance(event, (set, dict)) and (
+        "headers" in event or "multiValueHeaders" in event
+    ):
         context = extract_context_from_http_event_or_context(
             event, lambda_context, event_source, decode_authorizer_context
         )
@@ -654,6 +675,8 @@ def extract_dd_trace_context(
         context = extract_context_from_kinesis_event(event, lambda_context)
     elif event_source.equals(EventTypes.STEPFUNCTIONS):
         context = extract_context_from_step_functions(event, lambda_context)
+    elif isinstance(event, dict) and "DurableExecutionArn" in event:
+        context = extract_context_from_durable_execution(event)
     else:
         context = extract_context_from_lambda_context(lambda_context)
 
@@ -817,6 +840,9 @@ def create_inferred_span(
         elif event_source.equals(EventTypes.LAMBDA_FUNCTION_URL):
             logger.debug("Function URL event detected. Inferring a span")
             return create_inferred_span_from_lambda_function_url_event(event, context)
+        elif event_source.event_type == EventTypes.ALB:
+            logger.debug("ALB event detected. Inferring a span")
+            return create_inferred_span_from_alb_event(event, context)
         elif event_source.equals(
             EventTypes.API_GATEWAY, subtype=EventSubtypes.HTTP_API
         ):
@@ -932,6 +958,54 @@ def create_inferred_span_from_lambda_function_url_event(event, context):
     return span
 
 
+def create_inferred_span_from_alb_event(event, context):
+    request_context = event.get("requestContext") or {}
+    elb = request_context.get("elb") or {}
+    target_group_arn = elb.get("targetGroupArn")
+
+    headers = resolve_multivalue_headers(event)
+    host = headers.get("host")
+    method = event.get("httpMethod")
+    path = event.get("path")
+    proto = headers.get("x-forwarded-proto", "http")
+
+    # ALB has no api id; key the service mapping off the load-balancer host and
+    # fall back to it when DD_TRACE_AWS_SERVICE_REPRESENTATION_ENABLED is on.
+    service_name = determine_service_name(service_mapping, host, "lambda_alb", host)
+
+    http_url = "%s://%s%s" % (proto, host, path) if host and path is not None else None
+    if method and path is not None:
+        resource = f"{method} {path}"
+    else:
+        resource = method or path
+
+    tags = {
+        "operation_name": "aws.alb",
+        "span.kind": "server",
+        "http.method": method,
+        "http.url": http_url,
+        "http.useragent": headers.get("user-agent"),
+        "endpoint": path,
+        "resource_names": resource,
+        "request_id": context.aws_request_id,
+        "target_group_arn": target_group_arn,
+    }
+    # Drop tags we couldn't derive so the span never carries malformed values.
+    tags = {key: value for key, value in tags.items() if value is not None}
+
+    tracer.set_tags(_dd_origin)
+    # ALB events carry no request timestamp (unlike API GW requestTimeEpoch /
+    # Function URL timeEpoch), so the span starts at handler time.
+    span = tracer.trace(
+        "aws.alb", service=service_name, resource=resource, span_type="http"
+    )
+    InferredSpanInfo.set_tags(tags, tag_source="self", synchronicity="sync")
+    if span:
+        span.set_tags(tags)
+        span.set_metric(InferredSpanInfo.METRIC, 1.0)
+    return span
+
+
 def is_api_gateway_invocation_async(event):
     hdrs = event.get("headers")
     if not hdrs:

{datadog_lambda-8.125.0 → datadog_lambda-8.127.0}/datadog_lambda/trigger.py

@@ -293,6 +293,39 @@ def get_event_source_arn(source: _EventSource, event: dict, context: Any) -> str
     return event_source_arn
 
 
+def resolve_multivalue_headers(event):
+    """
+    Resolve request headers from single-value ``headers`` or ``multiValueHeaders``
+    (first value per key, matching datadog-lambda-js).
+    """
+    headers = event.get("headers")
+    if isinstance(headers, dict) and headers:
+        return headers
+
+    multi_value = event.get("multiValueHeaders")
+    if not isinstance(multi_value, dict):
+        return {}
+
+    resolved = {}
+    for key, value in multi_value.items():
+        if isinstance(value, list):
+            if value:
+                resolved[key] = value[0]
+        elif isinstance(value, str):
+            resolved[key] = value
+    return resolved
+
+
+def _get_header_case_insensitive(headers, name):
+    if not isinstance(headers, dict):
+        return None
+    name_lower = name.lower()
+    for key, value in headers.items():
+        if isinstance(key, str) and key.lower() == name_lower and value:
+            return value
+    return None
+
+
 def extract_http_tags(event):
     """
     Extracts HTTP facet tags from the triggering event
@@ -324,19 +357,32 @@ def extract_http_tags(event):
             path = apigateway_v2_http.get("path")
             method = apigateway_v2_http.get("method")
 
+    elif request_context and request_context.get("elb"):
+        # ALB events have no requestContext.stage; derive the URL from the
+        # forwarded host/proto headers and the top-level path.
+        alb_headers = resolve_multivalue_headers(event)
+        host = alb_headers.get("host")
+        if host:
+            proto = alb_headers.get("x-forwarded-proto", "http")
+            http_tags["http.url"] = proto + "://" + host
+
+        user_agent = alb_headers.get("user-agent")
+        if user_agent:
+            http_tags["http.useragent"] = user_agent
+
+        # ALB carries no route template, so use the request path as the route.
+        if path:
+            http_tags["http.route"] = path
+
     if path:
         if http_tags.get("http.url"):
             http_tags["http.url"] += path
     if method:
         http_tags["http.method"] = method
 
-    # 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")
+    referer = _get_header_case_insensitive(resolve_multivalue_headers(event), "referer")
+    if referer:
+        http_tags["http.referer"] = 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")
@@ -415,6 +461,8 @@ def is_step_function_event(event):
     The actual event must contain "Execution", "StateMachine", and "State" fields.
     """
     event = event.get("Payload", event)
+    if not isinstance(event, dict):
+        return False
 
     # JSONPath style
     if "Execution" in event and "StateMachine" in event and "State" in event:

datadog_lambda-8.127.0/datadog_lambda/version.py

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

{datadog_lambda-8.125.0 → datadog_lambda-8.127.0}/datadog_lambda/wrapper.py

@@ -9,7 +9,6 @@ import ujson as json
 from importlib import import_module
 from time import time_ns
 
-from ddtrace.internal._exceptions import BlockingException
 from datadog_lambda.extension import should_use_extension, flush_extension
 from datadog_lambda.cold_start import (
     set_cold_start,
@@ -191,8 +190,6 @@ class _LambdaDecorator(object):
             if self.blocking_response:
                 return self.blocking_response
             self.response = self.func(event, context, **kwargs)
-        except BlockingException:
-            self.blocking_response = get_asm_blocked_response(self.event_source)
         except Exception:
             from datadog_lambda.metric import submit_errors_metric
 
@@ -201,6 +198,9 @@ class _LambdaDecorator(object):
             if self.span:
                 self.span.set_traceback()
             raise
+        except BaseException as e:
+            if "BlockingException" in type(e).__name__:
+                self.blocking_response = get_asm_blocked_response(self.event_source)
         finally:
             self._after(event, context)
         if self.blocking_response:
@@ -346,7 +346,7 @@ class _LambdaDecorator(object):
                 durable_status = extract_durable_execution_status(self.response, event)
                 if durable_status:
                     self.span.set_tag(
-                        "aws_lambda.durable_function.execution_status",
+                        "aws.durable.execution_status",
                         durable_status,
                     )
 

{datadog_lambda-8.125.0 → datadog_lambda-8.127.0}/pyproject.toml

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

datadog_lambda-8.125.0/datadog_lambda/version.py

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