ddtrace 3.11.0rc1__cp310-cp310-musllinux_1_2_aarch64.whl → 3.11.0rc2__cp310-cp310-musllinux_1_2_aarch64.whl

ddtrace/contrib/internal/langchain/utils.py

@@ -106,32 +106,6 @@ def shared_stream(
         raise
 
 
-def tag_general_message_input(span, inputs, integration, langchain_core):
-    if langchain_core and isinstance(inputs, langchain_core.prompt_values.PromptValue):
-        inputs = inputs.to_messages()
-    elif not isinstance(inputs, list):
-        inputs = [inputs]
-    for input_idx, inp in enumerate(inputs):
-        if isinstance(inp, dict):
-            span.set_tag_str(
-                "langchain.request.messages.%d.content" % (input_idx),
-                integration.trunc(str(inp.get("content", ""))),
-            )
-            role = inp.get("role")
-            if role is not None:
-                span.set_tag_str(
-                    "langchain.request.messages.%d.message_type" % (input_idx),
-                    str(inp.get("role", "")),
-                )
-        elif langchain_core and isinstance(inp, langchain_core.messages.BaseMessage):
-            content = inp.content
-            role = inp.__class__.__name__
-            span.set_tag_str("langchain.request.messages.%d.content" % (input_idx), integration.trunc(str(content)))
-            span.set_tag_str("langchain.request.messages.%d.message_type" % (input_idx), str(role))
-        else:
-            span.set_tag_str("langchain.request.messages.%d.content" % (input_idx), integration.trunc(str(inp)))
-
-
 def _get_chunk_callback(interface_type, args, kwargs):
     results = core.dispatch_with_results("langchain.stream.chunk.callback", (interface_type, args, kwargs))
     callbacks = []

ddtrace/contrib/internal/logbook/patch.py

@@ -5,7 +5,6 @@ from wrapt import wrap_function_wrapper as _w
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 from ddtrace.internal.utils import get_argument_value
 
@@ -27,7 +26,7 @@ def _supported_versions() -> Dict[str, str]:
 
 def _w_process_record(func, instance, args, kwargs):
     # patch logger to include datadog info before logging
-    if config._logs_injection != LogInjectionState.DISABLED:
+    if config._logs_injection:
         record = get_argument_value(args, kwargs, 0, "record")
         record.extra.update(ddtrace.tracer.get_log_correlation_context())
     return func(*args, **kwargs)

ddtrace/contrib/internal/logging/patch.py

@@ -5,7 +5,6 @@ from wrapt import wrap_function_wrapper as _w
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace._logger import set_log_formatting
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 from ddtrace.internal.constants import LOG_ATTR_ENV
@@ -54,15 +53,13 @@ class DDLogRecord:
 def _w_makeRecord(func, instance, args, kwargs):
     # Get the LogRecord instance for this log
     record = func(*args, **kwargs)
-    if config._logs_injection == LogInjectionState.DISABLED:
-        # log injection is opt-in for non-structured logging
-        return record
-    record.__dict__.update(ddtrace.tracer.get_log_correlation_context())
+    if config._logs_injection:
+        record.__dict__.update(ddtrace.tracer.get_log_correlation_context())
     return record
 
 
 def _w_StrFormatStyle_format(func, instance, args, kwargs):
-    if config._logs_injection != LogInjectionState.ENABLED:
+    if not config._logs_injection:
         return func(*args, **kwargs)
     # The format string "dd.service={dd.service}" expects
     # the record to have a "dd" property which is an object that
@@ -103,7 +100,7 @@ def patch():
     _w(logging.Logger, "makeRecord", _w_makeRecord)
     _w(logging.StrFormatStyle, "_format", _w_StrFormatStyle_format)
 
-    if config._logs_injection == LogInjectionState.ENABLED:
+    if config._logs_injection:
         # Only set the formatter is DD_LOGS_INJECTION is set to True. We do not want to modify
         # unstructured logs if a user has not enabled logs injection.
         # Also, the Datadog log format must be set after the logging module has been patched,

ddtrace/contrib/internal/loguru/patch.py

@@ -5,7 +5,6 @@ from wrapt import wrap_function_wrapper as _w
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 
 
@@ -25,12 +24,11 @@ def _supported_versions() -> Dict[str, str]:
 
 
 def _tracer_injection(event_dict):
-    if config._logs_injection == LogInjectionState.DISABLED:
+    if not config._logs_injection:
         # log injection is opt-out for structured logging
         return event_dict
     event_dd_attributes = ddtrace.tracer.get_log_correlation_context()
     event_dict.update(event_dd_attributes)
-
     return event_dd_attributes
 
 

ddtrace/contrib/internal/protobuf/__init__.py

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

ddtrace/contrib/internal/pytest/__init__.py

@@ -0,0 +1,62 @@
+"""
+The pytest integration traces test executions.
+
+Enabling
+~~~~~~~~
+
+Enable traced execution of tests using ``pytest`` runner by
+running ``pytest --ddtrace`` or by modifying any configuration
+file read by pytest (``pytest.ini``, ``setup.cfg``, ...)::
+
+    [pytest]
+    ddtrace = 1
+
+
+If you need to disable it, the option ``--no-ddtrace`` will take
+precedence over ``--ddtrace`` and (``pytest.ini``, ``setup.cfg``, ...)
+
+You can enable all integrations by using the ``--ddtrace-patch-all`` option
+alongside ``--ddtrace`` or by adding this to your configuration::
+
+    [pytest]
+    ddtrace = 1
+    ddtrace-patch-all = 1
+
+
+.. note::
+   The ddtrace plugin for pytest has the side effect of importing the ddtrace
+   package and starting a global tracer.
+
+   If this is causing issues for your pytest runs where traced execution of
+   tests is not enabled, you can deactivate the plugin::
+
+     [pytest]
+     addopts = -p no:ddtrace
+
+   See the `pytest documentation
+   <https://docs.pytest.org/en/7.1.x/how-to/plugins.html#deactivating-unregistering-a-plugin-by-name>`_
+   for more details.
+
+
+Global Configuration
+~~~~~~~~~~~~~~~~~~~~
+
+.. py:data:: ddtrace.config.pytest["service"]
+
+   The service name reported by default for pytest traces.
+
+   This option can also be set with the integration specific ``DD_PYTEST_SERVICE`` environment
+   variable, or more generally with the `DD_SERVICE` environment variable.
+
+   Default: Name of the repository being tested, otherwise ``"pytest"`` if the repository name cannot be found.
+
+
+.. py:data:: ddtrace.config.pytest["operation_name"]
+
+   The operation name reported by default for pytest traces.
+
+   This option can also be set with the ``DD_PYTEST_OPERATION_NAME`` environment
+   variable.
+
+   Default: ``"pytest.test"``
+"""

ddtrace/contrib/internal/pytest/_plugin_v2.py

@@ -237,11 +237,12 @@ def _pytest_load_initial_conftests_pre_yield(early_config, parser, args):
     ModuleCodeCollector has a tangible impact on the time it takes to load modules, so it should only be installed if
     coverage collection is requested by the backend.
     """
+    take_over_logger_stream_handler()
+
     if not _is_enabled_early(early_config, args):
         return
 
     try:
-        take_over_logger_stream_handler()
         dd_config.test_visibility.itr_skipping_level = ITR_SKIPPING_LEVEL.SUITE
         enable_test_visibility(config=dd_config.pytest)
         if InternalTestSession.should_collect_coverage():
@@ -824,8 +825,16 @@ def _pytest_sessionfinish(session: pytest.Session, exitstatus: int) -> None:
             run_coverage_report()
 
         lines_pct_value = _coverage_data.get(PCT_COVERED_KEY, None)
-        if not isinstance(lines_pct_value, float):
-            log.warning("Tried to add total covered percentage to session span but the format was unexpected")
+        if lines_pct_value is None:
+            log.debug("Unable to retrieve coverage data for the session span")
+        elif not isinstance(lines_pct_value, (float, int)):
+            t = type(lines_pct_value)
+            log.warning(
+                "Unexpected format for total covered percentage: type=%s.%s, value=%r",
+                t.__module__,
+                t.__name__,
+                lines_pct_value,
+            )
         else:
             InternalTestSession.set_covered_lines_pct(lines_pct_value)
 

ddtrace/contrib/internal/pytest_bdd/__init__.py

@@ -0,0 +1,23 @@
+"""
+The pytest-bdd integration traces executions of scenarios and steps.
+
+Enabling
+~~~~~~~~
+
+Please follow the instructions for enabling `pytest` integration.
+
+.. note::
+   The ddtrace.pytest_bdd plugin for pytest-bdd has the side effect of importing
+   the ddtrace package and starting a global tracer.
+
+   If this is causing issues for your pytest-bdd runs where traced execution of
+   tests is not enabled, you can deactivate the plugin::
+
+     [pytest]
+     addopts = -p no:ddtrace.pytest_bdd
+
+   See the `pytest documentation
+   <https://docs.pytest.org/en/7.1.x/how-to/plugins.html#deactivating-unregistering-a-plugin-by-name>`_
+   for more details.
+
+"""

ddtrace/contrib/internal/pytest_benchmark/__init__.py

@@ -0,0 +1,3 @@
+"""
+The pytest-benchmark integration traces executions of pytest benchmarks.
+"""

ddtrace/contrib/internal/structlog/patch.py

@@ -4,7 +4,6 @@ import structlog
 
 import ddtrace
 from ddtrace import config
-from ddtrace._logger import LogInjectionState
 from ddtrace.contrib.internal.trace_utils import unwrap as _u
 from ddtrace.contrib.internal.trace_utils import wrap as _w
 from ddtrace.internal.utils import get_argument_value
@@ -27,9 +26,8 @@ def _supported_versions() -> Dict[str, str]:
 
 
 def _tracer_injection(_, __, event_dict):
-    if config._logs_injection == LogInjectionState.DISABLED:
-        return event_dict
-    event_dict.update(ddtrace.tracer.get_log_correlation_context())
+    if config._logs_injection:
+        event_dict.update(ddtrace.tracer.get_log_correlation_context())
     return event_dict
 
 

ddtrace/contrib/internal/unittest/__init__.py

@@ -0,0 +1,36 @@
+"""
+The unittest integration traces test executions.
+
+
+Enabling
+~~~~~~~~
+
+The unittest integration is enabled automatically when using
+:ref:`ddtrace-run<ddtracerun>` or :ref:`import ddtrace.auto<ddtraceauto>`.
+
+Alternately, use :func:`patch()<ddtrace.patch>` to manually enable the integration::
+
+    from ddtrace import patch
+    patch(unittest=True)
+
+Global Configuration
+~~~~~~~~~~~~~~~~~~~~
+
+.. py:data:: ddtrace.config.unittest["operation_name"]
+
+   The operation name reported by default for unittest traces.
+
+   This option can also be set with the ``DD_UNITTEST_OPERATION_NAME`` environment
+   variable.
+
+   Default: ``"unittest.test"``
+
+.. py:data:: ddtrace.config.unittest["strict_naming"]
+
+   Requires all ``unittest`` tests to start with ``test`` as stated in the Python documentation
+
+   This option can also be set with the ``DD_CIVISIBILITY_UNITTEST_STRICT_NAMING`` environment
+   variable.
+
+   Default: ``True``
+"""

ddtrace/internal/_encoding.pyi

@@ -23,7 +23,7 @@ class BufferedEncoder(object):
     def __init__(self, max_size: int, max_item_size: int) -> None: ...
     def __len__(self) -> int: ...
     def put(self, item: Any) -> None: ...
-    def encode(self) -> Tuple[Optional[bytes], int]: ...
+    def encode(self) -> List[Tuple[Optional[bytes], int]]: ...
     @property
     def size(self) -> int: ...
 

ddtrace/internal/ci_visibility/encoder.py

@@ -32,6 +32,7 @@ if TYPE_CHECKING:  # pragma: no cover
     from typing import Dict  # noqa:F401
     from typing import List  # noqa:F401
     from typing import Optional  # noqa:F401
+    from typing import Tuple  # noqa:F401
 
     from ddtrace._trace.span import Span  # noqa:F401
 
@@ -73,11 +74,10 @@ class CIVisibilityEncoderV01(BufferedEncoder):
     def encode(self):
         with self._lock:
             with StopWatch() as sw:
-                payload = self._build_payload(self.buffer)
+                result_payloads = self._build_payload(self.buffer)
             record_endpoint_payload_events_serialization_time(endpoint=self.ENDPOINT_TYPE, seconds=sw.elapsed())
-            buffer_size = len(self.buffer)
             self._init_buffer()
-            return payload, buffer_size
+            return result_payloads
 
     def _get_parent_session(self, traces):
         for trace in traces:
@@ -87,6 +87,7 @@ class CIVisibilityEncoderV01(BufferedEncoder):
         return 0
 
     def _build_payload(self, traces):
+        # type: (List[List[Span]]) -> List[Tuple[Optional[bytes], int]]
         new_parent_session_span_id = self._get_parent_session(traces)
         is_not_xdist_worker = os.getenv("PYTEST_XDIST_WORKER") is None
         normalized_spans = [
@@ -96,20 +97,25 @@ class CIVisibilityEncoderV01(BufferedEncoder):
             if (is_not_xdist_worker or span.get_tag(EVENT_TYPE) != SESSION_TYPE)
         ]
         if not normalized_spans:
-            return None
+            return []
         record_endpoint_payload_events_count(endpoint=ENDPOINT.TEST_CYCLE, count=len(normalized_spans))
 
         # TODO: Split the events in several payloads as needed to avoid hitting the intake's maximum payload size.
-        return CIVisibilityEncoderV01._pack_payload(
-            {"version": self.PAYLOAD_FORMAT_VERSION, "metadata": self._metadata, "events": normalized_spans}
-        )
+        return [
+            (
+                CIVisibilityEncoderV01._pack_payload(
+                    {"version": self.PAYLOAD_FORMAT_VERSION, "metadata": self._metadata, "events": normalized_spans}
+                ),
+                len(traces),
+            )
+        ]
 
     @staticmethod
     def _pack_payload(payload):
         return msgpack_packb(payload)
 
     def _convert_span(self, span, dd_origin, new_parent_session_span_id=0):
-        # type: (Span, str, Optional[int]) -> Dict[str, Any]
+        # type: (Span, Optional[str], Optional[int]) -> Dict[str, Any]
         sp = JSONEncoderV2._span_to_dict(span)
         sp = JSONEncoderV2._normalize_span(sp)
         sp["type"] = span.get_tag(EVENT_TYPE) or span.span_type
@@ -230,14 +236,14 @@ class CIVisibilityCoverageEncoderV02(CIVisibilityEncoderV01):
         return msgpack_packb({"version": self.PAYLOAD_FORMAT_VERSION, "coverages": normalized_covs})
 
     def _build_payload(self, traces):
-        # type: (List[List[Span]]) -> Optional[bytes]
+        # type: (List[List[Span]]) -> List[Tuple[Optional[bytes], int]]
         data = self._build_data(traces)
         if not data:
-            return None
-        return b"\r\n".join(self._build_body(data))
+            return []
+        return [(b"\r\n".join(self._build_body(data)), len(traces))]
 
     def _convert_span(self, span, dd_origin, new_parent_session_span_id=0):
-        # type: (Span, str, Optional[int]) -> Dict[str, Any]
+        # type: (Span, Optional[str], Optional[int]) -> Dict[str, Any]
         # DEV: new_parent_session_span_id is unused here, but it is used in super class
         files: Dict[str, Any] = {}
 

ddtrace/internal/ci_visibility/utils.py

@@ -112,11 +112,10 @@ def take_over_logger_stream_handler(remove_ddtrace_stream_handlers=True):
         log.debug("CIVisibility not taking over ddtrace logger because level is set to: %s", level)
         return
 
-    root_logger = logging.getLogger()
+    ddtrace_logger = logging.getLogger("ddtrace")
 
     if remove_ddtrace_stream_handlers:
         log.debug("CIVisibility removing DDTrace logger handler")
-        ddtrace_logger = logging.getLogger("ddtrace")
         for handler in list(ddtrace_logger.handlers):
             ddtrace_logger.removeHandler(handler)
     else:
@@ -136,8 +135,9 @@ def take_over_logger_stream_handler(remove_ddtrace_stream_handlers=True):
         log.warning("Invalid log level: %s", level)
         return
 
-    root_logger.addHandler(ci_visibility_handler)
-    root_logger.setLevel(min(root_logger.level, ci_visibility_handler.level))
+    ddtrace_logger.addHandler(ci_visibility_handler)
+    ddtrace_logger.setLevel(min(ddtrace_logger.level, ci_visibility_handler.level))
+    ddtrace_logger.propagate = False
 
     log.debug("logger setup complete")
 

ddtrace/internal/core/__init__.py

@@ -197,9 +197,12 @@ class ExecutionContext(object):
         self._parent = value
 
     def __exit__(
-        self, exc_type: Optional[type], exc_value: Optional[BaseException], traceback: Optional[types.TracebackType]
+        self,
+        exc_type: Optional[type],
+        exc_value: Optional[BaseException],
+        traceback: Optional[types.TracebackType],
     ) -> bool:
-        dispatch("context.ended.%s" % self.identifier, (self,))
+        dispatch("context.ended.%s" % self.identifier, (self, (exc_type, exc_value, traceback)))
         if self._span is None:
             try:
                 if self._token is not None:

ddtrace/internal/test_visibility/coverage_lines.py

@@ -41,8 +41,8 @@ class CoverageLines:
     def add(self, line_number: int):
         lines_byte = line_number // 8
 
-        if lines_byte >= len(self._lines):
-            self._lines.extend(bytearray(lines_byte - len(self._lines) + 1))
+        if lines_byte >= self._lines.__len__():
+            self._lines.extend(bytearray(lines_byte - self._lines.__len__() + 1))
 
         # DEV this fun bit allows us to trick ourselves into little-endianness, which is what the backend wants to see
         # in bytes
@@ -62,8 +62,8 @@ class CoverageLines:
 
     def update(self, other: "CoverageLines"):
         # Extend our lines if the other coverage has more lines
-        if len(other._lines) > len(self._lines):
-            self._lines.extend(bytearray(len(other._lines) - len(self._lines)))
+        if other._lines.__len__() > self._lines.__len__():
+            self._lines.extend(bytearray(other._lines.__len__() - self._lines.__len__()))
 
         for _byte_idx, _byte in enumerate(other._lines):
             self._lines[_byte_idx] |= _byte

ddtrace/internal/writer/writer.py

@@ -385,13 +385,28 @@ class HTTPWriter(periodic.PeriodicService, TraceWriter):
     def _flush_queue_with_client(self, client: WriterClientBase, raise_exc: bool = False) -> None:
         n_traces = len(client.encoder)
         try:
-            encoded, n_traces = client.encoder.encode()
-
-            if encoded is None:
+            if not (encoded_traces := client.encoder.encode()):
                 return
 
-            # Should gzip the payload if intake accepts it
-            if self._intake_accepts_gzip:
+        except Exception:
+            # FIXME(munir): if client.encoder raises an Exception n_traces may not be accurate due to race conditions
+            log.error("failed to encode trace with encoder %r", client.encoder, exc_info=True)
+            self._metrics_dist("encoder.dropped.traces", n_traces)
+            return
+
+        for payload in encoded_traces:
+            encoded_data, n_traces = payload
+            self._flush_single_payload(encoded_data, n_traces, client=client, raise_exc=raise_exc)
+
+    def _flush_single_payload(
+        self, encoded: Optional[bytes], n_traces: int, client: WriterClientBase, raise_exc: bool = False
+    ) -> None:
+        if encoded is None:
+            return
+
+        # Should gzip the payload if intake accepts it
+        if self._intake_accepts_gzip:
+            try:
                 original_size = len(encoded)
                 # Replace the value to send with the gzipped the value
                 encoded = gzip.compress(encoded, compresslevel=6)
@@ -399,12 +414,10 @@ class HTTPWriter(periodic.PeriodicService, TraceWriter):
 
                 # And add the header
                 self._headers["Content-Encoding"] = "gzip"
-
-        except Exception:
-            # FIXME(munir): if client.encoder raises an Exception n_traces may not be accurate due to race conditions
-            log.error("failed to encode trace with encoder %r", client.encoder, exc_info=True)
-            self._metrics_dist("encoder.dropped.traces", n_traces)
-            return
+            except Exception:
+                log.error("failed to compress traces with encoder %r", client.encoder, exc_info=True)
+                self._metrics_dist("encoder.dropped.traces", n_traces)
+                return
 
         try:
             self._send_payload_with_backoff(encoded, n_traces, client)

ddtrace/llmobs/_constants.py

@@ -56,6 +56,7 @@ AGENTLESS_EXP_BASE_URL = "https://{}".format(EXP_SUBDOMAIN_NAME)
 EVP_PAYLOAD_SIZE_LIMIT = 5 << 20  # 5MB (actual limit is 5.1MB)
 EVP_EVENT_SIZE_LIMIT = (1 << 20) - 1024  # 999KB (actual limit is 1MB)
 
+EXPERIMENT_CSV_FIELD_MAX_SIZE = 10 * 1024 * 1024
 
 DROPPED_IO_COLLECTION_ERROR = "dropped_io"
 DROPPED_VALUE_TEXT = "[This value has been dropped because this span's size exceeds the 1MB size limit.]"
@@ -97,3 +98,4 @@ PROXY_REQUEST = "llmobs.proxy_request"
 
 EXPERIMENT_ID_KEY = "_ml_obs.experiment_id"
 EXPERIMENT_EXPECTED_OUTPUT = "_ml_obs.meta.input.expected_output"
+DEFAULT_PROJECT_NAME = "default-project"