ddapm-test-agent 1.33.1__py3-none-any.whl → 1.35.0__py3-none-any.whl

ddapm_test_agent/agent.py

@@ -9,10 +9,12 @@ from dataclasses import field
 import json
 import logging
 import os
+import platform
 import pprint
 import re
 import socket
 import sys
+import threading
 from typing import Any
 from typing import Awaitable
 from typing import Callable
@@ -240,6 +242,59 @@ def default_value_trace_results_summary():
     }
 
 
+class MockQuery:
+    """Mock query object that behaves like a dict."""
+
+    def __init__(self):
+        self._data = {}  # Empty query params for named pipe processing
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __contains__(self, key):
+        return key in self._data
+
+
+class MockURL:
+    """Mock URL object for named pipe processing."""
+
+    def __init__(self, path: str):
+        self.path = path
+        self.query = MockQuery()
+
+
+class MockRequest:
+    """Mock Request object for named pipe processing."""
+
+    def __init__(
+        self, method: str, path: str, headers: Dict[str, str], body: bytes, agent: "Agent", app: web.Application
+    ):
+        self.method = method
+        self.path = path
+        self.headers = headers
+        self._body = body
+        self._data: Dict[str, Any] = {}
+        self.url = MockURL(path)
+        self.content_type = headers.get("Content-Type", "application/msgpack")
+        self.app = app
+
+    async def read(self) -> bytes:
+        """Mock read() method that returns the body data."""
+        return self._body
+
+    def __getitem__(self, key):
+        return self._data.get(key)
+
+    def __setitem__(self, key, value):
+        self._data[key] = value
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+
 @dataclass
 class _AgentSession:
     """Maintain Agent state across requests."""
@@ -831,7 +886,6 @@ class Agent:
                 "peer_tags": ["db.name", "mongodb.db", "messaging.system"],
                 "span_events": True,  # Advertise support for the top-level Span field for Span Events
             },
-            headers={"Datadog-Agent-State": "03e868b3ecdd62a91423cc4c3917d0d151fb9fa486736911ab7f5a0750c63824"},
         )
 
     async def _handle_traces(self, request: Request, version: Literal["v0.4", "v0.5", "v0.7", "v1"]) -> web.Response:
@@ -1288,6 +1342,174 @@ class Agent:
                 raise web.HTTPBadRequest(body=msg)
         return response
 
