ddapm-test-agent 1.34.0__tar.gz → 1.35.0__tar.gz

{ddapm_test_agent-1.34.0 → ddapm_test_agent-1.35.0}/.github/workflows/main.yml

@@ -22,17 +22,25 @@ jobs:
   test:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         python-version: ["3.11", "3.12", "3.13"]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
-      - uses: actions/setup-python@7f4fc3e22c37d6ff65e88745f38bd3157c663f7c # v4.9.1
+      - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:
           python-version: ${{ matrix.python-version }}
       - name: install deps
         run: pip install .[testing]
-      - run: |
+      # Windows: Use vanilla pytest (riot doesn't support Windows - see https://github.com/DataDog/riot/issues/74)
+      - name: Run tests (Windows - direct pytest)
+        if: runner.os == 'Windows'
+        run: |
+          echo "Using pytest directly due to riot Windows limitation (https://github.com/DataDog/riot/issues/74)"
+          python -m pytest -v --basetemp=$env:TEMP\pytest tests/ --ignore=tests/test_container.py
+      - name: Run tests (Unix - riot)
+        if: runner.os != 'Windows'
+        run: |
           riot run --pass-env -p ${{ matrix.python-version}} test
   cassettes-size:
     runs-on: ubuntu-latest
@@ -41,12 +49,12 @@ jobs:
       - name: Check VCR cassettes size
         run: |
           CASSETTES_SIZE=$(du -sb vcr-cassettes/ 2>/dev/null | cut -f1 || echo "0")
-          
+
           MAX_SIZE=2097152
-          
+
           echo "VCR cassettes size: ${CASSETTES_SIZE} bytes ($((CASSETTES_SIZE / 1024 / 1024))MB)"
           echo "Maximum allowed size: ${MAX_SIZE} bytes (2MB)"
-          
+
           if [ "$CASSETTES_SIZE" -gt "$MAX_SIZE" ]; then
             echo "❌ VCR cassettes directory is larger than 2MB!"
             echo "Current size: $((CASSETTES_SIZE / 1024 / 1024))MB"
@@ -55,4 +63,4 @@ jobs:
           else
             echo "✅ VCR cassettes directory size is within limits"
           fi
-    
+

{ddapm_test_agent-1.34.0 → ddapm_test_agent-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddapm-test-agent
-Version: 1.34.0
+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.

{ddapm_test_agent-1.34.0 → ddapm_test_agent-1.35.0}/README.md

@@ -139,7 +139,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.

{ddapm_test_agent-1.34.0 → ddapm_test_agent-1.35.0}/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."""
@@ -1287,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 +1579,8 @@ def make_app(
     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, vcr_ci_mode),
+                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,
@@ -1588,6 +1952,18 @@ def main(args: Optional[List[str]] = None) -> None:
         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)
 
@@ -1632,6 +2008,8 @@ def main(args: Optional[List[str]] = None) -> None:
         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
@@ -1644,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-1.34.0 → ddapm_test_agent-1.35.0}/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: