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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atrim/instrument-web",
-  "version": "0.5.0-c05e3a1-20251119131241",
+  "version": "0.5.0",
   "description": "OpenTelemetry instrumentation for browsers with centralized YAML configuration",
   "type": "module",
   "license": "MIT",
@@ -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": "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: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: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": "pnpm version 0.5.0 --no-git-tag-version",
+    "publish:dev:reset": "npm version 0.1.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, 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';
 
@@ -103,47 +103,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';
@@ -4095,20 +4095,7 @@ 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(),
-  // 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()
+  require_parent_for_outgoing_spans: external_exports.boolean().optional()
 });
 var InstrumentationConfigSchema = external_exports.object({
   version: external_exports.string(),
@@ -4539,34 +4526,43 @@ var PatternSpanProcessor = class {
 
 // src/core/sdk-initializer.ts
 var sdkInstance = null;
-var initializationDeferred = null;
-var initializeSdkEffect = (options) => Effect.gen(function* () {
+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 exporterOptions = {};
     if (options.otlpEndpoint) {
       exporterOptions.endpoint = options.otlpEndpoint;
@@ -4574,23 +4570,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({
@@ -4616,56 +4607,11 @@ var performInitializationEffect = (options) => Effect.gen(function* () {
         })
       ]
     });
-  });
-  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 +4624,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);