@dash0/sdk-web 0.19.0 → 0.21.0

package/src/instrumentations/http/fetch.ts

@@ -29,6 +29,7 @@ import {
   HTTP_RESPONSE_STATUS_CODE,
   SPAN_STATUS_ERROR,
   SPAN_STATUS_UNSET,
+  WEB_REQUEST_CANCELLED,
 } from "../../semantic-conventions";
 import { vars, PropagatorType } from "../../vars";
 import { httpRequestHeaderKey, httpResponseHeaderKey } from "../../utils/otel/http";
@@ -129,12 +130,20 @@ function wrapFetch(original: typeof fetch) {
         () => performanceObserver.end(),
         (e) => {
           performanceObserver.cancel();
-          endSpanOnError(span, e);
+          if (request.signal?.aborted) {
+            endSpanOnAbort(span);
+          } else {
+            endSpanOnError(span, e);
+          }
         }
       );
     } catch (e) {
       performanceObserver.cancel();
-      endSpanOnError(span, e as Exception);
+      if (request.signal?.aborted) {
+        endSpanOnAbort(span);
+      } else {
+        endSpanOnError(span, e as Exception);
+      }
       throw e;
     }
   };
@@ -277,6 +286,11 @@ function endSpanOnError(span: InProgressSpan, error: Exception) {
   sendSpan(endSpan(span, errorToSpanStatus(error), undefined));
 }
 
+function endSpanOnAbort(span: InProgressSpan) {
+  addAttribute(span.attributes, WEB_REQUEST_CANCELLED, true);
+  sendSpan(endSpan(span, undefined, undefined));
+}
+
 function determinePropagatorTypes(url: string): PropagatorType[] {
   const matchingTypes: PropagatorType[] = [];
   const isUrlSameOrigin = isSameOrigin(url);

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

@@ -6,10 +6,20 @@ export const DEPLOYMENT_ENVIRONMENT_NAME = "deployment.environment.name";
 export const DEPLOYMENT_NAME = "deployment.name";
 export const DEPLOYMENT_ID = "deployment.id";
 
+// VCS Resource Attribute Keys
+export const VCS_PROVIDER_NAME = "vcs.provider.name";
+export const VCS_OWNER_NAME = "vcs.owner.name";
+export const VCS_REPOSITORY_NAME = "vcs.repository.name";
+export const VCS_REPOSITORY_URL_FULL = "vcs.repository.url.full";
+export const VCS_REF_HEAD_NAME = "vcs.ref.head.name";
+export const VCS_REF_HEAD_REVISION = "vcs.ref.head.revision";
+export const VCS_CHANGE_ID = "vcs.change.id";
+
 // Misc Signal Attribute Keys
 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";

package/src/types/options.ts

@@ -4,6 +4,29 @@ import { Endpoint, Vars, PropagatorConfig } from "../vars";
 
 export type InstrumentationName = "@dash0/navigation" | "@dash0/web-vitals" | "@dash0/error" | "@dash0/fetch";
 
+/**
+ * VCS (version control) context describing the build the SDK is running
+ * inside. Used both as the public manual-override shape on `InitOptions.vcs`
+ * and internally as the merged result of auto-detection. Each field maps to
+ * a standard OpenTelemetry `vcs.*` resource attribute.
+ */
+export type VcsAttributes = {
+  /** vcs.provider.name — e.g. "github", "gitlab", "bitbucket". */
+  providerName?: string;
+  /** vcs.owner.name — repository owner / organization. */
+  ownerName?: string;
+  /** vcs.repository.name — short repository name (no owner prefix). */
+  repositoryName?: string;
+  /** vcs.repository.url.full — canonical repository URL. */
+  repositoryUrlFull?: string;
+  /** vcs.ref.head.name — branch or tag name the build was made from. */
+  refHeadName?: string;
+  /** vcs.ref.head.revision — commit SHA the build was made from. */
+  refHeadRevision?: string;
+  /** vcs.change.id — pull/merge request identifier (preview deploys). */
+  changeId?: string;
+};
+
 export type InitOptions = {
   serviceName: string;
   serviceNamespace?: string;
@@ -28,6 +51,39 @@ export type InitOptions = {
    */
   rejectSuspiciousServiceName?: boolean;
 
+  /**
+   * When `true`, disable auto-detection of VCS (version control) context
+   * from the build environment. By default the SDK reads VCS context from
+   * Vercel (`NEXT_PUBLIC_VERCEL_GIT_*`) and Netlify
+   * (`NEXT_PUBLIC_REPOSITORY_URL`, `NEXT_PUBLIC_BRANCH`,
+   * `NEXT_PUBLIC_COMMIT_REF`, `NEXT_PUBLIC_REVIEW_ID`) and applies the values
+   * as resource attributes following the OTel `vcs.*` semantic conventions:
+   *
+   *   - vcs.provider.name
+   *   - vcs.owner.name
+   *   - vcs.repository.name
+   *   - vcs.repository.url.full
+   *   - vcs.ref.head.name
+   *   - vcs.ref.head.revision
+   *   - vcs.change.id
+   *
+   * Pairing telemetry with the git commit + branch the build came from lets
+   * Dash0 Agent answer questions like "which PR introduced this error?".
+   *
+   * Note: any fields supplied via `vcs` are still applied even when this flag
+   * is `true` — manual overrides always win. Set this flag when you want to
+   * prevent env-var reads entirely but still supply context explicitly.
+   */
+  disableVcsDetection?: boolean;
+
+  /**
+   * Manually specify VCS (version control) context. Each provided field
+   * overrides the value the SDK would otherwise auto-detect from the build
+   * environment for that attribute. Use this for non-Vercel/Netlify
+   * deployments, or when the auto-detected values are wrong.
+   */
+  vcs?: VcsAttributes;
+
   /**
    * OTLP endpoints to which the generated telemetry should be sent to.
    */