ddtrace 3.11.0rc1__cp312-cp312-win32.whl → 3.11.0rc3__cp312-cp312-win32.whl

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/internal/botocore/services/bedrock.py

@@ -48,12 +48,9 @@ class TracedBotocoreStreamingBody(wrapt.ObjectProxy):
             self._body.append(json.loads(body))
             if self.__wrapped__.tell() == int(self.__wrapped__._content_length):
                 formatted_response = _extract_text_and_response_reason(self._execution_ctx, self._body[0])
-                model_provider = self._execution_ctx["model_provider"]
-                model_name = self._execution_ctx["model_name"]
-                should_set_choice_ids = model_provider == _COHERE and "embed" not in model_name
                 core.dispatch(
                     "botocore.bedrock.process_response",
-                    [self._execution_ctx, formatted_response, None, self._body[0], should_set_choice_ids],
+                    [self._execution_ctx, formatted_response],
                 )
             return body
         except Exception:
@@ -67,12 +64,9 @@ class TracedBotocoreStreamingBody(wrapt.ObjectProxy):
             for line in lines:
                 self._body.append(json.loads(line))
             formatted_response = _extract_text_and_response_reason(self._execution_ctx, self._body[0])
-            model_provider = self._execution_ctx["model_provider"]
-            model_name = self._execution_ctx["model_name"]
-            should_set_choice_ids = model_provider == _COHERE and "embed" not in model_name
             core.dispatch(
                 "botocore.bedrock.process_response",
-                [self._execution_ctx, formatted_response, None, self._body[0], should_set_choice_ids],
+                [self._execution_ctx, formatted_response],
             )
             return lines
         except Exception:
@@ -93,16 +87,10 @@ class TracedBotocoreStreamingBody(wrapt.ObjectProxy):
         finally:
             if exception_raised:
                 return
-            metadata = _extract_streamed_response_metadata(self._execution_ctx, self._body)
             formatted_response = _extract_streamed_response(self._execution_ctx, self._body)
-            model_provider = self._execution_ctx["model_provider"]
-            model_name = self._execution_ctx["model_name"]
-            should_set_choice_ids = (
-                model_provider == _COHERE and "is_finished" not in self._body[0] and "embed" not in model_name
-            )
             core.dispatch(
                 "botocore.bedrock.process_response",
-                [self._execution_ctx, formatted_response, metadata, self._body, should_set_choice_ids],
+                [self._execution_ctx, formatted_response],
             )
 
 
@@ -443,18 +431,6 @@ def handle_bedrock_response(
         safe_token_count(cache_write_tokens),
     )
 
-    # for both converse & invoke, dispatch success event to store basic metrics
-    core.dispatch(
-        "botocore.patched_bedrock_api_call.success",
-        [
-            ctx,
-            str(metadata.get("RequestId", "")),
-            request_latency,
-            str(input_tokens),
-            str(output_tokens),
-        ],
-    )
-
     if ctx["resource"] == "Converse":
         core.dispatch("botocore.bedrock.process_response_converse", [ctx, result])
         return result

ddtrace/contrib/internal/django/patch.py

@@ -49,6 +49,7 @@ from ddtrace.internal.utils.formats import asbool
 from ddtrace.internal.utils.importlib import func_name
 from ddtrace.propagation._database_monitoring import _DBM_Propagator
 from ddtrace.settings.asm import config as asm_config
+from ddtrace.settings.asm import endpoint_collection
 from ddtrace.settings.integration import IntegrationConfig
 from ddtrace.trace import Pin
 from ddtrace.vendor.packaging.version import parse as parse_version
@@ -81,6 +82,7 @@ config._add(
         use_legacy_resource_format=asbool(os.getenv("DD_DJANGO_USE_LEGACY_RESOURCE_FORMAT", default=False)),
         _trace_asgi_websocket=os.getenv("DD_ASGI_TRACE_WEBSOCKET", default=False),
         obfuscate_404_resource=os.getenv("DD_ASGI_OBFUSCATE_404_RESOURCE", default=False),
+        views={},
     ),
 )
 
