ddtrace 3.11.0rc1__cp311-cp311-win32.whl → 3.11.0rc2__cp311-cp311-win32.whl

ddtrace/llmobs/_experiment.py

@@ -21,6 +21,7 @@ from ddtrace.constants import ERROR_STACK
 from ddtrace.constants import ERROR_TYPE
 from ddtrace.internal.logger import get_logger
 from ddtrace.llmobs._constants import EXPERIMENT_EXPECTED_OUTPUT
+from ddtrace.llmobs._utils import convert_tags_dict_to_list
 
 
 if TYPE_CHECKING:
@@ -153,6 +154,12 @@ class Dataset:
         self._deleted_record_ids.append(record_id)
         del self._records[index]
 
+    @property
+    def url(self) -> str:
+        # FIXME: need to use the user's site
+        # also will not work for subdomain orgs
+        return f"https://app.datadoghq.com/llm/datasets/{self._id}"
+
     @overload
     def __getitem__(self, index: int) -> DatasetRecord:
         ...
@@ -170,6 +177,50 @@ class Dataset:
     def __iter__(self) -> Iterator[DatasetRecord]:
         return iter(self._records)
 
+    def as_dataframe(self) -> None:
+        try:
+            import pandas as pd
+        except ImportError as e:
+            raise ImportError(
+                "pandas is required to convert dataset to DataFrame. Please install via `pip install pandas`"
+            ) from e
+
+        column_tuples = set()
+        data_rows = []
+        for record in self._records:
+            flat_record = {}  # type: Dict[Union[str, Tuple[str, str]], Any]
+
+            input_data = record.get("input_data", {})
+            if isinstance(input_data, dict):
+                for input_data_col, input_data_val in input_data.items():
+                    flat_record[("input_data", input_data_col)] = input_data_val
+                    column_tuples.add(("input_data", input_data_col))
+            else:
+                flat_record[("input_data", "")] = input_data
+                column_tuples.add(("input_data", ""))
+
+            expected_output = record.get("expected_output", {})
+            if isinstance(expected_output, dict):
+                for expected_output_col, expected_output_val in expected_output.items():
+                    flat_record[("expected_output", expected_output_col)] = expected_output_val
+                    column_tuples.add(("expected_output", expected_output_col))
+            else:
+                flat_record[("expected_output", "")] = expected_output
+                column_tuples.add(("expected_output", ""))
+
+            for metadata_col, metadata_val in record.get("metadata", {}).items():
+                flat_record[("metadata", metadata_col)] = metadata_val
+                column_tuples.add(("metadata", metadata_col))
+
+            data_rows.append(flat_record)
+
+        records_list = []
+        for flat_record in data_rows:
+            row = [flat_record.get(col, None) for col in column_tuples]
+            records_list.append(row)
+
+        return pd.DataFrame(data=records_list, columns=pd.MultiIndex.from_tuples(column_tuples))
+
 
 class Experiment:
     def __init__(
@@ -180,7 +231,7 @@ class Experiment:
         evaluators: List[Callable[[DatasetRecordInputType, JSONType, JSONType], JSONType]],
         project_name: str,
         description: str = "",
-        tags: Optional[List[str]] = None,
+        tags: Optional[Dict[str, str]] = None,
         config: Optional[ExperimentConfigType] = None,
         _llmobs_instance: Optional["LLMObs"] = None,
     ) -> None:
@@ -189,8 +240,8 @@ class Experiment:
         self._dataset = dataset
         self._evaluators = evaluators
         self._description = description
-        self._tags: List[str] = [f"ddtrace.version:{ddtrace.__version__}"]
-        self._tags.extend(tags or [])
+        self._tags: Dict[str, str] = tags or {}
+        self._tags["ddtrace.version"] = str(ddtrace.__version__)
         self._config: Dict[str, JSONType] = config or {}
         self._llmobs_instance = _llmobs_instance
 
@@ -217,7 +268,8 @@ class Experiment:
         if not self._llmobs_instance.enabled:
             logger.warning(
                 "Skipping experiment as LLMObs is not enabled. "
-                "Ensure LLM Observability is enabled via `LLMObs.enable(...)` or set `DD_LLMOBS_ENABLED=1`."
+                "Ensure LLM Observability is enabled via `LLMObs.enable(...)` "
+                "or set `DD_LLMOBS_ENABLED=1` and use `ddtrace-run` to run your application."
             )
             return []
 
@@ -230,17 +282,19 @@ class Experiment:
             self._project_id,
             self._dataset._version,
             self._config,
-            self._tags,
+            convert_tags_dict_to_list(self._tags),
             self._description,
         )
         self._id = experiment_id
-        self._tags.append(f"experiment_id:{experiment_id}")
+        self._tags["experiment_id"] = str(experiment_id)
         self._run_name = experiment_run_name
         task_results = self._run_task(jobs, raise_errors, sample_size)
         evaluations = self._run_evaluators(task_results, raise_errors=raise_errors)
         experiment_results = self._merge_results(task_results, evaluations)
         experiment_evals = self._generate_metrics_from_exp_results(experiment_results)
