@atrim/instrument-web 0.5.0-c05e3a1-20251119131241 → 0.5.0-cda80ad-20251119134818

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atrim/instrument-web",
-  "version": "0.5.0-c05e3a1-20251119131241",
+  "version": "0.5.0-cda80ad-20251119134818",
   "description": "OpenTelemetry instrumentation for browsers with centralized YAML configuration",
   "type": "module",
   "license": "MIT",

package/target/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { Effect, Layer } from 'effect';
 import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
-import { InstrumentationConfig, InitializationError, ConfigLoader } from '@atrim/instrument-core';
+import { InstrumentationConfig, ConfigLoader } from '@atrim/instrument-core';
 export { ConfigError, ConfigFileError, ConfigUrlError, ConfigValidationError, ExportError, InitializationError, InstrumentationConfig, PatternConfig, PatternMatcher, ShutdownError, clearPatternMatcher, getPatternMatcher, initializePatternMatcher, shouldInstrumentSpan } from '@atrim/instrument-core';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { Layer } from 'effect';
 import { SpanProcessor, ReadableSpan } from '@opentelemetry/sdk-trace-base';
 import { Context, Span } from '@opentelemetry/api';
 
@@ -70,6 +70,31 @@ 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[];
 }
 /**
  * Get the current SDK instance
@@ -103,47 +128,37 @@ declare function resetSdk(): void;
  * Call this function once at application startup, before any other code runs.
  *
  * @param options - Initialization options
- * @returns Effect that yields WebTracerProvider instance
+ * @returns WebTracerProvider instance
+ * @throws {Error} If initialization fails
  *
  * @example
  * ```typescript
- * import { Effect } from 'effect'
  * import { initializeInstrumentation } from '@atrim/instrument-web'
  *
- * const program = initializeInstrumentation({
+ * await initializeInstrumentation({
  *   serviceName: 'my-app',
  *   otlpEndpoint: 'http://localhost:4318/v1/traces'
  * })
- *
- * await Effect.runPromise(program)
  * ```
  *
  * @example With pattern-based filtering
  * ```typescript
- * const program = initializeInstrumentation({
+ * await initializeInstrumentation({
  *   serviceName: 'my-app',
  *   configUrl: 'https://config.company.com/instrumentation.yaml'
  * })
- *
- * await Effect.runPromise(program)
  * ```
  *
- * @example With error handling
+ * @example Disable specific instrumentations
  * ```typescript
- * const program = initializeInstrumentation({
+ * await initializeInstrumentation({
  *   serviceName: 'my-app',
- *   enableUserInteraction: false
- * }).pipe(
- *   Effect.catchTag('InitializationError', (error) => {
- *     console.error('Failed to initialize:', error.reason)
- *     return Effect.die(error) // Re-throw or handle
- *   })
- * )
- *
- * await Effect.runPromise(program)
+ *   enableUserInteraction: false, // Disable click tracking
+ *   enableXhr: false // Disable XMLHttpRequest tracking
+ * })
  * ```
  */
