@atrim/instrument-web 0.4.1 → 0.5.0-c05e3a1-20251119131241

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atrim/instrument-web",
-  "version": "0.4.1",
+  "version": "0.5.0-c05e3a1-20251119131241",
   "description": "OpenTelemetry instrumentation for browsers with centralized YAML configuration",
   "type": "module",
   "license": "MIT",
@@ -68,7 +68,7 @@
     "tsup": "^8.0.1",
     "typescript": "^5.7.2",
     "vitest": "^4.0.8",
-    "@atrim/instrument-core": "0.4.1"
+    "@atrim/instrument-core": "0.5.0"
   },
   "scripts": {
     "build": "tsup",
@@ -82,10 +82,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

@@ -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';
 
@@ -103,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';
@@ -4095,7 +4095,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,43 +4539,34 @@ var PatternSpanProcessor = class {
 
 // src/core/sdk-initializer.ts
 var sdkInstance = null;
-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."
-      );
-    }
+  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;
@@ -4570,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({
@@ -4607,11 +4616,56 @@ async function initializeSdk(options) {
         })
       ]
     });
-    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;
@@ -4624,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);