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

ddtrace/contrib/internal/openai_agents/patch.py

@@ -5,6 +5,10 @@ from agents.tracing import add_trace_processor
 
 from ddtrace import config
 from ddtrace.contrib.internal.openai_agents.processor import LLMObsTraceProcessor
+from ddtrace.contrib.trace_utils import unwrap
+from ddtrace.contrib.trace_utils import with_traced_module_async
+from ddtrace.contrib.trace_utils import wrap
+from ddtrace.internal.utils.version import parse_version
 from ddtrace.llmobs._integrations.openai_agents import OpenAIAgentsIntegration
 from ddtrace.trace import Pin
 
@@ -22,6 +26,29 @@ def _supported_versions() -> Dict[str, str]:
     return {"agents": ">=0.0.2"}
 
 
+OPENAI_AGENTS_VERSION = parse_version(get_version())
+
+
+@with_traced_module_async
+async def patched_run_single_turn(agents, pin, func, instance, args, kwargs):
+    return await _patched_run_single_turn(agents, pin, func, instance, args, kwargs, agent_index=0)
+
+
+@with_traced_module_async
+async def patched_run_single_turn_streamed(agents, pin, func, instance, args, kwargs):
+    return await _patched_run_single_turn(agents, pin, func, instance, args, kwargs, agent_index=1)
+
+
+async def _patched_run_single_turn(agents, pin, func, instance, args, kwargs, agent_index=0):
+    current_span = pin.tracer.current_span()
+    result = await func(*args, **kwargs)
+
+    integration = agents._datadog_integration
+    integration.tag_agent_manifest(current_span, args, kwargs, agent_index)
+
+    return result
+
+
 def patch():
     """
     Patch the instrumented methods
@@ -33,7 +60,16 @@ def patch():
 
     Pin().onto(agents)
 
-    add_trace_processor(LLMObsTraceProcessor(OpenAIAgentsIntegration(integration_config=config.openai_agents)))
+    integration = OpenAIAgentsIntegration(integration_config=config.openai_agents)
+    add_trace_processor(LLMObsTraceProcessor(integration))
+    agents._datadog_integration = integration
+
+    if OPENAI_AGENTS_VERSION >= (0, 0, 19):
+        wrap(agents.run.AgentRunner, "_run_single_turn", patched_run_single_turn(agents))
+        wrap(agents.run.AgentRunner, "_run_single_turn_streamed", patched_run_single_turn_streamed(agents))
+    else:
+        wrap(agents.run.Runner, "_run_single_turn", patched_run_single_turn(agents))
+        wrap(agents.run.Runner, "_run_single_turn_streamed", patched_run_single_turn_streamed(agents))
 
 
 def unpatch():
@@ -44,3 +80,10 @@ def unpatch():
         return
 
     agents._datadog_patch = False
+
+    if OPENAI_AGENTS_VERSION >= (0, 0, 19):
+        unwrap(agents.run.AgentRunner, "_run_single_turn")
+        unwrap(agents.run.AgentRunner, "_run_single_turn_streamed")
+    else:
+        unwrap(agents.run.Runner, "_run_single_turn")
+        unwrap(agents.run.Runner, "_run_single_turn_streamed")

ddtrace/contrib/internal/pytest/_plugin_v2.py

@@ -345,7 +345,7 @@ def pytest_sessionstart(session: pytest.Session) -> None:
             test_impact_analysis="1" if _pytest_version_supports_itr() else None,
             test_management_quarantine="1",
             test_management_disable="1",
-            test_management_attempt_to_fix="4" if _pytest_version_supports_attempt_to_fix() else None,
+            test_management_attempt_to_fix="5" if _pytest_version_supports_attempt_to_fix() else None,
         )
 
         InternalTestSession.discover(

ddtrace/contrib/internal/vertexai/patch.py

@@ -14,7 +14,7 @@ from ddtrace.contrib.internal.trace_utils import wrap
 from ddtrace.contrib.internal.vertexai._utils import TracedAsyncVertexAIStreamResponse
 from ddtrace.contrib.internal.vertexai._utils import TracedVertexAIStreamResponse
 from ddtrace.llmobs._integrations import VertexAIIntegration
-from ddtrace.llmobs._integrations.utils import extract_model_name_google
+from ddtrace.llmobs._integrations.google_utils import extract_provider_and_model_name
 from ddtrace.trace import Pin
 
 
@@ -60,11 +60,12 @@ def _traced_generate(vertexai, pin, func, instance, args, kwargs, model_instance
     integration = vertexai._datadog_integration
     stream = kwargs.get("stream", False)
     generations = None
+    provider_name, model_name = extract_provider_and_model_name(instance=model_instance, model_name_attr="_model_name")
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        provider="google",
-        model=extract_model_name_google(model_instance, "_model_name"),
+        provider=provider_name,
+        model=model_name,
         submit_to_llmobs=True,
     )
     # history must be copied since it is modified during the LLM interaction
@@ -92,11 +93,12 @@ async def _traced_agenerate(vertexai, pin, func, instance, args, kwargs, model_i
     integration = vertexai._datadog_integration
     stream = kwargs.get("stream", False)
     generations = None
+    provider_name, model_name = extract_provider_and_model_name(instance=model_instance, model_name_attr="_model_name")
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        provider="google",
-        model=extract_model_name_google(model_instance, "_model_name"),
+        provider=provider_name,
+        model=model_name,
         submit_to_llmobs=True,
     )
     # history must be copied since it is modified during the LLM interaction

ddtrace/ext/ci.py

@@ -105,6 +105,16 @@ def tags(env=None, cwd=None):
             break
 
     git_info = git.extract_git_metadata(cwd=cwd)
+
+    # Whenever the HEAD commit SHA is present in the tags that come from the CI provider, we assume that
+    # the CI provider added a commit on top of the user's HEAD commit (e.g., GitHub Actions add a merge
+    # commit when triggered by a pull request). In that case, we extract the metadata for that commit specifically
+    # and add it to the tags.
+    head_commit_sha = tags.get(git.COMMIT_HEAD_SHA)
+    if head_commit_sha:
+        git_head_info = git.extract_git_head_metadata(head_commit_sha=head_commit_sha, cwd=cwd)
+        git_info.update(git_head_info)
+
     try:
         git_info[WORKSPACE_PATH] = git.extract_workspace_path(cwd=cwd)
     except git.GitNotFoundError:
@@ -349,6 +359,15 @@ def extract_github_actions(env):
         github_run_id,
     )
 
+    git_commit_head_sha = None
+    if "GITHUB_EVENT_PATH" in env:
+        try:
+            with open(env["GITHUB_EVENT_PATH"]) as f:
+                github_event_data = json.load(f)
+                git_commit_head_sha = github_event_data.get("pull_request", {}).get("head", {}).get("sha")
+        except Exception as e:
+            log.error("Failed to read or parse GITHUB_EVENT_PATH: %s", e)
+
     env_vars = {
         "GITHUB_SERVER_URL": github_server_url,
         "GITHUB_REPOSITORY": github_repository,
@@ -362,6 +381,7 @@ def extract_github_actions(env):
         git.BRANCH: env.get("GITHUB_HEAD_REF") or env.get("GITHUB_REF"),
         git.COMMIT_SHA: git_commit_sha,
         git.REPOSITORY_URL: "{0}/{1}.git".format(github_server_url, github_repository),
+        git.COMMIT_HEAD_SHA: git_commit_head_sha,
         JOB_URL: "{0}/{1}/commit/{2}/checks".format(github_server_url, github_repository, git_commit_sha),
         PIPELINE_ID: github_run_id,
         PIPELINE_NAME: env.get("GITHUB_WORKFLOW"),

ddtrace/ext/git.py

@@ -33,6 +33,30 @@ BRANCH = "git.branch"
 # Git Commit SHA
 COMMIT_SHA = "git.commit.sha"
 
+# Git Commit HEAD SHA
+COMMIT_HEAD_SHA = "git.commit.head.sha"
+
+# Git Commit HEAD message
+COMMIT_HEAD_MESSAGE = "git.commit.head.message"
+
+# Git Commit HEAD author date
+COMMIT_HEAD_AUTHOR_DATE = "git.commit.head.author.date"
+
+# Git Commit HEAD author email
+COMMIT_HEAD_AUTHOR_EMAIL = "git.commit.head.author.email"
+
+# Git Commit HEAD author name
+COMMIT_HEAD_AUTHOR_NAME = "git.commit.head.author.name"
+
+# Git Commit HEAD committer date
+COMMIT_HEAD_COMMITTER_DATE = "git.commit.head.committer.date"
+
+# Git Commit HEAD committer email
+COMMIT_HEAD_COMMITTER_EMAIL = "git.commit.head.committer.email"
+
+# Git Commit HEAD committer name
+COMMIT_HEAD_COMMITTER_NAME = "git.commit.head.committer.name"
+
 # Git Repository URL
 REPOSITORY_URL = "git.repository_url"
 
@@ -173,11 +197,12 @@ def _get_device_for_path(path):
     return os.stat(path).st_dev
 
 
-def _unshallow_repository_with_details(cwd=None, repo=None, refspec=None):
-    # type (Optional[str], Optional[str], Optional[str]) -> _GitSubprocessDetails
+def _unshallow_repository_with_details(
+    cwd: Optional[str] = None, repo: Optional[str] = None, refspec: Optional[str] = None, parent_only: bool = False
+) -> _GitSubprocessDetails:
     cmd = [
         "fetch",
-        '--shallow-since="1 month ago"',
+        "--deepen=1" if parent_only else '--shallow-since="1 month ago"',
         "--update-shallow",
         "--filter=blob:none",
         "--recurse-submodules=no",
@@ -190,18 +215,22 @@ def _unshallow_repository_with_details(cwd=None, repo=None, refspec=None):
     return _git_subprocess_cmd_with_details(*cmd, cwd=cwd)
 
 
-def _unshallow_repository(cwd=None, repo=None, refspec=None):
-    # type (Optional[str], Optional[str], Optional[str]) -> None
-    _unshallow_repository_with_details(cwd, repo, refspec)
+def _unshallow_repository(
+    cwd: Optional[str] = None,
+    repo: Optional[str] = None,
+    refspec: Optional[str] = None,
+    parent_only: bool = False,
+) -> None:
+    _unshallow_repository_with_details(cwd, repo, refspec, parent_only)
 
 
-def extract_user_info(cwd=None):
-    # type: (Optional[str]) -> Dict[str, Tuple[str, str, str]]
+def extract_user_info(cwd: Optional[str] = None, commit_sha: Optional[str] = None) -> Dict[str, Tuple[str, str, str]]:
     """Extract commit author info from the git repository in the current directory or one specified by ``cwd``."""
     # Note: `git show -s --format... --date...` is supported since git 2.1.4 onwards
-    stdout = _git_subprocess_cmd(
-        "show -s --format=%an|||%ae|||%ad|||%cn|||%ce|||%cd --date=format:%Y-%m-%dT%H:%M:%S%z", cwd=cwd
-    )
+    cmd = "show -s --format=%an|||%ae|||%ad|||%cn|||%ce|||%cd --date=format:%Y-%m-%dT%H:%M:%S%z"
+    if commit_sha:
+        cmd += " " + commit_sha
+    stdout = _git_subprocess_cmd(cmd=cmd, cwd=cwd)
     author_name, author_email, author_date, committer_name, committer_email, committer_date = stdout.split("|||")
     return {
         "author": (author_name, author_email, author_date),
@@ -316,6 +345,32 @@ def extract_commit_sha(cwd=None):
     return commit_sha
 
 
+def extract_git_head_metadata(head_commit_sha: str, cwd: Optional[str] = None) -> Dict[str, Optional[str]]:
+    tags: Dict[str, Optional[str]] = {}
+
+    is_shallow, *_ = _is_shallow_repository_with_details(cwd=cwd)
+    if is_shallow:
+        _unshallow_repository(cwd=cwd, repo=None, refspec=None, parent_only=True)
+
+    try:
+        users = extract_user_info(cwd=cwd, commit_sha=head_commit_sha)
+        tags[COMMIT_HEAD_AUTHOR_NAME] = users["author"][0]
+        tags[COMMIT_HEAD_AUTHOR_EMAIL] = users["author"][1]
+        tags[COMMIT_HEAD_AUTHOR_DATE] = users["author"][2]
+        tags[COMMIT_HEAD_COMMITTER_NAME] = users["committer"][0]
+        tags[COMMIT_HEAD_COMMITTER_EMAIL] = users["committer"][1]
+        tags[COMMIT_HEAD_COMMITTER_DATE] = users["committer"][2]
+        tags[COMMIT_HEAD_MESSAGE] = _git_subprocess_cmd(" ".join(("log -n 1 --format=%B", head_commit_sha)), cwd)
+    except GitNotFoundError:
+        log.error("Git executable not found, cannot extract git metadata.")
+    except ValueError as e:
+        debug_mode = log.isEnabledFor(logging.DEBUG)
+        stderr = str(e)
+        log.error("Error extracting git metadata: %s", stderr, exc_info=debug_mode)
+
+    return tags
+
+
 def extract_git_metadata(cwd=None):
     # type: (Optional[str]) -> Dict[str, Optional[str]]
     """Extract git commit metadata."""

ddtrace/internal/ci_visibility/encoder.py

@@ -1,7 +1,14 @@
+from __future__ import annotations
+
 import json
 import os
 import threading
 from typing import TYPE_CHECKING  # noqa:F401
+from typing import Any  # noqa:F401
+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 uuid import uuid4
 
 from ddtrace.ext import SpanTypes
@@ -28,12 +35,6 @@ from ddtrace.internal.writer.writer import NoEncodableSpansError
 log = get_logger(__name__)
 
 if TYPE_CHECKING:  # pragma: no cover
-    from typing import Any  # noqa:F401
-    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
 
 
@@ -43,79 +44,153 @@ class CIVisibilityEncoderV01(BufferedEncoder):
     TEST_SUITE_EVENT_VERSION = 1
     TEST_EVENT_VERSION = 2
     ENDPOINT_TYPE = ENDPOINT.TEST_CYCLE
+    _MAX_PAYLOAD_SIZE = 5 * 1024 * 1024  # 5MB
 
     def __init__(self, *args):
         # DEV: args are not used here, but are used by BufferedEncoder's __cinit__() method,
         #      which is called implicitly by Cython.
         super(CIVisibilityEncoderV01, self).__init__()
+        self._metadata: Dict[str, Dict[str, str]] = {}
         self._lock = threading.RLock()
-        self._metadata = {}
+        self._is_xdist_worker = os.getenv("PYTEST_XDIST_WORKER") is not None
         self._init_buffer()
 
     def __len__(self):
         with self._lock:
             return len(self.buffer)
 
-    def set_metadata(self, event_type, metadata):
-        # type: (str, Dict[str, str]) -> None
+    def set_metadata(self, event_type: str, metadata: Dict[str, str]):
         self._metadata.setdefault(event_type, {}).update(metadata)
 
     def _init_buffer(self):
         with self._lock:
             self.buffer = []
 
-    def put(self, spans):
+    def put(self, item):
         with self._lock:
-            self.buffer.append(spans)
+            self.buffer.append(item)
 
     def encode_traces(self, traces):
-        return self._build_payload(traces=traces)
+        """
+        Only used for LogWriter, not called for CI Visibility currently
+        """
+        raise NotImplementedError()
 
-    def encode(self):
+    def encode(self) -> List[Tuple[Optional[bytes], int]]:
         with self._lock:
+            if not self.buffer:
+                return []
+            payloads = []
             with StopWatch() as sw:
-                result_payloads = self._build_payload(self.buffer)
+                payloads = self._build_payload(self.buffer)
             record_endpoint_payload_events_serialization_time(endpoint=self.ENDPOINT_TYPE, seconds=sw.elapsed())
             self._init_buffer()
-            return result_payloads
+            return payloads
 
-    def _get_parent_session(self, traces):
+    def _get_parent_session(self, traces: List[List[Span]]) -> int:
         for trace in traces:
             for span in trace:
                 if span.get_tag(EVENT_TYPE) == SESSION_TYPE and span.parent_id is not None and span.parent_id != 0:
                     return span.parent_id
         return 0
 
-    def _build_payload(self, traces):
-        # type: (List[List[Span]]) -> List[Tuple[Optional[bytes], int]]
+    def _build_payload(self, traces: List[List[Span]]) -> List[Tuple[Optional[bytes], int]]:
+        """
+        Build multiple payloads from traces, splitting when necessary to stay under size limits.
+        Uses index-based recursive approach to avoid copying slices.
+
+        Returns a list of (payload_bytes, trace_count) tuples, where each payload contains
+        as many traces as possible without exceeding _MAX_PAYLOAD_SIZE.
+        """
+        if not traces:
+            return []
+
         new_parent_session_span_id = self._get_parent_session(traces)
-        is_not_xdist_worker = os.getenv("PYTEST_XDIST_WORKER") is None
-        normalized_spans = [
-            self._convert_span(span, trace[0].context.dd_origin, new_parent_session_span_id)
-            for trace in traces
-            for span in trace
-            if (is_not_xdist_worker or span.get_tag(EVENT_TYPE) != SESSION_TYPE)
-        ]
-        if not normalized_spans:
+        return self._build_payloads_recursive(traces, 0, len(traces), new_parent_session_span_id)
+
+    def _build_payloads_recursive(
+        self, traces: List[List[Span]], start_idx: int, end_idx: int, new_parent_session_span_id: int
+    ) -> List[Tuple[Optional[bytes], int]]:
+        """
+        Recursively build payloads using start/end indexes to avoid slice copying.
+
+        Args:
+            traces: Full list of traces
+            start_idx: Start index (inclusive)
+            end_idx: End index (exclusive)
+            new_parent_session_span_id: Parent session span ID
+
+        Returns:
+            List of (payload_bytes, trace_count) tuples
+        """
+        if start_idx >= end_idx:
             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}
-                ),
-                len(traces),
-            )
-        ]
+        trace_count = end_idx - start_idx
+
+        # Convert traces to spans with filtering (using indexes)
+        all_spans_with_trace_info = self._convert_traces_to_spans_indexed(
+            traces, start_idx, end_idx, new_parent_session_span_id
+        )
+
+        # Get all spans (flattened)
+        all_spans = [span for _, trace_spans in all_spans_with_trace_info for span in trace_spans]
+
+        if not all_spans:
+            log.debug("No spans to encode after filtering, skipping chunk")
+            return []
+
+        # Try to create payload from all spans
+        payload = self._create_payload_from_spans(all_spans)
+
+        if len(payload) <= self._MAX_PAYLOAD_SIZE or trace_count == 1:
+            # Payload fits or we can't split further (single trace)
+            record_endpoint_payload_events_count(endpoint=self.ENDPOINT_TYPE, count=len(all_spans))
+            return [(payload, trace_count)]
+        else:
+            # Payload is too large, split in half recursively
+            mid_idx = start_idx + (trace_count + 1) // 2
+
+            # Process both halves recursively
+            left_payloads = self._build_payloads_recursive(traces, start_idx, mid_idx, new_parent_session_span_id)
+            right_payloads = self._build_payloads_recursive(traces, mid_idx, end_idx, new_parent_session_span_id)
+
+            # Combine results
+            return left_payloads + right_payloads
+
+    def _convert_traces_to_spans_indexed(
+        self, traces: List[List[Span]], start_idx: int, end_idx: int, new_parent_session_span_id: int
+    ) -> List[Tuple[int, List[Dict[str, Any]]]]:
+        """Convert traces to spans with xdist filtering applied, using indexes to avoid slicing."""
+        all_spans_with_trace_info = []
+        for trace_idx in range(start_idx, end_idx):
+            trace = traces[trace_idx]
+            trace_spans = [
+                self._convert_span(span, trace[0].context.dd_origin, new_parent_session_span_id)
+                for span in trace
+                if (not self._is_xdist_worker) or (span.get_tag(EVENT_TYPE) != SESSION_TYPE)
+            ]
+            all_spans_with_trace_info.append((trace_idx, trace_spans))
+
+        return all_spans_with_trace_info
+
+    def _create_payload_from_spans(self, spans: List[Dict[str, Any]]) -> bytes:
+        """Create a payload from the given spans."""
+        return CIVisibilityEncoderV01._pack_payload(
+            {
+                "version": self.PAYLOAD_FORMAT_VERSION,
+                "metadata": self._metadata,
+                "events": spans,
+            }
+        )
 
     @staticmethod
     def _pack_payload(payload):
         return msgpack_packb(payload)
 
-    def _convert_span(self, span, dd_origin, new_parent_session_span_id=0):
-        # type: (Span, Optional[str], Optional[int]) -> Dict[str, Any]
+    def _convert_span(
+        self, span: Span, dd_origin: Optional[str] = None, new_parent_session_span_id: int = 0
+    ) -> 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
@@ -183,18 +258,17 @@ class CIVisibilityCoverageEncoderV02(CIVisibilityEncoderV01):
     def _set_itr_suite_skipping_mode(self, new_value):
         self.itr_suite_skipping_mode = new_value
 
-    def put(self, spans):
+    def put(self, item):
         spans_with_coverage = [
             span
-            for span in spans
+            for span in item
             if COVERAGE_TAG_NAME in span.get_tags() or span.get_struct_tag(COVERAGE_TAG_NAME) is not None
         ]
         if not spans_with_coverage:
             raise NoEncodableSpansError()
         return super(CIVisibilityCoverageEncoderV02, self).put(spans_with_coverage)
 
-    def _build_coverage_attachment(self, data):
-        # type: (bytes) -> List[bytes]
+    def _build_coverage_attachment(self, data: bytes) -> List[bytes]:
         return [
             b"--%s" % self.boundary.encode("utf-8"),
             b'Content-Disposition: form-data; name="coverage1"; filename="coverage1.msgpack"',
@@ -203,8 +277,7 @@ class CIVisibilityCoverageEncoderV02(CIVisibilityEncoderV01):
             data,
         ]
 
-    def _build_event_json_attachment(self):
-        # type: () -> List[bytes]
+    def _build_event_json_attachment(self) -> List[bytes]:
         return [
             b"--%s" % self.boundary.encode("utf-8"),
             b'Content-Disposition: form-data; name="event"; filename="event.json"',
@@ -213,18 +286,16 @@ class CIVisibilityCoverageEncoderV02(CIVisibilityEncoderV01):
             b'{"dummy":true}',
         ]
 
-    def _build_body(self, data):
-        # type: (bytes) -> List[bytes]
+    def _build_body(self, data: bytes) -> List[bytes]:
         return (
             self._build_coverage_attachment(data)
             + self._build_event_json_attachment()
             + [b"--%s--" % self.boundary.encode("utf-8")]
         )
 
-    def _build_data(self, traces):
-        # type: (List[List[Span]]) -> Optional[bytes]
+    def _build_data(self, traces: List[List[Span]]) -> Optional[bytes]:
         normalized_covs = [
-            self._convert_span(span, "")
+            self._convert_span(span)
             for trace in traces
             for span in trace
             if (COVERAGE_TAG_NAME in span.get_tags() or span.get_struct_tag(COVERAGE_TAG_NAME) is not None)
@@ -235,17 +306,17 @@ class CIVisibilityCoverageEncoderV02(CIVisibilityEncoderV01):
         # TODO: Split the events in several payloads as needed to avoid hitting the intake's maximum payload size.
         return msgpack_packb({"version": self.PAYLOAD_FORMAT_VERSION, "coverages": normalized_covs})
 
-    def _build_payload(self, traces):
-        # type: (List[List[Span]]) -> List[Tuple[Optional[bytes], int]]
+    def _build_payload(self, traces: List[List[Span]]) -> List[Tuple[Optional[bytes], int]]:
         data = self._build_data(traces)
         if not data:
             return []
-        return [(b"\r\n".join(self._build_body(data)), len(traces))]
+        return [(b"\r\n".join(self._build_body(data)), len(data))]
 
-    def _convert_span(self, span, dd_origin, new_parent_session_span_id=0):
-        # type: (Span, Optional[str], Optional[int]) -> Dict[str, Any]
+    def _convert_span(
+        self, span: Span, dd_origin: Optional[str] = None, new_parent_session_span_id: int = 0
+    ) -> Dict[str, Any]:
         # DEV: new_parent_session_span_id is unused here, but it is used in super class
-        files: Dict[str, Any] = {}
+        files: dict[str, Any] = {}
 
         files_struct_tag_value = span.get_struct_tag(COVERAGE_TAG_NAME)
         if files_struct_tag_value is not None and "files" in files_struct_tag_value:

ddtrace/internal/endpoints.py

@@ -0,0 +1,76 @@
+import dataclasses
+from time import monotonic
+from typing import List
+
+
+@dataclasses.dataclass(frozen=True)
+class HttpEndPoint:
+    method: str
+    path: str
+    resource_name: str = dataclasses.field(default="")
+    operation_name: str = dataclasses.field(default="http.request")
+
+    def __post_init__(self) -> None:
+        super().__setattr__("method", self.method.upper())
+        if not self.resource_name:
+            super().__setattr__("resource_name", f"{self.method} {self.path}")
+
+
+@dataclasses.dataclass()
+class HttpEndPointsCollection:
+    """A collection of HTTP endpoints that can be modified and flushed to a telemetry payload.
+
+    The collection collects HTTP endpoints at startup and can be flushed to a telemetry payload.
+    It maintains a maximum size and drops endpoints after a certain time period in case of a hot reload of the server.
+    """
+
+    endpoints: List[HttpEndPoint] = dataclasses.field(default_factory=list, init=False)
+    is_first: bool = dataclasses.field(default=True, init=False)
+    drop_time_seconds: float = dataclasses.field(default=90.0, init=False)
+    last_modification_time: float = dataclasses.field(default_factory=monotonic, init=False)
+    max_size_length: int = dataclasses.field(default=900, init=False)
+
+    def reset(self) -> None:
+        """Reset the collection to its initial state."""
+        self.endpoints.clear()
+        self.is_first = True
+        self.last_modification_time = monotonic()
+
+    def add_endpoint(
+        self, method: str, path: str, resource_name: str = "", operation_name: str = "http.request"
+    ) -> None:
+        """
+        Add an endpoint to the collection.
+        """
+        current_time = monotonic()
+        if current_time - self.last_modification_time > self.drop_time_seconds:
+            self.reset()
+            self.endpoints.append(
+                HttpEndPoint(method=method, path=path, resource_name=resource_name, operation_name=operation_name)
+            )
+        elif len(self.endpoints) < self.max_size_length:
+            self.last_modification_time = current_time
+            self.endpoints.append(
+                HttpEndPoint(method=method, path=path, resource_name=resource_name, operation_name=operation_name)
+            )
+
+    def flush(self, max_length: int) -> dict:
+        """
+        Flush the endpoints to a payload, returning the first `max` endpoints.
+        """
+        if max_length >= len(self.endpoints):
+            res = {
+                "is_first": self.is_first,
+                "endpoints": [dataclasses.asdict(ep) for ep in self.endpoints],
+            }
+            self.reset()
+            return res
+        else:
+            res = {
+                "is_first": self.is_first,
+                "endpoints": [dataclasses.asdict(ep) for ep in self.endpoints[:max_length]],
+            }
+            self.endpoints = self.endpoints[max_length:]
+            self.is_first = False
+            self.last_modification_time = monotonic()
+            return res