+    def _parse_http_request(self, data: bytes) -> tuple[str, str, Dict[str, str], bytes]:
+        """Parse HTTP request from raw bytes.
+
+        Returns:
+            tuple: (method, path, headers_dict, body)
+        """
+        try:
+            # Split request into headers and body
+            if b"\r\n\r\n" in data:
+                header_data, body = data.split(b"\r\n\r\n", 1)
+            else:
+                header_data, body = data, b""
+
+            # Parse headers
+            header_lines = header_data.decode("utf-8", errors="ignore").split("\r\n")
+            if not header_lines:
+                raise ValueError("No request line found")
+
+            # Parse request line (e.g., "POST /v0.4/traces HTTP/1.1")
+            request_line = header_lines[0]
+            parts = request_line.split(" ")
+            if len(parts) < 2:
+                raise ValueError(f"Invalid request line: {request_line}")
+
+            method = parts[0]
+            path = parts[1]
+
+            # Parse headers
+            headers: Dict[str, str] = {}
+            for line in header_lines[1:]:
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    headers[key.strip()] = value.strip()
+
+            return method, path, headers, body
+
+        except Exception as e:
+            log.error(f"Error parsing HTTP request: {e}")
+            raise ValueError(f"Failed to parse HTTP request: {e}") from e
+
+    def _process_named_pipe_request(self, data: bytes, app: web.Application) -> bytes:
+        """Process a request using the existing Agent infrastructure."""
+        try:
+            # Parse the HTTP request
+            method, path, headers, body = self._parse_http_request(data)
+
+            log.info(f"Processing Named Pipe request: {method} {path}")
+
+            # Create a mock Request object
+            mock_request = MockRequest(method, path, headers, body, self, app)
+
+            # Extract session token like the middleware does
+            token = None
+            if "X-Datadog-Test-Session-Token" in headers:
+                token = headers["X-Datadog-Test-Session-Token"]
+            mock_request["session_token"] = token
+
+            # Store request data for agent processing
+            mock_request["_testagent_data"] = body
+
+            # Route to appropriate handler based on path using dictionary lookup
+            path_handlers = {
+                "/v0.4/traces": self.handle_v04_traces,
+                "/v0.5/traces": self.handle_v05_traces,
+                "/v0.7/traces": self.handle_v07_traces,
+                "/v1.0/traces": self.handle_v1_traces,
+                "/v0.6/stats": self.handle_v06_tracestats,
+                "/v0.1/pipeline_stats": self.handle_v01_pipelinestats,
+                "/v0.7/config": self.handle_v07_remoteconfig,
+                "/telemetry/proxy/api/v2/apmtelemetry": self.handle_v2_apmtelemetry,
+                "/profiling/v1/input": self.handle_v1_profiling,
+                "/tracer_flare/v1": self.handle_v1_tracer_flare,
+                "/evp_proxy/v2/api/v2/llmobs": self.handle_evp_proxy_v2_api_v2_llmobs,
+                "/evp_proxy/v2/api/intake/llm-obs/v1/eval-metric": self.handle_evp_proxy_v2_llmobs_eval_metric,
+                "/evp_proxy/v2/api/intake/llm-obs/v2/eval-metric": self.handle_evp_proxy_v2_llmobs_eval_metric,
+                "/info": self.handle_info,
+                # Test endpoints
+                "/test/session/start": self.handle_session_start,
+                "/test/session/clear": self.handle_session_clear,
+                "/test/session/snapshot": self.handle_snapshot,
+                "/test/session/traces": self.handle_session_traces,
+                "/test/session/apmtelemetry": self.handle_session_apmtelemetry,
+                "/test/session/tracerflares": self.handle_session_tracerflares,
+                "/test/session/stats": self.handle_session_tracestats,
+                "/test/session/requests": self.handle_session_requests,
+                "/test/session/responses/config": self.handle_v07_remoteconfig_create,
+                "/test/session/responses/config/path": self.handle_v07_remoteconfig_path_create,
+                "/test/traces": self.handle_test_traces,
+                "/test/apmtelemetry": self.handle_test_apmtelemetry,
+                "/test/trace/analyze": self.handle_trace_analyze,
+                "/test/trace_check/failures": self.get_trace_check_failures,
+                "/test/trace_check/clear": self.clear_trace_check_failures,
+                "/test/trace_check/summary": self.get_trace_check_summary,
+                "/test/integrations/tested_versions": self.handle_get_tested_integrations,
+                "/test/settings": self.handle_settings,
+            }
+
+            # Get handler from dictionary lookup
+            handler = path_handlers.get(path)
+            if not handler:
+                return self._create_error_response(404, "Not Found")
+
+            try:
+                # Create a new event loop for this thread if one doesn't exist
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+
+            # Initialize the CheckTrace context like middleware does
+            start_trace("named_pipe_request %s %s" % (method, path))
+
+            # Run the handler
+            response = loop.run_until_complete(handler(mock_request))  # type: ignore[arg-type]
+
+            # Convert aiohttp response to HTTP bytes
+            return self._convert_response_to_http(response)
+
+        except Exception as e:
+            log.error(f"Error processing Named Pipe request: {e}", exc_info=True)
+            return self._create_error_response(500, "Internal Server Error")
+
+    def _convert_response_to_http(self, response: web.Response) -> bytes:
+        """Convert aiohttp Response to HTTP response bytes."""
+        try:
+            # Build HTTP response
+            status_line = f"HTTP/1.1 {response.status} {response.reason}\r\n"
+
+            # Build headers
+            headers_lines = []
+            for key, value in response.headers.items():
+                headers_lines.append(f"{key}: {value}\r\n")
+
+            # Get response body
+            body_data: bytes
+            if hasattr(response, "body") and response.body:
+                if isinstance(response.body, bytes):
+                    body_data = response.body
+                elif isinstance(response.body, str):
+                    body_data = response.body.encode()
+                else:
+                    # Handle Payload or other types by converting to string first
+                    body_data = str(response.body).encode()
+            else:
+                body_data = b""
+
+            # Add Content-Length header if not present
+            if "Content-Length" not in response.headers:
+                headers_lines.append(f"Content-Length: {len(body_data)}\r\n")
+
+            # Combine all parts
+            headers_str = "".join(headers_lines)
+            http_response = status_line + headers_str + "\r\n"
+            return http_response.encode("utf-8") + body_data
+
+        except Exception as e:
+            log.error(f"Error converting response to HTTP: {e}")
+            return self._create_error_response(500, "Internal Server Error")
+
+    def _create_error_response(self, status_code: int, reason: str) -> bytes:
+        """Create an HTTP error response."""
+        body = f"{status_code} {reason}".encode("utf-8")
+        response = f"HTTP/1.1 {status_code} {reason}\r\n"
+        response += f"Content-Length: {len(body)}\r\n"
+        response += "Content-Type: text/plain\r\n"
+        response += "\r\n"
+        return response.encode("utf-8") + body
+
 
 def make_otlp_http_app(agent: Agent) -> web.Application:
     """Create a separate HTTP application for OTLP endpoints using the shared agent instance."""