-        self._llmobs_instance._dne_client.experiment_eval_post(self._id, experiment_evals, self._tags)
+        self._llmobs_instance._dne_client.experiment_eval_post(
+            self._id, experiment_evals, convert_tags_dict_to_list(self._tags)
+        )
         return experiment_results
 
     def _process_record(self, idx_record: Tuple[int, DatasetRecord]) -> Optional[TaskResult]:
@@ -256,7 +310,12 @@ class Experiment:
                 span_id, trace_id = "", ""
             input_data = record["input_data"]
             record_id = record.get("record_id", "")
-            tags = {"dataset_id": self._dataset._id, "dataset_record_id": record_id, "experiment_id": self._id}
+            tags = {
+                **self._tags,
+                "dataset_id": str(self._dataset._id),
+                "dataset_record_id": str(record_id),
+                "experiment_id": str(self._id),
+            }
             output_data = None
             try:
                 output_data = self._task(input_data, self._config)
@@ -342,7 +401,7 @@ class Experiment:
         experiment_results = []
         for idx, task_result in enumerate(task_results):
             output_data = task_result["output"]
-            metadata: Dict[str, JSONType] = {"tags": cast(List[JSONType], self._tags)}
+            metadata: Dict[str, JSONType] = {"tags": cast(List[JSONType], convert_tags_dict_to_list(self._tags))}
             metadata.update(task_result.get("metadata") or {})
             record: DatasetRecord = self._dataset[idx]
             evals = evaluations[idx]["evaluations"]
@@ -383,7 +442,7 @@ class Experiment:
             "label": eval_name,
             f"{metric_type}_value": eval_value,  # type: ignore
             "error": err,
-            "tags": self._tags,
+            "tags": convert_tags_dict_to_list(self._tags),
             "experiment_id": self._id,
         }
 

ddtrace/llmobs/_integrations/bedrock.py

@@ -13,6 +13,7 @@ from ddtrace.llmobs._constants import CACHE_READ_INPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import CACHE_WRITE_INPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import INPUT_MESSAGES
 from ddtrace.llmobs._constants import INPUT_VALUE
+from ddtrace.llmobs._constants import INTEGRATION
 from ddtrace.llmobs._constants import METADATA
 from ddtrace.llmobs._constants import METRICS
 from ddtrace.llmobs._constants import MODEL_NAME
@@ -30,6 +31,7 @@ from ddtrace.llmobs._integrations.bedrock_utils import normalize_input_tokens
 from ddtrace.llmobs._integrations.utils import get_final_message_converse_stream_message
 from ddtrace.llmobs._integrations.utils import get_messages_from_converse_content
 from ddtrace.llmobs._integrations.utils import update_proxy_workflow_input_output_value
+from ddtrace.llmobs._telemetry import record_bedrock_agent_span_event_created
 from ddtrace.llmobs._writer import LLMObsSpanEvent
 from ddtrace.trace import Span
 
@@ -151,6 +153,7 @@ class BedrockIntegration(BaseLLMIntegration):
                 INPUT_VALUE: str(input_value),
                 TAGS: {"session_id": session_id},
                 METADATA: {"agent_id": agent_id, "agent_alias_id": agent_alias_id},
+                INTEGRATION: "bedrock_agents",
             }
         )
         if not response:
@@ -176,6 +179,7 @@ class BedrockIntegration(BaseLLMIntegration):
             )
         for _, span_event in self._spans.items():
             LLMObs._instance._llmobs_span_writer.enqueue(span_event)
+            record_bedrock_agent_span_event_created(span_event)
         self._spans.clear()
         self._active_span_by_step_id.clear()
 

ddtrace/llmobs/_integrations/bedrock_agents.py

@@ -15,6 +15,7 @@ from ddtrace.internal.utils.formats import format_trace_id
 from ddtrace.llmobs._constants import LLMOBS_TRACE_ID
 from ddtrace.llmobs._integrations.bedrock_utils import parse_model_id
 from ddtrace.llmobs._utils import _get_ml_app
+from ddtrace.llmobs._utils import _get_session_id
 from ddtrace.llmobs._utils import safe_json
 
 
