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

ddtrace/llmobs/_llmobs.py

@@ -1,3 +1,4 @@
+import csv
 from dataclasses import dataclass
 from dataclasses import field
 import inspect
@@ -43,11 +44,14 @@ from ddtrace.internal.utils.formats import format_trace_id
 from ddtrace.internal.utils.formats import parse_tags_str
 from ddtrace.llmobs import _constants as constants
 from ddtrace.llmobs import _telemetry as telemetry
+from ddtrace.llmobs._constants import AGENT_MANIFEST
 from ddtrace.llmobs._constants import ANNOTATIONS_CONTEXT_ID
 from ddtrace.llmobs._constants import DECORATOR
+from ddtrace.llmobs._constants import DEFAULT_PROJECT_NAME
 from ddtrace.llmobs._constants import DISPATCH_ON_LLM_TOOL_CHOICE
 from ddtrace.llmobs._constants import DISPATCH_ON_TOOL_CALL
 from ddtrace.llmobs._constants import DISPATCH_ON_TOOL_CALL_OUTPUT_USED
+from ddtrace.llmobs._constants import EXPERIMENT_CSV_FIELD_MAX_SIZE
 from ddtrace.llmobs._constants import EXPERIMENT_EXPECTED_OUTPUT
 from ddtrace.llmobs._constants import EXPERIMENT_ID_KEY
 from ddtrace.llmobs._constants import INPUT_DOCUMENTS
@@ -77,8 +81,8 @@ from ddtrace.llmobs._constants import TAGS
 from ddtrace.llmobs._context import LLMObsContextProvider
 from ddtrace.llmobs._evaluators.runner import EvaluatorRunner
 from ddtrace.llmobs._experiment import Dataset
+from ddtrace.llmobs._experiment import DatasetRecord
 from ddtrace.llmobs._experiment import DatasetRecordInputType
-from ddtrace.llmobs._experiment import DatasetRecordRaw as DatasetRecord
 from ddtrace.llmobs._experiment import Experiment
 from ddtrace.llmobs._experiment import ExperimentConfigType
 from ddtrace.llmobs._experiment import JSONType
@@ -168,7 +172,7 @@ class LLMObs(Service):
     _instance = None  # type: LLMObs
     enabled = False
     _app_key: str = os.getenv("DD_APP_KEY", "")