@@ -1356,6 +1578,9 @@ def make_app(
     snapshot_removed_attrs: List[str],
     snapshot_regex_placeholders: Dict[str, str],
     vcr_cassettes_directory: str,
+    vcr_ci_mode: bool,
+    vcr_provider_map: str,
+    vcr_ignore_headers: str,
 ) -> web.Application:
     agent = Agent()
     app = web.Application(
@@ -1417,7 +1642,9 @@ def make_app(
             web.route(
                 "*",
                 "/vcr/{path:.*}",
-                lambda request: proxy_request(request, vcr_cassettes_directory),
+                lambda request: proxy_request(
+                    request, vcr_cassettes_directory, vcr_ci_mode, vcr_provider_map, vcr_ignore_headers
+                ),
             ),
         ]
     )
@@ -1449,6 +1676,137 @@ def make_app(
     return app
 
 
+def _start_named_pipe_server(pipe_path: str, agent: "Agent", app: web.Application) -> None:
+    """Start Windows named pipe server."""
+    if platform.system() != "Windows":
+        log.warning("Named pipes are only supported on Windows, ignoring --trace-named-pipe")
+        return
+
+    # Import Windows-specific modules here to avoid import errors on other platforms
+    try:
+        import win32file
+        import win32pipe
+    except ImportError as e:
+        log.error(f"Failed to import Windows modules for named pipes: {e}")
+        return
+
+    _start_windows_named_pipe_server(pipe_path, agent, app, win32pipe, win32file)
+
+
+def _create_and_wait_for_client(
+    pipe_path: str, agent: "Agent", app: web.Application, win32pipe: Any, win32file: Any
+) -> None:
+    """Create a single pipe instance and wait for a client connection."""
+    while True:
+        try:
+            # Create named pipe instance
+            pipe_handle = win32pipe.CreateNamedPipe(
+                pipe_path,
+                win32pipe.PIPE_ACCESS_DUPLEX,
+                win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT,
+                win32pipe.PIPE_UNLIMITED_INSTANCES,  # allow multiple concurrent connections
+                65536,  # output buffer size
+                65536,  # input buffer size
+                0,  # default timeout
+                None,  # security attributes
+            )
+
+            if pipe_handle == win32file.INVALID_HANDLE_VALUE:
+                log.error("Failed to create named pipe instance")
+                import time
+
+                time.sleep(1)  # Wait before retrying
+                continue
+
+            log.debug("Named pipe instance created, waiting for client...")
+
+            # Wait for client connection
+            win32pipe.ConnectNamedPipe(pipe_handle, None)
+            log.info("Client connected to named pipe instance")
+
+            # Handle the client request
+            _handle_windows_named_pipe_client(pipe_handle, agent, app, win32pipe, win32file)
+
+        except Exception as e:
+            log.error(f"Error in named pipe instance: {e}")
+            import time
+
+            time.sleep(1)  # Wait before retrying
+
+
+def _start_windows_named_pipe_server(
+    pipe_path: str, agent: "Agent", app: web.Application, win32pipe: Any, win32file: Any
+) -> None:
+    """Start a Windows named pipe server with multiple instances."""
+    if win32pipe is None:
+        log.error("Windows named pipe support not available (pywin32 not installed)")
+        return
+
+    log.info(f"Starting Windows named pipe server on: {pipe_path}")
+
+    # Create multiple pipe instances for better concurrency
+    num_instances = 10  # Support up to 10 concurrent connections
+    threads = []
+
+    for _ in range(num_instances):
+        thread = threading.Thread(
+            target=_create_and_wait_for_client, args=(pipe_path, agent, app, win32pipe, win32file), daemon=True
+        )
+        thread.start()
+        threads.append(thread)
+
+    log.info(f"Started {num_instances} named pipe instances")
+
+    # Keep the main thread alive and monitor instance threads
+    try:
+        while True:
+            import time
+
+            time.sleep(5)
+
+            # Check if any threads have died and restart them
+            for i, thread in enumerate(threads):
+                if not thread.is_alive():
+                    log.warning(f"Restarting named pipe instance {i}")
+                    new_thread = threading.Thread(
+                        target=_create_and_wait_for_client,
+                        args=(pipe_path, agent, app, win32pipe, win32file),
+                        daemon=True,
+                    )
+                    new_thread.start()
+                    threads[i] = new_thread
+
+    except KeyboardInterrupt:
+        log.info("Named pipe server shutting down")
+
+
+def _handle_windows_named_pipe_client(
+    pipe_handle: Any, agent: "Agent", app: web.Application, win32pipe: Any, win32file: Any
+) -> None:
+    """Handle a Windows named pipe client connection."""
+    try:
+        # Read request data
+        result, data = win32file.ReadFile(pipe_handle, 65536)
+        if result == 0:  # SUCCESS
+            log.info(f"Received {len(data)} bytes from named pipe client")
+
+            # Process request
+            response = agent._process_named_pipe_request(data, app)
+
+            # Write response
+            win32file.WriteFile(pipe_handle, response)
+            log.info(f"Sent {len(response)} bytes response to named pipe client")
+
+    except Exception as e:
+        log.error(f"Error handling Windows named pipe client: {e}")
+    finally:
+        try:
+            win32pipe.DisconnectNamedPipe(pipe_handle)
+            win32file.CloseHandle(pipe_handle)
+        except Exception:
+            pass
+
+
 def main(args: Optional[List[str]] = None) -> None:
     if args is None:
         args = sys.argv[1:]
@@ -1550,6 +1908,12 @@ def main(args: Optional[List[str]] = None) -> None:
         default=os.environ.get("DD_APM_RECEIVER_SOCKET", None),
         help=("Will listen for traces on the specified socket path"),
     )
