datadog_lambda 8.122.0__tar.gz → 8.124.0__tar.gz

{datadog_lambda-8.122.0 → datadog_lambda-8.124.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: datadog_lambda
-Version: 8.122.0
+Version: 8.124.0
 Summary: The Datadog AWS Lambda Library
 Home-page: https://github.com/DataDog/datadog-lambda-python
 License: Apache-2.0
 Keywords: datadog,aws,lambda,layer
 Author: Datadog, Inc.
 Author-email: dev@datadoghq.com
-Requires-Python: >=3.8.0,<4
+Requires-Python: >=3.8.0,<3.15
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
@@ -21,12 +21,17 @@ Provides-Extra: dev
 Requires-Dist: botocore (>=1.34.0,<2.0.0) ; extra == "dev"
 Requires-Dist: datadog (>=0.51.0,<1.0.0)
 Requires-Dist: ddtrace (>=3.19.1,<4) ; python_version >= "3.8" and python_version < "3.10"
-Requires-Dist: ddtrace (>=4.1.1,<5) ; python_version >= "3.10"
+Requires-Dist: ddtrace (>=4.1.1,<5,!=4.6.*) ; python_version >= "3.10"
 Requires-Dist: flake8 (>=5.0.4,<6.0.0) ; extra == "dev"
-Requires-Dist: pytest (>=8.0.0,<9.0.0) ; extra == "dev"
+Requires-Dist: pytest (>=8.3.4,<9.0.0) ; (python_version >= "3.8" and python_version < "3.10") and (extra == "dev")
+Requires-Dist: pytest (>=9.0.3,<10.0.0) ; (python_version >= "3.10") and (extra == "dev")
 Requires-Dist: pytest-benchmark (>=4.0,<5.0) ; extra == "dev"
-Requires-Dist: requests (>=2.22.0,<3.0.0) ; extra == "dev"
-Requires-Dist: ujson (>=5.9.0)
+Requires-Dist: requests (>=2.22.0,<3.0.0) ; (python_version >= "3.8" and python_version < "3.10") and (extra == "dev")
+Requires-Dist: requests (>=2.33.0,<3.0.0) ; (python_version >= "3.10") and (extra == "dev")
+Requires-Dist: ujson (>=5.10.0,<5.12.0) ; python_version >= "3.8" and python_version < "3.10"
+Requires-Dist: ujson (>=5.12.0,<6.0.0) ; python_version >= "3.10"
+Requires-Dist: urllib3 (>=1.25.4,<1.27) ; python_version >= "3.8" and python_version < "3.10"
+Requires-Dist: urllib3 (>=2.6.3,<3.0.0) ; python_version >= "3.10"
 Requires-Dist: wrapt (>=1.11.2,<2.0.0)
 Project-URL: Repository, https://github.com/DataDog/datadog-lambda-python
 Description-Content-Type: text/markdown

{datadog_lambda-8.122.0 → datadog_lambda-8.124.0}/datadog_lambda/cold_start.py

@@ -63,6 +63,19 @@ def get_proactive_init_tag():
     )
 
 
+def is_managed_instances_mode():
+    """
+    Checks if the Lambda function is running in managed instances mode.
+    In managed instances mode, we should not create cold start tracing spans
+    as the gap between the sandbox initialization and the first
+    invocation might not be be a great experience.
+
+    Returns:
+        bool: True if running in managed instances mode, False otherwise
+    """
+    return config.aws_lambda_initialization_type == "lambda-managed-instances"
+
+
 class ImportNode(object):
     def __init__(self, module_name, full_file_path, start_time_ns, end_time_ns=None):
         self.module_name = module_name
@@ -145,6 +158,10 @@ def wrap_find_spec(original_find_spec):
 
 
 def initialize_cold_start_tracing():
+    # Skip cold start tracing initialization in managed instances mode
+    if is_managed_instances_mode():
+        return
+
     if is_new_sandbox() and config.cold_start_tracing:
         from sys import meta_path
 

