ddapm-test-agent 1.31.0__py3-none-any.whl → 1.32.0__py3-none-any.whl

ddapm_test_agent/agent.py

@@ -1,4 +1,5 @@
 import argparse
+import asyncio
 import atexit
 import base64
 from collections import OrderedDict
@@ -12,6 +13,7 @@ import pprint
 import re
 import socket
 import sys
+from typing import Any
 from typing import Awaitable
 from typing import Callable
 from typing import DefaultDict
@@ -32,8 +34,11 @@ from aiohttp import web
 from aiohttp.web import HTTPException
 from aiohttp.web import Request
 from aiohttp.web import middleware
+from grpc import aio as grpc_aio
 from msgpack.exceptions import ExtraData as MsgPackExtraDataException
 from multidict import CIMultiDict
+from opentelemetry.proto.collector.logs.v1.logs_service_pb2_grpc import add_LogsServiceServicer_to_server
+from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2_grpc import add_MetricsServiceServicer_to_server
 
 from . import _get_version
 from . import trace_snapshot
@@ -44,10 +49,17 @@ from .checks import CheckTrace
 from .checks import Checks
 from .checks import start_trace
 from .integration import Integration
+from .logs import LOGS_ENDPOINT
+from .logs import OTLPLogsGRPCServicer
+from .logs import decode_logs_request
+from .metrics import METRICS_ENDPOINT
+from .metrics import OTLPMetricsGRPCServicer
+from .metrics import decode_metrics_request
 from .remoteconfig import RemoteConfigServer
 from .trace import Span
 from .trace import Trace
 from .trace import TraceMap
+from .trace import decode_v1 as trace_decode_v1
 from .trace import decode_v04 as trace_decode_v04
 from .trace import decode_v05 as trace_decode_v05
 from .trace import decode_v07 as trace_decode_v07
@@ -66,6 +78,12 @@ from .tracestats import v06StatsPayload
 from .vcr_proxy import proxy_request
 
 
+# Default ports
+DEFAULT_APM_PORT = 8126
+DEFAULT_OTLP_HTTP_PORT = 4318
+DEFAULT_OTLP_GRPC_PORT = 4317
+
+
 class NoSuchSessionException(Exception):
     pass
 
@@ -118,7 +136,7 @@ async def _vcr_proxy_cassette_prefix(request: Request) -> Optional[str]:
         request_body: dict[str, str] = await request.json()
         requested_test_name = request_body.get("test_name")
         return requested_test_name
-    except json.JSONDecodeError:
+    except (json.JSONDecodeError, UnicodeDecodeError):
         return None
 
 
@@ -247,6 +265,7 @@ class Agent:
             "/v0.4/traces",
             "/v0.5/traces",
             "/v0.7/traces",
+            "/v1.0/traces",
             "/v0.6/stats",
             "/v0.7/config",
             "/telemetry/proxy/api/v2/apmtelemetry",
@@ -428,6 +447,8 @@ class Agent:
             return self._decode_v05_traces(req)
         elif req.match_info.handler == self.handle_v07_traces:
             return self._decode_v07_traces(req)
+        elif req.match_info.handler == self.handle_v1_traces:
+            return self._decode_v1_traces(req)
         return []
 
     async def _traces_by_session(self, token: Optional[str]) -> List[Trace]:
@@ -486,6 +507,34 @@ class Agent:
                 stats.append(s)
         return stats
 
+    async def _logs_by_session(self, token: Optional[str]) -> List[Dict[str, Any]]:
+        """Return the logs that belong to the given session token.
+
+        If token is None or if the token was used to manually start a session
+        with /session-start then return all logs that were sent since the last
+        /session-start request was made.
+        """
+        logs: List[Dict[str, Any]] = []
+        for req in self._requests_by_session(token):
+            if req.match_info.handler == self.handle_v1_logs:
+                logs_data = self._decode_v1_logs(req)
+                logs.append(logs_data)
+        return logs
+
+    async def _metrics_by_session(self, token: Optional[str]) -> List[Dict[str, Any]]:
+        """Return the metrics that belong to the given session token.
+
+        If token is None or if the token was used to manually start a session
+        with /session-start then return all metrics that were sent since the last
+        /session-start request was made.
+        """
+        metrics: List[Dict[str, Any]] = []
+        for req in self._requests_by_session(token):
+            if req.match_info.handler == self.handle_v1_metrics:
+                metrics_data = self._decode_v1_metrics(req)
+                metrics.append(metrics_data)
+        return metrics
+
     async def _integration_requests_by_session(
         self,
         token: Optional[str],
@@ -554,10 +603,30 @@ class Agent:
         raw_data = self._request_data(request)
         return trace_decode_v07(raw_data)
 
+    def _decode_v1_traces(self, request: Request) -> v04TracePayload:
+        raw_data = self._request_data(request)
+        return trace_decode_v1(raw_data)
+
     def _decode_v06_tracestats(self, request: Request) -> v06StatsPayload:
         raw_data = self._request_data(request)
         return tracestats_decode_v06(raw_data)
 
+    def _decode_v1_logs(self, request: Request) -> Dict[str, Any]:
+        raw_data = self._request_data(request)
+        content_type = request.headers.get("Content-Type", "").lower().strip()
+        try:
+            return decode_logs_request(raw_data, content_type)
+        except Exception as e:
+            raise web.HTTPBadRequest(text=str(e))
+
+    def _decode_v1_metrics(self, request: Request) -> Dict[str, Any]:
+        raw_data = self._request_data(request)
+        content_type = request.headers.get("Content-Type", "").lower().strip()
+        try:
+            return decode_metrics_request(raw_data, content_type)
+        except Exception as e:
+            raise web.HTTPBadRequest(text=str(e))
+
     async def handle_v04_traces(self, request: Request) -> web.Response:
         return await self._handle_traces(request, version="v0.4")
 
@@ -567,6 +636,9 @@ class Agent:
     async def handle_v07_traces(self, request: Request) -> web.Response:
         return await self._handle_traces(request, version="v0.7")
 
+    async def handle_v1_traces(self, request: Request) -> web.Response:
+        return await self._handle_traces(request, version="v1")
+
     async def handle_v06_tracestats(self, request: Request) -> web.Response:
         stats = self._decode_v06_tracestats(request)
         nstats = len(stats["Stats"])
@@ -581,6 +653,36 @@ class Agent:
         log.info("received /v0.1/pipeline_stats payload")
         return web.HTTPOk()
 
+    async def handle_v1_logs(self, request: Request) -> web.Response:
+        logs_data = self._decode_v1_logs(request)
+        num_resource_logs = len(logs_data.get("resource_logs", []))
+        total_log_records = sum(
+            len(scope_log.get("log_records", []))
+            for resource_log in logs_data.get("resource_logs", [])
+            for scope_log in resource_log.get("scope_logs", [])
+        )
+        log.info(
+            "received /v1/logs payload with %r resource log(s) containing %r log record(s)",
+            num_resource_logs,
+            total_log_records,
+        )
+        return web.HTTPOk()
+
+    async def handle_v1_metrics(self, request: Request) -> web.Response:
+        metrics_data = self._decode_v1_metrics(request)
+        num_resource_metrics = len(metrics_data.get("resource_metrics", []))
+        total_metrics = sum(
+            len(scope_metric.get("metrics", []))
+            for resource_metric in metrics_data.get("resource_metrics", [])
+            for scope_metric in resource_metric.get("scope_metrics", [])
+        )
+        log.info(
+            "received /v1/metrics payload with %r resource metric(s) containing %r metric(s)",
+            num_resource_metrics,
+            total_metrics,
+        )
+        return web.HTTPOk()
+
     async def handle_v07_remoteconfig(self, request: Request) -> web.Response:
         """Emulates Remote Config endpoint: /v0.7/config"""
         token = _session_token(request)
@@ -732,7 +834,7 @@ class Agent:
             headers={"Datadog-Agent-State": "03e868b3ecdd62a91423cc4c3917d0d151fb9fa486736911ab7f5a0750c63824"},
         )
 