-    _project_name: str = os.getenv("DD_LLMOBS_PROJECT_NAME", "")
+    _project_name: str = os.getenv("DD_LLMOBS_PROJECT_NAME", DEFAULT_PROJECT_NAME)
 
     def __init__(
         self,
@@ -253,7 +257,10 @@ class LLMObs(Service):
         if span_kind in ("llm", "embedding") and span._get_ctx_item(MODEL_NAME) is not None:
             meta["model_name"] = span._get_ctx_item(MODEL_NAME)
             meta["model_provider"] = (span._get_ctx_item(MODEL_PROVIDER) or "custom").lower()
-        meta["metadata"] = span._get_ctx_item(METADATA) or {}
+        metadata = span._get_ctx_item(METADATA) or {}
+        if span_kind == "agent" and span._get_ctx_item(AGENT_MANIFEST) is not None:
+            metadata["agent_manifest"] = span._get_ctx_item(AGENT_MANIFEST)
+        meta["metadata"] = metadata
 
         input_type: Literal["value", "messages", ""] = ""
         output_type: Literal["value", "messages", ""] = ""
@@ -509,12 +516,16 @@ class LLMObs(Service):
         config._dd_site = site or config._dd_site
         config._dd_api_key = api_key or config._dd_api_key
         cls._app_key = app_key or cls._app_key
-        cls._project_name = project_name or cls._project_name
+        cls._project_name = project_name or cls._project_name or DEFAULT_PROJECT_NAME
         config.env = env or config.env
         config.service = service or config.service
         config._llmobs_ml_app = ml_app or config._llmobs_ml_app
         config._llmobs_instrumented_proxy_urls = instrumented_proxy_urls or config._llmobs_instrumented_proxy_urls
 
+        # FIXME: workaround to prevent noisy logs when using the experiments feature
+        if config._dd_api_key and cls._app_key and os.environ.get("DD_TRACE_ENABLED", "").lower() not in ["true", "1"]:
+            ddtrace.tracer.enabled = False
+
         error = None
         start_ns = time.time_ns()
         try:
@@ -596,6 +607,67 @@ class LLMObs(Service):
             ds.push()
         return ds
 
+    @classmethod
+    def create_dataset_from_csv(
+        cls,
+        csv_path: str,
+        dataset_name: str,
+        input_data_columns: List[str],
+        expected_output_columns: List[str],
+        metadata_columns: List[str] = [],
+        csv_delimiter: str = ",",
+        description="",
+    ) -> Dataset:
+        ds = cls._instance._dne_client.dataset_create(dataset_name, description)
+
+        # Store the original field size limit to restore it later
+        original_field_size_limit = csv.field_size_limit()
+
+        csv.field_size_limit(EXPERIMENT_CSV_FIELD_MAX_SIZE)  # 10mb
+
+        try:
+            with open(csv_path, mode="r") as csvfile:
+                content = csvfile.readline().strip()
+                if not content:
+                    raise ValueError("CSV file appears to be empty or header is missing.")
+
+                csvfile.seek(0)
+
+                rows = csv.DictReader(csvfile, delimiter=csv_delimiter)
+
+                if rows.fieldnames is None:
+                    raise ValueError("CSV file appears to be empty or header is missing.")
+
+                header_columns = rows.fieldnames
+                missing_input_columns = [col for col in input_data_columns if col not in header_columns]
+                missing_output_columns = [col for col in expected_output_columns if col not in header_columns]
+                missing_metadata_columns = [col for col in metadata_columns if col not in metadata_columns]
+
+                if any(col not in header_columns for col in input_data_columns):
+                    raise ValueError(f"Input columns not found in CSV header: {missing_input_columns}")
+                if any(col not in header_columns for col in expected_output_columns):
+                    raise ValueError(f"Expected output columns not found in CSV header: {missing_output_columns}")
+                if any(col not in header_columns for col in metadata_columns):
+                    raise ValueError(f"Metadata columns not found in CSV header: {missing_metadata_columns}")
+
+                for row in rows:
+                    ds.append(
+                        DatasetRecord(
+                            input_data={col: row[col] for col in input_data_columns},
+                            expected_output={col: row[col] for col in expected_output_columns},
+                            metadata={col: row[col] for col in metadata_columns},
+                            record_id="",
+                        )
+                    )
+
+        finally:
+            # Always restore the original field size limit
+            csv.field_size_limit(original_field_size_limit)
+
+        if len(ds) > 0:
+            ds.push()
+        return ds
+
     @classmethod
     def _delete_dataset(cls, dataset_id: str) -> None:
         return cls._instance._dne_client.dataset_delete(dataset_id)
@@ -608,21 +680,19 @@ class LLMObs(Service):
         dataset: Dataset,
         evaluators: List[Callable[[DatasetRecordInputType, JSONType, JSONType], JSONType]],
         description: str = "",
-        project_name: Optional[str] = None,
-        tags: Optional[List[str]] = None,
+        tags: Optional[Dict[str, str]] = None,
+        config: Optional[ExperimentConfigType] = None,
     ) -> Experiment:
         """Initializes an Experiment to run a task on a Dataset and evaluators.
 
         :param name: The name of the experiment.
-        :param task: The task function to run. Must accept a parameter ``input_data`` and optionally ``config``.
+        :param task: The task function to run. Must accept parameters ``input_data`` and ``config``.
         :param dataset: The dataset to run the experiment on, created with LLMObs.pull/create_dataset().
         :param evaluators: A list of evaluator functions to evaluate the task output.
                            Must accept parameters ``input_data``, ``output_data``, and ``expected_output``.
         :param description: A description of the experiment.
-        :param project_name: The name of the project to associate with the experiment. If not provided, defaults to the
-                             configured value set via environment variable `DD_LLMOBS_PROJECT_NAME`
-                             or `LLMObs.enable(project_name=...)`.
-        :param tags: A list of string tags to associate with the experiment.
+        :param tags: A dictionary of string key-value tag pairs to associate with the experiment.
+        :param config: A configuration dictionary describing the experiment.
         """
         if not callable(task):
             raise TypeError("task must be a callable function.")
@@ -640,16 +710,15 @@ class LLMObs(Service):
             required_params = ("input_data", "output_data", "expected_output")
             if not all(param in params for param in required_params):
                 raise TypeError("Evaluator function must have parameters {}.".format(required_params))
