ddtrace 3.11.0rc2__cp38-cp38-win_amd64.whl → 3.11.0rc3__cp38-cp38-win_amd64.whl

ddtrace/llmobs/_integrations/pydantic_ai.py

@@ -2,9 +2,11 @@ from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
+from typing import Tuple
 
 from ddtrace.internal.utils import get_argument_value
 from ddtrace.internal.utils.formats import format_trace_id
+from ddtrace.llmobs._constants import AGENT_MANIFEST
 from ddtrace.llmobs._constants import INPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import INPUT_VALUE
 from ddtrace.llmobs._constants import METADATA
@@ -45,13 +47,19 @@ class PydanticAIIntegration(BaseLLMIntegration):
             span._set_ctx_item(SPAN_KIND, kind)
         return span
 
-    def _set_base_span_tags(self, span: Span, model: Optional[str] = None, **kwargs) -> None:
+    def _set_base_span_tags(self, span: Span, model: Optional[Any] = None, **kwargs) -> None:
         if model:
-            span.set_tag("pydantic_ai.request.model", getattr(model, "model_name", ""))
-            system = getattr(model, "system", None)
-            if system:
-                system = PYDANTIC_AI_SYSTEM_TO_PROVIDER.get(system, system)
-                span.set_tag("pydantic_ai.request.provider", system)
+            model_name, provider = self._get_model_and_provider(model)
+            span.set_tag("pydantic_ai.request.model", model_name)
+            if provider:
+                span.set_tag("pydantic_ai.request.provider", provider)
+
+    def _get_model_and_provider(self, model: Optional[Any]) -> Tuple[str, str]:
+        model_name = getattr(model, "model_name", "")
+        system = getattr(model, "system", None)
+        if system:
+            system = PYDANTIC_AI_SYSTEM_TO_PROVIDER.get(system, system)
+        return model_name, system
 
     def _llmobs_set_tags(
         self,
@@ -84,26 +92,8 @@ class PydanticAIIntegration(BaseLLMIntegration):
         from pydantic_ai.agent import AgentRun
 
         agent_instance = kwargs.get("instance", None)
-        if agent_instance:
-            agent_name = getattr(agent_instance, "name", None)
-            agent_instructions = getattr(agent_instance, "_instructions", None)
-            agent_system_prompts = getattr(agent_instance, "_system_prompts", None)
-            agent_tools = list(getattr(agent_instance, "_function_tools", {}).keys())
-            agent_model_settings = getattr(agent_instance, "model_settings", None)
-            metadata = {
-                "instructions": agent_instructions,
-                "system_prompts": agent_system_prompts,
-                "tools": agent_tools,
-            }
-            if agent_model_settings:
-                metadata["max_tokens"] = agent_model_settings.get("max_tokens", None)
-                metadata["temperature"] = agent_model_settings.get("temperature", None)
-            span._set_ctx_items(
-                {
-                    NAME: agent_name or "PydanticAI Agent",
-                    METADATA: metadata,
-                }
-            )
+        agent_name = getattr(agent_instance, "name", None)
+        self._tag_agent_manifest(span, kwargs, agent_instance)
         user_prompt = get_argument_value(args, kwargs, 0, "user_prompt")
         result = response
         if isinstance(result, AgentRun) and hasattr(result, "result"):
@@ -119,6 +109,7 @@ class PydanticAIIntegration(BaseLLMIntegration):
         metrics = self.extract_usage_metrics(response, kwargs)
         span._set_ctx_items(
             {
+                NAME: agent_name or "PydanticAI Agent",
                 INPUT_VALUE: user_prompt,
                 OUTPUT_VALUE: result,
                 METRICS: metrics,
@@ -145,6 +136,56 @@ class PydanticAIIntegration(BaseLLMIntegration):
         if not span.error:
             span._set_ctx_item(OUTPUT_VALUE, getattr(response, "content", ""))
 
+    def _tag_agent_manifest(self, span: Span, kwargs: Dict[str, Any], agent: Any) -> None:
+        if not agent:
+            return
+
+        manifest: Dict[str, Any] = {}
+        manifest["framework"] = "PydanticAI"
+        manifest["name"] = agent.name if hasattr(agent, "name") and agent.name else "PydanticAI Agent"
+        model = getattr(agent, "model", None)
+        if model:
+            model_name, _ = self._get_model_and_provider(model)
+            if model_name:
+                manifest["model"] = model_name
+        if hasattr(agent, "model_settings"):
+            manifest["model_settings"] = agent.model_settings
+        if hasattr(agent, "_instructions"):
+            manifest["instructions"] = agent._instructions
+        if hasattr(agent, "_system_prompts"):
+            manifest["system_prompts"] = agent._system_prompts
+        if hasattr(agent, "_function_tools"):
+            manifest["tools"] = self._get_agent_tools(agent._function_tools)
+        if kwargs.get("deps", None):
+            agent_dependencies = kwargs.get("deps", None)
+            manifest["dependencies"] = getattr(agent_dependencies, "__dict__", agent_dependencies)
+
+        span._set_ctx_item(AGENT_MANIFEST, manifest)
+
+    def _get_agent_tools(self, tools: Any) -> List[Dict[str, Any]]:
+        if not tools:
+            return []
+        formatted_tools = []
+        for tool_name, tool_instance in tools.items():
+            tool_dict = {}
+            tool_dict["name"] = tool_name
+            if hasattr(tool_instance, "description"):
+                tool_dict["description"] = tool_instance.description
+            function_schema = getattr(tool_instance, "function_schema", {})
+            json_schema = getattr(function_schema, "json_schema", {})
+            required_params = {param: True for param in json_schema.get("required", [])}
+            parameters = {}
+            for param, schema in json_schema.get("properties", {}).items():
+                param_dict = {}
+                if "type" in schema:
+                    param_dict["type"] = schema["type"]
+                if param in required_params:
+                    param_dict["required"] = True
+                parameters[param] = param_dict
+            tool_dict["parameters"] = parameters
+            formatted_tools.append(tool_dict)
+        return formatted_tools
+
     def extract_usage_metrics(self, response: Any, kwargs: Dict[str, Any]) -> Dict[str, Any]:
         response = kwargs.get("streamed_run_result", None) or response
         usage = None

ddtrace/llmobs/_integrations/utils.py

@@ -1,6 +1,4 @@
-from dataclasses import asdict
 from dataclasses import dataclass
-from dataclasses import is_dataclass
 import json
 import re
 from typing import Any
@@ -19,7 +17,6 @@ from ddtrace.llmobs._constants import DISPATCH_ON_TOOL_CALL_OUTPUT_USED
 from ddtrace.llmobs._constants import INPUT_MESSAGES
 from ddtrace.llmobs._constants import INPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import INPUT_VALUE
-from ddtrace.llmobs._constants import LITELLM_ROUTER_INSTANCE_KEY
 from ddtrace.llmobs._constants import METADATA
 from ddtrace.llmobs._constants import OAI_HANDOFF_TOOL_ARG
 from ddtrace.llmobs._constants import OUTPUT_MESSAGES
@@ -27,6 +24,7 @@ from ddtrace.llmobs._constants import OUTPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import OUTPUT_VALUE
 from ddtrace.llmobs._constants import TOTAL_TOKENS_METRIC_KEY
 from ddtrace.llmobs._utils import _get_attr
+from ddtrace.llmobs._utils import load_data_value
 from ddtrace.llmobs._utils import safe_json
 
 
@@ -39,31 +37,71 @@ except ModuleNotFoundError:
 
 logger = get_logger(__name__)
 
-OPENAI_SKIPPED_COMPLETION_TAGS = (
-    "model",
-    "prompt",
-    "api_key",
-    "user_api_key",
-    "user_api_key_hash",
-    LITELLM_ROUTER_INSTANCE_KEY,
+COMMON_METADATA_KEYS = (
+    "stream",
+    "temperature",
+    "top_p",
+    "user",
 )
-OPENAI_SKIPPED_CHAT_TAGS = (
-    "model",
-    "messages",
+OPENAI_METADATA_RESPONSE_KEYS = (
+    "background",
+    "include",
+    "max_output_tokens",
+    "max_tool_calls",
+    "parallel_tool_calls",
+    "previous_response_id",
+    "prompt",
+    "reasoning",
+    "service_tier",
+    "store",
+    "text",
+    "tool_choice",
     "tools",
-    "functions",
-    "api_key",
-    "user_api_key",
-    "user_api_key_hash",
-    LITELLM_ROUTER_INSTANCE_KEY,
+    "top_logprobs",
+    "truncation",
+)
+OPENAI_METADATA_CHAT_KEYS = (
+    "audio",
+    "frequency_penalty",
+    "function_call",
+    "logit_bias",
+    "logprobs",
+    "max_completion_tokens",
+    "max_tokens",
+    "modalities",
+    "n",
+    "parallel_tool_calls",
+    "prediction",
+    "presence_penalty",
+    "reasoning_effort",
+    "response_format",
+    "seed",
+    "service_tier",
+    "stop",
+    "store",
+    "stream_options",
+    "tool_choice",
+    "top_logprobs",
+    "web_search_options",
+)
+OPENAI_METADATA_COMPLETION_KEYS = (
+    "best_of",
+    "echo",
+    "frequency_penalty",
+    "logit_bias",
+    "logprobs",
+    "max_tokens",
+    "n",
+    "presence_penalty",
+    "seed",
+    "stop",
+    "stream_options",
+    "suffix",
 )
 
 LITELLM_METADATA_CHAT_KEYS = (
     "timeout",
-    "temperature",
-    "top_p",
     "n",
-    "stream",
     "stream_options",
     "stop",
     "max_completion_tokens",
@@ -73,7 +111,6 @@ LITELLM_METADATA_CHAT_KEYS = (
     "presence_penalty",
     "frequency_penalty",
     "logit_bias",
-    "user",
     "response_format",
     "seed",
     "tool_choice",
@@ -97,12 +134,8 @@ LITELLM_METADATA_COMPLETION_KEYS = (
     "n",
     "presence_penalty",
     "stop",
-    "stream",
     "stream_options",
     "suffix",
-    "temperature",
-    "top_p",
-    "user",
     "api_base",
     "api_version",
     "model_list",
@@ -110,67 +143,6 @@ LITELLM_METADATA_COMPLETION_KEYS = (
 )
 
 
-def extract_model_name_google(instance, model_name_attr):
-    """Extract the model name from the instance.
-    Model names are stored in the format `"models/{model_name}"`
-    so we do our best to return the model name instead of the full string.
-    """
-    model_name = _get_attr(instance, model_name_attr, "")
-    if not model_name or not isinstance(model_name, str):
-        return ""
-    if "/" in model_name:
-        return model_name.split("/")[-1]
-    return model_name
-
-
-def get_generation_config_google(instance, kwargs):
-    """
-    The generation config can be defined on the model instance or
-    as a kwarg of the request. Therefore, try to extract this information
-    from the kwargs and otherwise default to checking the model instance attribute.
-    """
-    generation_config = kwargs.get("generation_config", {})
-    return generation_config or _get_attr(instance, "_generation_config", {})
-
-
-def llmobs_get_metadata_google(kwargs, instance):
-    metadata = {}
-    model_config = getattr(instance, "_generation_config", {}) or {}
-    model_config = model_config.to_dict() if hasattr(model_config, "to_dict") else model_config
-    request_config = kwargs.get("generation_config", {}) or {}
-    request_config = request_config.to_dict() if hasattr(request_config, "to_dict") else request_config
-
-    parameters = ("temperature", "max_output_tokens", "candidate_count", "top_p", "top_k")
-    for param in parameters:
-        model_config_value = _get_attr(model_config, param, None)
-        request_config_value = _get_attr(request_config, param, None)
-        if model_config_value or request_config_value:
-            metadata[param] = request_config_value or model_config_value
-    return metadata
-
-
-def extract_message_from_part_google(part, role=None):
-    text = _get_attr(part, "text", "")
-    function_call = _get_attr(part, "function_call", None)
-    function_response = _get_attr(part, "function_response", None)
-    message = {"content": text}
-    if role:
-        message["role"] = role
-    if function_call:
-        function_call_dict = function_call
-        if not isinstance(function_call, dict):
-            function_call_dict = type(function_call).to_dict(function_call)
-        message["tool_calls"] = [
-            {"name": function_call_dict.get("name", ""), "arguments": function_call_dict.get("args", {})}
-        ]
-    if function_response:
-        function_response_dict = function_response
-        if not isinstance(function_response, dict):
-            function_response_dict = type(function_response).to_dict(function_response)
-        message["content"] = "[tool result: {}]".format(function_response_dict.get("response", ""))
-    return message
-
-
 def get_llmobs_metrics_tags(integration_name, span):
     usage = {}
 
@@ -209,41 +181,6 @@ def parse_llmobs_metric_args(metrics):
     return usage
 
 
-def get_system_instructions_from_google_model(model_instance):
-    """
-    Extract system instructions from model and convert to []str for tagging.
-    """
-    try:
-        from google.ai.generativelanguage_v1beta.types.content import Content
-    except ImportError:
-        Content = None
-    try:
-        from vertexai.generative_models._generative_models import Part
-    except ImportError:
-        Part = None
-
-    raw_system_instructions = getattr(model_instance, "_system_instruction", [])
-    if Content is not None and isinstance(raw_system_instructions, Content):
-        system_instructions = []
-        for part in raw_system_instructions.parts:
-            system_instructions.append(_get_attr(part, "text", ""))
-        return system_instructions
-    elif isinstance(raw_system_instructions, str):
-        return [raw_system_instructions]
-    elif Part is not None and isinstance(raw_system_instructions, Part):
-        return [_get_attr(raw_system_instructions, "text", "")]
-    elif not isinstance(raw_system_instructions, list):
-        return []
-
-    system_instructions = []
-    for elem in raw_system_instructions:
-        if isinstance(elem, str):
-            system_instructions.append(elem)
-        elif Part is not None and isinstance(elem, Part):
-            system_instructions.append(_get_attr(elem, "text", ""))
-    return system_instructions
-
-
 LANGCHAIN_ROLE_MAPPING = {
     "human": "user",
     "ai": "assistant",
@@ -471,12 +408,12 @@ def get_metadata_from_kwargs(
     kwargs: Dict[str, Any], integration_name: str = "openai", operation: str = "chat"
 ) -> Dict[str, Any]:
     metadata = {}
+    keys_to_include: Tuple[str, ...] = COMMON_METADATA_KEYS
     if integration_name == "openai":
-        keys_to_skip = OPENAI_SKIPPED_CHAT_TAGS if operation == "chat" else OPENAI_SKIPPED_COMPLETION_TAGS
-        metadata = {k: v for k, v in kwargs.items() if k not in keys_to_skip}
+        keys_to_include += OPENAI_METADATA_CHAT_KEYS if operation == "chat" else OPENAI_METADATA_COMPLETION_KEYS
     elif integration_name == "litellm":
-        keys_to_include = LITELLM_METADATA_CHAT_KEYS if operation == "chat" else LITELLM_METADATA_COMPLETION_KEYS
-        metadata = {k: v for k, v in kwargs.items() if k in keys_to_include}
+        keys_to_include += LITELLM_METADATA_CHAT_KEYS if operation == "chat" else LITELLM_METADATA_COMPLETION_KEYS
+    metadata = {k: v for k, v in kwargs.items() if k in keys_to_include}
     return metadata
 
 
@@ -621,7 +558,7 @@ def openai_get_metadata_from_response(
     metadata = {}
 
     if kwargs:
-        metadata.update({k: v for k, v in kwargs.items() if k not in ("model", "input", "instructions")})
+        metadata.update({k: v for k, v in kwargs.items() if k in OPENAI_METADATA_RESPONSE_KEYS + COMMON_METADATA_KEYS})
 
     if not response:
         return metadata
@@ -630,7 +567,7 @@ def openai_get_metadata_from_response(
     for field in ["temperature", "max_output_tokens", "top_p", "tools", "tool_choice", "truncation", "text", "user"]:
         value = getattr(response, field, None)
         if value is not None:
-            metadata[field] = load_oai_span_data_value(value)
+            metadata[field] = load_data_value(value)
 
     usage = getattr(response, "usage", None)
     output_tokens_details = getattr(usage, "output_tokens_details", None)
@@ -863,7 +800,7 @@ class OaiSpanAdapter:
         data = self.data
         if not data:
             return {}
-        return load_oai_span_data_value(data)
+        return load_data_value(data)
 
     @property
     def response_output_text(self) -> str:
@@ -922,25 +859,14 @@ class OaiSpanAdapter:
                 if hasattr(self.response, field):
                     value = getattr(self.response, field)
                     if value is not None:
-                        metadata[field] = load_oai_span_data_value(value)
+                        metadata[field] = load_data_value(value)
 
             if hasattr(self.response, "text") and self.response.text:
-                metadata["text"] = load_oai_span_data_value(self.response.text)
+                metadata["text"] = load_data_value(self.response.text)
 
             if hasattr(self.response, "usage") and hasattr(self.response.usage, "output_tokens_details"):
                 metadata["reasoning_tokens"] = self.response.usage.output_tokens_details.reasoning_tokens
 
-        if self.span_type == "agent":
-            agent_metadata: Dict[str, List[str]] = {
-                "handoffs": [],
-                "tools": [],
-            }
-            if self.handoffs:
-                agent_metadata["handoffs"] = load_oai_span_data_value(self.handoffs)
-            if self.tools:
-                agent_metadata["tools"] = load_oai_span_data_value(self.tools)
-            metadata.update(agent_metadata)
-
         if self.span_type == "custom" and hasattr(self._raw_oai_span.span_data, "data"):
             custom_data = getattr(self._raw_oai_span.span_data, "data", None)
             if custom_data:
@@ -1153,22 +1079,6 @@ class OaiTraceAdapter:
         return self._trace
 
 
-def load_oai_span_data_value(value):
-    """Helper function to load values stored in openai span data in a consistent way"""
-    if isinstance(value, list):
-        return [load_oai_span_data_value(item) for item in value]
-    elif hasattr(value, "model_dump"):
-        return value.model_dump()
-    elif is_dataclass(value):
-        return asdict(value)
-    else:
-        value_str = safe_json(value)
-        try:
-            return json.loads(value_str)
-        except json.JSONDecodeError:
-            return value_str
-
-
 @dataclass
 class LLMObsTraceInfo:
     """Metadata for llmobs trace used for setting root span attributes and span links"""

ddtrace/llmobs/_integrations/vertexai.py

@@ -17,9 +17,9 @@ from ddtrace.llmobs._constants import OUTPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import SPAN_KIND
 from ddtrace.llmobs._constants import TOTAL_TOKENS_METRIC_KEY
 from ddtrace.llmobs._integrations.base import BaseLLMIntegration
-from ddtrace.llmobs._integrations.utils import extract_message_from_part_google
-from ddtrace.llmobs._integrations.utils import get_system_instructions_from_google_model
-from ddtrace.llmobs._integrations.utils import llmobs_get_metadata_google
+from ddtrace.llmobs._integrations.google_utils import extract_message_from_part_gemini_vertexai
+from ddtrace.llmobs._integrations.google_utils import get_system_instructions_gemini_vertexai
+from ddtrace.llmobs._integrations.google_utils import llmobs_get_metadata_gemini_vertexai
 from ddtrace.llmobs._utils import _get_attr
 from ddtrace.trace import Span
 
@@ -46,9 +46,9 @@ class VertexAIIntegration(BaseLLMIntegration):
         instance = kwargs.get("instance", None)
         history = kwargs.get("history", [])
         metrics = kwargs.get("metrics", {})
-        metadata = llmobs_get_metadata_google(kwargs, instance)
+        metadata = llmobs_get_metadata_gemini_vertexai(kwargs, instance)
 
-        system_instruction = get_system_instructions_from_google_model(instance)
+        system_instruction = get_system_instructions_gemini_vertexai(instance)
         input_contents = None
         try:
             input_contents = get_argument_value(args, kwargs, 0, "content")
@@ -117,7 +117,7 @@ class VertexAIIntegration(BaseLLMIntegration):
             messages.append({"content": contents})
             return messages
         if isinstance(contents, Part):
-            message = extract_message_from_part_google(contents)
+            message = extract_message_from_part_gemini_vertexai(contents)
             messages.append(message)
             return messages
         if not isinstance(contents, list):
@@ -128,7 +128,7 @@ class VertexAIIntegration(BaseLLMIntegration):
                 messages.append({"content": content})
                 continue
             if isinstance(content, Part):
-                message = extract_message_from_part_google(content)
+                message = extract_message_from_part_gemini_vertexai(content)
                 messages.append(message)
                 continue
             messages.extend(self._extract_messages_from_content(content))
@@ -170,6 +170,6 @@ class VertexAIIntegration(BaseLLMIntegration):
             messages.append(message)
             return messages
         for part in parts:
-            message = extract_message_from_part_google(part, role)
+            message = extract_message_from_part_gemini_vertexai(part, role)
             messages.append(message)
         return messages

ddtrace/llmobs/_llmobs.py

@@ -44,6 +44,7 @@ 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
@@ -256,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", ""] = ""

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(

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-3.11.0rc2.dist-info → ddtrace-3.11.0rc3.dist-info}/METADATA

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