ddtrace 3.11.0rc1__cp39-cp39-musllinux_1_2_x86_64.whl → 3.11.0rc2__cp39-cp39-musllinux_1_2_x86_64.whl

ddtrace/_logger.py

@@ -20,6 +20,7 @@ class LogInjectionState(object):
     # Log injection is enabled, but not yet configured
     ENABLED = "true"
     # Log injection is enabled and configured for structured logging
+    # This value is deprecated, but kept for backwards compatibility
     STRUCTURED = "structured"
 
 
@@ -108,17 +109,15 @@ def set_log_formatting():
         handler.setFormatter(logging.Formatter(DD_LOG_FORMAT))
 
 
-def get_log_injection_state(raw_config: Optional[str]) -> str:
+def get_log_injection_state(raw_config: Optional[str]) -> bool:
     """Returns the current log injection state."""
     if raw_config:
         normalized = raw_config.lower().strip()
-        if normalized == LogInjectionState.STRUCTURED:
-            return LogInjectionState.STRUCTURED
-        elif normalized in ("true", "1"):
-            return LogInjectionState.ENABLED
+        if normalized == LogInjectionState.STRUCTURED or normalized in ("true", "1"):
+            return True
         elif normalized not in ("false", "0"):
             logging.warning(
                 "Invalid log injection state '%s'. Expected 'true', 'false', or 'structured'. Defaulting to 'false'.",
                 normalized,
             )
-    return LogInjectionState.DISABLED
+    return False

ddtrace/_trace/product.py

@@ -215,7 +215,7 @@ def apm_tracing_rc(lib_config, dd_config):
             new_rc_configs["_trace_sampling_rules"] = trace_sampling_rules
 
     if "log_injection_enabled" in lib_config:
-        new_rc_configs["_logs_injection"] = str(lib_config["log_injection_enabled"]).lower()
+        new_rc_configs["_logs_injection"] = lib_config["log_injection_enabled"]
 
     if "tracing_tags" in lib_config:
         tags = lib_config["tracing_tags"]

ddtrace/_trace/trace_handlers.py

