@atrim/instrument-node 0.5.0-c05e3a1-20251119131235 → 0.5.0

package/target/dist/index.js

@@ -1,4 +1,4 @@
-import { Data, Context, Effect, Layer, Deferred } from 'effect';
+import { Data, Context, Effect, Layer } from 'effect';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { SimpleSpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
@@ -59,20 +59,7 @@ var HttpFilteringConfigSchema = z.object({
   // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
   ignore_incoming_paths: z.array(z.string()).optional(),
   // Require parent span for outgoing requests (prevents root spans for HTTP calls)
-  require_parent_for_outgoing_spans: z.boolean().optional(),
-  // Trace context propagation configuration
-  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
-  propagate_trace_context: z.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: z.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: z.array(z.string()).optional()
-  }).optional()
+  require_parent_for_outgoing_spans: z.boolean().optional()
 });
 var InstrumentationConfigSchema = z.object({
   version: z.string(),
@@ -683,6 +670,15 @@ var getServiceInfoWithFallback = detectServiceInfo.pipe(
     })
   )
 );
+async function detectServiceInfoAsync() {
+  return Effect.runPromise(getServiceInfoWithFallback);
+}
+async function getServiceNameAsync() {
+  return Effect.runPromise(getServiceName);
+}
+async function getServiceVersionAsync() {
+  return Effect.runPromise(getServiceVersion);
+}
 var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
   Layer.provide(Layer.mergeAll(NodeContext.layer, FetchHttpClient.layer))
 );
