@atrim/instrument-web 0.5.0 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atrim/instrument-web",
-  "version": "0.5.0",
+  "version": "0.5.3",
   "description": "OpenTelemetry instrumentation for browsers with centralized YAML configuration",
   "type": "module",
   "license": "MIT",
@@ -52,7 +52,6 @@
     "effect": "^3.19.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/auto-instrumentations-web": "^0.54.0",
-    "@opentelemetry/context-zone": "^2.2.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.208.0",
     "@opentelemetry/instrumentation": "^0.208.0",
     "@opentelemetry/resources": "^2.2.0",
@@ -60,7 +59,16 @@
     "@opentelemetry/sdk-trace-web": "^2.2.0",
     "yaml": "^2.8.1"
   },
+  "peerDependencies": {
+    "@opentelemetry/context-zone": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/context-zone": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@opentelemetry/context-zone": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
     "@types/node": "^20.10.0",
     "@vitest/coverage-v8": "^4.0.8",
@@ -82,10 +90,10 @@
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
     "clean": "rm -rf target",
-    "publish:dev:version": "npm version $(git describe --tags --abbrev=0 | sed 's/^.*@//' | sed 's/^v//')-$(git rev-parse --short HEAD)-$(date -u +%Y%m%d%H%M%S) --no-git-tag-version",
+    "publish:dev:version": "pnpm version $(node -p \"require('./package.json').version\")-$(git rev-parse --short HEAD)-$(date -u +%Y%m%d%H%M%S) --no-git-tag-version",
     "publish:dev:save": "node -p \"require('./package.json').version\" > .version",
     "publish:dev:publish": "pnpm build && pnpm publish --tag dev --access public --no-git-checks",
-    "publish:dev:reset": "npm version 0.1.0 --no-git-tag-version",
+    "publish:dev:reset": "pnpm version 0.5.0 --no-git-tag-version",
     "publish:dev": "pnpm publish:dev:version && pnpm publish:dev:save && pnpm publish:dev:publish && pnpm publish:dev:reset"
   }
 }

package/target/dist/index.d.ts

@@ -70,6 +70,54 @@ interface SdkInitializationOptions {
      * @default true
      */
     enableXhr?: boolean;
+    /**
+     * Control trace context propagation for cross-origin requests
+     *
+     * Determines which cross-origin requests receive W3C Trace Context headers
+     * (traceparent, tracestate). Note: Backends must allow these headers in CORS
+     * configuration or requests will fail with CORS errors.
+     *
+     * - 'all': Propagate to all cross-origin requests (may cause CORS errors)
+     * - 'none': Never propagate trace headers
+     * - 'same-origin': Only propagate to same-origin requests (default)
+     * - Array of URL patterns: Custom propagation patterns (regex strings)
+     *
+     * @default 'same-origin'
+     *
+     * @example Propagate to specific API domains
+     * ```typescript
+     * propagateTraceContext: ['^https://api\\.myapp\\.com', '^http://localhost:300[0-9]']
+     * ```
+     *
+     * @example Disable propagation (for debugging CORS issues)
+     * ```typescript
+     * propagateTraceContext: 'none'
+     * ```
+     */
+    propagateTraceContext?: 'all' | 'none' | 'same-origin' | string[];
+    /**
+     * Use Zone.js-based context manager for async context propagation
+     *
+     * By default, we use StackContextManager which is lightweight and doesn't
+     * interfere with application behavior. However, it has limited async context
+     * propagation.
+     *
+     * Enable this option if you need context to propagate across async boundaries
+     * (e.g., setTimeout, Promise chains). Note that Zone.js monkey-patches many
+     * browser APIs which can cause issues with some libraries:
+     *
+     * - Libraries that call preventDefault() on wheel/touch events may fail
+     * - Some React patterns may lose context
+     * - Bundle size increases due to Zone.js dependency
+     *
+     * @default false
+     *
+     * @example Enable Zone.js context (use with caution)
+     * ```typescript
+     * useZoneContext: true
+     * ```
+     */
+    useZoneContext?: boolean;
 }
 /**
  * Get the current SDK instance

package/target/dist/index.js

@@ -1,8 +1,7 @@
-import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
+import { WebTracerProvider, StackContextManager } from '@opentelemetry/sdk-trace-web';
 import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import { getWebAutoInstrumentations } from '@opentelemetry/auto-instrumentations-web';
-import { ZoneContextManager } from '@opentelemetry/context-zone';
 import { Data, Context, Effect, Layer } from 'effect';
 import { FileSystem } from '@effect/platform/FileSystem';
 import * as HttpClient from '@effect/platform/HttpClient';
@@ -3845,7 +3844,7 @@ ZodNaN.create = (params) => {
     ...processCreateParams(params)
   });
 };
-var BRAND = Symbol("zod_brand");
+var BRAND = /* @__PURE__ */ Symbol("zod_brand");
 var ZodBranded = class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