@@ -872,10 +872,12 @@ def _on_azure_functions_service_bus_trigger_span_modifier(
     span = ctx.span
     _set_azure_function_tags(span, azure_functions_config, function_name, trigger, span_kind)
     span.set_tag_str(MESSAGING_DESTINATION_NAME, entity_name)
-    span.set_tag_str(MESSAGING_MESSAGE_ID, message_id)
     span.set_tag_str(MESSAGING_OPERATION, "receive")
     span.set_tag_str(MESSAGING_SYSTEM, azure_servicebusx.SERVICE)
 
+    if message_id is not None:
+        span.set_tag_str(MESSAGING_MESSAGE_ID, message_id)
+
 
 def _on_azure_servicebus_send_message_modifier(ctx, azure_servicebus_config, entity_name, fully_qualified_namespace):
     span = ctx.span

ddtrace/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.11.0rc1'
-__version_tuple__ = version_tuple = (3, 11, 0, 'rc1')
+__version__ = version = '3.11.0rc2'
+__version_tuple__ = version_tuple = (3, 11, 0, 'rc2')

ddtrace/appsec/_asm_request_context.py

@@ -1,6 +1,7 @@
 import functools
 import json
 import re
+from types import TracebackType
 from typing import Any
 from typing import Callable
 from typing import Dict
@@ -8,6 +9,7 @@ from typing import List
 from typing import Literal
 from typing import Optional
 from typing import Set
+from typing import Tuple
 from typing import Union
 from urllib import parse
 
@@ -534,7 +536,7 @@ def end_context(span: Span):
         finalize_asm_env(env)
 
 
-def _on_context_ended(ctx):
+def _on_context_ended(ctx, _exc_info: Tuple[Optional[type], Optional[BaseException], Optional[TracebackType]]):
     env = ctx.get_local_item(_ASM_CONTEXT)
     if env is not None:
         finalize_asm_env(env)

ddtrace/appsec/_iast/_listener.py

@@ -1,3 +1,7 @@
+from types import TracebackType
+from typing import Optional
+from typing import Tuple
+
 from ddtrace.appsec._iast._handlers import _iast_on_wrapped_view
 from ddtrace.appsec._iast._handlers import _on_asgi_finalize_response
 from ddtrace.appsec._iast._handlers import _on_django_finalize_response_pre
@@ -19,6 +23,12 @@ from ddtrace.internal import core
 
 
 def iast_listen():
+    def _iast_context_end(
+        ctx: core.ExecutionContext,
+        _exc_info: Tuple[Optional[type], Optional[BaseException], Optional[TracebackType]],
+    ):
+        _iast_end_request(ctx)
+
     core.on("grpc.client.response.message", _on_grpc_response)
     core.on("grpc.server.response.message", _on_grpc_server_response)
 
@@ -37,8 +47,8 @@ def iast_listen():
     core.on("flask.finalize_request.post", _on_flask_finalize_request_post)
     core.on("werkzeug.render_debugger_html", _on_werkzeug_render_debugger_html)
 
-    core.on("context.ended.wsgi.__call__", _iast_end_request)
-    core.on("context.ended.asgi.__call__", _iast_end_request)
+    core.on("context.ended.wsgi.__call__", _iast_context_end)
+    core.on("context.ended.asgi.__call__", _iast_context_end)
 
     # Sink points
     core.on("db_query_check", _on_report_sqli)

ddtrace/contrib/integration_registry/registry.yaml

@@ -393,6 +393,16 @@ integrations:
       min: 20.12.1
       max: 24.11.1
 
+- integration_name: gunicorn
+  is_external_package: true
+  is_tested: true
+  dependency_names:
+  - gunicorn
+  tested_versions_by_dependency:
+    gunicorn:
+      min: 20.0.4
+      max: 23.0.0
+
 - integration_name: google_genai
   is_external_package: true
   is_tested: true

ddtrace/contrib/internal/avro/__init__.py

@@ -0,0 +1,17 @@
+"""
+The Avro integration will trace all Avro read / write calls made with the ``avro``
+library. This integration is enabled by default.
+
+Enabling
+~~~~~~~~
+
+The avro integration is enabled by default. Use
+:func:`patch()<ddtrace.patch>` to enable the integration::
+
+    from ddtrace import patch
+    patch(avro=True)
+
+Configuration
+~~~~~~~~~~~~~
+
+"""

ddtrace/contrib/internal/azure_functions/patch.py

@@ -12,6 +12,7 @@ from ddtrace.internal.utils.formats import asbool
 from ddtrace.trace import Pin
 
 from .utils import create_context
+from .utils import message_list_has_single_context
 from .utils import wrap_function_with_tracing
 
 
@@ -97,24 +98,34 @@ def _wrap_service_bus_trigger(pin, func, function_name, trigger_arg_name, trigge
     def context_factory(kwargs):
         resource_name = f"{trigger_type} {function_name}"
         msg = kwargs.get(trigger_arg_name)
-        return create_context(
-            "azure.functions.patched_service_bus", pin, resource_name, headers=msg.application_properties
-        )
+
+        # Reparent trace if single message or list of messages all with same context
+        if isinstance(msg, azure_functions.ServiceBusMessage):
+            application_properties = msg.application_properties
+        elif (
+            isinstance(msg, list)
+            and msg
+            and isinstance(msg[0], azure_functions.ServiceBusMessage)
+            and message_list_has_single_context(msg)
+        ):
+            application_properties = msg[0].application_properties
+        else:
+            application_properties = None
+
+        return create_context("azure.functions.patched_service_bus", pin, resource_name, headers=application_properties)
 
     def pre_dispatch(ctx, kwargs):
         msg = kwargs.get(trigger_arg_name)
+
+        if isinstance(msg, azure_functions.ServiceBusMessage):
+            message_id = msg.message_id
+        else:
+            message_id = None
+
         entity_name = trigger_details.get("topicName") or trigger_details.get("queueName")
         return (
             "azure.functions.service_bus_trigger_modifier",
-            (
-                ctx,
-                config.azure_functions,
-                function_name,
-                trigger_type,
-                SpanKind.CONSUMER,
-                entity_name,
-                msg.message_id,
-            ),
+            (ctx, config.azure_functions, function_name, trigger_type, SpanKind.CONSUMER, entity_name, message_id),
         )
 
     return wrap_function_with_tracing(func, context_factory, pre_dispatch=pre_dispatch)

ddtrace/contrib/internal/azure_functions/utils.py

@@ -1,11 +1,15 @@
 import functools
 import inspect
+from typing import List
+
+import azure.functions as azure_functions
 
 from ddtrace import config
 from ddtrace.contrib.internal.trace_utils import int_service
 from ddtrace.ext import SpanTypes
 from ddtrace.internal import core
 from ddtrace.internal.schema import schematize_cloud_faas_operation
+from ddtrace.propagation.http import HTTPPropagator
 
 
 def create_context(context_name, pin, resource=None, headers=None):
@@ -59,3 +63,13 @@ def wrap_function_with_tracing(func, context_factory, pre_dispatch=None, post_di
                     core.dispatch(*post_dispatch(ctx, res))
 
     return wrapper
+
+
+def message_list_has_single_context(msg_list: List[azure_functions.ServiceBusMessage]):
+    first_context = HTTPPropagator.extract(msg_list[0].application_properties)
+    for message in msg_list[1:]:
+        context = HTTPPropagator.extract(message.application_properties)
+        if first_context != context:
+            return False
+
+    return True

ddtrace/contrib/internal/botocore/__init__.py

@@ -0,0 +1,153 @@
+"""
+The Botocore integration will trace all AWS calls made with the botocore
+library. Libraries like Boto3 that use Botocore will also be patched.
+
+Enabling
+~~~~~~~~
+
+The botocore integration is enabled automatically when using
+:ref:`ddtrace-run<ddtracerun>` or :ref:`import ddtrace.auto<ddtraceauto>`.
+
+Or use :func:`patch()<ddtrace.patch>` to manually enable the integration::
+
+    from ddtrace import patch
+    patch(botocore=True)
+
+To patch only specific botocore modules, pass a list of the module names instead::
+
+    from ddtrace import patch
+    patch(botocore=['s3', 'sns'])
+
+Configuration
+~~~~~~~~~~~~~
+
+.. py:data:: ddtrace.config.botocore['distributed_tracing']
+
+   Whether to inject distributed tracing data to requests in SQS, SNS, EventBridge, Kinesis Streams and Lambda.
+
+   Can also be enabled with the ``DD_BOTOCORE_DISTRIBUTED_TRACING`` environment variable.
+
+    Example::
+
+        from ddtrace import config
+
+        # Enable distributed tracing
+        config.botocore['distributed_tracing'] = True
+
+
+   Default: ``True``
+
+
+.. py:data:: ddtrace.config.botocore['invoke_with_legacy_context']
+
+    This preserves legacy behavior when tracing directly invoked Python and Node Lambda
+    functions instrumented with datadog-lambda-python < v41 or datadog-lambda-js < v3.58.0.
+
+    Legacy support for older libraries is available with
+    ``ddtrace.config.botocore.invoke_with_legacy_context = True`` or by setting the environment
+    variable ``DD_BOTOCORE_INVOKE_WITH_LEGACY_CONTEXT=true``.
+
+
+    Default: ``False``
+
+
+.. py:data:: ddtrace.config.botocore['operations'][<operation>].error_statuses = "<error statuses>"
+
+    Definition of which HTTP status codes to consider for making a span as an error span.
+
+    By default response status codes of ``'500-599'`` are considered as errors for all endpoints.
+
+    Example marking 404, and 5xx as errors for ``s3.headobject`` API calls::
+
+        from ddtrace import config
+
+        config.botocore['operations']['s3.headobject'].error_statuses = '404,500-599'
+
+
+    See :ref:`HTTP - Custom Error Codes<http-custom-error>` documentation for more examples.
+
+.. py:data:: ddtrace.config.botocore['tag_no_params']
+
+    This opts out of the default behavior of collecting a narrow set of API parameters as span tags.
+
+    To not collect any API parameters, ``ddtrace.config.botocore.tag_no_params = True`` or by setting the environment
+    variable ``DD_AWS_TAG_NO_PARAMS=true``.
+
+
+    Default: ``False``
+
+
+.. py:data:: ddtrace.config.botocore['instrument_internals']
+
+    This opts into collecting spans for some internal functions, including ``parsers.ResponseParser.parse``.
+
+    Can also be enabled with the ``DD_BOTOCORE_INSTRUMENT_INTERNALS`` environment variable.
+
+    Default: ``False``
+
+
+.. py:data:: ddtrace.config.botocore['span_prompt_completion_sample_rate']
+
+   Configure the sample rate for the collection of bedrock prompts and completions as span tags.
+
+   Alternatively, you can set this option with the ``DD_BEDROCK_SPAN_PROMPT_COMPLETION_SAMPLE_RATE`` environment
+   variable.
+
+   Default: ``1.0``
+
+
+.. py:data:: (beta) ddtrace.config.botocore["span_char_limit"]
+
+   Configure the maximum number of characters for bedrock span tags for prompt/response text.
+
+   Text exceeding the maximum number of characters is truncated to the character limit
+   and has ``...`` appended to the end.
+
+   Alternatively, you can set this option with the ``DD_BEDROCK_SPAN_CHAR_LIMIT`` environment
+   variable.
+
+   Default: ``128``
+
+
+.. py:data:: ddtrace.config.botocore['dynamodb_primary_key_names_for_tables']
+
+    This enables DynamoDB API calls to be instrumented with span pointers. Many
+    DynamoDB API calls do not include the Item's Primary Key fields as separate
+    values, so they need to be provided to the tracer separately. This field
+    should be structured as a ``dict`` keyed by the table names as ``str``.
+    Each value should be the ``set`` of primary key field names (as ``str``)
+    for the associated table. The set may have exactly one or two elements,
+    depending on the Table's Primary Key schema.
+
+    In python this would look like::
+
+        ddtrace.config.botocore['dynamodb_primary_key_names_for_tables'] = {
+            'table_name': {'key1', 'key2'},
+            'other_table': {'other_key'},
+        }
+
+    Can also be enabled with the ``DD_BOTOCORE_DYNAMODB_TABLE_PRIMARY_KEYS``
+    environment variable which is parsed as a JSON object with strings for keys
+    and lists of strings for values.
+
+    This would look something like::
+
+        export DD_BOTOCORE_DYNAMODB_TABLE_PRIMARY_KEYS='{
+            "table_name": ["key1", "key2"],
+            "other_table": ["other_key"]
+        }'
+
+    Default: ``{}``
+
+
+.. py:data:: ddtrace.config.botocore['add_span_pointers']
+
+    This enables the addition of span pointers to spans associated with
+    successful AWS API calls.
+
+    Alternatively, you can set this option with the
+    ``DD_BOTOCORE_ADD_SPAN_POINTERS`` environment variable.
+
+    Default: ``True``
+
+"""

ddtrace/contrib/{_freezegun.py → internal/freezegun/__init__.py}

@@ -1,5 +1,5 @@
 """
-The freezegun integration reconfigures freezegun's default ignore list to ignore ddtrace.
+The freezegun integration updates freezegun's default ignore list to ignore ddtrace.
 
 Enabling
 ~~~~~~~~