-        if project_name is None:
-            project_name = cls._project_name
         return Experiment(
             name,
             task,
             dataset,
             evaluators,
-            project_name=project_name,
+            project_name=cls._project_name,
             tags=tags,
             description=description,
+            config=config,
             _llmobs_instance=cls._instance,
         )
 

ddtrace/llmobs/_telemetry.py

@@ -36,16 +36,17 @@ class LLMObsTelemetryMetrics:
     USER_PROCESSOR_CALLED = "user_processor_called"
 
 
-def _find_integration_from_tags(tags):
-    integration_tag = next((tag for tag in tags if tag.startswith("integration:")), None)
-    if not integration_tag:
+def _find_tag_value_from_tags(tags, tag_key):
+    tag_string = next((tag for tag in tags if tag.startswith(f"{tag_key}:")), None)
+    if not tag_string:
         return None
-    return integration_tag.split("integration:")[-1]
+    return tag_string.split(f"{tag_key}:")[-1]
 
 
 def _get_tags_from_span_event(event: LLMObsSpanEvent):
     span_kind = event.get("meta", {}).get("span.kind", "")
-    integration = _find_integration_from_tags(event.get("tags", []))
+    integration = _find_tag_value_from_tags(event.get("tags", []), "integration")
+    ml_app = _find_tag_value_from_tags(event.get("tags", []), "ml_app")
     autoinstrumented = integration is not None
     error = event.get("status") == "error"
     return [
@@ -53,6 +54,7 @@ def _get_tags_from_span_event(event: LLMObsSpanEvent):
         ("autoinstrumented", str(int(autoinstrumented))),
         ("error", str(int(error))),
         ("integration", integration if integration else "N/A"),
+        ("ml_app", ml_app if ml_app else "N/A"),
     ]
 
 
@@ -125,6 +127,19 @@ def record_span_created(span: Span):
     )
 
 