+    parser.add_argument(
+        "--trace-named-pipe",
+        type=str,
+        default=os.environ.get("DD_APM_RECEIVER_NAMED_PIPE", None),
+        help=("Will listen for traces on the specified named pipe path"),
+    )
     parser.add_argument(
         "--trace-request-delay",
         type=float,
@@ -1582,6 +1946,24 @@ def main(args: Optional[List[str]] = None) -> None:
         default=os.environ.get("VCR_CASSETTES_DIRECTORY", os.path.join(os.getcwd(), "vcr-cassettes")),
         help="Directory to read and store third party API cassettes.",
     )
+    parser.add_argument(
+        "--vcr-ci-mode",
+        type=bool,
+        default=os.environ.get("VCR_CI_MODE", False),
+        help="Will change the test agent to record VCR cassettes in CI mode, throwing an error if a cassette is not found on /vcr/{provider}",
+    )
+    parser.add_argument(
+        "--vcr-provider-map",
+        type=str,
+        default=os.environ.get("VCR_PROVIDER_MAP", ""),
+        help="Comma-separated list of provider=base_url tuples to map providers to paths. Used in addition to the default provider paths.",
+    )
+    parser.add_argument(
+        "--vcr-ignore-headers",
+        type=str,
+        default=os.environ.get("VCR_IGNORE_HEADERS", ""),
+        help="Comma-separated list of headers to ignore when recording VCR cassettes.",
+    )
     parsed_args = parser.parse_args(args=args)
     logging.basicConfig(level=parsed_args.log_level)
 
