Merge branch 'main' into alex/MLOB-4193_fix-openai-model-listing-function

Author: PROFeNoM

.gitlab/benchmarks/bp-runner.microbenchmarks.fail-on-breach.yml

@@ -1067,7 +1067,7 @@ experiments:
               - max_rss_usage < 34.00 MB
           - name: span-start-finish-traceid128
             thresholds:
-              - execution_time < 56.00 ms
+              - execution_time < 57.00 ms
               - max_rss_usage < 34.00 MB
           - name: span-start-traceid128
             thresholds:

ddtrace/appsec/_ddwaf/ddwaf_types.py

@@ -1,3 +1,5 @@
+from collections.abc import Mapping
+from collections.abc import Sequence
 import ctypes
 import ctypes.util
 from enum import IntEnum
@@ -128,7 +130,7 @@ def truncate_string(string: bytes) -> bytes:
             ddwaf_object_string(self, truncate_string(struct))
         elif isinstance(struct, float):
             ddwaf_object_float(self, struct)
-        elif isinstance(struct, list):
+        elif isinstance(struct, Sequence):
             if max_depth <= 0:
                 observator.set_container_depth(DDWAF_MAX_CONTAINER_DEPTH)
                 max_objects = 0
@@ -145,7 +147,7 @@ def truncate_string(string: bytes) -> bytes:
                     max_string_length=max_string_length,
                 )
                 ddwaf_object_array_add(array, obj)
-        elif isinstance(struct, dict):
+        elif isinstance(struct, Mapping):
             if max_depth <= 0:
                 observator.set_container_depth(DDWAF_MAX_CONTAINER_DEPTH)
                 max_objects = 0

ddtrace/internal/datadog/profiling/stack_v2/CMakeLists.txt

@@ -41,7 +41,7 @@ endif()
 
 # Add echion
 set(ECHION_COMMIT
-    "ee5df24d7becce660223e9b8b1bd7d6dce3e8ede" # https://github.com/kowalskithomas/echion/commit/ee5df24d7becce660223e9b8b1bd7d6dce3e8ede
+    "3ebeb3e975239f252fa0d6bb739344f35eaf1657" # https://github.com/kowalskithomas/echion/commit/3ebeb3e975239f252fa0d6bb739344f35eaf1657
     CACHE STRING "Commit hash of echion to use")
 FetchContent_Declare(
     echion

ddtrace/internal/datadog/profiling/stack_v2/src/stack_v2.cpp

@@ -73,7 +73,10 @@ stack_v2_thread_register(PyObject* self, PyObject* args)
         return NULL;
     }
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().register_thread(id, native_id, name);
+    Py_END_ALLOW_THREADS;
+
     Py_RETURN_NONE;
 }
 
@@ -87,8 +90,11 @@ stack_v2_thread_unregister(PyObject* self, PyObject* args)
         return NULL;
     }
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().unregister_thread(id);
     ThreadSpanLinks::get_instance().unlink_span(id);
+    Py_END_ALLOW_THREADS;
+
     Py_RETURN_NONE;
 }
 
@@ -122,7 +128,9 @@ _stack_v2_link_span(PyObject* self, PyObject* args, PyObject* kwargs)
         span_type = empty_string.c_str();
     }
 
+    Py_BEGIN_ALLOW_THREADS;
     ThreadSpanLinks::get_instance().link_span(thread_id, span_id, local_root_span_id, std::string(span_type));
+    Py_END_ALLOW_THREADS;
 
     Py_RETURN_NONE;
 }
@@ -140,7 +148,9 @@ stack_v2_track_asyncio_loop(PyObject* self, PyObject* args)
         return NULL;
     }
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().track_asyncio_loop(thread_id, loop);
+    Py_END_ALLOW_THREADS;
 
     Py_RETURN_NONE;
 }
@@ -172,7 +182,9 @@ stack_v2_link_tasks(PyObject* self, PyObject* args)
         return NULL;
     }
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().link_tasks(parent, child);
+    Py_END_ALLOW_THREADS;
 
     Py_RETURN_NONE;
 }
