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

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';
@@ -11,8 +11,7 @@ import { z } from 'zod';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
-import { NodeContext } from '@effect/platform-node';
-import { FetchHttpClient } from '@effect/platform';
+import { createRequire } from 'module';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -84,11 +83,50 @@ var InstrumentationConfigSchema = z.object({
     ignore_patterns: z.array(PatternConfigSchema)
   }),
   effect: z.object({
+    // Enable/disable Effect tracing entirely
+    // When false, EffectInstrumentationLive returns Layer.empty
+    enabled: 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: z.enum(["unified", "standalone"]).default("unified"),
     auto_extract_metadata: 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 = parse(content);
+  } else {
+    parsed = content;
+  }
+  return InstrumentationConfigSchema.parse(parsed);
+}
 (class extends Data.TaggedError("ConfigError") {
   get message() {
     return this.reason;
@@ -266,7 +304,7 @@ var makeConfigLoader = Effect.gen(function* () {
     })
   });
 });
-var ConfigLoaderLive = Layer.effect(ConfigLoader, makeConfigLoader);
+Layer.effect(ConfigLoader, makeConfigLoader);
 var PatternMatcher = class {
   constructor(config) {
     __publicField2(this, "ignorePatterns", []);
@@ -430,8 +468,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
@@ -449,12 +493,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
@@ -683,88 +755,69 @@ var getServiceInfoWithFallback = detectServiceInfo.pipe(
     })
   )
 );
-var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
-  Layer.provide(Layer.mergeAll(NodeContext.layer, FetchHttpClient.layer))
-);
-var cachedLoaderPromise = null;
-function getCachedLoader() {
-  if (!cachedLoaderPromise) {
-    cachedLoaderPromise = Effect.runPromise(
-      Effect.gen(function* () {
-        return yield* ConfigLoader;
-      }).pipe(Effect.provide(NodeConfigLoaderLive))
-    );
-  }
-  return cachedLoaderPromise;
+async function detectServiceInfoAsync() {
+  return Effect.runPromise(getServiceInfoWithFallback);
 }
-function _resetConfigLoaderCache() {
-  cachedLoaderPromise = null;
+async function getServiceNameAsync() {
+  return Effect.runPromise(getServiceName);
 }
-async function loadConfig(uri, options) {
-  if (options?.cacheTimeout === 0) {
-    const program = Effect.gen(function* () {
-      const loader2 = yield* ConfigLoader;
-      return yield* loader2.loadFromUri(uri);
-    });
-    return Effect.runPromise(program.pipe(Effect.provide(NodeConfigLoaderLive)));
+async function getServiceVersionAsync() {
+  return 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.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.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 || [];
@@ -880,38 +933,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 +969,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 +989,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 +1025,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 +1049,7 @@ async function shutdownSdk() {
 }
 function resetSdk() {
   sdkInstance = null;
-  initializationDeferred = null;
+  initializationPromise = null;
 }
 function registerShutdownHandlers(sdk) {
   const shutdown = async (signal) => {
@@ -1071,10 +1104,63 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
   logger.log(`  - OTLP endpoint: ${endpoint}`);
   logger.log("");
 }
+var require2 = createRequire(import.meta.url);
+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.try({
+  try: () => validateOpenTelemetryApi(),
+  catch: (error) => new InitializationError2({
+    reason: error instanceof Error ? error.message : "Dependency validation failed",
+    cause: error
+  })
+});
+Effect.sync(() => validateEffectDependencies());
 
 // src/api.ts
-var initializeInstrumentation = (options = {}) => 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.gen(function* () {
+  yield* validateDependencies;
+  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 +1178,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 +1188,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 +1289,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