@atrim/instrument-node 0.5.0-c05e3a1-20251119131235 → 0.5.1-1451fcf-20260105212505

package/target/dist/index.cjs

@@ -13,9 +13,9 @@ var zod = require('zod');
 var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
 var promises = require('fs/promises');
 var path = require('path');
-var platformNode = require('@effect/platform-node');
-var platform = require('@effect/platform');
+var module$1 = require('module');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   var n = Object.create(null);
@@ -107,11 +107,50 @@ var InstrumentationConfigSchema = zod.z.object({
     ignore_patterns: zod.z.array(PatternConfigSchema)
   }),
   effect: zod.z.object({
+    // Enable/disable Effect tracing entirely
+    // When false, EffectInstrumentationLive returns Layer.empty
+    enabled: zod.z.boolean().default(true),
+    // Exporter mode:
+    // - "unified": Use global TracerProvider from Node SDK (recommended, enables filtering)
+    // - "standalone": Use Effect's own OTLP exporter (bypasses Node SDK filtering)
+    exporter: zod.z.enum(["unified", "standalone"]).default("unified"),
     auto_extract_metadata: zod.z.boolean(),
     auto_isolation: AutoIsolationConfigSchema.optional()
   }).optional(),
   http: HttpFilteringConfigSchema.optional()
 });
+var defaultConfig = {
+  version: "1.0",
+  instrumentation: {
+    enabled: true,
+    logging: "on",
+    description: "Default instrumentation configuration",
+    instrument_patterns: [
+      { pattern: "^app\\.", enabled: true, description: "Application operations" },
+      { pattern: "^http\\.server\\.", enabled: true, description: "HTTP server operations" },
+      { pattern: "^http\\.client\\.", enabled: true, description: "HTTP client operations" }
+    ],
+    ignore_patterns: [
+      { pattern: "^test\\.", description: "Test utilities" },
+      { pattern: "^internal\\.", description: "Internal operations" },
+      { pattern: "^health\\.", description: "Health checks" }
+    ]
+  },
+  effect: {
+    enabled: true,
+    exporter: "unified",
+    auto_extract_metadata: true
+  }
+};
+function parseAndValidateConfig(content) {
+  let parsed;
+  if (typeof content === "string") {
+    parsed = yaml.parse(content);
+  } else {
+    parsed = content;
+  }
+  return InstrumentationConfigSchema.parse(parsed);
+}
 (class extends effect.Data.TaggedError("ConfigError") {
   get message() {
     return this.reason;
@@ -289,7 +328,7 @@ var makeConfigLoader = effect.Effect.gen(function* () {
     })
   });
 });