@@ -57,12 +58,15 @@ def _build_span_event(
     llmobs_trace_id = root_span._get_ctx_item(LLMOBS_TRACE_ID)
     if llmobs_trace_id is None:
         llmobs_trace_id = root_span.trace_id
+    session_id = _get_session_id(root_span)
+    ml_app = _get_ml_app(root_span)
+    tags = [f"ml_app:{ml_app}", f"session_id:{session_id}", "integration:bedrock_agents"]
     span_event = {
         "name": span_name,
         "span_id": str(span_id),
         "trace_id": format_trace_id(llmobs_trace_id),
         "parent_id": str(parent_id or root_span.span_id),
-        "tags": ["ml_app:{}".format(_get_ml_app(root_span))],
+        "tags": tags,
         "start_ns": int(start_ns or root_span.start_ns),
         "duration": int(duration_ns or DEFAULT_SPAN_DURATION),
         "status": "error" if error else "ok",

ddtrace/llmobs/_integrations/langchain.py

@@ -163,7 +163,6 @@ class LangChainIntegration(BaseLLMIntegration):
 
         self._set_links(span)
         model_provider = span.get_tag(PROVIDER)
-        self._llmobs_set_metadata(span, model_provider)
 
         is_workflow = False
 
@@ -365,26 +364,37 @@ class LangChainIntegration(BaseLLMIntegration):
         if hasattr(instance, "_datadog_spans"):
             delattr(instance, "_datadog_spans")
 
-    def _llmobs_set_metadata(self, span: Span, model_provider: Optional[str] = None) -> None:
-        if not model_provider:
+    def _llmobs_set_metadata(self, span: Span, kwargs: Dict[str, Any]) -> None:
+        identifying_params = kwargs.pop("_dd.identifying_params", None)
+        if not identifying_params:
             return
+        metadata = self._llmobs_extract_parameters(identifying_params)
+        for val in identifying_params.values():
+            if metadata:
+                break
+            if not isinstance(val, dict):
+                continue
+            metadata = self._llmobs_extract_parameters(val)
 
-        metadata = {}
-        temperature = span.get_tag(f"langchain.request.{model_provider}.parameters.temperature") or span.get_tag(
-            f"langchain.request.{model_provider}.parameters.model_kwargs.temperature"
-        )  # huggingface
-        max_tokens = (
-            span.get_tag(f"langchain.request.{model_provider}.parameters.max_tokens")
-            or span.get_tag(f"langchain.request.{model_provider}.parameters.maxTokens")  # ai21
-            or span.get_tag(f"langchain.request.{model_provider}.parameters.model_kwargs.max_tokens")  # huggingface
-        )
+        if metadata:
+            span._set_ctx_item(METADATA, metadata)
 
+    def _llmobs_extract_parameters(self, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        metadata: Dict[str, Any] = {}
+        max_tokens = None
+        temperature = None
+        if "temperature" in parameters:
+            temperature = parameters["temperature"]
+        for max_token_key in ["max_tokens", "maxTokens", "max_completion_tokens"]:
+            if max_token_key in parameters:
+                max_tokens = parameters[max_token_key]
+                break
         if temperature is not None and temperature != "None":
             metadata["temperature"] = float(temperature)
         if max_tokens is not None and max_tokens != "None":
             metadata["max_tokens"] = int(max_tokens)
-        if metadata:
-            span._set_ctx_item(METADATA, metadata)
+
+        return metadata
 
     def _llmobs_set_tags_from_llm(
         self, span: Span, args: List[Any], kwargs: Dict[str, Any], completions: Any, is_workflow: bool = False
@@ -411,6 +421,8 @@ class LangChainIntegration(BaseLLMIntegration):
             }
         )
 
+        self._llmobs_set_metadata(span, kwargs)
+
         if span.error:
             span._set_ctx_item(output_tag_key, [{"content": ""}])
             return
@@ -444,6 +456,9 @@ class LangChainIntegration(BaseLLMIntegration):
                 MODEL_PROVIDER: span.get_tag(PROVIDER) or "",
             }
         )
+
+        self._llmobs_set_metadata(span, kwargs)
+
         input_tag_key = INPUT_VALUE if is_workflow else INPUT_MESSAGES
         output_tag_key = OUTPUT_VALUE if is_workflow else OUTPUT_MESSAGES
         stream = span.get_tag("langchain.request.stream")
@@ -700,16 +715,10 @@ class LangChainIntegration(BaseLLMIntegration):
         **kwargs,
     ) -> None:
         """Set base level tags that should be present on all LangChain spans (if they are not None)."""
-        span.set_tag_str(TYPE, interface_type)
         if provider is not None:
             span.set_tag_str(PROVIDER, provider)
         if model is not None:
             span.set_tag_str(MODEL, model)
-        if api_key is not None:
-            if len(api_key) >= 4:
-                span.set_tag_str(API_KEY, "...%s" % str(api_key[-4:]))
-            else:
-                span.set_tag_str(API_KEY, api_key)
 
     def check_token_usage_chat_or_llm_result(self, result):
         """Checks for token usage on the top-level ChatResult or LLMResult object"""

ddtrace/llmobs/_llmobs.py

@@ -1,3 +1,4 @@
+import csv
 from dataclasses import dataclass
 from dataclasses import field
 import inspect
@@ -45,9 +46,11 @@ from ddtrace.llmobs import _constants as constants
 from ddtrace.llmobs import _telemetry as telemetry
 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 +80,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 +171,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,
@@ -509,12 +512,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 +603,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 +676,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 +706,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

@@ -234,6 +234,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/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.0rc2.dist-info}/METADATA

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