@@ -211,7 +223,9 @@ track_greenlet(PyObject* Py_UNUSED(m), PyObject* args)
         return NULL;
     }
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().track_greenlet(greenlet_id, greenlet_name, frame);
+    Py_END_ALLOW_THREADS;
 
     Py_RETURN_NONE;
 }
@@ -223,7 +237,9 @@ untrack_greenlet(PyObject* Py_UNUSED(m), PyObject* args)
     if (!PyArg_ParseTuple(args, "l", &greenlet_id))
         return NULL;
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().untrack_greenlet(greenlet_id);
+    Py_END_ALLOW_THREADS;
 
     Py_RETURN_NONE;
 }
@@ -236,7 +252,9 @@ link_greenlets(PyObject* Py_UNUSED(m), PyObject* args)
     if (!PyArg_ParseTuple(args, "ll", &child, &parent))
         return NULL;
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().link_greenlets(parent, child);
+    Py_END_ALLOW_THREADS;
 
     Py_RETURN_NONE;
 }
@@ -250,7 +268,9 @@ update_greenlet_frame(PyObject* Py_UNUSED(m), PyObject* args)
     if (!PyArg_ParseTuple(args, "lO", &greenlet_id, &frame))
         return NULL;
 
+    Py_BEGIN_ALLOW_THREADS;
     Sampler::get().update_greenlet_frame(greenlet_id, frame);
+    Py_END_ALLOW_THREADS;
 
     Py_RETURN_NONE;
 }

ddtrace/llmobs/_evaluators/ragas/base.py