{datadog_lambda-8.122.0 → datadog_lambda-8.124.0}/datadog_lambda/config.py

@@ -98,6 +98,7 @@ class Config:
     integration_test = _get_env("DD_INTEGRATION_TEST", "false", as_bool)
 
     aws_lambda_function_name = _get_env("AWS_LAMBDA_FUNCTION_NAME")
+    aws_lambda_initialization_type = _get_env("AWS_LAMBDA_INITIALIZATION_TYPE")
 
     @property
     def function_name(self):
@@ -140,6 +141,17 @@ if config.is_gov_region or config.fips_mode_enabled:
         "enabled" if config.fips_mode_enabled else "not enabled",
     )
 
+# Remote configuration relies on /dev/shm which is unavailable in Lambda.
+# Disable it before ddtrace loads to avoid the shared-memory warning.
+if "DD_REMOTE_CONFIGURATION_ENABLED" not in os.environ:
+    os.environ["DD_REMOTE_CONFIGURATION_ENABLED"] = "false"
+
+# disable css to prevent double counting in lambda
+os.environ["DD_TRACE_STATS_COMPUTATION_ENABLED"] = "false"
+
+# unset css aliases to ensure it is disabled
+if "DD_TRACE_COMPUTE_STATS" in os.environ:
+    del os.environ["DD_TRACE_COMPUTE_STATS"]
 
 if (
     "DD_INSTRUMENTATION_TELEMETRY_ENABLED" not in os.environ

datadog_lambda-8.124.0/datadog_lambda/durable.py

@@ -0,0 +1,69 @@
+# 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 re
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_durable_execution_arn(arn):
+    """
+    Parses a DurableExecutionArn to extract execution name and ID.
+    ARN format:
+        arn:aws:lambda:{region}:{account}:function:{func}:{version}/durable-execution/{name}/{id}
+    Returns (execution_name, execution_id) or None if parsing fails.
+    """
+    match = re.search(r"/durable-execution/([^/]+)/([^/]+)$", arn)
+    if not match:
+        return None
+    execution_name, execution_id = match.group(1), match.group(2)
+    if not execution_name or not execution_id:
+        return None
+    return execution_name, execution_id
+
+
+def extract_durable_function_tags(event):
+    """
+    Extracts durable function tags from the Lambda event payload.
+    Returns a dict with durable function tags, or an empty dict if the event
+    is not a durable function invocation.
+    """
+    if not isinstance(event, dict):
+        return {}
+
+    durable_execution_arn = event.get("DurableExecutionArn")
+    if not isinstance(durable_execution_arn, str):
+        return {}
+
+    parsed = _parse_durable_execution_arn(durable_execution_arn)
+    if not parsed:
+        logger.error("Failed to parse DurableExecutionArn: %s", durable_execution_arn)
+        return {}
+    execution_name, execution_id = parsed
+    # Use the number of operations to determine if it's the first invocation. This is
+    # what the durable execution SDK does to determine the replay status.
+    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(),
+    }
+
+
+VALID_DURABLE_STATUSES = {"SUCCEEDED", "FAILED", "PENDING"}
+
+
+def extract_durable_execution_status(response, event):
+    if not isinstance(event, dict) or "DurableExecutionArn" not in event:
+        return None
+    if not isinstance(response, dict):
+        return None
+    status = response.get("Status")
+    if status not in VALID_DURABLE_STATUSES:
+        return None
+    return status

{datadog_lambda-8.122.0 → datadog_lambda-8.124.0}/datadog_lambda/tracing.py

@@ -977,16 +977,12 @@ def process_injected_data(event, request_time_epoch_ms, args, tags):
             start_time_ns = int(
                 injected_authorizer_data.get(Headers.Parent_Span_Finish_Time)
             )
