ddapm-test-agent 1.31.0__tar.gz → 1.32.0__tar.gz

{ddapm_test_agent-1.31.0 → ddapm_test_agent-1.32.0}/PKG-INFO

@@ -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 → ddapm_test_agent-1.32.0}/README.md

@@ -26,13 +26,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
@@ -379,6 +382,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`
 
@@ -479,6 +500,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 → ddapm_test_agent-1.32.0}/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-1.31.0 → ddapm_test_agent-1.32.0}/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)))