@@ -170,7 +170,7 @@ def run_and_submit_evaluation(self, span_event: dict):
         )
         if isinstance(score_result_or_failure, float):
             self.llmobs_service.submit_evaluation(
-                span_context={"trace_id": span_event.get("trace_id"), "span_id": span_event.get("span_id")},
+                span={"trace_id": span_event.get("trace_id"), "span_id": span_event.get("span_id")},
                 label=self.LABEL,
                 metric_type=self.METRIC_TYPE,
                 value=score_result_or_failure,

ddtrace/llmobs/_llmobs.py

@@ -1564,6 +1564,42 @@ def submit_evaluation_for(
         timestamp_ms: Optional[int] = None,
         metadata: Optional[Dict[str, object]] = None,
         assessment: Optional[str] = None,
+    ) -> None:
+        """
+        Submits a custom evaluation metric for a given span. This method is deprecated and will be
+        removed in the next major version of ddtrace (4.0). Please use `LLMObs.submit_evaluation()` instead.
+        """
+        log.warning(
+            "LLMObs.submit_evaluation_for() is deprecated and will be removed in the next major "
+            "version of ddtrace (4.0). Please use LLMObs.submit_evaluation() instead."
+        )
+        return cls.submit_evaluation(
+            label=label,
+            metric_type=metric_type,
+            value=value,
+            span=span,
+            span_with_tag_value=span_with_tag_value,
+            tags=tags,
+            ml_app=ml_app,
+            timestamp_ms=timestamp_ms,
+            metadata=metadata,
+            assessment=assessment,
+        )
+
+    @classmethod
+    def submit_evaluation(
+        cls,
+        label: str,
+        metric_type: str,
+        value: Union[str, int, float, bool],
+        span_context: Optional[Dict[str, str]] = None,
+        span: Optional[dict] = None,
+        span_with_tag_value: Optional[Dict[str, str]] = None,
+        tags: Optional[Dict[str, str]] = None,
+        ml_app: Optional[str] = None,
+        timestamp_ms: Optional[int] = None,
+        metadata: Optional[Dict[str, object]] = None,
+        assessment: Optional[str] = None,
     ) -> None:
         """
         Submits a custom evaluation metric for a given span.
@@ -1572,6 +1608,9 @@ def submit_evaluation_for(
         :param str metric_type: The type of the evaluation metric. One of "categorical", "score", "boolean".
         :param value: The value of the evaluation metric.
                       Must be a string (categorical), integer (score), float (score), or boolean (boolean).
+        :param dict span_context: A dictionary containing the span_id and trace_id of interest. This is a
+                            deprecated parameter and will be removed in the next major version of
+                            ddtrace (4.0). Please use `span` or `span_with_tag_value` instead.
         :param dict span: A dictionary of shape {'span_id': str, 'trace_id': str} uniquely identifying
                             the span associated with this evaluation.
         :param dict span_with_tag_value: A dictionary with the format {'tag_key': str, 'tag_value': str}
@@ -1584,9 +1623,16 @@ def submit_evaluation_for(
                                 evaluation metric.
         :param str assessment: An assessment of the validity of this evaluation. Must be either "pass" or "fail".
         """
+        if span_context is not None:
+            log.warning(
+                "The `span_context` parameter is deprecated and will be removed in the next major version of "
+                "ddtrace (4.0). Please use `span` or `span_with_tag_value` instead."
+            )
+            span = span or span_context
+
         if cls.enabled is False:
             log.debug(
-                "LLMObs.submit_evaluation_for() called when LLMObs is not enabled. ",
+                "LLMObs.submit_evaluation() called when LLMObs is not enabled. ",
                 "Evaluation metric data will not be sent.",
             )
             return
@@ -1659,6 +1705,15 @@ def submit_evaluation_for(
                 log.warning("tags must be a dictionary of string key-value pairs.")
                 tags = {}
 
+            ml_app = ml_app if ml_app else config._llmobs_ml_app
+            if not ml_app:
+                error = "missing_ml_app"
+                log.warning(
+                    "ML App name is required for sending evaluation metrics. Evaluation metric data will not be sent. "
+                    "Ensure this configuration is set before running your application."
+                )
+                return
+
             evaluation_tags = {
                 "ddtrace.version": ddtrace.__version__,
                 "ml_app": ml_app,
@@ -1672,15 +1727,6 @@ def submit_evaluation_for(
                         error = "invalid_tags"
                         log.warning("Failed to parse tags. Tags for evaluation metrics must be strings.")
 
-            ml_app = ml_app if ml_app else config._llmobs_ml_app
-            if not ml_app:
-                error = "missing_ml_app"
-                log.warning(
-                    "ML App name is required for sending evaluation metrics. Evaluation metric data will not be sent. "
-                    "Ensure this configuration is set before running your application."
-                )
-                return
-
             evaluation_metric: LLMObsEvaluationMetricEvent = {
                 "join_on": join_on,
                 "label": str(label),
@@ -1711,144 +1757,6 @@ def submit_evaluation_for(
         finally:
             telemetry.record_llmobs_submit_evaluation(join_on, metric_type, error)
 
-    @classmethod
-    def submit_evaluation(
-        cls,
-        span_context: Dict[str, str],
-        label: str,
-        metric_type: str,
-        value: Union[str, int, float, bool],
-        tags: Optional[Dict[str, str]] = None,
-        ml_app: Optional[str] = None,
-        timestamp_ms: Optional[int] = None,
-        metadata: Optional[Dict[str, object]] = None,
-    ) -> None:
-        """
-        Submits a custom evaluation metric for a given span ID and trace ID.
-
-        :param span_context: A dictionary containing the span_id and trace_id of interest.
-        :param str label: The name of the evaluation metric.
-        :param str metric_type: The type of the evaluation metric. One of "categorical", "score", "boolean".
-        :param value: The value of the evaluation metric.
-                      Must be a string (categorical), integer (score), float (score), or boolean (boolean).
-        :param tags: A dictionary of string key-value pairs to tag the evaluation metric with.
-        :param str ml_app: The name of the ML application
-        :param int timestamp_ms: The timestamp in milliseconds when the evaluation metric result was generated.
-        :param dict metadata: A JSON serializable dictionary of key-value metadata pairs relevant to the
-                                evaluation metric.
-        """
-        if cls.enabled is False:
-            log.debug(
-                "LLMObs.submit_evaluation() called when LLMObs is not enabled. Evaluation metric data will not be sent."
-            )
-            return
-        error = None
-        try:
-            if not isinstance(span_context, dict):
-                error = "invalid_span"
-                log.warning(
-                    "span_context must be a dictionary containing both span_id and trace_id keys. "
-                    "LLMObs.export_span() can be used to generate this dictionary from a given span."
-                )
-                return
-
-            ml_app = ml_app if ml_app else config._llmobs_ml_app
-            if not ml_app:
-                error = "missing_ml_app"
-                log.warning(
-                    "ML App name is required for sending evaluation metrics. Evaluation metric data will not be sent. "
-                    "Ensure this configuration is set before running your application."
-                )
-                return
-
-            timestamp_ms = timestamp_ms if timestamp_ms else int(time.time() * 1000)
-
-            if not isinstance(timestamp_ms, int) or timestamp_ms < 0:
-                error = "invalid_timestamp"
-                log.warning("timestamp_ms must be a non-negative integer. Evaluation metric data will not be sent")
-                return
-
-            span_id = span_context.get("span_id")
-            trace_id = span_context.get("trace_id")
-            if not (span_id and trace_id):
-                error = "invalid_span"
-                log.warning(
-                    "span_id and trace_id must both be specified for the given evaluation metric to be submitted."
-                )
-                return
-            if not label:
-                error = "invalid_metric_label"
-                log.warning("label must be the specified name of the evaluation metric.")
-                return
-
-            if not metric_type or metric_type.lower() not in ("categorical", "numerical", "score", "boolean"):
-                error = "invalid_metric_type"
-                log.warning("metric_type must be one of 'categorical', 'score', or 'boolean'.")
-                return
-
-            metric_type = metric_type.lower()
-            if metric_type == "numerical":
-                error = "invalid_metric_type"
-                log.warning(
-                    "The evaluation metric type 'numerical' is unsupported. Use 'score' instead. "
-                    "Converting `numerical` metric to `score` type."
-                )
-                metric_type = "score"
-
-            if metric_type == "categorical" and not isinstance(value, str):
-                error = "invalid_metric_value"
-                log.warning("value must be a string for a categorical metric.")
-                return
-            if metric_type == "score" and not isinstance(value, (int, float)):
-                error = "invalid_metric_value"
-                log.warning("value must be an integer or float for a score metric.")
-                return
-            if metric_type == "boolean" and not isinstance(value, bool):
-                error = "invalid_metric_value"
-                log.warning("value must be a boolean for a boolean metric.")
-                return
-            if tags is not None and not isinstance(tags, dict):
-                error = "invalid_tags"
-                log.warning("tags must be a dictionary of string key-value pairs.")
-                return
-
-            # initialize tags with default values that will be overridden by user-provided tags
-            evaluation_tags = {
-                "ddtrace.version": ddtrace.__version__,
-                "ml_app": ml_app,
-            }
-
-            if tags:
-                for k, v in tags.items():
-                    try:
-                        evaluation_tags[ensure_text(k)] = ensure_text(v)
-                    except TypeError:
-                        error = "invalid_tags"
-                        log.warning("Failed to parse tags. Tags for evaluation metrics must be strings.")
-
-            evaluation_metric: LLMObsEvaluationMetricEvent = {
-                "join_on": {"span": {"span_id": span_id, "trace_id": trace_id}},
-                "label": str(label),
-                "metric_type": metric_type.lower(),
-                "timestamp_ms": timestamp_ms,
-                "{}_value".format(metric_type): value,  # type: ignore
-                "ml_app": ml_app,
-                "tags": ["{}:{}".format(k, v) for k, v in evaluation_tags.items()],
-            }
-
-            if metadata:
-                if not isinstance(metadata, dict):
-                    error = "invalid_metadata"
-                    log.warning("metadata must be json serializable dictionary.")
-                else:
-                    metadata = safe_json(metadata)
-                    if metadata and isinstance(metadata, str):
-                        evaluation_metric["metadata"] = json.loads(metadata)
-
-            cls._instance._llmobs_eval_metric_writer.enqueue(evaluation_metric)
-        finally:
-            telemetry.record_llmobs_submit_evaluation({"span": span_context}, metric_type, error)
-
     @classmethod
     def _inject_llmobs_context(cls, span_context: Context, request_headers: Dict[str, str]) -> None:
         if cls.enabled is False:

releasenotes/notes/aap-down-req-headers-urllib3-61b27c7fdc927312.yaml

@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    AAP: This fix resolves an issue where downstream request analysis would not match headers in rules when using `requests` with `urllib3<2`.