ddapm-test-agent 1.31.1__py3-none-any.whl → 1.33.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
 
@@ -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