@@ -1625,6 +2007,9 @@ def main(args: Optional[List[str]] = None) -> None:
         snapshot_removed_attrs=parsed_args.snapshot_removed_attrs,
         snapshot_regex_placeholders=parsed_args.snapshot_regex_placeholders,
         vcr_cassettes_directory=parsed_args.vcr_cassettes_directory,
+        vcr_ci_mode=parsed_args.vcr_ci_mode,
+        vcr_provider_map=parsed_args.vcr_provider_map,
+        vcr_ignore_headers=parsed_args.vcr_ignore_headers,
     )
 
     # Validate port configuration
@@ -1637,6 +2022,18 @@ def main(args: Optional[List[str]] = None) -> None:
 
     # Get the shared agent instance from the main app
     agent = app["agent"]
+
+    # Named pipe setup (after agent is available)
+    named_pipe_thread = None
+    if parsed_args.trace_named_pipe is not None:
+
+        def start_named_pipe_server():
+            _start_named_pipe_server(parsed_args.trace_named_pipe, agent, app)
+
+        named_pipe_thread = threading.Thread(target=start_named_pipe_server, daemon=True)
+        named_pipe_thread.start()
+        log.info(f"Started named pipe server on: {parsed_args.trace_named_pipe}")
+
     otlp_http_app = make_otlp_http_app(agent)
 
     async def run_servers():

ddapm_test_agent/trace_snapshot.py

@@ -34,6 +34,27 @@ log = logging.getLogger(__name__)
 DEFAULT_SNAPSHOT_IGNORES = "span_id,trace_id,parent_id,duration,start,metrics.system.pid,metrics.system.process_id,metrics.process_id,metrics._dd.tracer_kr,meta.runtime-id,span_links.trace_id_high,span_events.time_unix_nano,meta.pathway.hash,meta._dd.p.tid"
 
 
