@dash0/sdk-web 0.19.0 → 0.20.0

package/src/instrumentations/http/fetch_test.ts

@@ -1,6 +1,12 @@
 import { expect, vi, beforeEach, afterEach } from "vitest";
 import { vars } from "../../vars";
 import { instrumentFetch } from "./fetch";
+import { sendSpan } from "../../transport";
+import type { Span } from "../../types/otlp";
+
+vi.mock("../../transport", () => ({
+  sendSpan: vi.fn(),
+}));
 
 describe("fetch test", () => {
   let fetchMock: any;
@@ -188,4 +194,121 @@ describe("fetch test", () => {
     expect(fetchHeaders.get("traceparent")).not.toBeNull();
     expect(fetchHeaders.get("X-Amzn-Trace-Id")).toBeNull();
   });
+
+  describe("aborted requests", () => {
+    const sendSpanMock = sendSpan as unknown as ReturnType<typeof vi.fn>;
+    const NativeRequest = Request;
+
+    const lastSpan = (): Span => {
+      const calls = sendSpanMock.mock.calls;
+      return calls[calls.length - 1]![0] as Span;
+    };
+
+    const hasAttribute = (span: Span, key: string, expectedValue: unknown) =>
+      span.attributes.some((a) => a.key === key && JSON.stringify(a.value) === JSON.stringify(expectedValue));
+
+    beforeEach(() => {
+      sendSpanMock.mockClear();
+      // jsdom's Request rejects its own AbortSignal instances (known jsdom bug).
+      // Stub Request with a minimal implementation that preserves signals verbatim.
+      class FakeRequest {
+        url: string;
+        method: string;
+        headers: Headers;
+        signal: AbortSignal | undefined;
+        constructor(input: string | FakeRequest, init?: RequestInit) {
+          if (input instanceof FakeRequest) {
+            this.url = input.url;
+            this.method = init?.method ?? input.method;
+            this.headers = new Headers(init?.headers ?? input.headers);
+            this.signal = init?.signal ?? input.signal;
+          } else {
+            this.url = String(input);
+            this.method = init?.method ?? "GET";
+            this.headers = new Headers(init?.headers);
+            this.signal = init?.signal ?? undefined;
+          }
+        }
+      }
+      vi.stubGlobal("Request", FakeRequest);
+    });
+
+    afterEach(() => {
+      vi.stubGlobal("Request", NativeRequest);
+    });
+
+    it("marks fetch as cancelled when the abort signal fires before the response arrives", async () => {
+      const controller = new AbortController();
+      fetchMock.mockImplementation(
+        (_input: RequestInfo, init?: RequestInit) =>
+          new Promise((_resolve, reject) => {
+            const signal = init?.signal;
+            if (signal?.aborted) {
+              reject(new DOMException("aborted", "AbortError"));
+              return;
+            }
+            signal?.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")));
+          })
+      );
+
+      instrumentFetch();
+      // eslint-disable-next-line no-restricted-globals
+      const pending = fetch("http://localhost:3000/api/test", { signal: controller.signal });
+      controller.abort();
+      await expect(pending).rejects.toBeInstanceOf(DOMException);
+
+      expect(sendSpanMock).toHaveBeenCalledTimes(1);
+      const span = lastSpan();
+      expect(span.status?.code).toBe(0);
+      expect(span.status?.message).toBeUndefined();
+      expect(hasAttribute(span, "dash0.web.request.cancelled", { boolValue: true })).toBe(true);
+      expect(span.events.find((e) => e.name === "exception")).toBeUndefined();
+    });
+
+    it("marks fetch as cancelled when the abort signal fires while reading the response body", async () => {
+      const controller = new AbortController();
+      const body = new ReadableStream({
+        start(streamController) {
+          streamController.enqueue(new Uint8Array([0x68, 0x69]));
+          controller.signal.addEventListener("abort", () => {
+            streamController.error(new DOMException("aborted", "AbortError"));
+          });
+        },
+      });
+
+      fetchMock.mockImplementation(() => Promise.resolve(new Response(body, { status: 200 })));
+
+      instrumentFetch();
+      // eslint-disable-next-line no-restricted-globals
+      const response = await fetch("http://localhost:3000/api/test", { signal: controller.signal });
+      const reader = response.body!.getReader();
+      await reader.read();
+      controller.abort();
+      await expect(reader.read()).rejects.toBeInstanceOf(DOMException);
+
+      expect(sendSpanMock).toHaveBeenCalledTimes(1);
+      const span = lastSpan();
+      // status was set from the 200 response and should not be overwritten
+      expect(span.status?.code).toBe(0);
+      expect(span.status?.message).toBeUndefined();
+      expect(hasAttribute(span, "dash0.web.request.cancelled", { boolValue: true })).toBe(true);
+      expect(hasAttribute(span, "http.response.status_code", { stringValue: "200" })).toBe(true);
+      expect(span.events.find((e) => e.name === "exception")).toBeUndefined();
+    });
+
+    it("still treats non-abort rejections as failures", async () => {
+      fetchMock.mockImplementation(() => Promise.reject(new TypeError("network down")));
+
+      instrumentFetch();
+      // eslint-disable-next-line no-restricted-globals
+      await expect(fetch("http://localhost:3000/api/test")).rejects.toBeInstanceOf(TypeError);
+
+      expect(sendSpanMock).toHaveBeenCalledTimes(1);
+      const span = lastSpan();
+      expect(span.status?.code).toBe(2);
+      expect(span.status?.message).toBe("network down");
+      expect(hasAttribute(span, "dash0.web.request.cancelled", { boolValue: true })).toBe(false);
+      expect(span.events.some((e) => e.name === "exception")).toBe(true);
+    });
+  });
 });

package/src/semantic-conventions.ts

@@ -10,6 +10,7 @@ export const DEPLOYMENT_ID = "deployment.id";
 export const EVENT_NAME = "event.name";
 export const WEB_EVENT_TITLE = "dash0.web.event.title";
 export const WEB_EVENT_ID = "dash0.web.event.id";
+export const WEB_REQUEST_CANCELLED = "dash0.web.request.cancelled";
 export const PAGE_LOAD_ID = "page.load.id";
 export const SESSION_ID = "session.id";
 export const USER_AGENT = "user_agent.original";