+def record_bedrock_agent_span_event_created(span_event: LLMObsSpanEvent):
+    is_root_span = span_event["parent_id"] == ROOT_PARENT_ID
+    has_session_id = any("session_id" in tag for tag in span_event["tags"])
+    tags = _get_tags_from_span_event(span_event)
+    tags.extend([("has_session_id", str(int(has_session_id))), ("is_root_span", str(int(is_root_span)))])
+    model_provider = span_event["meta"]["metadata"].get("model_provider")
+    if model_provider is not None:
+        tags.append(("model_provider", model_provider))
+    telemetry_writer.add_count_metric(
+        namespace=TELEMETRY_NAMESPACE.MLOBS, name=LLMObsTelemetryMetrics.SPAN_FINISHED, value=1, tags=tuple(tags)
+    )
+
+
 def record_span_event_raw_size(event: LLMObsSpanEvent, raw_event_size: int):
     telemetry_writer.add_distribution_metric(
         namespace=TELEMETRY_NAMESPACE.MLOBS,

ddtrace/llmobs/_utils.py

@@ -1,4 +1,6 @@
+from dataclasses import asdict
 from dataclasses import dataclass
+from dataclasses import is_dataclass
 import json
 from typing import Dict
 from typing import List
@@ -215,6 +217,25 @@ def safe_json(obj, ensure_ascii=True):
         log.error("Failed to serialize object to JSON.", exc_info=True)
 
 
+def load_data_value(value):
+    if isinstance(value, (list, tuple, set)):
+        return [load_data_value(item) for item in value]
+    elif isinstance(value, dict):
+        return {str(k): load_data_value(v) for k, v in value.items()}
+    elif hasattr(value, "model_dump"):
+        return value.model_dump()
+    elif is_dataclass(value):
+        return asdict(value)
+    elif isinstance(value, (int, float, str, bool)) or value is None:
+        return value
+    else:
+        value_str = safe_json(value)
+        try:
+            return json.loads(value_str)
+        except json.JSONDecodeError:
+            return value_str
+
+
 def add_span_link(span: Span, span_id: str, trace_id: str, from_io: str, to_io: str) -> None:
     current_span_links = span._get_ctx_item(SPAN_LINKS) or []
     current_span_links.append(
@@ -234,6 +255,12 @@ def enforce_message_role(messages: List[Dict[str, str]]) -> List[Dict[str, str]]
     return messages
 
 
+def convert_tags_dict_to_list(tags: Dict[str, str]) -> List[str]:
+    if not tags:
+        return []
+    return [f"{key}:{value}" for key, value in tags.items()]
+
+
 @dataclass
 class ToolCall:
     """

ddtrace/settings/_config.py

@@ -17,7 +17,6 @@ from ddtrace.internal.telemetry import telemetry_writer
 from ddtrace.internal.telemetry import validate_otel_envs
 from ddtrace.internal.utils.cache import cachedmethod
 
-from .._logger import LogInjectionState
 from .._logger import get_log_injection_state
 from ..internal import gitmetadata
 from ..internal.constants import _PROPAGATION_BEHAVIOR_DEFAULT
@@ -378,7 +377,7 @@ def _default_config() -> Dict[str, _ConfigItem]:
             modifier=str,
         ),
         "_logs_injection": _ConfigItem(
-            default=LogInjectionState.STRUCTURED,
+            default=True,
             envs=["DD_LOGS_INJECTION"],
             modifier=get_log_injection_state,
         ),

ddtrace/settings/asm.py

@@ -16,6 +16,7 @@ from ddtrace.appsec._constants import TELEMETRY_INFORMATION_NAME
 from ddtrace.constants import APPSEC_ENV
 from ddtrace.ext import SpanTypes
 from ddtrace.internal import core
+from ddtrace.internal.endpoints import HttpEndPointsCollection
 from ddtrace.internal.serverless import in_aws_lambda
 from ddtrace.settings._config import config as tracer_config
 from ddtrace.settings._core import DDConfig
@@ -59,6 +60,9 @@ def build_libddwaf_filename() -> str:
     return os.path.join(_DIRNAME, "appsec", "_ddwaf", "libddwaf", ARCHITECTURE, "lib", "libddwaf." + FILE_EXTENSION)
 
 
+endpoint_collection = HttpEndPointsCollection()
+
+
 class ASMConfig(DDConfig):
     _asm_enabled = DDConfig.var(bool, APPSEC_ENV, default=False)
     _asm_enabled_origin = APPSEC.ENABLED_ORIGIN_UNKNOWN
@@ -92,6 +96,10 @@ class ASMConfig(DDConfig):
     _api_security_enabled = DDConfig.var(bool, API_SECURITY.ENV_VAR_ENABLED, default=True)
     _api_security_sample_delay = DDConfig.var(float, API_SECURITY.SAMPLE_DELAY, default=30.0)
     _api_security_parse_response_body = DDConfig.var(bool, API_SECURITY.PARSE_RESPONSE_BODY, default=True)
+    _api_security_endpoint_collection = DDConfig.var(bool, API_SECURITY.ENDPOINT_COLLECTION, default=True)
+    _api_security_endpoint_collection_limit = DDConfig.var(
+        int, API_SECURITY.ENDPOINT_COLLECTION_LIMIT, default=DEFAULT.ENDPOINT_COLLECTION_LIMIT
+    )
 
     # internal state of the API security Manager service.
     # updated in API Manager enable/disable
@@ -246,9 +254,8 @@ class ASMConfig(DDConfig):
             self._asm_processed_span_types.add(SpanTypes.SERVERLESS)
             self._asm_http_span_types.add(SpanTypes.SERVERLESS)
 
-            # As a first step, only Threat Management in monitoring mode should be enabled in AWS Lambda
+            # Disable all features that are not supported in Lambda
             tracer_config._remote_config_enabled = False
-            self._api_security_enabled = False
             self._ep_enabled = False
             self._iast_supported = False
 

ddtrace/settings/profiling.py

@@ -240,15 +240,6 @@ class ProfilingConfig(DDConfig):
         help="Whether to enable debug assertions in the profiler code",
     )
 
-    _force_legacy_exporter = DDConfig.v(
-        bool,
-        "_force_legacy_exporter",
-        default=False,
-        help_type="Boolean",
-        help="Exclusively used in testing environments to force the use of the legacy exporter. This parameter is "
-        "not for general use and will be removed in the near future.",
-    )
-
     sample_pool_capacity = DDConfig.v(
         int,
         "sample_pool_capacity",

{ddtrace-3.11.0rc1.dist-info → ddtrace-3.11.0rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddtrace
-Version: 3.11.0rc1
+Version: 3.11.0rc3
 Summary: Datadog APM client library
 Author-email: "Datadog, Inc." <dev@datadoghq.com>
 License: LICENSE.BSD3