+def _normalize_span_for_comparison(span: Span) -> Span:
+    """Normalize span for cross-platform comparison (Windows vs Unix).
+
+    Handles differences in how ddtrace creates spans on different platforms:
+    - Windows may omit fields with default values (error, type)
+    - Windows may use None instead of empty string for service
+    """
+    normalized = dict(span)
+
+    if "error" not in normalized:
+        normalized["error"] = 0
+
+    if "type" not in normalized:
+        normalized["type"] = ""
+
+    if normalized.get("service") is None:
+        normalized["service"] = ""
+
+    return cast(Span, normalized)
+
+
 def _key_match(d1: Dict[str, Any], d2: Dict[str, Any], key: str) -> bool:
     """
     >>> _key_match({"a": 1}, {"a": 2}, "a")
@@ -347,6 +368,10 @@ def _compare_traces(expected: Trace, received: Trace, ignored: Set[str]) -> None
         )
 
     for s_exp, s_rec in zip(expected, received):
+        # Normalize spans for cross-platform comparison (Windows vs Unix)
+        s_exp_norm = _normalize_span_for_comparison(s_exp)
+        s_rec_norm = _normalize_span_for_comparison(s_rec)
+
         with CheckTrace.add_frame(
             f"snapshot compare of span '{s_exp['name']}' at position {s_exp['span_id']} in trace"
         ) as frame:
@@ -358,12 +383,12 @@ def _compare_traces(expected: Trace, received: Trace, ignored: Set[str]) -> None
                 metrics_diffs,
                 span_link_diffs,
                 span_event_diffs,
-            ) = _diff_spans(s_exp, s_rec, ignored)
+            ) = _diff_spans(s_exp_norm, s_rec_norm, ignored)
 
             for diffs, diff_type, d_exp, d_rec in [
-                (top_level_diffs, "span", s_exp, s_rec),
-                (meta_diffs, "meta", s_exp["meta"], s_rec["meta"]),
-                (metrics_diffs, "metrics", s_exp["metrics"], s_rec["metrics"]),
+                (top_level_diffs, "span", s_exp_norm, s_rec_norm),
+                (meta_diffs, "meta", s_exp_norm["meta"], s_rec_norm["meta"]),
+                (metrics_diffs, "metrics", s_exp_norm["metrics"], s_rec_norm["metrics"]),
             ]:
                 for diff_key in diffs:
                     if diff_key not in d_exp:

ddapm_test_agent/vcr_proxy.py

@@ -1,3 +1,4 @@
+import asyncio
 import hashlib
 import json
 import logging
@@ -75,6 +76,16 @@ def _file_safe_string(s: str) -> str:
     return "".join(c if c.isalnum() or c in ".-" else "_" for c in s)
 
 
+def get_custom_vcr_providers(vcr_provider_map: str) -> Dict[str, str]:
+    return dict(
+        [
+            vcr_provider_map.strip().split("=", 1)
+            for vcr_provider_map in vcr_provider_map.split(",")
+            if vcr_provider_map.strip()
+        ]
+    )
+
+
 def normalize_multipart_body(body: bytes) -> str:
     if not body:
         return ""
@@ -114,14 +125,15 @@ def parse_authorization_header(auth_header: str) -> Dict[str, str]:
     return parsed
 
 
-def get_vcr(subdirectory: str, vcr_cassettes_directory: str) -> vcr.VCR:
+def get_vcr(subdirectory: str, vcr_cassettes_directory: str, vcr_ignore_headers: str) -> vcr.VCR:
     cassette_dir = os.path.join(vcr_cassettes_directory, subdirectory)
+    extra_ignore_headers = vcr_ignore_headers.split(",")
 
     return vcr.VCR(
         cassette_library_dir=cassette_dir,
         record_mode="once",
         match_on=["path", "method"],
-        filter_headers=CASSETTE_FILTER_HEADERS,
+        filter_headers=CASSETTE_FILTER_HEADERS + extra_ignore_headers,
     )
 
 
@@ -146,7 +158,12 @@ def generate_cassette_name(path: str, method: str, body: bytes, vcr_cassette_pre
     )
 
 
-async def proxy_request(request: Request, vcr_cassettes_directory: str) -> Response:
+async def proxy_request(
+    request: Request, vcr_cassettes_directory: str, vcr_ci_mode: bool, vcr_provider_map: str, vcr_ignore_headers: str
+) -> Response:
+    provider_base_urls = PROVIDER_BASE_URLS.copy()
+    provider_base_urls.update(get_custom_vcr_providers(vcr_provider_map))
+
     path = request.match_info["path"]
     if request.query_string:
         path = path + "?" + request.query_string
@@ -156,18 +173,25 @@ async def proxy_request(request: Request, vcr_cassettes_directory: str) -> Respo
         return Response(body="Invalid path format. Expected /{provider}/...", status=400)
 
     provider, remaining_path = parts
-    if provider not in PROVIDER_BASE_URLS:
+    if provider not in provider_base_urls:
         return Response(body=f"Unsupported provider: {provider}", status=400)
 
-    target_url = url_path_join(PROVIDER_BASE_URLS[provider], remaining_path)
-
-    headers = {key: value for key, value in request.headers.items() if key != "Host"}
-
     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)
     cassette_file_name = f"{cassette_name}.yaml"
+    cassette_file_path = os.path.join(vcr_cassettes_directory, provider, cassette_file_name)
+    cassette_exists = os.path.exists(cassette_file_path)
+
+    if vcr_ci_mode and not cassette_exists:
+        return Response(
+            body=f"Cassette {cassette_file_name} not found while running in CI mode. Please generate the cassette locally and commit it.",
+            status=500,
+        )
+
+    target_url = url_path_join(provider_base_urls[provider], remaining_path)
+    headers = {key: value for key, value in request.headers.items() if key != "Host"}
 
     request_kwargs: Dict[str, Any] = {
         "method": request.method,
@@ -179,9 +203,7 @@ async def proxy_request(request: Request, vcr_cassettes_directory: str) -> Respo
         "stream": True,
     }
 
-    if provider in AWS_SERVICES and not os.path.exists(
-        os.path.join(vcr_cassettes_directory, provider, cassette_file_name)
-    ):
+    if provider in AWS_SERVICES and not cassette_exists:
         if not AWS_SECRET_ACCESS_KEY:
             return Response(
                 body="AWS_SECRET_ACCESS_KEY environment variable not set for aws signature recalculation",
@@ -195,8 +217,11 @@ async def proxy_request(request: Request, vcr_cassettes_directory: str) -> Respo
         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(cassette_file_name):
-        provider_response = requests.request(**request_kwargs)
+    def _make_request():
+        with get_vcr(provider, vcr_cassettes_directory, vcr_ignore_headers).use_cassette(cassette_file_name):
+            return requests.request(**request_kwargs)
+
+    provider_response = await asyncio.to_thread(_make_request)
 
     # Extract content type without charset
     content_type = provider_response.headers.get("content-type", "")

{ddapm_test_agent-1.33.1.dist-info → ddapm_test_agent-1.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddapm-test-agent
-Version: 1.33.1
+Version: 1.35.0
 Summary: Test agent for Datadog APM client libraries
 Home-page: https://github.com/Datadog/dd-apm-test-agent
 Author: Kyle Verhoog
@@ -25,10 +25,12 @@ 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
+Requires-Dist: pywin32; sys_platform == "win32"
 Provides-Extra: testing
 Requires-Dist: ddtrace==3.11.0; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: riot==0.20.1; extra == "testing"
+Requires-Dist: PyYAML==6.0.3; extra == "testing"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -183,7 +185,33 @@ The cassettes are matched based on the path, method, and body of the request. To
             -v $PWD/vcr-cassettes:/vcr-cassettes
             ghcr.io/datadog/dd-apm-test-agent/ddapm-test-agent:latest
 
-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.
+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, DeepSeek, Anthropic, Google GenAI, and AWS Bedrock Runtime.
+
+#### Custom 3rd Party Providers
+
+The test agent can be configured to also register custom 3rd party providers. This is done by setting the `VCR_PROVIDER_MAP` environment variable or the `--vcr-provider-map` command-line option to a comma-separated list of provider names and their corresponding base URLs.
+
+```shell
+VCR_PROVIDER_MAP="provider1=http://provider1.com/,provider2=http://provider2.com/"
+```
+
+or
+
+```shell
+--vcr-provider-map="provider1=http://provider1.com/,provider2=http://provider2.com/"
+```
+
+The provider names are used to match the provider name in the request path, and the base URLs are used to proxy the request to the corresponding provider API endpoint.
+
+With this configuration set, you can make the following request to the test agent without error:
+
+```shell
+curl -X POST 'http://127.0.0.1:9126/vcr/provider1/some/path'
+```
+
+#### Ignoring Headers in Recorded Cassettes
+
+To ignore headers in recorded cassettes, you can use the `--vcr-ignore-headers` flag or `VCR_IGNORE_HEADERS` environment variable. The list should take the form of `header1,header2,header3`, and will be omitted from the recorded cassettes.
 
 #### 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.
@@ -240,6 +268,10 @@ And pass in a valid API key (if needed) in the way that provider expects.
 
 To redact api keys, modify the `filter_headers` list in the `get_vcr` function in `ddapm_test_agent/vcr_proxy.py`. This can be confirmed by viewing cassettes in the `vcr-cassettes` directory (or the otherwise specified directory), and verifying that any new cassettes do not contain the api key.
 
+#### Running in CI
+
+To have the vcr proxy throw a 404 error if a cassette is not found in CI mode to ensure that all cassettes are generated locally and committed, set the `VCR_CI_MODE` environment variable or the `--vcr-ci-mode` flag in the cli tool to `true` (this value defaults to `false`).
+
 ## Configuration
 
 The test agent can be configured via command-line options or via environment variables.

{ddapm_test_agent-1.33.1.dist-info → ddapm_test_agent-1.35.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 ddapm_test_agent/__init__.py,sha256=IEYMDM-xI0IoHYSYw4Eva5263puB_crrrbLstOCScRw,106
-ddapm_test_agent/agent.py,sha256=296wweDNsF7cw5QuGdSzbKa4vWrVpea3rvZU4Laddkc,74000
+ddapm_test_agent/agent.py,sha256=EIIIAPYvz6NyJqgiNDWQqHE0TWnoQ_HCqzYUmOM8Mz0,89626
 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=ViEmiRX9Y3SQ-KBhSc-FdzBmIVIe8Ij9jj-Q6VGyzLY,7359
@@ -12,15 +12,15 @@ ddapm_test_agent/metrics.py,sha256=EZo7lSec2oAiH7tUqavKZ2MJM7TwbuFGE3AT3cXwmSM,3
 ddapm_test_agent/remoteconfig.py,sha256=_QjYUKc3JF31DxdvISDXgslm5WVnYWAw0hyckWuLc1c,3606
 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=ayOUcCFo6xyotFRm0fSNdeA91_T447W5ShlkRvi0nZE,22932
+ddapm_test_agent/trace_snapshot.py,sha256=vcz9uCgtpnInKl32nq1n62shhsVdMQPzOWfV3-RjTVM,23781
 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=jTm9Q0LeWOUJrwlDrG632WrQB6ScWvjb3dLR7oSFa6o,6808
-ddapm_test_agent-1.33.1.dist-info/licenses/LICENSE.BSD3,sha256=J9S_Tq-hhvteDV2W8R0rqht5DZHkmvgdx3gnLZg4j6Q,1493
-ddapm_test_agent-1.33.1.dist-info/licenses/LICENSE.apache2,sha256=5V2RruBHZQIcPyceiv51DjjvdvhgsgS4pnXAOHDuZkQ,11342
-ddapm_test_agent-1.33.1.dist-info/METADATA,sha256=fPwXRZgry4efp28Ft0jEWhzxwW8rZx134I01GBFHt0c,28104
-ddapm_test_agent-1.33.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ddapm_test_agent-1.33.1.dist-info/entry_points.txt,sha256=ulayVs6YJ-0Ej2kxbwn39wOHDVXbyQgFgsbRQmXydcs,250
-ddapm_test_agent-1.33.1.dist-info/top_level.txt,sha256=A9jiKOrrg6VjFAk-mtlSVYN4wr0VsZe58ehGR6IW47U,17
-ddapm_test_agent-1.33.1.dist-info/RECORD,,
+ddapm_test_agent/vcr_proxy.py,sha256=dEJ5xXxxvFHAbvN-OgXEaOlqz54Vh1k_1eQBgf146lU,7812
+ddapm_test_agent-1.35.0.dist-info/licenses/LICENSE.BSD3,sha256=J9S_Tq-hhvteDV2W8R0rqht5DZHkmvgdx3gnLZg4j6Q,1493
+ddapm_test_agent-1.35.0.dist-info/licenses/LICENSE.apache2,sha256=5V2RruBHZQIcPyceiv51DjjvdvhgsgS4pnXAOHDuZkQ,11342
+ddapm_test_agent-1.35.0.dist-info/METADATA,sha256=1MNta2Fe5Bl7amhHjPBTcDt9purf0FpgsVD_BVy1ok8,29678
+ddapm_test_agent-1.35.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ddapm_test_agent-1.35.0.dist-info/entry_points.txt,sha256=ulayVs6YJ-0Ej2kxbwn39wOHDVXbyQgFgsbRQmXydcs,250
+ddapm_test_agent-1.35.0.dist-info/top_level.txt,sha256=A9jiKOrrg6VjFAk-mtlSVYN4wr0VsZe58ehGR6IW47U,17
+ddapm_test_agent-1.35.0.dist-info/RECORD,,