-var ConfigLoaderLive = effect.Layer.effect(ConfigLoader, makeConfigLoader);
+effect.Layer.effect(ConfigLoader, makeConfigLoader);
 var PatternMatcher = class {
   constructor(config) {
     __publicField2(this, "ignorePatterns", []);
@@ -453,8 +492,14 @@ var PatternSpanProcessor = class {
   constructor(config, wrappedProcessor) {
     __publicField(this, "matcher");
     __publicField(this, "wrappedProcessor");
+    __publicField(this, "httpIgnorePatterns", []);
     this.matcher = new PatternMatcher(config);
     this.wrappedProcessor = wrappedProcessor;
+    if (config.http?.ignore_incoming_paths) {
+      this.httpIgnorePatterns = config.http.ignore_incoming_paths.map(
+        (pattern) => new RegExp(pattern)
+      );
+    }
   }
   /**
    * Called when a span is started
@@ -472,12 +517,40 @@ var PatternSpanProcessor = class {
    * Called when a span is ended
    *
    * This is where we make the final decision on whether to export the span.
+   * We check both span name patterns and HTTP path patterns.
    */
   onEnd(span) {
     const spanName = span.name;
-    if (this.matcher.shouldInstrument(spanName)) {
-      this.wrappedProcessor.onEnd(span);
+    if (!this.matcher.shouldInstrument(spanName)) {
+      return;
+    }
+    if (this.shouldIgnoreHttpSpan(span)) {
+      return;
     }
+    this.wrappedProcessor.onEnd(span);
+  }
+  /**
+   * Check if span should be ignored based on HTTP path attributes
+   *
+   * This checks the span's url.path, http.route, or http.target attributes
+   * against the configured http.ignore_incoming_paths patterns.
+   *
+   * This enables filtering of Effect HTTP spans (and any other HTTP spans)
+   * based on path patterns, which is essential for filtering out OTLP
+   * endpoint requests like /v1/traces, /v1/logs, /v1/metrics.
+   */
+  shouldIgnoreHttpSpan(span) {
+    if (this.httpIgnorePatterns.length === 0) {
+      return false;
+    }
+    const urlPath = span.attributes["url.path"];
+    const httpRoute = span.attributes["http.route"];
+    const httpTarget = span.attributes["http.target"];
+    const pathToCheck = urlPath || httpRoute || httpTarget;
+    if (!pathToCheck) {
+      return false;
+    }
+    return this.httpIgnorePatterns.some((pattern) => pattern.test(pathToCheck));
   }
   /**
    * Shutdown the processor
@@ -706,88 +779,69 @@ var getServiceInfoWithFallback = detectServiceInfo.pipe(
     })
   )
 );
-var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
-  effect.Layer.provide(effect.Layer.mergeAll(platformNode.NodeContext.layer, platform.FetchHttpClient.layer))
-);
-var cachedLoaderPromise = null;
-function getCachedLoader() {
-  if (!cachedLoaderPromise) {
-    cachedLoaderPromise = effect.Effect.runPromise(
-      effect.Effect.gen(function* () {
-        return yield* ConfigLoader;
-      }).pipe(effect.Effect.provide(NodeConfigLoaderLive))
-    );
-  }
-  return cachedLoaderPromise;
+async function detectServiceInfoAsync() {
+  return effect.Effect.runPromise(getServiceInfoWithFallback);
 }
-function _resetConfigLoaderCache() {
-  cachedLoaderPromise = null;
+async function getServiceNameAsync() {
+  return effect.Effect.runPromise(getServiceName);
 }
-async function loadConfig(uri, options) {
-  if (options?.cacheTimeout === 0) {
-    const program = effect.Effect.gen(function* () {
-      const loader2 = yield* ConfigLoader;
-      return yield* loader2.loadFromUri(uri);
-    });
-    return effect.Effect.runPromise(program.pipe(effect.Effect.provide(NodeConfigLoaderLive)));
+async function getServiceVersionAsync() {
+  return effect.Effect.runPromise(getServiceVersion);
+}
+async function loadFromFile(filePath) {
+  const { readFile: readFile2 } = await import('fs/promises');
+  const content = await readFile2(filePath, "utf-8");
+  return parseAndValidateConfig(content);
+}
+async function loadFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch config from ${url}: ${response.statusText}`);
   }
-  const loader = await getCachedLoader();
-  return effect.Effect.runPromise(loader.loadFromUri(uri));
+  const content = await response.text();
+  return parseAndValidateConfig(content);
+}
+async function loadConfig(uri, _options) {
+  if (uri.startsWith("http://") || uri.startsWith("https://")) {
+    return loadFromUrl(uri);
+  }
+  if (uri.startsWith("file://")) {
+    const filePath = uri.slice(7);
+    return loadFromFile(filePath);
+  }
+  return loadFromFile(uri);
 }
 async function loadConfigFromInline(content) {
-  const loader = await getCachedLoader();
-  return effect.Effect.runPromise(loader.loadFromInline(content));
+  return parseAndValidateConfig(content);
 }
-function getDefaultConfig() {
-  return {
-    version: "1.0",
-    instrumentation: {
-      enabled: true,
-      logging: "on",
-      description: "Default instrumentation configuration",
-      instrument_patterns: [
-        { pattern: "^app\\.", enabled: true, description: "Application operations" },
-        { pattern: "^http\\.server\\.", enabled: true, description: "HTTP server operations" },
-        { pattern: "^http\\.client\\.", enabled: true, description: "HTTP client operations" }
-      ],
-      ignore_patterns: [
-        { pattern: "^test\\.", description: "Test utilities" },
-        { pattern: "^internal\\.", description: "Internal operations" },
-        { pattern: "^health\\.", description: "Health checks" }
-      ]
-    },
-    effect: {
-      auto_extract_metadata: true
-    }
-  };
+function _resetConfigLoaderCache() {
 }
 async function loadConfigWithOptions(options = {}) {
-  const loadOptions = options.cacheTimeout !== void 0 ? { cacheTimeout: options.cacheTimeout } : void 0;
   if (options.config) {
     return loadConfigFromInline(options.config);
   }
   const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
   if (envConfigPath) {
-    return loadConfig(envConfigPath, loadOptions);
+    return loadConfig(envConfigPath);
   }
   if (options.configUrl) {
-    return loadConfig(options.configUrl, loadOptions);
+    return loadConfig(options.configUrl);
   }
   if (options.configPath) {
-    return loadConfig(options.configPath, loadOptions);
+    return loadConfig(options.configPath);
   }
   const { existsSync } = await import('fs');
   const { join: join2 } = await import('path');
   const defaultPath = join2(process.cwd(), "instrumentation.yaml");
   if (existsSync(defaultPath)) {
-    return loadConfig(defaultPath, loadOptions);
+    return loadConfig(defaultPath);
   }
-  return getDefaultConfig();
+  return defaultConfig;
 }
 
 // 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 || [];
@@ -903,38 +957,27 @@ function isTracingAlreadyInitialized() {
     return false;
   }
 }
-var initializeSdkEffect = (options = {}) => effect.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* effect.Deferred.await(initializationDeferred);
-  }
-  const deferred = yield* effect.Deferred.make();
-  initializationDeferred = deferred;
-  const result = yield* performInitializationEffect(options).pipe(
-    effect.Effect.tap((sdk) => effect.Deferred.succeed(deferred, sdk)),
-    effect.Effect.tapError((error) => effect.Deferred.fail(deferred, error)),
-    effect.Effect.ensuring(
-      effect.Effect.sync(() => {
-        initializationDeferred = null;
-      })
-    )
-  );
-  return result;
-});
-var performInitializationEffect = (options) => effect.Effect.gen(function* () {
-  const config = yield* effect.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();
@@ -950,25 +993,14 @@ var performInitializationEffect = (options) => effect.Effect.gen(function* () {
     logger.log("");
     return null;
   }
-  const serviceInfo = yield* detectServiceInfo.pipe(
-    effect.Effect.catchAll(
-      () => effect.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.Effect.sync(() => createOtlpExporter(options.otlp));
-  const exporter = yield* effect.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.Effect.sync(
-    () => useSimpleProcessor ? new sdkTraceBase.SimpleSpanProcessor(exporter) : new sdkTraceBase.BatchSpanProcessor(exporter)
-  );
-  const patternProcessor = yield* effect.Effect.sync(
-    () => new PatternSpanProcessor(config, baseProcessor)
-  );
+  const baseProcessor = useSimpleProcessor ? new sdkTraceBase.SimpleSpanProcessor(exporter) : new sdkTraceBase.BatchSpanProcessor(exporter);
+  const patternProcessor = new PatternSpanProcessor(config, baseProcessor);
   const instrumentations = [];
   const hasWebFramework = hasWebFrameworkInstalled();
   const enableAutoInstrumentation = shouldEnableAutoInstrumentation(
@@ -981,11 +1013,15 @@ var performInitializationEffect = (options) => effect.Effect.gen(function* () {
     const undiciConfig = buildUndiciInstrumentationConfig(options, config);
     instrumentations.push(
       ...autoInstrumentationsNode.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 }
       })
@@ -1013,20 +1049,18 @@ var performInitializationEffect = (options) => effect.Effect.gen(function* () {
     serviceName,
     ...serviceVersion && { serviceVersion },
     instrumentations,
+    // Allow advanced overrides
     ...options.sdk
   };
-  const sdk = yield* effect.Effect.sync(() => {
-    const s = new sdkNode.NodeSDK(sdkConfig);
-    s.start();
-    return s;
-  });
+  const sdk = new sdkNode.NodeSDK(sdkConfig);
+  sdk.start();
   sdkInstance = sdk;
   if (!options.disableAutoShutdown) {
-    yield* effect.Effect.sync(() => registerShutdownHandlers(sdk));
+    registerShutdownHandlers(sdk);
   }
   logInitialization(config, serviceName, serviceVersion, options, enableAutoInstrumentation);
   return sdk;
-});
+}
 function getSdkInstance() {
   return sdkInstance;
 }
@@ -1039,7 +1073,7 @@ async function shutdownSdk() {
 }
 function resetSdk() {
   sdkInstance = null;
-  initializationDeferred = null;
+  initializationPromise = null;
 }
 function registerShutdownHandlers(sdk) {
   const shutdown = async (signal) => {
@@ -1094,10 +1128,63 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
   logger.log(`  - OTLP endpoint: ${endpoint}`);
   logger.log("");
 }
+var require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+function validateOpenTelemetryApi() {
+  try {
+    require2.resolve("@opentelemetry/api");
+  } catch {
+    throw new Error(
+      "@atrim/instrument-node requires @opentelemetry/api as a peer dependency.\n\nInstall it with:\n  npm install @opentelemetry/api\n\nOr with your preferred package manager:\n  pnpm add @opentelemetry/api\n  yarn add @opentelemetry/api\n  bun add @opentelemetry/api"
+    );
+  }
+}
+function validateEffectDependencies() {
+  const packages = ["effect", "@effect/opentelemetry", "@effect/platform"];
+  for (const pkg of packages) {
+    try {
+      require2.resolve(pkg);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+var validateDependencies = effect.Effect.try({
+  try: () => validateOpenTelemetryApi(),
+  catch: (error) => new InitializationError2({
+    reason: error instanceof Error ? error.message : "Dependency validation failed",
+    cause: error
+  })
+});
+effect.Effect.sync(() => validateEffectDependencies());
 
 // src/api.ts
-var initializeInstrumentation = (options = {}) => effect.Effect.gen(function* () {
-  const sdk = yield* initializeSdkEffect(options);
+async function initializeInstrumentation(options = {}) {
+  validateOpenTelemetryApi();
+  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.Effect.gen(function* () {
+  yield* validateDependencies;
+  const sdk = yield* effect.Effect.tryPromise({
+    try: () => initializeSdk(options),
+    catch: (error) => new InitializationError2({
+      reason: "SDK initialization failed",
+      cause: error
+    })
+  });
   if (sdk) {
     yield* effect.Effect.tryPromise({
       try: () => loadConfigWithOptions(options),
@@ -1115,7 +1202,7 @@ var initializeInstrumentation = (options = {}) => effect.Effect.gen(function* ()
   }
   return sdk;
 });
-var initializePatternMatchingOnly = (options = {}) => effect.Effect.gen(function* () {
+var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(function* () {
   const config = yield* effect.Effect.tryPromise({
     try: () => loadConfigWithOptions(options),
     catch: (error) => new ConfigError2({
@@ -1125,7 +1212,7 @@ var initializePatternMatchingOnly = (options = {}) => effect.Effect.gen(function
   });
   yield* effect.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."
     );
@@ -1241,15 +1328,20 @@ exports.annotateDbQuery = annotateDbQuery;
 exports.annotateHttpRequest = annotateHttpRequest;
 exports.clearConfigCache = _resetConfigLoaderCache;
 exports.createOtlpExporter = createOtlpExporter;
-exports.detectServiceInfo = detectServiceInfo;
+exports.detectServiceInfo = detectServiceInfoAsync;
+exports.detectServiceInfoEffect = detectServiceInfo;
 exports.getOtlpEndpoint = getOtlpEndpoint;
 exports.getPatternMatcher = getPatternMatcher;
 exports.getSdkInstance = getSdkInstance;
 exports.getServiceInfoWithFallback = getServiceInfoWithFallback;
-exports.getServiceName = getServiceName;
-exports.getServiceVersion = getServiceVersion;
+exports.getServiceName = getServiceNameAsync;
+exports.getServiceNameEffect = getServiceName;
+exports.getServiceVersion = getServiceVersionAsync;
+exports.getServiceVersionEffect = getServiceVersion;
 exports.initializeInstrumentation = initializeInstrumentation;
+exports.initializeInstrumentationEffect = initializeInstrumentationEffect;
 exports.initializePatternMatchingOnly = initializePatternMatchingOnly;
+exports.initializePatternMatchingOnlyEffect = initializePatternMatchingOnlyEffect;
 exports.loadConfig = loadConfig;
 exports.loadConfigFromInline = loadConfigFromInline;
 exports.loadConfigWithOptions = loadConfigWithOptions;