@@ -764,7 +760,7 @@ async function loadConfigWithOptions(options = {}) {
 
 // src/core/sdk-initializer.ts
 var sdkInstance = null;
-var initializationDeferred = null;
+var initializationPromise = null;
 function buildHttpInstrumentationConfig(options, config, _otlpEndpoint) {
   const httpConfig = { enabled: true };
   const programmaticPatterns = options.http?.ignoreOutgoingUrls || [];
@@ -880,38 +876,27 @@ function isTracingAlreadyInitialized() {
     return false;
   }
 }
-var initializeSdkEffect = (options = {}) => Effect.gen(function* () {
+async function initializeSdk(options = {}) {
   if (sdkInstance) {
     logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
     return sdkInstance;
   }
-  if (initializationDeferred) {
+  if (initializationPromise) {
     logger.log(
-      "@atrim/instrumentation: SDK initialization in progress, waiting for completion..."
+      "@atrim/instrumentation: SDK already initialized, waiting for initialization to complete..."
     );
-    return yield* Deferred.await(initializationDeferred);
-  }
-  const deferred = yield* Deferred.make();
-  initializationDeferred = deferred;
-  const result = yield* performInitializationEffect(options).pipe(
-    Effect.tap((sdk) => Deferred.succeed(deferred, sdk)),
-    Effect.tapError((error) => Deferred.fail(deferred, error)),
-    Effect.ensuring(
-      Effect.sync(() => {
-        initializationDeferred = null;
-      })
-    )
-  );
-  return result;
-});
-var performInitializationEffect = (options) => Effect.gen(function* () {
-  const config = yield* Effect.tryPromise({
-    try: () => loadConfigWithOptions(options),
-    catch: (error) => new InitializationError2({
-      reason: "Failed to load configuration",
-      cause: error
-    })
-  });
+    return initializationPromise;
+  }
+  initializationPromise = performInitialization(options);
+  try {
+    const result = await initializationPromise;
+    return result;
+  } finally {
+    initializationPromise = null;
+  }
+}
+async function performInitialization(options) {
+  const config = await loadConfigWithOptions(options);
   const loggingLevel = config.instrumentation.logging || "on";
   logger.setLevel(loggingLevel);
   const alreadyInitialized = isTracingAlreadyInitialized();
@@ -927,25 +912,14 @@ var performInitializationEffect = (options) => Effect.gen(function* () {
     logger.log("");
     return null;
   }
-  const serviceInfo = yield* detectServiceInfo.pipe(
-    Effect.catchAll(
-      () => Effect.succeed({
-        name: "unknown-service",
-        version: void 0
-      })
-    )
-  );
+  const serviceInfo = await detectServiceInfoAsync();
   const serviceName = options.serviceName || serviceInfo.name;
   const serviceVersion = options.serviceVersion || serviceInfo.version;
-  const rawExporter = yield* Effect.sync(() => createOtlpExporter(options.otlp));
-  const exporter = yield* Effect.sync(() => new SafeSpanExporter(rawExporter));
+  const rawExporter = createOtlpExporter(options.otlp);
+  const exporter = new SafeSpanExporter(rawExporter);
   const useSimpleProcessor = process.env.NODE_ENV === "test" || process.env.OTEL_USE_SIMPLE_PROCESSOR === "true";
-  const baseProcessor = yield* Effect.sync(
-    () => useSimpleProcessor ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter)
-  );
-  const patternProcessor = yield* Effect.sync(
-    () => new PatternSpanProcessor(config, baseProcessor)
-  );
+  const baseProcessor = useSimpleProcessor ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter);
+  const patternProcessor = new PatternSpanProcessor(config, baseProcessor);
   const instrumentations = [];
   const hasWebFramework = hasWebFrameworkInstalled();
   const enableAutoInstrumentation = shouldEnableAutoInstrumentation(
@@ -958,11 +932,15 @@ var performInitializationEffect = (options) => Effect.gen(function* () {
     const undiciConfig = buildUndiciInstrumentationConfig(options, config);
     instrumentations.push(
       ...getNodeAutoInstrumentations({
+        // Enable HTTP instrumentation with filtering (for http/https modules)
         "@opentelemetry/instrumentation-http": httpConfig,
+        // Enable undici instrumentation with filtering (for fetch API)
         "@opentelemetry/instrumentation-undici": undiciConfig,
+        // Enable web framework instrumentations
         "@opentelemetry/instrumentation-express": { enabled: true },
         "@opentelemetry/instrumentation-fastify": { enabled: true },
         "@opentelemetry/instrumentation-koa": { enabled: true },
+        // Disable noisy instrumentations by default
         "@opentelemetry/instrumentation-fs": { enabled: false },
         "@opentelemetry/instrumentation-dns": { enabled: false }
       })
@@ -990,20 +968,18 @@ var performInitializationEffect = (options) => Effect.gen(function* () {
     serviceName,
     ...serviceVersion && { serviceVersion },
     instrumentations,
+    // Allow advanced overrides
     ...options.sdk
   };
-  const sdk = yield* Effect.sync(() => {
-    const s = new NodeSDK(sdkConfig);
-    s.start();
-    return s;
-  });
+  const sdk = new NodeSDK(sdkConfig);
+  sdk.start();
   sdkInstance = sdk;
   if (!options.disableAutoShutdown) {
-    yield* Effect.sync(() => registerShutdownHandlers(sdk));
+    registerShutdownHandlers(sdk);
   }
   logInitialization(config, serviceName, serviceVersion, options, enableAutoInstrumentation);
   return sdk;
-});
+}
 function getSdkInstance() {
   return sdkInstance;
 }
@@ -1016,7 +992,7 @@ async function shutdownSdk() {
 }
 function resetSdk() {
   sdkInstance = null;
-  initializationDeferred = null;
+  initializationPromise = null;
 }
 function registerShutdownHandlers(sdk) {
   const shutdown = async (signal) => {
@@ -1073,8 +1049,30 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
 }
 
 // src/api.ts
-var initializeInstrumentation = (options = {}) => Effect.gen(function* () {
-  const sdk = yield* initializeSdkEffect(options);
+async function initializeInstrumentation(options = {}) {
+  const sdk = await initializeSdk(options);
+  if (sdk) {
+    const config = await loadConfigWithOptions(options);
+    initializePatternMatcher(config);
+  }
+  return sdk;
+}
+async function initializePatternMatchingOnly(options = {}) {
+  const config = await loadConfigWithOptions(options);
+  initializePatternMatcher(config);
+  logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+  logger.log(
+    "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
+  );
+}
+var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* () {
+  const sdk = yield* Effect.tryPromise({
+    try: () => initializeSdk(options),
+    catch: (error) => new InitializationError2({
+      reason: "SDK initialization failed",
+      cause: error
+    })
+  });
   if (sdk) {
     yield* Effect.tryPromise({
       try: () => loadConfigWithOptions(options),
@@ -1092,7 +1090,7 @@ var initializeInstrumentation = (options = {}) => Effect.gen(function* () {
   }
   return sdk;
 });
-var initializePatternMatchingOnly = (options = {}) => Effect.gen(function* () {
+var initializePatternMatchingOnlyEffect = (options = {}) => Effect.gen(function* () {
   const config = yield* Effect.tryPromise({
     try: () => loadConfigWithOptions(options),
     catch: (error) => new ConfigError2({
@@ -1102,7 +1100,7 @@ var initializePatternMatchingOnly = (options = {}) => Effect.gen(function* () {
   });
   yield* Effect.sync(() => {
     initializePatternMatcher(config);
-    logger.log("@atrim/instrumentation: Pattern matching initialized (pattern-only mode)");
+    logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
     logger.log(
       "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
     );
@@ -1203,6 +1201,6 @@ function suppressShutdownErrors() {
   });
 }
 
-export { ConfigError2 as ConfigError, ConfigFileError2 as ConfigFileError, ConfigUrlError2 as ConfigUrlError, ConfigValidationError2 as ConfigValidationError, ExportError2 as ExportError, InitializationError2 as InitializationError, PatternMatcher, PatternSpanProcessor, ServiceDetectionError2 as ServiceDetectionError, ShutdownError2 as ShutdownError, annotateCacheOperation, annotateDbQuery, annotateHttpRequest, _resetConfigLoaderCache as clearConfigCache, createOtlpExporter, detectServiceInfo, getOtlpEndpoint, getPatternMatcher, getSdkInstance, getServiceInfoWithFallback, getServiceName, getServiceVersion, initializeInstrumentation, initializePatternMatchingOnly, loadConfig, loadConfigFromInline, loadConfigWithOptions, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shouldInstrumentSpan, shutdownSdk, suppressShutdownErrors };
+export { ConfigError2 as ConfigError, ConfigFileError2 as ConfigFileError, ConfigUrlError2 as ConfigUrlError, ConfigValidationError2 as ConfigValidationError, ExportError2 as ExportError, InitializationError2 as InitializationError, PatternMatcher, PatternSpanProcessor, ServiceDetectionError2 as ServiceDetectionError, ShutdownError2 as ShutdownError, annotateCacheOperation, annotateDbQuery, annotateHttpRequest, _resetConfigLoaderCache as clearConfigCache, createOtlpExporter, detectServiceInfoAsync as detectServiceInfo, detectServiceInfo as detectServiceInfoEffect, getOtlpEndpoint, getPatternMatcher, getSdkInstance, getServiceInfoWithFallback, getServiceNameAsync as getServiceName, getServiceName as getServiceNameEffect, getServiceVersionAsync as getServiceVersion, getServiceVersion as getServiceVersionEffect, initializeInstrumentation, initializeInstrumentationEffect, initializePatternMatchingOnly, initializePatternMatchingOnlyEffect, loadConfig, loadConfigFromInline, loadConfigWithOptions, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shouldInstrumentSpan, shutdownSdk, suppressShutdownErrors };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map