@@ -4095,7 +4094,20 @@ var HttpFilteringConfigSchema = external_exports.object({
   // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
   ignore_incoming_paths: external_exports.array(external_exports.string()).optional(),
   // Require parent span for outgoing requests (prevents root spans for HTTP calls)
-  require_parent_for_outgoing_spans: external_exports.boolean().optional()
+  require_parent_for_outgoing_spans: external_exports.boolean().optional(),
+  // Trace context propagation configuration
+  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+  propagate_trace_context: external_exports.object({
+    // Strategy for trace propagation
+    // - "all": Propagate to all cross-origin requests (may cause CORS errors)
+    // - "none": Never propagate trace headers
+    // - "same-origin": Only propagate to same-origin requests (default, safe)
+    // - "patterns": Propagate based on include_urls patterns
+    strategy: external_exports.enum(["all", "none", "same-origin", "patterns"]).default("same-origin"),
+    // URL patterns to include when strategy is "patterns"
+    // Supports regex patterns (e.g., "^https://api\\.myapp\\.com")
+    include_urls: external_exports.array(external_exports.string()).optional()
+  }).optional()
 });
 var InstrumentationConfigSchema = external_exports.object({
   version: external_exports.string(),
@@ -4526,6 +4538,75 @@ var PatternSpanProcessor = class {
 
 // src/core/sdk-initializer.ts
 var sdkInstance = null;
+function buildPropagateTraceUrls(options, config) {
+  const apiOption = options.propagateTraceContext;
+  const yamlStrategy = config?.http?.propagate_trace_context?.strategy;
+  const yamlIncludeUrls = config?.http?.propagate_trace_context?.include_urls;
+  let effectiveStrategy;
+  let patterns = [];
+  if (apiOption !== void 0) {
+    if (typeof apiOption === "string") {
+      effectiveStrategy = apiOption;
+    } else {
+      effectiveStrategy = "patterns";
+      patterns = apiOption;
+    }
+  } else if (yamlStrategy) {
+    effectiveStrategy = yamlStrategy;
+    if (effectiveStrategy === "patterns" && yamlIncludeUrls) {
+      patterns = yamlIncludeUrls;
+    }
+  } else {
+    effectiveStrategy = "same-origin";
+  }
+  switch (effectiveStrategy) {
+    case "all":
+      return [/.*/];
+    case "none":
+    case "same-origin":
+      return [];
+    case "patterns": {
+      const regexes = [];
+      for (const pattern of patterns) {
+        try {
+          regexes.push(new RegExp(pattern));
+        } catch (error) {
+          console.warn(
+            `[@atrim/instrument-web] Invalid trace propagation pattern: "${pattern}"`,
+            error
+          );
+        }
+      }
+      return regexes;
+    }
+    default:
+      console.warn(
+        `[@atrim/instrument-web] Unknown trace propagation strategy: "${effectiveStrategy}". Defaulting to same-origin only.`
+      );
+      return [];
+  }
+}
+async function createContextManager(useZoneContext) {
+  if (!useZoneContext) {
+    return new StackContextManager();
+  }
+  if (typeof window !== "undefined") {
+    window.__zone_symbol__PASSIVE_EVENTS = [];
+    console.info(
+      "[@atrim/instrument-web] Zone.js context enabled. Passive events disabled for wheel/touch events to prevent breaking preventDefault()."
+    );
+  }
+  try {
+    const { ZoneContextManager } = await import('@opentelemetry/context-zone');
+    return new ZoneContextManager();
+  } catch (error) {
+    console.warn(
+      "[@atrim/instrument-web] Failed to load ZoneContextManager. Falling back to StackContextManager. Make sure @opentelemetry/context-zone is installed if you need async context propagation.",
+      error
+    );
+    return new StackContextManager();
+  }
+}
 async function initializeSdk(options) {
   if (sdkInstance) {
     return sdkInstance;
@@ -4563,6 +4644,7 @@ async function initializeSdk(options) {
         "[@atrim/instrument-web] Missing http.ignore_outgoing_urls in instrumentation.yaml. Using default OTLP endpoint patterns only. Consider adding http filtering to your config for better control."
       );
     }
+    const propagateTraceUrls = buildPropagateTraceUrls(options, config);
     const exporterOptions = {};
     if (options.otlpEndpoint) {
       exporterOptions.endpoint = options.otlpEndpoint;
@@ -4579,8 +4661,11 @@ async function initializeSdk(options) {
     const provider = new WebTracerProvider({
       spanProcessors
     });
+    const contextManager = await createContextManager(
+      options.useZoneContext ?? false
+    );
     provider.register({
-      contextManager: new ZoneContextManager()
+      contextManager
     });
     registerInstrumentations({
       instrumentations: [
@@ -4594,15 +4679,16 @@ async function initializeSdk(options) {
           },
           "@opentelemetry/instrumentation-fetch": {
             enabled: options.enableFetch ?? true,
-            propagateTraceHeaderCorsUrls: [/.*/],
-            // Propagate to all origins
+            propagateTraceHeaderCorsUrls: propagateTraceUrls,
+            // Controlled by config/API
             clearTimingResources: true,
             ignoreUrls
             // Prevent self-instrumentation of OTLP exports
           },
           "@opentelemetry/instrumentation-xml-http-request": {
             enabled: options.enableXhr ?? true,
-            propagateTraceHeaderCorsUrls: [/.*/]
+            propagateTraceHeaderCorsUrls: propagateTraceUrls
+            // Controlled by config/API
           }
         })
       ]