@dash0/sdk-web 0.17.0 → 0.18.1

package/src/api/init_test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { InitOptions, InstrumentationName } from "../types/options";
 import { PropagatorConfig, Vars } from "../vars";
+import { SERVICE_NAME } from "../semantic-conventions";
 import { init as initFun } from "./init";
 
 // Mock all the instrumentation modules
@@ -20,6 +21,15 @@ vi.mock("../instrumentations/navigation", () => ({
   startNavigationInstrumentation: vi.fn(),
 }));
 
+// Mock the utils module to control loc.hostname
+vi.mock("../utils", async () => {
+  const actual = await vi.importActual("../utils");
+  return {
+    ...actual,
+    loc: { hostname: "test-hostname.example.com" },
+  };
+});
+
 import { startErrorInstrumentation } from "../instrumentations/errors";
 import { instrumentFetch } from "../instrumentations/http/fetch";
 import { startNavigationInstrumentation } from "../instrumentations/navigation";
@@ -226,4 +236,71 @@ describe("init", () => {
       expect(spyOnWarn).not.toHaveBeenCalled();
     });
   });
+
+  describe("serviceName fallback", () => {
+    it("should use provided serviceName when it is valid", async () => {
+      init({
+        ...baseOptions,
+        serviceName: "my-service",
+      });
+
+      const serviceNameAttr = vars.resource.attributes.find((attr) => attr.key === SERVICE_NAME);
+      expect(serviceNameAttr?.value.stringValue).toBe("my-service");
+    });
+
+    it("should fallback to location.hostname when serviceName is empty string", async () => {
+      init({
+        ...baseOptions,
+        serviceName: "",
+      });
+
+      const serviceNameAttr = vars.resource.attributes.find((attr) => attr.key === SERVICE_NAME);
+      expect(serviceNameAttr?.value.stringValue).toBe("test-hostname.example.com");
+    });
+
+    it("should fallback to location.hostname when serviceName is only whitespace", async () => {
+      init({
+        ...baseOptions,
+        serviceName: "   ",
+      });
+
+      const serviceNameAttr = vars.resource.attributes.find((attr) => attr.key === SERVICE_NAME);
+      expect(serviceNameAttr?.value.stringValue).toBe("test-hostname.example.com");
+    });
+
+    it("should fallback to location.hostname when serviceName is tabs and spaces", async () => {
+      init({
+        ...baseOptions,
+        serviceName: " \t  \n ",
+      });
+
+      const serviceNameAttr = vars.resource.attributes.find((attr) => attr.key === SERVICE_NAME);
+      expect(serviceNameAttr?.value.stringValue).toBe("test-hostname.example.com");
+    });
+
+    it("should fallback to 'unknown' when serviceName is empty and location.hostname is not available", async () => {
+      vi.resetModules();
+
+      // Mock utils module with loc as undefined
+      vi.doMock("../utils", async () => {
+        const actual = await vi.importActual("../utils");
+        return {
+          ...actual,
+          loc: undefined,
+        };
+      });
+
+      const { vars: importedVars } = await import("../vars");
+      const { init: importedInit } = await import("./init");
+      const { SERVICE_NAME: importedServiceName } = await import("../semantic-conventions");
+
+      importedInit({
+        ...baseOptions,
+        serviceName: "",
+      });
+
+      const serviceNameAttr = importedVars.resource.attributes.find((attr) => attr.key === importedServiceName);
+      expect(serviceNameAttr?.value.stringValue).toBe("unknown");
+    });
+  });
 });

package/src/instrumentations/errors/unhandled-error.ts

@@ -10,7 +10,7 @@ import {
   EXCEPTION_TYPE,
   LOG_SEVERITIES,
 } from "../../semantic-conventions";
-import { addAttribute } from "../../utils/otel";
+import { addAttribute, addAttributes } from "../../utils/otel";
 import { addCommonAttributes } from "../../attributes";
 import { KeyValue, LogRecord } from "../../types/otlp";
 import { ReportErrorOpts, ErrorLike } from "../../types/errors";
@@ -117,9 +117,13 @@ function onUnhandledError({ message, type, stack, opts }: UnhandledErrorArgs) {
   if (trackedError) {
     trackedError.seenCount++;
   } else {
-    const attributes: KeyValue[] = opts?.attributes ? [...opts.attributes] : [];
+    const attributes: KeyValue[] = [];
+
+    addCommonAttributes(attributes);
+
     addAttribute(attributes, EVENT_NAME, EVENT_NAMES.ERROR);
     addAttribute(attributes, EXCEPTION_MESSAGE, message);
+
     if (type) {
       addAttribute(attributes, EXCEPTION_TYPE, type);
     }
@@ -129,7 +133,9 @@ function onUnhandledError({ message, type, stack, opts }: UnhandledErrorArgs) {
     if (opts?.componentStack) {
       addAttribute(attributes, EXCEPTION_COMPONENT_STACK, opts?.componentStack.substring(0, 2048));
     }
-    addCommonAttributes(attributes);
+
+    // Add custom attributes last to allow overrides
+    addAttributes(attributes, opts?.attributes);
 
     trackedError = {
       seenCount: 1,

package/src/types/errors.ts

@@ -1,4 +1,5 @@
-import { KeyValue } from "./otlp";
+import { AttributeValueType } from "../utils/otel";
+import { AnyValue } from "./otlp";
 
 export type ErrorLike = {
   message: string;
@@ -7,9 +8,9 @@ export type ErrorLike = {
 };
 
 export type ReportErrorOpts = {
-  componentStack: string | null | undefined;
+  componentStack?: string | null | undefined;
   /**
    * Additional attributes to add to the error span
    */
-  attributes?: KeyValue[];
+  attributes?: Record<string, AttributeValueType | AnyValue>;
 };

package/src/utils/otel/attributes.ts

@@ -55,12 +55,36 @@ export function toKeyValue(key: string, value: AttributeValueType | AnyValue): K
   };
 }
 
+/**
+ * Adds a single attribute to the provided attributes array
+ */
 export function addAttribute(attributes: KeyValue[], key: string, value: AttributeValueType | AnyValue) {
   if (!key) return;
 
   attributes.push(toKeyValue(key, value));
 }
 
+/**
+ * Adds multiple attributes to the provided attributes array
+ */
+export function addAttributes(
+  /**
+   * The attributes array to add to
+   */
+  attributes: KeyValue[],
+  /**
+   * Additional attributes to add
+   * If no attributes are provided, nothing is added
+   */
+  attrs: Record<string, AttributeValueType | AnyValue> | undefined
+) {
+  if (!attrs) return;
+  Object.entries(attrs).forEach(([key, value]) => addAttribute(attributes, key, value));
+}
+
+/**
+ * Removes an attribute from the provided attributes array by its key
+ */
 export function removeAttribute(attributes: KeyValue[], key: string) {
   const index = attributes.findIndex((attr) => attr["key"] === key);
   if (index !== -1) {