@atrim/instrument-node 1.0.0

package/target/dist/index.js

@@ -0,0 +1,1095 @@
+import { Data, Effect, Cache, Duration, Schedule } from 'effect';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { SimpleSpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { trace } from '@opentelemetry/api';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { parse } from 'yaml';
+import { z } from 'zod';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { readFile } from 'fs/promises';
+
+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;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var PatternConfigSchema = z.object({
+  pattern: z.string(),
+  enabled: z.boolean().optional(),
+  description: z.string().optional()
+});
+var AutoIsolationConfigSchema = z.object({
+  // Global enable/disable for auto-isolation
+  enabled: z.boolean().default(false),
+  // Which operators to auto-isolate
+  operators: z.object({
+    fiberset_run: z.boolean().default(true),
+    effect_fork: z.boolean().default(true),
+    effect_fork_daemon: z.boolean().default(true),
+    effect_fork_in: z.boolean().default(false)
+  }).default({}),
+  // Virtual parent tracking configuration
+  tracking: z.object({
+    use_span_links: z.boolean().default(true),
+    use_attributes: z.boolean().default(true),
+    capture_logical_parent: z.boolean().default(true)
+  }).default({}),
+  // Span categorization
+  attributes: z.object({
+    category: z.string().default("background_task"),
+    add_metadata: z.boolean().default(true)
+  }).default({})
+});
+var InstrumentationConfigSchema = z.object({
+  version: z.string(),
+  instrumentation: z.object({
+    enabled: z.boolean(),
+    description: z.string().optional(),
+    logging: z.enum(["on", "off", "minimal"]).optional().default("on"),
+    instrument_patterns: z.array(PatternConfigSchema),
+    ignore_patterns: z.array(PatternConfigSchema)
+  }),
+  effect: z.object({
+    auto_extract_metadata: z.boolean(),
+    auto_isolation: AutoIsolationConfigSchema.optional()
+  }).optional()
+});
+(class extends Data.TaggedError("ConfigError") {
+});
+var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
+};
+var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
+};
+var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
+};
+(class extends Data.TaggedError("ServiceDetectionError") {
+});
+(class extends Data.TaggedError("InitializationError") {
+});
+(class extends Data.TaggedError("ExportError") {
+});
+(class extends Data.TaggedError("ShutdownError") {
+});
+var SECURITY_DEFAULTS = {
+  maxConfigSize: 1e6,
+  // 1MB
+  requestTimeout: 5e3,
+  allowedProtocols: ["https:"],
+  // Only HTTPS for remote configs
+  cacheTimeout: 3e5
+  // 5 minutes
+};
+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
+    }
+  };
+}
+var validateConfigEffect = (rawConfig) => Effect.try({
+  try: () => InstrumentationConfigSchema.parse(rawConfig),
+  catch: (error) => new ConfigValidationError({
+    reason: "Invalid configuration schema",
+    cause: error
+  })
+});
+var loadConfigFromFileEffect = (filePath) => Effect.gen(function* () {
+  const fileContents = yield* Effect.try({
+    try: () => readFileSync(filePath, "utf8"),
+    catch: (error) => new ConfigFileError({
+      reason: `Failed to read config file at ${filePath}`,
+      cause: error
+    })
+  });
+  if (fileContents.length > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* Effect.fail(
+      new ConfigFileError({
+        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  let rawConfig;
+  try {
+    rawConfig = parse(fileContents);
+  } catch (error) {
+    return yield* Effect.fail(
+      new ConfigValidationError({
+        reason: "Invalid YAML syntax",
+        cause: error
+      })
+    );
+  }
+  return yield* validateConfigEffect(rawConfig);
+});
+var fetchAndParseConfig = (url) => Effect.gen(function* () {
+  let urlObj;
+  try {
+    urlObj = new URL(url);
+  } catch (error) {
+    return yield* Effect.fail(
+      new ConfigUrlError({
+        reason: `Invalid URL: ${url}`,
+        cause: error
+      })
+    );
+  }
+  if (!SECURITY_DEFAULTS.allowedProtocols.includes(urlObj.protocol)) {
+    return yield* Effect.fail(
+      new ConfigUrlError({
+        reason: `Insecure protocol ${urlObj.protocol}. Only ${SECURITY_DEFAULTS.allowedProtocols.join(", ")} are allowed`
+      })
+    );
+  }
+  const response = yield* Effect.tryPromise({
+    try: () => fetch(url, {
+      redirect: "follow",
+      headers: {
+        Accept: "application/yaml, text/yaml, text/x-yaml"
+      }
+    }),
+    catch: (error) => new ConfigUrlError({
+      reason: `Failed to load config from URL ${url}`,
+      cause: error
+    })
+  }).pipe(
+    Effect.timeout(Duration.millis(SECURITY_DEFAULTS.requestTimeout)),
+    Effect.retry({
+      times: 3,
+      schedule: Schedule.exponential(Duration.millis(100))
+    }),
+    Effect.catchAll((error) => {
+      if (error._tag === "TimeoutException") {
+        return Effect.fail(
+          new ConfigUrlError({
+            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms`
+          })
+        );
+      }
+      return Effect.fail(error);
+    })
+  );
+  if (!response.ok) {
+    return yield* Effect.fail(
+      new ConfigUrlError({
+        reason: `HTTP ${response.status}: ${response.statusText}`
+      })
+    );
+  }
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && parseInt(contentLength) > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* Effect.fail(
+      new ConfigUrlError({
+        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  const text = yield* Effect.tryPromise({
+    try: () => response.text(),
+    catch: (error) => new ConfigUrlError({
+      reason: "Failed to read response body",
+      cause: error
+    })
+  });
+  if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* Effect.fail(
+      new ConfigUrlError({
+        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  let rawConfig;
+  try {
+    rawConfig = parse(text);
+  } catch (error) {
+    return yield* Effect.fail(
+      new ConfigValidationError({
+        reason: "Invalid YAML syntax",
+        cause: error
+      })
+    );
+  }
+  return yield* validateConfigEffect(rawConfig);
+});
+var makeConfigCache = () => Cache.make({
+  capacity: 100,
+  timeToLive: Duration.minutes(5),
+  lookup: (url) => fetchAndParseConfig(url)
+});
+var cacheInstance = null;
+var getCache = Effect.gen(function* () {
+  if (!cacheInstance) {
+    cacheInstance = yield* makeConfigCache();
+  }
+  return cacheInstance;
+});
+var loadConfigFromUrlEffect = (url, cacheTimeout = SECURITY_DEFAULTS.cacheTimeout) => Effect.gen(function* () {
+  if (cacheTimeout === 0) {
+    return yield* fetchAndParseConfig(url);
+  }
+  const cache = yield* getCache;
+  return yield* cache.get(url);
+});
+var loadConfigEffect = (options = {}) => Effect.gen(function* () {
+  if (options.config) {
+    return yield* validateConfigEffect(options.config);
+  }
+  const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
+  if (envConfigPath) {
+    if (envConfigPath.startsWith("http://") || envConfigPath.startsWith("https://")) {
+      return yield* loadConfigFromUrlEffect(envConfigPath, options.cacheTimeout);
+    }
+    return yield* loadConfigFromFileEffect(envConfigPath);
+  }
+  if (options.configUrl) {
+    return yield* loadConfigFromUrlEffect(options.configUrl, options.cacheTimeout);
+  }
+  if (options.configPath) {
+    return yield* loadConfigFromFileEffect(options.configPath);
+  }
+  const defaultPath = join(process.cwd(), "instrumentation.yaml");
+  const exists = yield* Effect.sync(() => existsSync(defaultPath));
+  if (exists) {
+    return yield* loadConfigFromFileEffect(defaultPath);
+  }
+  return getDefaultConfig();
+});
+async function loadConfig(options = {}) {
+  return Effect.runPromise(
+    loadConfigEffect(options).pipe(
+      // Convert typed errors to regular Error with reason message for backward compatibility
+      Effect.mapError((error) => {
+        const message = error.reason;
+        const newError = new Error(message);
+        newError.cause = error.cause;
+        return newError;
+      })
+    )
+  );
+}
+var PatternMatcher = class {
+  constructor(config) {
+    __publicField2(this, "ignorePatterns", []);
+    __publicField2(this, "instrumentPatterns", []);
+    __publicField2(this, "enabled", true);
+    this.enabled = config.instrumentation.enabled;
+    this.ignorePatterns = config.instrumentation.ignore_patterns.map((p) => this.compilePattern(p));
+    this.instrumentPatterns = config.instrumentation.instrument_patterns.filter((p) => p.enabled !== false).map((p) => this.compilePattern(p));
+  }
+  /**
+   * Compile a pattern configuration into a RegExp
+   */
+  compilePattern(pattern) {
+    try {
+      const compiled = {
+        regex: new RegExp(pattern.pattern),
+        enabled: pattern.enabled !== false
+      };
+      if (pattern.description !== void 0) {
+        compiled.description = pattern.description;
+      }
+      return compiled;
+    } catch (error) {
+      throw new Error(
+        `Failed to compile pattern "${pattern.pattern}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if a span should be instrumented
+   *
+   * Returns true if the span should be created, false otherwise.
+   *
+   * Logic:
+   * 1. If instrumentation disabled globally, return false
+   * 2. Check ignore patterns - if any match, return false
+   * 3. Check instrument patterns - if any match, return true
+   * 4. Default: return true (fail-open - create span if no patterns match)
+   */
+  shouldInstrument(spanName) {
+    if (!this.enabled) {
+      return false;
+    }
+    for (const pattern of this.ignorePatterns) {
+      if (pattern.regex.test(spanName)) {
+        return false;
+      }
+    }
+    for (const pattern of this.instrumentPatterns) {
+      if (pattern.enabled && pattern.regex.test(spanName)) {
+        return true;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get statistics about pattern matching (for debugging/monitoring)
+   */
+  getStats() {
+    return {
+      enabled: this.enabled,
+      ignorePatternCount: this.ignorePatterns.length,
+      instrumentPatternCount: this.instrumentPatterns.filter((p) => p.enabled).length
+    };
+  }
+};
+var globalMatcher = null;
+function initializePatternMatcher(config) {
+  globalMatcher = new PatternMatcher(config);
+}
+function shouldInstrumentSpan(spanName) {
+  if (!globalMatcher) {
+    return true;
+  }
+  return globalMatcher.shouldInstrument(spanName);
+}
+function getPatternMatcher() {
+  return globalMatcher;
+}
+var Logger = class {
+  constructor() {
+    __publicField2(this, "level", "on");
+    __publicField2(this, "hasLoggedMinimal", false);
+  }
+  /**
+   * Set the logging level
+   */
+  setLevel(level) {
+    this.level = level;
+    this.hasLoggedMinimal = false;
+  }
+  /**
+   * Get the current logging level
+   */
+  getLevel() {
+    return this.level;
+  }
+  /**
+   * Log a minimal initialization message (only shown once in minimal mode)
+   */
+  minimal(message) {
+    if (this.level === "off") {
+      return;
+    }
+    if (this.level === "minimal" && !this.hasLoggedMinimal) {
+      console.log(message);
+      this.hasLoggedMinimal = true;
+      return;
+    }
+    if (this.level === "on") {
+      console.log(message);
+    }
+  }
+  /**
+   * Log an informational message
+   */
+  log(...args) {
+    if (this.level === "on") {
+      console.log(...args);
+    }
+  }
+  /**
+   * Log a warning message (shown in minimal mode)
+   */
+  warn(...args) {
+    if (this.level !== "off") {
+      console.warn(...args);
+    }
+  }
+  /**
+   * Log an error message (shown in minimal mode)
+   */
+  error(...args) {
+    if (this.level !== "off") {
+      console.error(...args);
+    }
+  }
+  /**
+   * Check if full logging is enabled
+   */
+  isEnabled() {
+    return this.level === "on";
+  }
+  /**
+   * Check if minimal logging is enabled
+   */
+  isMinimal() {
+    return this.level === "minimal";
+  }
+  /**
+   * Check if logging is completely disabled
+   */
+  isDisabled() {
+    return this.level === "off";
+  }
+};
+var logger = new Logger();
+
+// src/core/span-processor.ts
+var PatternSpanProcessor = class {
+  constructor(config, wrappedProcessor) {
+    __publicField(this, "matcher");
+    __publicField(this, "wrappedProcessor");
+    this.matcher = new PatternMatcher(config);
+    this.wrappedProcessor = wrappedProcessor;
+  }
+  /**
+   * Called when a span is started
+   *
+   * We check if the span should be instrumented here. If not, we can mark it
+   * to be dropped later in onEnd().
+   */
+  onStart(span, parentContext) {
+    const spanName = span.name;
+    if (this.matcher.shouldInstrument(spanName)) {
+      this.wrappedProcessor.onStart(span, parentContext);
+    }
+  }
+  /**
+   * Called when a span is ended
+   *
+   * This is where we make the final decision on whether to export the span.
+   */
+  onEnd(span) {
+    const spanName = span.name;
+    if (this.matcher.shouldInstrument(spanName)) {
+      this.wrappedProcessor.onEnd(span);
+    }
+  }
+  /**
+   * Shutdown the processor
+   */
+  async shutdown() {
+    return this.wrappedProcessor.shutdown();
+  }
+  /**
+   * Force flush any pending spans
+   */
+  async forceFlush() {
+    return this.wrappedProcessor.forceFlush();
+  }
+  /**
+   * Get the pattern matcher (for debugging/testing)
+   */
+  getPatternMatcher() {
+    return this.matcher;
+  }
+};
+var DEFAULT_OTLP_ENDPOINT = "http://localhost:4318/v1/traces";
+function createOtlpExporter(options = {}) {
+  const endpoint = options.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_OTLP_ENDPOINT;
+  const normalizedEndpoint = normalizeEndpoint(endpoint);
+  const config = {
+    url: normalizedEndpoint
+  };
+  if (options.headers) {
+    config.headers = options.headers;
+  }
+  return new OTLPTraceExporter(config);
+}
+function normalizeEndpoint(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    if (!url.pathname || url.pathname === "/") {
+      url.pathname = "/v1/traces";
+      return url.toString();
+    }
+    return endpoint;
+  } catch {
+    return endpoint;
+  }
+}
+function getOtlpEndpoint(options = {}) {
+  const endpoint = options.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_OTLP_ENDPOINT;
+  return normalizeEndpoint(endpoint);
+}
+
+// src/core/safe-exporter.ts
+var SafeSpanExporter = class {
+  // Log errors max once per minute
+  constructor(exporter) {
+    __publicField(this, "exporter");
+    __publicField(this, "errorCount", 0);
+    __publicField(this, "lastErrorTime", 0);
+    __publicField(this, "errorThrottleMs", 6e4);
+    this.exporter = exporter;
+  }
+  /**
+   * Export spans with error handling
+   */
+  export(spans, resultCallback) {
+    try {
+      this.exporter.export(spans, (result) => {
+        if (result.code !== 0) {
+          this.handleExportError(result.error);
+        }
+        resultCallback(result);
+      });
+    } catch (error) {
+      this.handleExportError(error);
+      resultCallback({
+        code: 2,
+        // FAILED
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+  /**
+   * Shutdown with error handling
+   */
+  async shutdown() {
+    try {
+      await this.exporter.shutdown();
+    } catch (error) {
+      logger.error(
+        "@atrim/instrumentation: Error during exporter shutdown (non-critical):",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Force flush with error handling
+   */
+  async forceFlush() {
+    if (!this.exporter.forceFlush) {
+      return;
+    }
+    try {
+      await this.exporter.forceFlush();
+    } catch (error) {
+      this.handleExportError(error);
+    }
+  }
+  /**
+   * Handle export errors with throttling
+   */
+  handleExportError(error) {
+    this.errorCount++;
+    const now = Date.now();
+    const shouldLog = now - this.lastErrorTime > this.errorThrottleMs;
+    if (shouldLog) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.isConnectionError(error)) {
+        logger.warn(`@atrim/instrumentation: Unable to export spans - collector not available`);
+        logger.warn(`  Error: ${errorMessage}`);
+        logger.warn(`  Spans will be dropped. Ensure OTEL collector is running.`);
+      } else {
+        logger.error("@atrim/instrumentation: Span export failed:", errorMessage);
+      }
+      if (this.errorCount > 1) {
+        logger.warn(`  (${this.errorCount} errors total, throttled to 1/min)`);
+      }
+      this.lastErrorTime = now;
+      this.errorCount = 0;
+    }
+  }
+  /**
+   * Check if error is a connection error (ECONNREFUSED, ENOTFOUND, etc.)
+   */
+  isConnectionError(error) {
+    if (!error || typeof error !== "object") {
+      return false;
+    }
+    const err = error;
+    if (err.code === "ECONNREFUSED" || err.code === "ENOTFOUND" || err.code === "ETIMEDOUT") {
+      return true;
+    }
+    if (Array.isArray(err.errors)) {
+      return err.errors.every((e) => this.isConnectionError(e));
+    }
+    if (err.message) {
+      const msg = err.message.toLowerCase();
+      return msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("etimedout") || msg.includes("connection refused");
+    }
+    return false;
+  }
+};
+var ConfigError2 = class extends Data.TaggedError("ConfigError") {
+};
+var ConfigUrlError2 = class extends Data.TaggedError("ConfigUrlError") {
+};
+var ConfigValidationError2 = class extends Data.TaggedError("ConfigValidationError") {
+};
+var ConfigFileError2 = class extends Data.TaggedError("ConfigFileError") {
+};
+var ServiceDetectionError2 = class extends Data.TaggedError("ServiceDetectionError") {
+};
+var InitializationError2 = class extends Data.TaggedError("InitializationError") {
+};
+var ExportError2 = class extends Data.TaggedError("ExportError") {
+};
+var ShutdownError2 = class extends Data.TaggedError("ShutdownError") {
+};
+
+// src/core/service-detector.ts
+var detectServiceInfo = Effect.gen(
+  function* () {
+    const envServiceName = process.env.OTEL_SERVICE_NAME;
+    const envServiceVersion = process.env.OTEL_SERVICE_VERSION;
+    if (envServiceName) {
+      return {
+        name: envServiceName,
+        version: envServiceVersion
+      };
+    }
+    const packageJsonPath = join(process.cwd(), "package.json");
+    const packageJsonContent = yield* Effect.tryPromise({
+      try: () => readFile(packageJsonPath, "utf-8"),
+      catch: (error) => new ServiceDetectionError2({
+        reason: `Failed to read package.json at ${packageJsonPath}`,
+        cause: error
+      })
+    });
+    let parsed;
+    try {
+      parsed = JSON.parse(packageJsonContent);
+    } catch (error) {
+      yield* Effect.fail(
+        new ServiceDetectionError2({
+          reason: "Invalid JSON in package.json",
+          cause: error
+        })
+      );
+    }
+    if (typeof parsed === "object" && parsed !== null) {
+      const packageJson = parsed;
+      if (packageJson.name) {
+        return {
+          name: packageJson.name,
+          version: envServiceVersion || packageJson.version
+        };
+      }
+    }
+    return yield* Effect.fail(
+      new ServiceDetectionError2({
+        reason: 'package.json exists but has no "name" field'
+      })
+    );
+  }
+);
+var getServiceName = detectServiceInfo.pipe(
+  Effect.map((info) => info.name),
+  Effect.catchAll(() => Effect.succeed("unknown-service"))
+);
+var getServiceVersion = detectServiceInfo.pipe(
+  Effect.map((info) => info.version),
+  Effect.catchAll(() => Effect.succeed(void 0))
+);
+var getServiceInfoWithFallback = detectServiceInfo.pipe(
+  Effect.catchAll(
+    () => Effect.succeed({
+      name: "unknown-service",
+      version: process.env.OTEL_SERVICE_VERSION
+    })
+  )
+);
+async function detectServiceInfoAsync() {
+  return Effect.runPromise(getServiceInfoWithFallback);
+}
+async function getServiceNameAsync() {
+  return Effect.runPromise(getServiceName);
+}
+async function getServiceVersionAsync() {
+  return Effect.runPromise(getServiceVersion);
+}
+
+// src/core/sdk-initializer.ts
+var sdkInstance = null;
+var initializationPromise = null;
+function isEffectProject() {
+  try {
+    __require.resolve("effect");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shouldEnableAutoInstrumentation(explicitValue, hasWebFramework) {
+  if (explicitValue !== void 0) {
+    return explicitValue;
+  }
+  const isEffect = isEffectProject();
+  if (isEffect && !hasWebFramework) {
+    logger.log("@atrim/instrumentation: Detected Effect-TS without web framework");
+    logger.log("  - Auto-instrumentation disabled by default");
+    logger.log("  - Effect.withSpan() will create spans");
+    return false;
+  }
+  return true;
+}
+function hasWebFrameworkInstalled() {
+  const frameworks = ["express", "fastify", "koa", "@hono/node-server", "restify"];
+  for (const framework of frameworks) {
+    try {
+      __require.resolve(framework);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function isTracingAlreadyInitialized() {
+  try {
+    const provider = trace.getTracerProvider();
+    const providerWithDelegate = provider;
+    const delegate = providerWithDelegate._delegate || providerWithDelegate.getDelegate?.();
+    if (delegate) {
+      const delegateName = delegate.constructor.name;
+      if (!delegateName.includes("Noop")) {
+        return true;
+      }
+    }
+    const providerWithProps = provider;
+    const hasResource = providerWithProps.resource !== void 0;
+    const hasActiveSpanProcessor = providerWithProps.activeSpanProcessor !== void 0;
+    const hasTracers = providerWithProps._tracers !== void 0;
+    return hasResource || hasActiveSpanProcessor || hasTracers;
+  } catch {
+    return false;
+  }
+}
+async function initializeSdk(options = {}) {
+  if (sdkInstance) {
+    logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
+    return sdkInstance;
+  }
+  if (initializationPromise) {
+    logger.log(
+      "@atrim/instrumentation: SDK already initialized, waiting for initialization to complete..."
+    );
+    return initializationPromise;
+  }
+  initializationPromise = performInitialization(options);
+  try {
+    const result = await initializationPromise;
+    return result;
+  } finally {
+    initializationPromise = null;
+  }
+}
+async function performInitialization(options) {
+  const config = await loadConfig(options);
+  const loggingLevel = config.instrumentation.logging || "on";
+  logger.setLevel(loggingLevel);
+  const alreadyInitialized = isTracingAlreadyInitialized();
+  if (alreadyInitialized) {
+    logger.log("@atrim/instrumentation: Detected existing OpenTelemetry initialization.");
+    logger.log("  - Skipping NodeSDK setup");
+    logger.log("  - Setting up pattern-based filtering only");
+    logger.log("");
+    initializePatternMatcher(config);
+    logger.log("@atrim/instrumentation: Pattern filtering initialized");
+    logger.log("  \u26A0\uFE0F  Note: Pattern filtering will only work with manual spans");
+    logger.log("  \u26A0\uFE0F  Auto-instrumentation must be configured separately");
+    logger.log("");
+    return null;
+  }
+  const serviceInfo = await detectServiceInfoAsync();
+  const serviceName = options.serviceName || serviceInfo.name;
+  const serviceVersion = options.serviceVersion || serviceInfo.version;
+  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 = useSimpleProcessor ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter);
+  const patternProcessor = new PatternSpanProcessor(config, baseProcessor);
+  const instrumentations = [];
+  const hasWebFramework = hasWebFrameworkInstalled();
+  const enableAutoInstrumentation = shouldEnableAutoInstrumentation(
+    options.autoInstrument,
+    hasWebFramework
+  );
+  if (enableAutoInstrumentation) {
+    instrumentations.push(
+      ...getNodeAutoInstrumentations({
+        // Enable common instrumentations
+        "@opentelemetry/instrumentation-http": { enabled: true },
+        "@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 }
+      })
+    );
+  }
+  if (options.instrumentations) {
+    instrumentations.push(...options.instrumentations);
+  }
+  if (!enableAutoInstrumentation && instrumentations.length === 0) {
+    const wasExplicit = options.autoInstrument === false;
+    const detectionMessage = wasExplicit ? "@atrim/instrumentation: Auto-instrumentation: disabled" : "@atrim/instrumentation: Pure Effect-TS app detected (auto-detected)";
+    logger.log(detectionMessage);
+    logger.log("  - Skipping NodeSDK setup");
+    logger.log("  - Pattern matching configured from instrumentation.yaml");
+    if (!wasExplicit) {
+      logger.log("  - Use EffectInstrumentationLive for tracing");
+    }
+    logger.log("");
+    initializePatternMatcher(config);
+    return null;
+  }
+  const sdkConfig = {
+    spanProcessor: patternProcessor,
+    serviceName,
+    ...serviceVersion && { serviceVersion },
+    instrumentations,
+    // Allow advanced overrides
+    ...options.sdk
+  };
+  const sdk = new NodeSDK(sdkConfig);
+  sdk.start();
+  sdkInstance = sdk;
+  if (!options.disableAutoShutdown) {
+    registerShutdownHandlers(sdk);
+  }
+  logInitialization(config, serviceName, serviceVersion, options, enableAutoInstrumentation);
+  return sdk;
+}
+function getSdkInstance() {
+  return sdkInstance;
+}
+async function shutdownSdk() {
+  if (!sdkInstance) {
+    return;
+  }
+  await sdkInstance.shutdown();
+  sdkInstance = null;
+}
+function resetSdk() {
+  sdkInstance = null;
+  initializationPromise = null;
+}
+function registerShutdownHandlers(sdk) {
+  const shutdown = async (signal) => {
+    logger.log(`
+@atrim/instrumentation: Received ${signal}, shutting down gracefully...`);
+    try {
+      await sdk.shutdown();
+      logger.log("@atrim/instrumentation: Shutdown complete");
+      process.exit(0);
+    } catch (error) {
+      logger.error(
+        "@atrim/instrumentation: Error during shutdown:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("uncaughtException", async (error) => {
+    logger.error("@atrim/instrumentation: Uncaught exception:", error);
+    await sdk.shutdown();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", async (reason) => {
+    logger.error("@atrim/instrumentation: Unhandled rejection:", reason);
+    await sdk.shutdown();
+    process.exit(1);
+  });
+}
+function logInitialization(config, serviceName, serviceVersion, options, autoInstrumentEnabled) {
+  logger.minimal("@atrim/instrumentation: SDK initialized successfully");
+  logger.log(`  - Service: ${serviceName}${serviceVersion ? ` v${serviceVersion}` : ""}`);
+  if (config.instrumentation.enabled) {
+    const instrumentCount = config.instrumentation.instrument_patterns.filter(
+      (p) => p.enabled !== false
+    ).length;
+    const ignoreCount = config.instrumentation.ignore_patterns.length;
+    logger.log(`  - Pattern filtering: enabled`);
+    logger.log(`    - Instrument patterns: ${instrumentCount}`);
+    logger.log(`    - Ignore patterns: ${ignoreCount}`);
+  } else {
+    logger.log(`  - Pattern filtering: disabled`);
+  }
+  const autoInstrumentLabel = autoInstrumentEnabled ? "enabled" : "disabled";
+  const autoDetected = options.autoInstrument === void 0 ? " (auto-detected)" : "";
+  logger.log(`  - Auto-instrumentation: ${autoInstrumentLabel}${autoDetected}`);
+  if (options.instrumentations && options.instrumentations.length > 0) {
+    logger.log(`  - Custom instrumentations: ${options.instrumentations.length}`);
+  }
+  const endpoint = options.otlp?.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318/v1/traces";
+  logger.log(`  - OTLP endpoint: ${endpoint}`);
+  logger.log("");
+}
+
+// src/api.ts
+async function initializeInstrumentation(options = {}) {
+  const sdk = await initializeSdk(options);
+  if (sdk) {
+    const config = await loadConfig(options);
+    initializePatternMatcher(config);
+  }
+  return sdk;
+}
+async function initializePatternMatchingOnly(options = {}) {
+  const config = await loadConfig(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: () => loadConfig(options),
+      catch: (error) => new ConfigError2({
+        reason: "Failed to load config for pattern matcher",
+        cause: error
+      })
+    }).pipe(
+      Effect.tap(
+        (config) => Effect.sync(() => {
+          initializePatternMatcher(config);
+        })
+      )
+    );
+  }
+  return sdk;
+});
+var initializePatternMatchingOnlyEffect = (options = {}) => Effect.gen(function* () {
+  const config = yield* Effect.tryPromise({
+    try: () => loadConfig(options),
+    catch: (error) => new ConfigError2({
+      reason: "Failed to load configuration",
+      cause: error
+    })
+  });
+  yield* Effect.sync(() => {
+    initializePatternMatcher(config);
+    logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+    logger.log(
+      "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
+    );
+  });
+});
+
+// src/integrations/standard/span-helpers.ts
+function setSpanAttributes(span, attributes) {
+  for (const [key, value] of Object.entries(attributes)) {
+    span.setAttribute(key, value);
+  }
+}
+function recordException(span, error, context) {
+  span.recordException(error);
+  if (context) {
+    for (const [key, value] of Object.entries(context)) {
+      span.setAttribute(`error.${key}`, value);
+    }
+  }
+}
+function markSpanSuccess(span) {
+  span.setStatus({ code: 1 });
+}
+function markSpanError(span, message) {
+  if (message !== void 0) {
+    span.setStatus({
+      code: 2,
+      // SpanStatusCode.ERROR = 2
+      message
+    });
+  } else {
+    span.setStatus({
+      code: 2
+      // SpanStatusCode.ERROR = 2
+    });
+  }
+}
+function annotateHttpRequest(span, method, url, statusCode) {
+  span.setAttribute("http.method", method);
+  span.setAttribute("http.url", url);
+  if (statusCode !== void 0) {
+    span.setAttribute("http.status_code", statusCode);
+    if (statusCode >= 400) {
+      markSpanError(span, `HTTP ${statusCode}`);
+    } else {
+      markSpanSuccess(span);
+    }
+  }
+}
+function annotateDbQuery(span, system, statement, table) {
+  span.setAttribute("db.system", system);
+  span.setAttribute("db.statement", statement);
+  if (table) {
+    span.setAttribute("db.table", table);
+  }
+}
+function annotateCacheOperation(span, operation, key, hit) {
+  span.setAttribute("cache.operation", operation);
+  span.setAttribute("cache.key", key);
+  if (hit !== void 0) {
+    span.setAttribute("cache.hit", hit);
+  }
+}
+
+// src/core/test-utils.ts
+function suppressShutdownErrors() {
+  if (!process.env.CI && process.env.NODE_ENV !== "test") {
+    return;
+  }
+  const isHarmlessConnectionError = (error) => {
+    if (!error || typeof error !== "object") {
+      return false;
+    }
+    const nodeError = error;
+    if (nodeError.code === "ECONNREFUSED") {
+      return true;
+    }
+    if (nodeError.errors && Array.isArray(nodeError.errors) && nodeError.errors.length > 0 && nodeError.errors.every((e) => e?.code === "ECONNREFUSED")) {
+      return true;
+    }
+    return false;
+  };
+  process.on("uncaughtException", (error) => {
+    if (isHarmlessConnectionError(error)) {
+      console.log("\u{1F4E4} Export failed (collector stopped) - this is expected in tests");
+      return;
+    }
+    console.error("Uncaught exception:", error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isHarmlessConnectionError(reason)) {
+      console.log("\u{1F4E4} Export failed (collector stopped) - this is expected in tests");
+      return;
+    }
+    console.error("Unhandled rejection:", reason);
+    process.exit(1);
+  });
+}
+
+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, 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, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shouldInstrumentSpan, shutdownSdk, suppressShutdownErrors };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map