-    async def _handle_traces(self, request: Request, version: Literal["v0.4", "v0.5", "v0.7"]) -> web.Response:
+    async def _handle_traces(self, request: Request, version: Literal["v0.4", "v0.5", "v0.7", "v1"]) -> web.Response:
         token = request["session_token"]
         checks: Checks = request.app["checks"]
         headers = request.headers
@@ -753,6 +855,8 @@ class Agent:
                     traces = self._decode_v05_traces(request)
                 elif version == "v0.7":
                     traces = self._decode_v07_traces(request)
+                elif version == "v1":
+                    traces = self._decode_v1_traces(request)
                 log.info(
                     "received trace for token %r payload with %r trace chunks",
                     token,
@@ -941,6 +1045,16 @@ class Agent:
         stats = await self._tracestats_by_session(token)
         return web.json_response(stats)
 
+    async def handle_session_logs(self, request: Request) -> web.Response:
+        token = request["session_token"]
+        logs = await self._logs_by_session(token)
+        return web.json_response(logs)
+
+    async def handle_session_metrics(self, request: Request) -> web.Response:
+        token = request["session_token"]
+        metrics = await self._metrics_by_session(token)
+        return web.json_response(metrics)
+
     async def handle_session_requests(self, request: Request) -> web.Response:
         token = request["session_token"]
         resp = []
@@ -957,6 +1071,8 @@ class Agent:
                 self.handle_v1_tracer_flare,
                 self.handle_evp_proxy_v2_api_v2_llmobs,
                 self.handle_evp_proxy_v2_llmobs_eval_metric,
+                self.handle_v1_logs,
+                self.handle_v1_metrics,
             ):
                 continue
             resp.append(
@@ -1174,6 +1290,59 @@ class Agent:
         return response
 
 
+def make_otlp_http_app(agent: Agent) -> web.Application:
+    """Create a separate HTTP application for OTLP endpoints using the shared agent instance."""
+
+    @middleware
+    async def otlp_store_request_middleware(request: Request, handler: _Handler) -> web.Response:
+        # Always store requests for OTLP endpoints
+        await agent._store_request(request)
+        return await handler(request)
+
+    app = web.Application(
+        middlewares=[
+            otlp_store_request_middleware,  # type: ignore
+            session_token_middleware,  # type: ignore
+        ],
+    )
+
+    # Add only OTLP HTTP endpoints
+    app.add_routes(
+        [
+            web.post(LOGS_ENDPOINT, agent.handle_v1_logs),
+            web.post(METRICS_ENDPOINT, agent.handle_v1_metrics),
+            web.get("/test/session/requests", agent.handle_session_requests),
+            web.get("/test/session/logs", agent.handle_session_logs),
+            web.get("/test/session/metrics", agent.handle_session_metrics),
+            web.get("/test/session/clear", agent.handle_session_clear),
+            web.get("/test/session/start", agent.handle_session_start),
+        ]
+    )
+
+    return app
+
+
+async def make_otlp_grpc_server_async(agent: Agent, http_port: int, grpc_port: int) -> Any:
+    """Create and start a separate GRPC server for OTLP endpoints that forwards to HTTP server."""
+    # Define the servicer class only when GRPC is available
+    server = grpc_aio.server()
+
+    # Add the OTLP logs servicer
+    logs_servicer = OTLPLogsGRPCServicer(http_port)
+    add_LogsServiceServicer_to_server(logs_servicer, server)
+
+    # Add the OTLP metrics servicer
+    metrics_servicer = OTLPMetricsGRPCServicer(http_port)
+    add_MetricsServiceServicer_to_server(metrics_servicer, server)
+
+    # Setup and start the server
+    listen_addr = f"[::]:{grpc_port}"
+    server.add_insecure_port(listen_addr)
+    await server.start()
+
+    return server
+
+
 def make_app(
     enabled_checks: List[str],
     log_span_fmt: str,
@@ -1209,6 +1378,8 @@ def make_app(
             web.put("/v0.5/traces", agent.handle_v05_traces),
             web.post("/v0.7/traces", agent.handle_v07_traces),
             web.put("/v0.7/traces", agent.handle_v07_traces),
+            web.post("/v1.0/traces", agent.handle_v1_traces),
+            web.put("/v1.0/traces", agent.handle_v1_traces),
             web.post("/v0.6/stats", agent.handle_v06_tracestats),
             web.post("/v0.1/pipeline_stats", agent.handle_v01_pipelinestats),
             web.put("/v0.6/stats", agent.handle_v06_tracestats),
@@ -1262,6 +1433,7 @@ def make_app(
         ],
         enabled=enabled_checks,
     )
+    app["agent"] = agent
     app["checks"] = checks
     app["snapshot_dir"] = snapshot_dir
     app["snapshot_ci_mode"] = snapshot_ci_mode
@@ -1293,6 +1465,18 @@ def main(args: Optional[List[str]] = None) -> None:
         help="Print version info and exit.",
     )
     parser.add_argument("-p", "--port", type=int, default=int(os.environ.get("PORT", 8126)))
+    parser.add_argument(
+        "--otlp-http-port",
+        type=int,
+        default=int(os.environ.get("OTLP_HTTP_PORT", 4318)),
+        help="Port to listen for OTLP HTTP requests (default: 4318)",
+    )
+    parser.add_argument(
+        "--otlp-grpc-port",
+        type=int,
+        default=int(os.environ.get("OTLP_GRPC_PORT", 4317)),
+        help="Port to listen for OTLP GRPC requests (default: 4317)",
+    )
     parser.add_argument(
         "--snapshot-dir",
         type=str,
@@ -1444,7 +1628,60 @@ def main(args: Optional[List[str]] = None) -> None:
         vcr_cassettes_directory=parsed_args.vcr_cassettes_directory,
     )
 
-    web.run_app(app, sock=apm_sock, port=parsed_args.port)
+    # Validate port configuration
+    if parsed_args.port == parsed_args.otlp_http_port:
+        raise ValueError("APM and OTLP HTTP ports cannot be the same")
+    if parsed_args.port == parsed_args.otlp_grpc_port:
+        raise ValueError("APM and OTLP GRPC ports cannot be the same")
+    if parsed_args.otlp_http_port == parsed_args.otlp_grpc_port:
+        raise ValueError("OTLP HTTP and GRPC ports cannot be the same")
+
+    # Get the shared agent instance from the main app
+    agent = app["agent"]
+    otlp_http_app = make_otlp_http_app(agent)
+
+    async def run_servers():
+        """Run APM and OTLP HTTP servers concurrently."""
+        # Create runners for both apps
+        apm_runner = web.AppRunner(app)
+        await apm_runner.setup()
+
+        otlp_http_runner = web.AppRunner(otlp_http_app)
+        await otlp_http_runner.setup()
+
+        # Start GRPC server if available (async creation)
+        otlp_grpc_server = await make_otlp_grpc_server_async(
+            agent, parsed_args.otlp_http_port, parsed_args.otlp_grpc_port
+        )
+
+        # Create sites for both apps
+        if apm_sock:
+            apm_site = web.SockSite(apm_runner, apm_sock)
+        else:
+            apm_site = web.TCPSite(apm_runner, port=parsed_args.port)
+
+        otlp_http_site = web.TCPSite(otlp_http_runner, port=parsed_args.otlp_http_port)
+
+        # Start both servers concurrently
+        await asyncio.gather(apm_site.start(), otlp_http_site.start())
+
+        print(f"======== Running APM server on port {parsed_args.port} ========")
+        print(f"======== Running OTLP HTTP server on port {parsed_args.otlp_http_port} ========")
+        print(f"======== Running OTLP GRPC server on port {parsed_args.otlp_grpc_port} ========")
+        print("(Press CTRL+C to quit)")
+
+        try:
+            # Keep the servers running
+            await asyncio.Event().wait()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            await apm_runner.cleanup()
+            await otlp_http_runner.cleanup()
+            await otlp_grpc_server.stop(grace=5.0)
+
+    # Run the servers
+    asyncio.run(run_servers())
 
 
 if __name__ == "__main__":

ddapm_test_agent/client.py

@@ -9,7 +9,7 @@ import requests
 from ddapm_test_agent.trace import Trace
 
 
-class TestAgentClient:
+class TestClient:
     __test__ = False
 
     def __init__(self, base_url: str):
@@ -19,6 +19,28 @@ class TestAgentClient:
     def _url(self, path: str) -> str:
         return urllib.parse.urljoin(self._base_url, path)
 
+    def requests(self, **kwargs: Any) -> List[Any]:
+        resp = self._session.get(self._url("/test/session/requests"), **kwargs)
+        json = resp.json()
+        return cast(List[Any], json)
+
+    def clear(self, **kwargs: Any) -> None:
+        self._session.get(self._url("/test/session/clear"), **kwargs)
+
+    def wait_to_start(self, num_tries: int = 50, delay: float = 0.1) -> None:
+        exc = []
+        for i in range(num_tries):
+            try:
+                self.requests()
+            except requests.exceptions.RequestException as e:
+                exc.append(e)
+                time.sleep(delay)
+            else:
+                return
+        raise AssertionError(f"Test agent did not start in time ({num_tries * delay} seconds). Got {exc[-1]}")
+
+
+class TestAgentClient(TestClient):
     def traces(self, clear: bool = False, **kwargs: Any) -> List[Trace]:
         resp = self._session.get(self._url("/test/session/traces"), **kwargs)
         if clear:
@@ -26,11 +48,6 @@ class TestAgentClient:
         json = resp.json()
         return cast(List[Trace], json)
 
-    def requests(self, **kwargs: Any) -> List[Any]:
-        resp = self._session.get(self._url("/test/session/requests"), **kwargs)
-        json = resp.json()
-        return cast(List[Any], json)
-
     def raw_telemetry(self, clear: bool = False) -> List[Any]:
         raw_reqs = self.requests()
         reqs = []
@@ -47,9 +64,6 @@ class TestAgentClient:
             self.clear()
         return cast(List[Any], resp.json())
 
-    def clear(self, **kwargs: Any) -> None:
-        self._session.get(self._url("/test/session/clear"), **kwargs)
-
     def info(self, **kwargs):
         resp = self._session.get(self._url("/info"), **kwargs)
         json = resp.json()
@@ -126,14 +140,43 @@ class TestAgentClient:
             time.sleep(0.01)
         raise AssertionError("Telemetry event %r not found" % event_name)
 
-    def wait_to_start(self, num_tries: int = 50, delay: float = 0.1) -> None:
-        exc = []
-        for i in range(num_tries):
-            try:
-                self.info()
-            except requests.exceptions.RequestException as e:
-                exc.append(e)
-                time.sleep(delay)
-            else:
-                return
-        raise AssertionError(f"Test agent did not start in time ({num_tries * delay} seconds). Got {exc[-1]}")
+
+class TestOTLPClient(TestClient):
+    def __init__(self, host: str = "127.0.0.1", http_port: int = 4318, scheme: str = "http"):
+        # OTLP grpc server will forward all requests to the http server
+        # so we can use the same client to receive logs for both http and grpc endpoints
+        super().__init__(f"{scheme}://{host}:{http_port}")
+
+    def logs(self, clear: bool = False, **kwargs: Any) -> List[Any]:
+        resp = self._session.get(self._url("/test/session/logs"), **kwargs)
+        if clear:
+            self.clear()
+        return cast(List[Any], resp.json())
+
+    def wait_for_num_logs(self, num: int, clear: bool = False, wait_loops: int = 30) -> List[Any]:
+        """Wait for `num` logs to be received from the test agent."""
+        for _ in range(wait_loops):
+            logs = self.logs(clear=False)
+            if len(logs) == num:
+                if clear:
+                    self.clear()
+                return logs
+            time.sleep(0.1)
+        raise ValueError("Number (%r) of logs not available from test agent, got %r" % (num, len(logs)))
+
+    def metrics(self, clear: bool = False, **kwargs: Any) -> List[Any]:
+        resp = self._session.get(self._url("/test/session/metrics"), **kwargs)
+        if clear:
+            self.clear()
+        return cast(List[Any], resp.json())
+
+    def wait_for_num_metrics(self, num: int, clear: bool = False, wait_loops: int = 30) -> List[Any]:
+        """Wait for `num` metrics to be received from the test agent."""
+        for _ in range(wait_loops):
+            metrics = self.metrics(clear=False)
+            if len(metrics) == num:
+                if clear:
+                    self.clear()
+                return metrics
+            time.sleep(0.1)
+        raise ValueError("Number (%r) of metrics not available from test agent, got %r" % (num, len(metrics)))

ddapm_test_agent/logs.py

@@ -0,0 +1,67 @@
+"""OTLP Logs handling for the test agent."""
+
+import json
+import logging
+from typing import Any
+from typing import Dict
+
+from aiohttp import ClientSession
+from google.protobuf.json_format import MessageToDict
+from grpc import aio as grpc_aio
+from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceRequest
+from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceResponse
+from opentelemetry.proto.collector.logs.v1.logs_service_pb2_grpc import LogsServiceServicer
+
+
+LOGS_ENDPOINT = "/v1/logs"
+
+
+log = logging.getLogger(__name__)
+
+
+def decode_logs_request(request_body: bytes, content_type: str) -> Dict[str, Any]:
+    if content_type == "application/json":
+        parsed_json = json.loads(request_body)
+        if not isinstance(parsed_json, dict):
+            raise Exception("JSON payload must be an object")
+        return parsed_json
+    elif content_type == "application/x-protobuf":
+        export_request = ExportLogsServiceRequest()
+        export_request.ParseFromString(request_body)
+        return protobuf_to_dict(export_request)
+    else:
+        raise ValueError(f"Content-Type must be application/x-protobuf or application/json, got {content_type}")
+
+
+def protobuf_to_dict(pb_obj: Any) -> Dict[str, Any]:
+    return MessageToDict(pb_obj, preserving_proto_field_name=True)
+
+
+class OTLPLogsGRPCServicer(LogsServiceServicer):
+
+    def __init__(self, http_port: int):
+        self.http_url = f"http://127.0.0.1:{http_port}"
+
+    async def Export(
+        self, request: ExportLogsServiceRequest, context: grpc_aio.ServicerContext
+    ) -> ExportLogsServiceResponse:
+        try:
+            protobuf_data = request.SerializeToString()
+            headers = {"Content-Type": "application/x-protobuf"}
+            metadata = dict(context.invocation_metadata())
+            if "session-token" in metadata:
+                headers["Session-Token"] = metadata["session-token"]
+            async with ClientSession(self.http_url) as session:
+                async with session.post(LOGS_ENDPOINT, headers=headers, data=protobuf_data) as resp:
+                    context.set_trailing_metadata([("http-status", str(resp.status))])
+                    response = ExportLogsServiceResponse()
+                    if resp.status >= 400:
+                        response.partial_success.rejected_log_records = len(request.resource_logs)
+                        response.partial_success.error_message = f"HTTP {resp.status}: {await resp.text()}"
+                    return response
+        except Exception as e:
+            context.set_trailing_metadata([("http-status", "500"), ("error", str(e))])
+            response = ExportLogsServiceResponse()
+            response.partial_success.rejected_log_records = len(request.resource_logs)
+            response.partial_success.error_message = f"Forward failed: {str(e)}"
+            return response

ddapm_test_agent/metrics.py

@@ -0,0 +1,94 @@
+"""OTLP Metrics handling for the test agent."""
+
+import json
+import logging
+from typing import Any
+from typing import Dict
+
+from aiohttp import ClientSession
+from google.protobuf.json_format import MessageToDict
+from grpc import aio as grpc_aio
+from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import ExportMetricsServiceRequest
+from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import ExportMetricsServiceResponse
+from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2_grpc import MetricsServiceServicer
+
+
+METRICS_ENDPOINT = "/v1/metrics"
+
+
+log = logging.getLogger(__name__)
+
+
+def decode_metrics_request(request_body: bytes, content_type: str) -> Dict[str, Any]:
+    if content_type == "application/json":
+        parsed_json = json.loads(request_body)
+        if not isinstance(parsed_json, dict):
+            raise Exception("JSON payload must be an object")
+        return parsed_json
+    elif content_type == "application/x-protobuf":
+        export_request = ExportMetricsServiceRequest()
+        export_request.ParseFromString(request_body)
+        return protobuf_to_dict(export_request)
+    else:
+        raise ValueError(f"Content-Type must be application/x-protobuf or application/json, got {content_type}")
+
+
+def protobuf_to_dict(pb_obj: Any) -> Dict[str, Any]:
+    return MessageToDict(pb_obj, preserving_proto_field_name=True)
+
+
+class OTLPMetricsGRPCServicer(MetricsServiceServicer):
+
+    def __init__(self, http_port: int):
+        self.http_url = f"http://127.0.0.1:{http_port}"
+
+    def _count_data_points(self, request: ExportMetricsServiceRequest) -> int:
+        return len(
+            [
+                dp
+                for rm in request.resource_metrics
+                for sm in rm.scope_metrics
+                for m in sm.metrics
+                for dp in (
+                    m.gauge.data_points
+                    if m.HasField("gauge")
+                    else (
+                        m.sum.data_points
+                        if m.HasField("sum")
+                        else (
+                            m.histogram.data_points
+                            if m.HasField("histogram")
+                            else (
+                                m.exponential_histogram.data_points
+                                if m.HasField("exponential_histogram")
+                                else m.summary.data_points if m.HasField("summary") else []
+                            )
+                        )
+                    )
+                )
+            ]
+        )
+
+    async def Export(
+        self, request: ExportMetricsServiceRequest, context: grpc_aio.ServicerContext
+    ) -> ExportMetricsServiceResponse:
+        try:
+            protobuf_data = request.SerializeToString()
+            headers = {"Content-Type": "application/x-protobuf"}
+            metadata = dict(context.invocation_metadata())
+            if "session-token" in metadata:
+                headers["Session-Token"] = metadata["session-token"]
+            async with ClientSession(self.http_url) as session:
+                async with session.post(METRICS_ENDPOINT, headers=headers, data=protobuf_data) as resp:
+                    context.set_trailing_metadata([("http-status", str(resp.status))])
+                    response = ExportMetricsServiceResponse()
+                    if resp.status >= 400:
+                        response.partial_success.rejected_data_points = self._count_data_points(request)
+                        response.partial_success.error_message = f"HTTP {resp.status}: {await resp.text()}"
+                    return response
+        except Exception as e:
+            context.set_trailing_metadata([("http-status", "500"), ("error", str(e))])
+            response = ExportMetricsServiceResponse()
+            response.partial_success.rejected_data_points = self._count_data_points(request)
+            response.partial_success.error_message = f"Forward failed: {str(e)}"
+            return response

ddapm_test_agent/trace.py

@@ -1,5 +1,6 @@
 """Tracing specific functions and types"""
 
+from enum import IntEnum
 import json
 from typing import Any
 from typing import Callable
@@ -114,6 +115,59 @@ v04TracePayload = List[List[Span]]
 TraceMap = OrderedDict[int, Trace]
 
 
+class V1ChunkKeys(IntEnum):
+    PRIORITY = 1
+    ORIGIN = 2
+    ATTRIBUTES = 3
+    SPANS = 4
+    DROPPED_TRACE = 5
+    TRACE_ID = 6
+    SAMPLING_MECHANISM = 7
+
+
+class V1SpanKeys(IntEnum):
+    SERVICE = 1
+    NAME = 2
+    RESOURCE = 3
+    SPAN_ID = 4
+    PARENT_ID = 5
+    START = 6
+    DURATION = 7
+    ERROR = 8
+    ATTRIBUTES = 9
+    TYPE = 10
+    SPAN_LINKS = 11
+    SPAN_EVENTS = 12
+    ENV = 13
+    VERSION = 14
+    COMPONENT = 15
+    SPAN_KIND = 16
+
+
+class V1SpanLinkKeys(IntEnum):
+    TRACE_ID = 1
+    SPAN_ID = 2
+    ATTRIBUTES = 3
+    TRACE_STATE = 4
+    FLAGS = 5
+
+
+class V1SpanEventKeys(IntEnum):
+    TIME = 1
+    NAME = 2
+    ATTRIBUTES = 3
+
+
+class V1AnyValueKeys(IntEnum):
+    STRING = 1
+    BOOL = 2
+    DOUBLE = 3
+    INT = 4
+    BYTES = 5
+    ARRAY = 6
+    KEY_VALUE_LIST = 7
+
+
 # TODO:ban add extra tags to add to the span
 # TODO:ban warn about dropping metastruct
 def verify_span(d: Any) -> Span:
@@ -702,6 +756,351 @@ def decode_v07(data: bytes) -> v04TracePayload:
     return _verify_v07_payload(payload)
 
 
+def decode_v1(data: bytes) -> v04TracePayload:
+    """Decode a v1 trace payload.
+    The v1 format is similar to the v07 format but in an optimized format and with a few changes:
+    - Strings are deduplicated and sent in a "Streaming" format where strings are referred to by their index in a string table
+    - Trace IDs are sent as 128 bit integers in a bytes array
+    - 'meta' and 'metrics' are now sent as typed 'attributes', more similar to how OTLP traces are sent
+    """
+    payload = msgpack.unpackb(data, strict_map_key=False)
+    return _convert_v1_payload(payload)
+
+
+def _get_and_add_string(string_table: List[str], value: Union[int, str]) -> str:
+    if isinstance(value, str):
+        string_table.append(value)
+        return value
+    elif isinstance(value, int):
+        if value >= len(string_table) or value < 0:
+            raise ValueError(f"Value {value} is out of range for string table of length {len(string_table)}")
+        return string_table[value]
+
+
+def _convert_v1_payload(data: Any) -> v04TracePayload:
+    if not isinstance(data, dict):
+        raise TypeError("Trace payload must be a map, got type %r." % type(data))
+
+    string_table: List[str] = [""]  # 0 is reserved for empty string
+
+    v04Payload: List[List[Span]] = []
+
+    for k, v in data.items():
+        if k == 1:
+            raise TypeError("Message pack representation of v1 trace payload must stream strings")
+        elif k > 1 and k < 10:  # All keys from 2-9 are strings, for now we can just build the string table
+            # TODO: In the future we can assert on these keys
+            if isinstance(v, str):
+                string_table.append(v)
+        elif k == 11:
+            if not isinstance(v, list):
+                raise TypeError("Trace payload 'chunks' (11) must be a list.")
+            for chunk in v:
+                v04Payload.append(_convert_v1_chunk(chunk, string_table))
+        else:
+            raise TypeError("Unknown key %r in v1 trace payload" % k)
+    return cast(v04TracePayload, v04Payload)
+
+
+def _convert_v1_chunk(chunk: Any, string_table: List[str]) -> List[Span]:
+    if not isinstance(chunk, dict):
+        raise TypeError("Chunk must be a map.")
+
+    priority, origin, sampling_mechanism = "", "", None
+    trace_id, trace_id_high = 0, 0
+    meta: Dict[str, str] = {}
+    metrics: Dict[str, MetricType] = {}
+    spans: List[Span] = []
+    for k, v in chunk.items():
+        if k == V1ChunkKeys.PRIORITY:
+            priority = v
+        elif k == V1ChunkKeys.ORIGIN:
+            origin = _get_and_add_string(string_table, v)
+        elif k == V1ChunkKeys.ATTRIBUTES:
+            if not isinstance(v, list):
+                raise TypeError("Chunk Attributes must be a list, got type %r." % type(v))
+            _convert_v1_attributes(v, meta, metrics, string_table)
+        elif k == V1ChunkKeys.SPANS:
+            if not isinstance(v, list):
+                raise TypeError("Chunk 'spans'(4) must be a list.")
+            for span in v:
+                converted_span = _convert_v1_span(span, string_table)
+                spans.append(converted_span)
+        elif k == V1ChunkKeys.DROPPED_TRACE:
+            raise TypeError("Tracers must not set the droppedTrace(5) flag.")
+        elif k == V1ChunkKeys.TRACE_ID:
+            if len(v) != 16:
+                raise TypeError("Trace ID must be 16 bytes, got %r." % len(v))
+            # trace_id is a 128 bit integer in a bytes array, so we need to get the last 64 bits
+            trace_id = int.from_bytes(v[8:], "big")
+            trace_id_high = int.from_bytes(v[:8], "big")
+        elif k == V1ChunkKeys.SAMPLING_MECHANISM:
+            sampling_mechanism = v
+        else:
+            raise TypeError("Unknown key %r in v1 trace chunk" % k)
+
+    for span in spans:
+        if "metrics" not in span:
+            span["metrics"] = {}
+        if "meta" not in span:
+            span["meta"] = {}
+        span["trace_id"] = trace_id
+        span["meta"]["_dd.p.tid"] = hex(trace_id_high)
+        if sampling_mechanism is not None:
+            span["meta"]["_dd.p.dm"] = "-" + str(sampling_mechanism)
+        if origin != "":
+            span["meta"]["_dd.origin"] = origin
+        if priority != "":
+            span["metrics"]["_sampling_priority_v1"] = priority
+        for k, v in meta.items():
+            span["meta"][k] = v
+        for k, v in metrics.items():
+            span["metrics"][k] = v
+    return spans
+
+
+def _convert_v1_span(span: Any, string_table: List[str]) -> Span:
+    if not isinstance(span, dict):
+        raise TypeError("Span must be a map.")
+
+    # Create a regular dict first, then cast to TypedDict
+    v4Span: Dict[str, Any] = {}
+    env, version, component, spanKind = "", "", "", ""
+
+    for k, v in span.items():
+        if k == V1SpanKeys.SERVICE:
+            v4Span["service"] = _get_and_add_string(string_table, v)
+        elif k == V1SpanKeys.NAME:
+            v4Span["name"] = _get_and_add_string(string_table, v)
+        elif k == V1SpanKeys.RESOURCE:
+            v4Span["resource"] = _get_and_add_string(string_table, v)
+        elif k == V1SpanKeys.SPAN_ID:
+            v4Span["span_id"] = v
+        elif k == V1SpanKeys.PARENT_ID:
+            v4Span["parent_id"] = v
+        elif k == V1SpanKeys.START:
+            v4Span["start"] = v
+        elif k == V1SpanKeys.DURATION:
+            v4Span["duration"] = v
+        elif k == V1SpanKeys.ERROR:
+            if not isinstance(v, bool):
+                raise TypeError("Error must be a boolean, got type %r." % type(v))
+            v4Span["error"] = 1 if v else 0
+        elif k == V1SpanKeys.ATTRIBUTES:
+            if not isinstance(v, list):
+                raise TypeError("Attributes must be a list, got type %r." % type(v))
+            meta: Dict[str, str] = {}
+            metrics: Dict[str, MetricType] = {}
+            _convert_v1_attributes(v, meta, metrics, string_table)
+            v4Span["meta"] = meta
+            v4Span["metrics"] = metrics
+        elif k == V1SpanKeys.TYPE:
+            v4Span["type"] = _get_and_add_string(string_table, v)
+        elif k == V1SpanKeys.SPAN_LINKS:
+            if not isinstance(v, list):
+                raise TypeError("Span links must be a list, got type %r." % type(v))
+            links: List[SpanLink] = []
+            for raw_link in v:
+                link = _convert_v1_span_link(raw_link, string_table)
+                links.append(link)
+            v4Span["span_links"] = links
+        elif k == V1SpanKeys.SPAN_EVENTS:
+            if not isinstance(v, list):
+                raise TypeError("Span events must be a list, got type %r." % type(v))
+            events: List[SpanEvent] = []
+            for raw_event in v:
+                event = _convert_v1_span_event(raw_event, string_table)
+                events.append(event)
+            v4Span["span_events"] = events
+        elif k == V1SpanKeys.ENV:
+            env = _get_and_add_string(string_table, v)
+        elif k == V1SpanKeys.VERSION:
+            version = _get_and_add_string(string_table, v)
+        elif k == V1SpanKeys.COMPONENT:
+            component = _get_and_add_string(string_table, v)
+        elif k == V1SpanKeys.SPAN_KIND:
+            if not isinstance(v, int):
+                raise TypeError("Span kind must be an integer, got type %r." % type(v))
+            if v == 1:
+                spanKind = "internal"
+            elif v == 2:
+                spanKind = "server"
+            elif v == 3:
+                spanKind = "client"
+            elif v == 4:
+                spanKind = "producer"
+            elif v == 5:
+                spanKind = "consumer"
+            else:
+                raise TypeError("Unknown span kind %r." % v)
+
+    if "meta" not in v4Span or v4Span["meta"] is None:
+        v4Span["meta"] = {}
+    if env != "":
+        v4Span["meta"]["env"] = env
+    if version != "":
+        v4Span["meta"]["version"] = version
+    if component != "":
+        v4Span["meta"]["component"] = component
+    if spanKind != "":
+        v4Span["meta"]["span.kind"] = spanKind
+
+    # Cast to TypedDict
+    return v4Span  # type: ignore
+
+
+def _convert_v1_span_event(event: Any, string_table: List[str]) -> SpanEvent:
+    if not isinstance(event, dict):
+        raise TypeError("Span event must be a map, got type %r." % type(event))
+
+    # Create a regular dict first, then cast to TypedDict
+    v4Event: Dict[str, Any] = {}
+
+    for k, v in event.items():
+        if k == V1SpanEventKeys.TIME:
+            v4Event["time_unix_nano"] = v
+        elif k == V1SpanEventKeys.NAME:
+            v4Event["name"] = _get_and_add_string(string_table, v)
+        elif k == V1SpanEventKeys.ATTRIBUTES:
+            v4Event["attributes"] = _convert_v1_span_event_attributes(v, string_table)
+        else:
+            raise TypeError("Unknown key %r in v1 span event" % k)
+
+    # Cast to TypedDict
+    return v4Event  # type: ignore
+
+
+def _convert_v1_span_link(link: Any, string_table: List[str]) -> SpanLink:
+    if not isinstance(link, dict):
+        raise TypeError("Span link must be a map, got type %r." % type(link))
+
+    # Create a regular dict first, then cast to TypedDict
+    v4Link: Dict[str, Any] = {}
+
+    for k, v in link.items():
+        if k == V1SpanLinkKeys.TRACE_ID:
+            if len(v) != 16:
+                raise TypeError("Trace ID must be 16 bytes, got %r." % len(v))
+            # trace_id is a 128 bit integer in a bytes array, so we need to get the last 64 bits
+            v4Link["trace_id"] = int.from_bytes(v[8:], "big")
+            v4Link["trace_id_high"] = int.from_bytes(v[:8], "big")
+        elif k == V1SpanLinkKeys.SPAN_ID:
+            v4Link["span_id"] = v
+        elif k == V1SpanLinkKeys.ATTRIBUTES:
+            v4Link["attributes"] = _convert_v1_span_link_attributes(v, string_table)
+        elif k == V1SpanLinkKeys.TRACE_STATE:
+            v4Link["tracestate"] = _get_and_add_string(string_table, v)
+        elif k == V1SpanLinkKeys.FLAGS:
+            v4Link["flags"] = v
+        else:
+            raise TypeError("Unknown key %r in v1 span link" % k)
+
+    # Cast to TypedDict
+    return v4Link  # type: ignore
+
+
+def _convert_v1_span_link_attributes(attr: Any, string_table: List[str]) -> Dict[str, str]:
+    """
+    Convert a v1 span link attributes to a v4 span link attributes. Unfortunately we need multiple implementations that
+    convert "attributes" as the v0.4 representation of attributes is different between span links and span events.
+    """
+    if not isinstance(attr, list):
+        raise TypeError("Attribute must be a list, got type %r." % type(attr))
+    if len(attr) % 3 != 0:
+        raise TypeError("Attribute list must have a multiple of 3 elements, got %r." % len(attr))
+    v4_attributes: Dict[str, str] = {}
+    for i in range(0, len(attr), 3):
+        key = _get_and_add_string(string_table, attr[i])
+        value_type = attr[i + 1]
+        value = attr[i + 2]
+        if value_type == V1AnyValueKeys.STRING:
+            v4_attributes[key] = _get_and_add_string(string_table, value)
+        elif value_type == V1AnyValueKeys.BOOL:
+            v4_attributes[key] = "true" if value else "false"
+        elif value_type == V1AnyValueKeys.DOUBLE:
+            v4_attributes[key] = str(value)
+        elif value_type == V1AnyValueKeys.INT:
+            v4_attributes[key] = str(value)
+        elif value_type == V1AnyValueKeys.BYTES:
+            raise NotImplementedError("Bytes values are not supported yet.")
+        elif value_type == V1AnyValueKeys.ARRAY:
+            raise NotImplementedError("Array of values are not supported yet.")
+        elif value_type == V1AnyValueKeys.KEY_VALUE_LIST:
+            raise NotImplementedError("Key value list values are not supported yet.")
+        else:
+            raise TypeError("Unknown attribute value type %r." % value_type)
+    return v4_attributes
+
+
+def _convert_v1_span_event_attributes(attr: Any, string_table: List[str]) -> Dict[str, Dict[str, Any]]:
+    """
+    Convert a v1 span event attributes to a v4 span event attributes. Unfortunately we need multiple implementations that
+    convert "attributes" as the v0.4 representation of attributes is different between span links and span events.
+    """
+    if not isinstance(attr, list):
+        raise TypeError("Attribute must be a list, got type %r." % type(attr))
+    if len(attr) % 3 != 0:
+        raise TypeError("Attribute list must have a multiple of 3 elements, got %r." % len(attr))
+    attributes: Dict[str, Dict[str, Any]] = {}
+    for i in range(0, len(attr), 3):
+        v4_attr_value: Dict[str, Any] = {}
+        key = _get_and_add_string(string_table, attr[i])
+        value_type = attr[i + 1]
+        value = attr[i + 2]
+        if value_type == V1AnyValueKeys.STRING:
+            v4_attr_value["type"] = 0
+            v4_attr_value["string_value"] = _get_and_add_string(string_table, value)
+        elif value_type == V1AnyValueKeys.BOOL:
+            v4_attr_value["type"] = 1
+            v4_attr_value["bool_value"] = value
+        elif value_type == V1AnyValueKeys.DOUBLE:
+            v4_attr_value["type"] = 3
+            v4_attr_value["double_value"] = value
+        elif value_type == V1AnyValueKeys.INT:
+            v4_attr_value["type"] = 2  # Yes the constants are different here
+            v4_attr_value["int_value"] = value
+        elif value_type == V1AnyValueKeys.BYTES:
+            raise NotImplementedError("Bytes values are not supported yet.")
+        elif value_type == V1AnyValueKeys.ARRAY:
+            raise NotImplementedError("Array of strings values are not supported yet.")
+        elif value_type == V1AnyValueKeys.KEY_VALUE_LIST:
+            raise NotImplementedError("Key value list values are not supported yet.")
+        else:
+            raise TypeError("Unknown attribute value type %r." % value_type)
+        attributes[key] = v4_attr_value
+    return attributes
+
+
+def _convert_v1_attributes(
+    attr: Any, meta: Dict[str, str], metrics: Dict[str, MetricType], string_table: List[str]
+) -> None:
+    if not isinstance(attr, list):
+        raise TypeError("Attribute must be a list, got type %r." % type(attr))
+    if len(attr) % 3 != 0:
+        raise TypeError("Attribute list must have a multiple of 3 elements, got %r." % len(attr))
+    for i in range(0, len(attr), 3):
+        key = _get_and_add_string(string_table, attr[i])
+        value_type = attr[i + 1]
+        value = attr[i + 2]
+        if value_type == V1AnyValueKeys.STRING:
+            meta[key] = _get_and_add_string(string_table, value)
+        elif value_type == V1AnyValueKeys.BOOL:
+            # Treat v1 boolean attributes as metrics with a value of 1 or 0
+            metrics[key] = 1 if value else 0
+        elif value_type == V1AnyValueKeys.DOUBLE:
+            metrics[key] = value
+        elif value_type == V1AnyValueKeys.INT:
+            metrics[key] = value
+        elif value_type == V1AnyValueKeys.BYTES:
+            raise NotImplementedError("Bytes values are not supported yet.")
+        elif value_type == V1AnyValueKeys.ARRAY:
+            raise NotImplementedError("Array of strings values are not supported yet.")
+        elif value_type == V1AnyValueKeys.KEY_VALUE_LIST:
+            raise NotImplementedError("Key value list values are not supported yet.")
+        else:
+            raise TypeError("Unknown attribute value type %r." % value_type)
+
+
 def _verify_v07_payload(data: Any) -> v04TracePayload:
     if not isinstance(data, dict):
         raise TypeError("Trace payload must be a map, got type %r." % type(data))

{ddapm_test_agent-1.31.0.dist-info → ddapm_test_agent-1.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddapm-test-agent
-Version: 1.31.0
+Version: 1.32.0
 Summary: Test agent for Datadog APM client libraries
 Home-page: https://github.com/Datadog/dd-apm-test-agent
 Author: Kyle Verhoog
@@ -24,6 +24,9 @@ Requires-Dist: requests
 Requires-Dist: typing_extensions
 Requires-Dist: yarl
 Requires-Dist: vcrpy
+Requires-Dist: opentelemetry-proto<1.37.0,>1.33.0
+Requires-Dist: protobuf>=3.19.0
+Requires-Dist: grpcio<2.0,>=1.66.2
 Provides-Extra: testing
 Requires-Dist: ddtrace==3.11.0; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
@@ -69,13 +72,16 @@ The test agent can be installed from PyPI:
 
     pip install ddapm-test-agent
 
-    ddapm-test-agent --port=8126
+    # HTTP on port 8126, OTLP HTTP on port 4318, OTLP GRPC on port 4317
+    ddapm-test-agent --port=8126 --otlp-http-port=4318 --otlp-grpc-port=4317
 
 or from Docker:
 
     # Run the test agent and mount the snapshot directory
     docker run --rm\
             -p 8126:8126\
+            -p 4318:4318\
+            -p 4317:4317\
             -e SNAPSHOT_CI=0\
             -v $PWD/tests/snapshots:/snapshots\
             ghcr.io/datadog/dd-apm-test-agent/ddapm-test-agent:latest
@@ -422,6 +428,24 @@ Return stats that have been received by the agent for the given session token.
 
 Stats are returned as a JSON list of the stats payloads received.
 
+### /test/session/logs
+
+Return OpenTelemetry logs that have been received by the agent for the given session token.
+
+#### [optional] `?test_session_token=`
+#### [optional] `X-Datadog-Test-Session-Token`
+
+Logs are returned as a JSON list of the OTLP logs payloads received. The logs are in the standard OpenTelemetry Protocol (OTLP) v1.7.0 format, decoded from protobuf into JSON.
+
+### /test/session/metrics
+
+Return OpenTelemetry metrics that have been received by the agent for the given session token.
+
+#### [optional] `?test_session_token=`
+#### [optional] `X-Datadog-Test-Session-Token`
+
+Metrics are returned as a JSON list of the OTLP metrics payloads received. The metrics are in the standard OpenTelemetry Protocol (OTLP) v1.7.0 format, decoded from protobuf into JSON.
+
 ### /test/session/responses/config (POST)
 Create a Remote Config payload to retrieve in endpoint `/v0.7/config`
 
@@ -522,6 +546,35 @@ curl -X GET 'http://0.0.0.0:8126/test/integrations/tested_versions'
 
 Mimics the pipeline_stats endpoint of the agent, but always returns OK, and logs a line everytime it's called.
 
+### /v1/logs (HTTP)
+
+Accepts OpenTelemetry Protocol (OTLP) v1.7.0 logs in protobuf format via HTTP. This endpoint validates and decodes OTLP logs payloads for testing OpenTelemetry logs exporters and libraries.
+
+The HTTP endpoint accepts `POST` requests with `Content-Type: application/x-protobuf` and `Content-Type: application/json` and stores the decoded logs for retrieval via the `/test/session/logs` endpoint.
+
+### /v1/metrics (HTTP)
+
+Accepts OpenTelemetry Protocol (OTLP) v1.7.0 metrics in protobuf format via HTTP. This endpoint validates and decodes OTLP metrics payloads for testing OpenTelemetry metrics exporters and libraries.
+
+The HTTP endpoint accepts `POST` requests with `Content-Type: application/x-protobuf` and `Content-Type: application/json` and stores the decoded metrics for retrieval via the `/test/session/metrics` endpoint.
+
+### OTLP Logs and Metrics via GRPC
+
+OTLP logs and metrics can also be sent via GRPC using the OpenTelemetry `LogsService.Export` and `MetricsService.Export` methods respectively. The GRPC server implements the standard OTLP service interfaces and forwards all requests to the HTTP server, ensuring consistent processing and session management.
+
+**Note:** OTLP endpoints are served on separate ports from the main APM endpoints (default: 8126):
+- **HTTP**: Port 4318 (default) - Use `--otlp-http-port` to configure
+- **GRPC**: Port 4317 (default) - Use `--otlp-grpc-port` to configure
+
+Both protocols store decoded data for retrieval via the `/test/session/logs` and `/test/session/metrics` HTTP endpoints respectively.
+
+GRPC Client → GRPC Server → HTTP POST → HTTP Server → Agent Storage
+                    ↓                                      ↓
+            (forwards protobuf)                    (session management)
+                    ↓                                      ↓
+                   HTTP                              Retrievable via
+                Response                     /test/session/{logs,metrics}
+
 ### /tracer_flare/v1
 
 Mimics the tracer_flare endpoint of the agent. Returns OK if the flare contains the required form fields, otherwise `400`.

{ddapm_test_agent-1.31.0.dist-info → ddapm_test_agent-1.32.0.dist-info}/RECORD

@@ -1,24 +1,26 @@
 ddapm_test_agent/__init__.py,sha256=hJBQduemued6MAWH6Uk2gqJx2vb0_dd0UO52pJ83nLM,138
-ddapm_test_agent/agent.py,sha256=jg0ZykOgz_JIWf0ypUNGvOPFjof0qyCKpwHNUf0mZDI,64387
+ddapm_test_agent/agent.py,sha256=S5VzW5yvBQKqsGj50Xqb_u8gXvRnZguwWTZXn6BcX-M,73960
 ddapm_test_agent/apmtelemetry.py,sha256=w_9-yUDh1dgox-FfLqeOHU2C14GcjOjen-_SVagiZrc,861
 ddapm_test_agent/checks.py,sha256=pBa4YKZQVA8qaTVJ_XgMA6TmlUZNh99YOrCFJA7fwo0,6865
-ddapm_test_agent/client.py,sha256=BbXuukX9UJuuA7T2NKnrkGneeaHZykgY8LiM4q0w_sk,5476
+ddapm_test_agent/client.py,sha256=ViEmiRX9Y3SQ-KBhSc-FdzBmIVIe8Ij9jj-Q6VGyzLY,7359
 ddapm_test_agent/cmd.py,sha256=UL8dVGBN4j77Nyx9EJrwE9LLmoPNgru81h9f1qrZLyc,2451
 ddapm_test_agent/context.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ddapm_test_agent/fmt.py,sha256=BarFfTI8bd_2gFBrRc40lKgJiUP3T7VMp4NQUeJ9ZRY,3675
 ddapm_test_agent/integration.py,sha256=DbrPb6UvyIDSHcmKe6ZJVaieNeUXalb15yd0smvhgAA,265
+ddapm_test_agent/logs.py,sha256=NDM-FPL52oCL1tL75XJ0xbBLIxyZkS99iZkQ-weOQns,2901
+ddapm_test_agent/metrics.py,sha256=EZo7lSec2oAiH7tUqavKZ2MJM7TwbuFGE3AT3cXwmSM,3988
 ddapm_test_agent/remoteconfig.py,sha256=_QjYUKc3JF31DxdvISDXgslm5WVnYWAw0hyckWuLc1c,3606
-ddapm_test_agent/trace.py,sha256=FFHPu3gLHGqoT-hx0yzn5n_d4EF9I_8STvbPpyeQ1WA,29733
+ddapm_test_agent/trace.py,sha256=t0OR8w3NcZK-EOOoadgPITiZqS5tAJGtxqLVGLEw7Kg,45816
 ddapm_test_agent/trace_checks.py,sha256=bRg2eLKoHROXIFJRbujMUn0T3x1X8pZso-j8wXNomec,9972
 ddapm_test_agent/trace_snapshot.py,sha256=g2MhKi8UE-Wsf6PtuzPoXymcW-cYRUnvj63SP9FETJs,22354
 ddapm_test_agent/tracerflare.py,sha256=uoSjhPCOKZflgJn5JLv1Unh4gUdAR1-YbC9_1n1iH9w,954
 ddapm_test_agent/tracestats.py,sha256=q_WQZnh2kXSSN3fRIBe_0jMYCBQHcaS3fZmJTge4lWc,2073
 ddapm_test_agent/tracestats_snapshot.py,sha256=VsB6MVnHPjPWHVWnnDdCXJcVKL_izKXEf9lvJ0qbjNQ,3609
 ddapm_test_agent/vcr_proxy.py,sha256=g6ix7laiS8Hqq9p14nkTMARhj5KMZmyRZjZpfFEMxOM,4973
-ddapm_test_agent-1.31.0.dist-info/licenses/LICENSE.BSD3,sha256=J9S_Tq-hhvteDV2W8R0rqht5DZHkmvgdx3gnLZg4j6Q,1493
-ddapm_test_agent-1.31.0.dist-info/licenses/LICENSE.apache2,sha256=5V2RruBHZQIcPyceiv51DjjvdvhgsgS4pnXAOHDuZkQ,11342
-ddapm_test_agent-1.31.0.dist-info/METADATA,sha256=lUdrQ0yGV6hobEBnRaKBg86NCobb6ZcIB-FYuFicBRU,24437
-ddapm_test_agent-1.31.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ddapm_test_agent-1.31.0.dist-info/entry_points.txt,sha256=ulayVs6YJ-0Ej2kxbwn39wOHDVXbyQgFgsbRQmXydcs,250
-ddapm_test_agent-1.31.0.dist-info/top_level.txt,sha256=A9jiKOrrg6VjFAk-mtlSVYN4wr0VsZe58ehGR6IW47U,17
-ddapm_test_agent-1.31.0.dist-info/RECORD,,
+ddapm_test_agent-1.32.0.dist-info/licenses/LICENSE.BSD3,sha256=J9S_Tq-hhvteDV2W8R0rqht5DZHkmvgdx3gnLZg4j6Q,1493
+ddapm_test_agent-1.32.0.dist-info/licenses/LICENSE.apache2,sha256=5V2RruBHZQIcPyceiv51DjjvdvhgsgS4pnXAOHDuZkQ,11342
+ddapm_test_agent-1.32.0.dist-info/METADATA,sha256=mf922XgdhlbHNJk3P5jCiw5HBkmzfwpex-FDvqjHXa4,27493
+ddapm_test_agent-1.32.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ddapm_test_agent-1.32.0.dist-info/entry_points.txt,sha256=ulayVs6YJ-0Ej2kxbwn39wOHDVXbyQgFgsbRQmXydcs,250
+ddapm_test_agent-1.32.0.dist-info/top_level.txt,sha256=A9jiKOrrg6VjFAk-mtlSVYN4wr0VsZe58ehGR6IW47U,17
+ddapm_test_agent-1.32.0.dist-info/RECORD,,