-declare const initializeInstrumentation: (options: SdkInitializationOptions) => Effect.Effect<WebTracerProvider, InitializationError>;
+declare function initializeInstrumentation(options: SdkInitializationOptions): Promise<WebTracerProvider>;
 
 /**
  * OTLP Exporter Factory for Browser

package/target/dist/index.js

@@ -1,9 +1,9 @@
-import { Data, Context, Effect, Layer, Deferred } from 'effect';
 import { WebTracerProvider } 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';
 import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
@@ -4539,34 +4539,92 @@ var PatternSpanProcessor = class {
 
 // src/core/sdk-initializer.ts
 var sdkInstance = null;
-var initializationDeferred = null;
-var initializeSdkEffect = (options) => Effect.gen(function* () {
+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 initializeSdk(options) {
   if (sdkInstance) {
     return sdkInstance;
   }
-  if (initializationDeferred) {
-    return yield* Deferred.await(initializationDeferred);
-  }
-  const deferred = yield* Deferred.make();
-  initializationDeferred = deferred;
-  const result = yield* performInitializationEffect(options).pipe(
-    Effect.tap((provider) => Deferred.succeed(deferred, provider)),
-    Effect.tapError((error) => Deferred.fail(deferred, error)),
-    Effect.ensuring(
-      Effect.sync(() => {
-        initializationDeferred = null;
-      })
-    )
-  );
-  return result;
-});
-var performInitializationEffect = (options) => Effect.gen(function* () {
-  const config = yield* loadConfigEffect(options);
-  if (config) {
-    initializePatternMatcher(config);
-  }
-  const ignoreUrls = buildIgnoreUrls(config);
-  const exporter = yield* Effect.sync(() => {
+  try {
+    let config = null;
+    if (options.config) {
+      config = await loadConfigFromInline(options.config);
+    } else if (options.configPath || options.configUrl) {
+      const url = options.configUrl || options.configPath;
+      config = await loadConfig(url);
+    }
+    if (config) {
+      initializePatternMatcher(config);
+    }
+    const ignoreUrls = [
+      // Always ignore standard OTLP endpoints (prevents infinite loops)
+      /\/v1\/traces$/,
+      /\/v1\/metrics$/,
+      /\/v1\/logs$/
+    ];
+    if (config?.http?.ignore_outgoing_urls) {
+      for (const pattern of config.http.ignore_outgoing_urls) {
+        try {
+          ignoreUrls.push(new RegExp(pattern));
+        } catch (error) {
+          console.warn(
+            `[@atrim/instrument-web] Invalid ignore_outgoing_urls pattern: "${pattern}"`,
+            error
+          );
+        }
+      }
+    } else {
+      console.warn(
+        "[@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;
@@ -4574,23 +4632,18 @@ var performInitializationEffect = (options) => Effect.gen(function* () {
     if (options.otlpHeaders) {
       exporterOptions.headers = options.otlpHeaders;
     }
-    return createOtlpExporter(exporterOptions);
-  });
-  const spanProcessors = [];
-  if (config) {
-    spanProcessors.push(new PatternSpanProcessor());
-  }
-  spanProcessors.push(new SimpleSpanProcessor(exporter));
-  const provider = yield* Effect.sync(() => {
-    const p = new WebTracerProvider({
+    const exporter = createOtlpExporter(exporterOptions);
+    const spanProcessors = [];
+    if (config) {
+      spanProcessors.push(new PatternSpanProcessor());
+    }
+    spanProcessors.push(new SimpleSpanProcessor(exporter));
+    const provider = new WebTracerProvider({
       spanProcessors
     });
-    p.register({
+    provider.register({
       contextManager: new ZoneContextManager()
     });
-    return p;
-  });
-  yield* Effect.sync(() => {
     registerInstrumentations({
       instrumentations: [
         getWebAutoInstrumentations({
@@ -4603,69 +4656,25 @@ var performInitializationEffect = (options) => Effect.gen(function* () {
           },
           "@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
           }
         })
       ]
     });
-  });
-  sdkInstance = provider;
-  return provider;
-});
-var loadConfigEffect = (options) => Effect.gen(function* () {
-  if (options.config) {
-    return yield* Effect.tryPromise({
-      try: () => loadConfigFromInline(options.config),
-      catch: (error) => new InitializationError({
-        reason: "Failed to load inline config",
-        cause: error
-      })
-    });
+    sdkInstance = provider;
+    return provider;
+  } catch (error) {
+    throw new Error(`Failed to initialize OpenTelemetry SDK: ${error}`);
   }
-  if (options.configPath || options.configUrl) {
-    const url = options.configUrl || options.configPath;
-    return yield* Effect.tryPromise({
-      try: () => loadConfig(url),
-      catch: (error) => new InitializationError({
-        reason: `Failed to load config from ${url}`,
-        cause: error
-      })
-    });
-  }
-  return null;
-});
-function buildIgnoreUrls(config) {
-  const ignoreUrls = [
-    // Always ignore standard OTLP endpoints (prevents infinite loops)
-    /\/v1\/traces$/,
-    /\/v1\/metrics$/,
-    /\/v1\/logs$/
-  ];
-  if (config?.http?.ignore_outgoing_urls) {
-    for (const pattern of config.http.ignore_outgoing_urls) {
-      try {
-        ignoreUrls.push(new RegExp(pattern));
-      } catch (error) {
-        console.warn(
-          `[@atrim/instrument-web] Invalid ignore_outgoing_urls pattern: "${pattern}"`,
-          error
-        );
-      }
-    }
-  } else {
-    console.warn(
-      "[@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."
-    );
-  }
-  return ignoreUrls;
 }
 function getSdkInstance() {
   return sdkInstance;
@@ -4678,11 +4687,12 @@ async function shutdownSdk() {
 }
 function resetSdk() {
   sdkInstance = null;
-  initializationDeferred = null;
 }
 
 // src/api.ts
-var initializeInstrumentation = (options) => initializeSdkEffect(options);
+async function initializeInstrumentation(options) {
+  return await initializeSdk(options);
+}
 function setSpanAttributes(span, attributes) {
   for (const [key, value] of Object.entries(attributes)) {
     span.setAttribute(key, value);