-            finish_time_ns = (
-                request_time_epoch_ms
-                + (
-                    int(
-                        event["requestContext"]["authorizer"].get(
-                            "integrationLatency", 0
-                        )
-                    )
-                )
-            ) * 1e6
+            integration_latency = int(
+                event["requestContext"]["authorizer"].get("integrationLatency", 0)
+            )
+            finish_time_ns = max(
+                start_time_ns, (request_time_epoch_ms + integration_latency) * 1e6
+            )
             upstream_authorizer_span = insert_upstream_authorizer_span(
                 args, tags, start_time_ns, finish_time_ns
             )
@@ -1449,6 +1445,7 @@ def create_function_execution_span(
     trace_context_source,
     merge_xray_traces,
     trigger_tags,
+    durable_function_tags=None,
     parent_span=None,
     span_pointers=None,
 ):
@@ -1459,6 +1456,7 @@ def create_function_execution_span(
         function_arn = ":".join(tk[0:7]) if len(tk) > 7 else function_arn
         function_version = tk[7] if len(tk) > 7 else "$LATEST"
         tags = {
+            "span.kind": "server",
             "cold_start": str(is_cold_start).lower(),
             "function_arn": function_arn,
             "function_version": function_version,
@@ -1477,6 +1475,8 @@ def create_function_execution_span(
     if trace_context_source == TraceContextSource.XRAY and merge_xray_traces:
         tags["_dd.parent_source"] = trace_context_source
     tags.update(trigger_tags)
+    if durable_function_tags:
+        tags.update(durable_function_tags)
     tracer.set_tags(_dd_origin)
     # Determine service name based on config and env var
     if config.service:

datadog_lambda-8.124.0/datadog_lambda/version.py

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

{datadog_lambda-8.122.0 → datadog_lambda-8.124.0}/datadog_lambda/wrapper.py

@@ -16,6 +16,7 @@ from datadog_lambda.cold_start import (
     is_cold_start,
     is_proactive_init,
     is_new_sandbox,
+    is_managed_instances_mode,
     ColdStartTracer,
 )
 from datadog_lambda.config import config
@@ -41,6 +42,10 @@ from datadog_lambda.tracing import (
     tracer,
     propagator,
 )
+from datadog_lambda.durable import (
+    extract_durable_function_tags,
+    extract_durable_execution_status,
+)
 from datadog_lambda.trigger import (
     extract_trigger_tags,
     extract_http_status_code_tag,
@@ -151,7 +156,7 @@ class _LambdaDecorator(object):
             if config.trace_extractor:
                 extractor_parts = config.trace_extractor.rsplit(".", 1)
                 if len(extractor_parts) == 2:
-                    (mod_name, extractor_name) = extractor_parts
+                    mod_name, extractor_name = extractor_parts
                     modified_extractor_name = modify_module_name(mod_name)
                     extractor_module = import_module(modified_extractor_name)
                     self.trace_extractor = getattr(extractor_module, extractor_name)
@@ -186,7 +191,6 @@ class _LambdaDecorator(object):
             if self.blocking_response:
                 return self.blocking_response
             self.response = self.func(event, context, **kwargs)
-            return self.response
         except BlockingException:
             self.blocking_response = get_asm_blocked_response(self.event_source)
         except Exception:
@@ -199,8 +203,9 @@ class _LambdaDecorator(object):
             raise
         finally:
             self._after(event, context)
-            if self.blocking_response:
-                return self.blocking_response
+        if self.blocking_response:
+            return self.blocking_response
+        return self.response
 
     def _inject_authorizer_span_headers(self, request_id):
         reference_span = self.inferred_span if self.inferred_span else self.span
@@ -242,6 +247,7 @@ class _LambdaDecorator(object):
                 submit_invocations_metric(context)
 
             self.trigger_tags = extract_trigger_tags(event, context)
+            self.durable_function_tags = extract_durable_function_tags(event)
             # Extract Datadog trace context and source from incoming requests
             dd_context, trace_context_source, event_source = extract_dd_trace_context(
                 event,
@@ -279,6 +285,7 @@ class _LambdaDecorator(object):
                     trace_context_source=trace_context_source,
                     merge_xray_traces=config.merge_xray_traces,
                     trigger_tags=self.trigger_tags,
+                    durable_function_tags=self.durable_function_tags,
                     parent_span=self.inferred_span,
                     span_pointers=calculate_span_pointers(event_source, event),
                 )
@@ -288,7 +295,7 @@ class _LambdaDecorator(object):
             else:
                 set_correlation_ids()
             if config.profiling_enabled and profiler and is_new_sandbox():
-                self.prof.start(stop_on_exit=False, profile_children=True)
+                self.prof.start()
             logger.debug("datadog_lambda_wrapper _before() done")
         except Exception as e:
             logger.error(format_err_with_traceback(e))
@@ -301,6 +308,16 @@ class _LambdaDecorator(object):
 
             status_code = extract_http_status_code_tag(self.trigger_tags, self.response)
 
+            # Skip creating cold start spans in managed instances mode
+            # In managed instances, the tracer library handles cold start independently
+            should_trace_cold_start = (
+                config.cold_start_tracing
+                and is_new_sandbox()
+                and not is_managed_instances_mode()
+            )
+            if should_trace_cold_start:
+                trace_ctx = tracer.current_trace_context()
+
             if self.span:
                 if config.appsec_enabled and not self.blocking_response:
                     asm_start_response(
@@ -326,6 +343,13 @@ class _LambdaDecorator(object):
                 if status_code:
                     self.span.set_tag("http.status_code", status_code)
 
+                durable_status = extract_durable_execution_status(self.response, event)
+                if durable_status:
+                    self.span.set_tag(
+                        "aws_lambda.durable_function.execution_status",
+                        durable_status,
+                    )
+
                 self.span.finish()
 
             if status_code:
@@ -338,9 +362,6 @@ class _LambdaDecorator(object):
                 create_dd_dummy_metadata_subsegment(
                     self.trigger_tags, XraySubsegment.LAMBDA_FUNCTION_TAGS_KEY
                 )
-            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.inferred_span:
                 if status_code:

{datadog_lambda-8.122.0 → datadog_lambda-8.124.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "datadog_lambda"
-version = "8.122.0"
+version = "8.124.0"
 description = "The Datadog AWS Lambda Library"
 authors = ["Datadog, Inc. <dev@datadoghq.com>"]
 license = "Apache-2.0"
@@ -26,17 +26,30 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.8.0,<4"
+python = ">=3.8.0,<3.15"
 datadog = ">=0.51.0,<1.0.0"
 wrapt = "^1.11.2"
 ddtrace = [
     {version = ">=3.19.1,<4", python = ">=3.8,<3.10"},
-    {version = ">=4.1.1,<5", python = ">=3.10"}
+    {version = ">=4.1.1,<5,!=4.6.*", python = ">=3.10"}
+]
+ujson = [
+    {version = ">=5.10.0,<5.12.0", python = ">=3.8,<3.10"},
+    {version = "^5.12.0", python = ">=3.10"},
+]
+urllib3 = [
+    {version = ">=1.25.4,<1.27", python = ">=3.8,<3.10"},
+    {version = "^2.6.3", python = ">=3.10"},
 ]
-ujson = ">=5.9.0"
 botocore = { version = "^1.34.0", optional = true }
-requests = { version ="^2.22.0", optional = true }
-pytest = { version= "^8.0.0", optional = true }
+requests = [
+    { version = "^2.22.0", optional = true, python = ">=3.8,<3.10" },
+    { version = "^2.33.0", optional = true, python = ">=3.10" },
+]
+pytest = [
+    { version = "^8.3.4", optional = true, python = ">=3.8,<3.10" },
+    { version = "^9.0.3", optional = true, python = ">=3.10" },
+]
 pytest-benchmark = { version = "^4.0", optional = true }
 flake8 = { version = "^5.0.4", optional = true }
 
@@ -54,4 +67,4 @@ requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.pytest.ini_options]
-addopts = "--benchmark-disable --benchmark-autosave"
+addopts = "--benchmark-disable --benchmark-autosave"

datadog_lambda-8.122.0/datadog_lambda/version.py

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