@@ -598,7 +600,7 @@ def traced_template_render(django, pin, wrapped, instance, args, kwargs):
         return wrapped(*args, **kwargs)
 
 
-def instrument_view(django, view):
+def instrument_view(django, view, path=None):
     """
     Helper to wrap Django views.
 
@@ -608,10 +610,24 @@ def instrument_view(django, view):
         for cls in reversed(getmro(view)):
             _instrument_view(django, cls)
 
-    return _instrument_view(django, view)
+    return _instrument_view(django, view, path=path)
 
 
-def _instrument_view(django, view):
+def extract_request_method_list(view):
+    try:
+        while "view_func" in view.__code__.co_freevars:
+            view = view.__closure__[view.__code__.co_freevars.index("view_func")].cell_contents
+        if "request_method_list" in view.__code__.co_freevars:
+            return view.__closure__[view.__code__.co_freevars.index("request_method_list")].cell_contents
+        return []
+    except Exception:
+        return []
+
+
+_DEFAULT_METHODS = ("get", "delete", "post", "options", "head")
+
+
+def _instrument_view(django, view, path=None):
     """Helper to wrap Django views."""
     from . import utils
 
@@ -620,9 +636,14 @@ def _instrument_view(django, view):
         return view
 
     # Patch view HTTP methods and lifecycle methods
-    http_method_names = getattr(view, "http_method_names", ("get", "delete", "post", "options", "head"))
+
+    http_method_names = getattr(view, "http_method_names", ())
+    request_method_list = extract_request_method_list(view) or http_method_names
+    if path is not None:
+        for method in request_method_list or ["*"]:
+            endpoint_collection.add_endpoint(method, path, operation_name="django.request")
     lifecycle_methods = ("setup", "dispatch", "http_method_not_allowed")
-    for name in list(http_method_names) + list(lifecycle_methods):
+    for name in list(request_method_list or _DEFAULT_METHODS) + list(lifecycle_methods):
         try:
             func = getattr(view, name, None)
             if not func or isinstance(func, wrapt.ObjectProxy):
@@ -665,18 +686,20 @@ def traced_urls_path(django, pin, wrapped, instance, args, kwargs):
     try:
         from_args = False
         view = kwargs.pop("view", None)
+        path = kwargs.pop("path", None)
         if view is None:
             view = args[1]
             from_args = True
+        if path is None:
+            path = args[0]
 
         core.dispatch("service_entrypoint.patch", (unwrap(view),))
-
         if from_args:
             args = list(args)
-            args[1] = instrument_view(django, view)
+            args[1] = instrument_view(django, view, path=path)
             args = tuple(args)
         else:
-            kwargs["view"] = instrument_view(django, view)
+            kwargs["view"] = instrument_view(django, view, path=path)
     except Exception:
         log.debug("Failed to instrument Django url path %r %r", args, kwargs, exc_info=True)
     return wrapped(*args, **kwargs)

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
 ~~~~~~~~

ddtrace/contrib/internal/google_genai/_utils.py

@@ -6,7 +6,7 @@ from typing import Optional
 
 import wrapt
 
-from ddtrace.llmobs._integrations.google_genai_utils import DEFAULT_MODEL_ROLE
+from ddtrace.llmobs._integrations.google_utils import GOOGLE_GENAI_DEFAULT_MODEL_ROLE
 from ddtrace.llmobs._utils import _get_attr
 
 
@@ -32,7 +32,7 @@ def _join_chunks(chunks: List[Any]) -> Optional[Dict[str, Any]]:
                     continue
 
                 if role is None:
-                    role = _get_attr(content, "role", DEFAULT_MODEL_ROLE)
+                    role = _get_attr(content, "role", GOOGLE_GENAI_DEFAULT_MODEL_ROLE)
 
                 parts = _get_attr(content, "parts", [])
                 for part in parts:

ddtrace/contrib/internal/google_genai/patch.py

@@ -9,7 +9,7 @@ from ddtrace.contrib.internal.trace_utils import unwrap
 from ddtrace.contrib.internal.trace_utils import with_traced_module
 from ddtrace.contrib.internal.trace_utils import wrap
 from ddtrace.llmobs._integrations import GoogleGenAIIntegration
-from ddtrace.llmobs._integrations.google_genai_utils import extract_provider_and_model_name
+from ddtrace.llmobs._integrations.google_utils import extract_provider_and_model_name
 from ddtrace.trace import Pin
 
 
@@ -27,7 +27,7 @@ def get_version() -> str:
 @with_traced_module
 def traced_generate(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
-    provider_name, model_name = extract_provider_and_model_name(kwargs)
+    provider_name, model_name = extract_provider_and_model_name(kwargs=kwargs)
     with integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
@@ -46,7 +46,7 @@ def traced_generate(genai, pin, func, instance, args, kwargs):
 @with_traced_module
 async def traced_async_generate(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
-    provider_name, model_name = extract_provider_and_model_name(kwargs)
+    provider_name, model_name = extract_provider_and_model_name(kwargs=kwargs)
     with integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
@@ -65,7 +65,7 @@ async def traced_async_generate(genai, pin, func, instance, args, kwargs):
 @with_traced_module
 def traced_generate_stream(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
-    provider_name, model_name = extract_provider_and_model_name(kwargs)
+    provider_name, model_name = extract_provider_and_model_name(kwargs=kwargs)
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
@@ -86,7 +86,7 @@ def traced_generate_stream(genai, pin, func, instance, args, kwargs):
 @with_traced_module
 async def traced_async_generate_stream(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
-    provider_name, model_name = extract_provider_and_model_name(kwargs)
+    provider_name, model_name = extract_provider_and_model_name(kwargs=kwargs)
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
@@ -107,7 +107,7 @@ async def traced_async_generate_stream(genai, pin, func, instance, args, kwargs)
 @with_traced_module
 def traced_embed_content(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
-    provider_name, model_name = extract_provider_and_model_name(kwargs)
+    provider_name, model_name = extract_provider_and_model_name(kwargs=kwargs)
     with integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
@@ -126,7 +126,7 @@ def traced_embed_content(genai, pin, func, instance, args, kwargs):
 @with_traced_module
 async def traced_async_embed_content(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
-    provider_name, model_name = extract_provider_and_model_name(kwargs)
+    provider_name, model_name = extract_provider_and_model_name(kwargs=kwargs)
     with integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),

ddtrace/contrib/internal/google_generativeai/patch.py

@@ -11,7 +11,7 @@ from ddtrace.contrib.internal.trace_utils import unwrap
 from ddtrace.contrib.internal.trace_utils import with_traced_module
 from ddtrace.contrib.internal.trace_utils import wrap
 from ddtrace.llmobs._integrations import GeminiIntegration
-from ddtrace.llmobs._integrations.utils import extract_model_name_google
+from ddtrace.llmobs._integrations.google_utils import extract_provider_and_model_name
 from ddtrace.trace import Pin
 
 
@@ -40,11 +40,12 @@ def traced_generate(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
     stream = kwargs.get("stream", False)
     generations = None
+    provider_name, model_name = extract_provider_and_model_name(instance=instance, model_name_attr="model_name")
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        provider="google",
-        model=extract_model_name_google(instance, "model_name"),
+        provider=provider_name,
+        model=model_name,
         submit_to_llmobs=True,
     )
     try:
@@ -68,11 +69,12 @@ async def traced_agenerate(genai, pin, func, instance, args, kwargs):
     integration = genai._datadog_integration
     stream = kwargs.get("stream", False)
     generations = None
+    provider_name, model_name = extract_provider_and_model_name(instance=instance, model_name_attr="model_name")
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        provider="google",
-        model=extract_model_name_google(instance, "model_name"),
+        provider=provider_name,
+        model=model_name,
         submit_to_llmobs=True,
     )
     try: