@atrim/instrument-web 0.5.0-11e06b7-20251119014031 → 0.5.0-c05e3a1-20251119131241

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atrim/instrument-web",
-  "version": "0.5.0-11e06b7-20251119014031",
+  "version": "0.5.0-c05e3a1-20251119131241",
   "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, ConfigLoader } from '@atrim/instrument-core';
+import { InstrumentationConfig, InitializationError, 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,31 +70,6 @@ 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
@@ -128,37 +103,47 @@ declare function resetSdk(): void;
  * Call this function once at application startup, before any other code runs.
  *
  * @param options - Initialization options
- * @returns WebTracerProvider instance
- * @throws {Error} If initialization fails
+ * @returns Effect that yields WebTracerProvider instance
  *
  * @example
  * ```typescript
+ * import { Effect } from 'effect'
  * import { initializeInstrumentation } from '@atrim/instrument-web'
  *
- * await initializeInstrumentation({
+ * const program = initializeInstrumentation({
  *   serviceName: 'my-app',
  *   otlpEndpoint: 'http://localhost:4318/v1/traces'
  * })
+ *
+ * await Effect.runPromise(program)
  * ```
  *
  * @example With pattern-based filtering
  * ```typescript
- * await initializeInstrumentation({
+ * const program = initializeInstrumentation({
  *   serviceName: 'my-app',
  *   configUrl: 'https://config.company.com/instrumentation.yaml'
  * })
+ *
+ * await Effect.runPromise(program)
  * ```
  *
- * @example Disable specific instrumentations
+ * @example With error handling
  * ```typescript
- * await initializeInstrumentation({
+ * const program = initializeInstrumentation({
  *   serviceName: 'my-app',
- *   enableUserInteraction: false, // Disable click tracking
- *   enableXhr: false // Disable XMLHttpRequest tracking
- * })
+ *   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)
  * ```
  */
-declare function initializeInstrumentation(options: SdkInitializationOptions): Promise<WebTracerProvider>;
+declare const initializeInstrumentation: (options: SdkInitializationOptions) => Effect.Effect<WebTracerProvider, InitializationError>;
 
 /**
  * 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,92 +4539,34 @@ 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 initializeSdk(options) {
+var initializationDeferred = null;
+var initializeSdkEffect = (options) => Effect.gen(function* () {
   if (sdkInstance) {
     return sdkInstance;
   }
-  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);
+  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(() => {
     const exporterOptions = {};
     if (options.otlpEndpoint) {
       exporterOptions.endpoint = options.otlpEndpoint;
@@ -4632,18 +4574,23 @@ async function initializeSdk(options) {
     if (options.otlpHeaders) {
       exporterOptions.headers = options.otlpHeaders;
     }
-    const exporter = createOtlpExporter(exporterOptions);
-    const spanProcessors = [];
-    if (config) {
-      spanProcessors.push(new PatternSpanProcessor());
-    }
-    spanProcessors.push(new SimpleSpanProcessor(exporter));
-    const provider = new WebTracerProvider({
+    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({
       spanProcessors
     });
-    provider.register({
+    p.register({
       contextManager: new ZoneContextManager()
     });
+    return p;
+  });
+  yield* Effect.sync(() => {
     registerInstrumentations({
       instrumentations: [
         getWebAutoInstrumentations({
@@ -4656,25 +4603,69 @@ async function initializeSdk(options) {
           },
           "@opentelemetry/instrumentation-fetch": {
             enabled: options.enableFetch ?? true,
-            propagateTraceHeaderCorsUrls: propagateTraceUrls,
-            // Controlled by config/API
+            propagateTraceHeaderCorsUrls: [/.*/],
+            // Propagate to all origins
             clearTimingResources: true,
             ignoreUrls
             // Prevent self-instrumentation of OTLP exports
           },
           "@opentelemetry/instrumentation-xml-http-request": {
             enabled: options.enableXhr ?? true,
-            propagateTraceHeaderCorsUrls: propagateTraceUrls
-            // Controlled by config/API
+            propagateTraceHeaderCorsUrls: [/.*/]
           }
         })
       ]
     });
-    sdkInstance = provider;
-    return provider;
-  } catch (error) {
-    throw new Error(`Failed to initialize OpenTelemetry SDK: ${error}`);
+  });
+  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
+      })
+    });
   }
+  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;
@@ -4687,12 +4678,11 @@ async function shutdownSdk() {
 }
 function resetSdk() {
   sdkInstance = null;
+  initializationDeferred = null;
 }
 
 // src/api.ts
-async function initializeInstrumentation(options) {
-  return await initializeSdk(options);
-}
+var initializeInstrumentation = (options) => initializeSdkEffect(options);
 function setSpanAttributes(span, attributes) {
   for (const [key, value] of Object.entries(attributes)) {
     span.setAttribute(key, value);