ddapm-test-agent 1.31.1__py3-none-any.whl → 1.33.0__py3-none-any.whl

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/vcr_proxy.py

@@ -1,21 +1,38 @@
 import hashlib
 import json
+import logging
 import os
 import re
+from typing import Any
+from typing import Dict
 from typing import Optional
 from urllib.parse import urljoin
 
 from aiohttp.web import Request
 from aiohttp.web import Response
 import requests
+from requests_aws4auth import AWS4Auth
 import vcr
 
 
+logger = logging.getLogger(__name__)
+
+
+#  Used for AWS signature recalculation for aws services initial proxying
+AWS_REGION = os.environ.get("AWS_REGION", "us-east-1")
+AWS_SECRET_ACCESS_KEY = os.environ.get("AWS_SECRET_ACCESS_KEY")
+
+
 def url_path_join(base_url: str, path: str) -> str:
     """Join a base URL with a path, handling slashes automatically."""
     return urljoin(base_url.rstrip("/") + "/", path.lstrip("/"))
 
 
+AWS_SERVICES = {
+    "bedrock-runtime": "bedrock",
+}
+
+
 PROVIDER_BASE_URLS = {
     "openai": "https://api.openai.com/v1",
     "azure-openai": "https://dd.openai.azure.com/",
@@ -23,8 +40,25 @@ PROVIDER_BASE_URLS = {
     "anthropic": "https://api.anthropic.com/",
     "datadog": "https://api.datadoghq.com/",
     "genai": "https://generativelanguage.googleapis.com/",
+    "bedrock-runtime": f"https://bedrock-runtime.{AWS_REGION}.amazonaws.com",
 }
 
+CASSETTE_FILTER_HEADERS = [
+    "authorization",
+    "OpenAI-Organization",
+    "api-key",
+    "x-api-key",
+    "dd-api-key",
+    "dd-application-key",
+    "x-goog-api-key",
+    "x-amz-security-token",
+    "x-amz-content-sha256",
+    "x-amz-date",
+    "x-amz-user-agent",
+    "amz-sdk-invocation-id",
+    "amz-sdk-request",
+]
+
 NORMALIZERS = [
     (
         r"--form-data-boundary-[^\r\n]+",
@@ -65,6 +99,21 @@ def normalize_multipart_body(body: bytes) -> str:
             return f"[binary_data_{hex_digest}]"
 
 
+def parse_authorization_header(auth_header: str) -> Dict[str, str]:
+    """Parse AWS Authorization header to extract components"""
+    if not auth_header.startswith("AWS4-HMAC-SHA256 "):
+        return {}
+
+    auth_parts = auth_header[len("AWS4-HMAC-SHA256 ") :].split(",")
+    parsed = {}
+
+    for part in auth_parts:
+        key, value = part.split("=", 1)
+        parsed[key.strip()] = value.strip()
+
+    return parsed
+
+
 def get_vcr(subdirectory: str, vcr_cassettes_directory: str) -> vcr.VCR:
     cassette_dir = os.path.join(vcr_cassettes_directory, subdirectory)
 
@@ -72,15 +121,7 @@ def get_vcr(subdirectory: str, vcr_cassettes_directory: str) -> vcr.VCR:
         cassette_library_dir=cassette_dir,
         record_mode="once",
         match_on=["path", "method"],
-        filter_headers=[
-            "authorization",
-            "OpenAI-Organization",
-            "api-key",
-            "x-api-key",
-            "dd-api-key",
-            "dd-application-key",
-            "x-goog-api-key",
-        ],
+        filter_headers=CASSETTE_FILTER_HEADERS,
     )
 
 
@@ -125,31 +166,47 @@ async def proxy_request(request: Request, vcr_cassettes_directory: str) -> Respo
     body_bytes = await request.read()
 
     vcr_cassette_prefix = request.pop("vcr_cassette_prefix", None)
-
     cassette_name = generate_cassette_name(path, request.method, body_bytes, vcr_cassette_prefix)
+
+    request_kwargs: Dict[str, Any] = {
+        "method": request.method,
+        "url": target_url,
+        "headers": headers,
+        "data": body_bytes,
+        "cookies": dict(request.cookies),
+        "allow_redirects": False,
+        "stream": True,
+    }
+
+    if provider in AWS_SERVICES and not os.path.exists(os.path.join(vcr_cassettes_directory, provider, cassette_name)):
+        if not AWS_SECRET_ACCESS_KEY:
+            return Response(
+                body="AWS_SECRET_ACCESS_KEY environment variable not set for aws signature recalculation",
+                status=400,
+            )
+
+        auth_header = request.headers.get("Authorization", "")
+        auth_parts = parse_authorization_header(auth_header)
+        aws_access_key = auth_parts.get("Credential", "").split("/")[0]
+
+        auth = AWS4Auth(aws_access_key, AWS_SECRET_ACCESS_KEY, AWS_REGION, AWS_SERVICES[provider])
+        request_kwargs["auth"] = auth
+
     with get_vcr(provider, vcr_cassettes_directory).use_cassette(f"{cassette_name}.yaml"):
-        oai_response = requests.request(
-            method=request.method,
-            url=target_url,
-            headers=headers,
-            data=body_bytes,
-            cookies=dict(request.cookies),
-            allow_redirects=False,
-            stream=True,
-        )
+        provider_response = requests.request(**request_kwargs)
 
     # Extract content type without charset
-    content_type = oai_response.headers.get("content-type", "")
+    content_type = provider_response.headers.get("content-type", "")
     if ";" in content_type:
         content_type = content_type.split(";")[0].strip()
 
     response = Response(
-        body=oai_response.content,
-        status=oai_response.status_code,
+        body=provider_response.content,
+        status=provider_response.status_code,
         content_type=content_type,
     )
 
-    for key, value in oai_response.headers.items():
+    for key, value in provider_response.headers.items():
         if key.lower() not in (
             "content-length",
             "transfer-encoding",

{ddapm_test_agent-1.31.1.dist-info → ddapm_test_agent-1.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddapm-test-agent
-Version: 1.31.1
+Version: 1.33.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,10 @@ Requires-Dist: requests
 Requires-Dist: typing_extensions
 Requires-Dist: yarl
 Requires-Dist: vcrpy
+Requires-Dist: requests-aws4auth
+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 +73,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
@@ -186,6 +193,13 @@ The cassettes are matched based on the path, method, and body of the request. To
 
 Optionally specifying whatever mounted path is used for the cassettes directory. The test agent comes with a default set of cassettes for OpenAI, Azure OpenAI, and DeepSeek.
 
+#### AWS Services
+AWS service proxying, specifically recording cassettes for the first time, requires a `AWS_SECRET_ACCESS_KEY` environment variable to be set for the container running the test agent. This is used to recalculate the AWS signature for the request, as the one generated client-side likely used `{test-agent-host}:{test-agent-port}/vcr/{aws-service}` as the host, and the signature will mismatch that on the actual AWS service.
+
+Additionally, the `AWS_REGION` environment variable can be set, defaulting to `us-east-1`.
+
+To add a new AWS service to proxy, add an entry in the `PROVIDER_BASE_URLS` for its provider url, and an entry in the `AWS_SERVICES` dictionary for the service name, since they are not always a one-to-one mapping with the implied provider url (e.g, `https://bedrock-runtime.{AWS_REGION}.amazonaws.com` is the provider url, but the service name is `bedrock`, as `bedrock` also has multiple sub services, like `converse`).
+
 #### Usage in clients
 
 To use this feature in your client, you can use the `/vcr/{provider}` endpoint to proxy requests to the provider API.
@@ -422,6 +436,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 +554,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`.