@atrim/instrument-node 0.7.0-b9eaf74-20260108193056 → 0.7.0

package/target/dist/integrations/effect/auto/index.js

@@ -1,875 +0,0 @@
-import { Data, Context, Effect, Layer, FiberRef, Option, Supervisor, FiberRefs, Exit } from 'effect';
-import * as OtelApi from '@opentelemetry/api';
-import { FileSystem } from '@effect/platform/FileSystem';
-import * as HttpClient from '@effect/platform/HttpClient';
-import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
-import { parse } from 'yaml';
-import { z } from 'zod';
-import * as path from 'path';
-
-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 __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 SpanNamingRuleSchema = z.object({
-  // Match criteria (all specified criteria must match)
-  match: z.object({
-    // Regex pattern to match file path
-    file: z.string().optional(),
-    // Regex pattern to match function name
-    function: z.string().optional(),
-    // Regex pattern to match module name
-    module: z.string().optional()
-  }),
-  // Span name template with variables:
-  // {fiber_id} - Fiber ID
-  // {function} - Function name
-  // {module} - Module name
-  // {file} - File path
-  // {line} - Line number
-  // {operator} - Effect operator (gen, all, forEach, etc.)
-  // {match:field:N} - Captured regex group from match
-  name: z.string()
-});
-var AutoInstrumentationConfigSchema = z.object({
-  // Enable/disable auto-instrumentation
-  enabled: z.boolean().default(false),
-  // Tracing granularity
-  // - 'fiber': Trace at fiber creation (recommended, lower overhead)
-  // - 'operator': Trace each Effect operator (higher granularity, more overhead)
-  granularity: z.enum(["fiber", "operator"]).default("fiber"),
-  // Smart span naming configuration
-  span_naming: z.object({
-    // Default span name template when no rules match
-    default: z.string().default("effect.fiber.{fiber_id}"),
-    // Infer span names from source code (requires stack trace parsing)
-    // Adds ~50-100μs overhead per fiber
-    infer_from_source: z.boolean().default(true),
-    // Naming rules (first match wins)
-    rules: z.array(SpanNamingRuleSchema).default([])
-  }).default({}),
-  // Pattern-based filtering
-  filter: z.object({
-    // Only trace spans matching these patterns (empty = trace all)
-    include: z.array(z.string()).default([]),
-    // Never trace spans matching these patterns
-    exclude: z.array(z.string()).default([])
-  }).default({}),
-  // Performance controls
-  performance: z.object({
-    // Sample rate (0.0 - 1.0)
-    sampling_rate: z.number().min(0).max(1).default(1),
-    // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
-    min_duration: z.string().default("0ms"),
-    // Maximum concurrent traced fibers (0 = unlimited)
-    max_concurrent: z.number().default(0)
-  }).default({}),
-  // Automatic metadata extraction
-  metadata: z.object({
-    // Extract Effect fiber information
-    fiber_info: z.boolean().default(true),
-    // Extract source location (file:line)
-    source_location: z.boolean().default(true),
-    // Extract parent fiber information
-    parent_fiber: z.boolean().default(true)
-  }).default({})
-});
-var HttpFilteringConfigSchema = z.object({
-  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
-  ignore_outgoing_urls: z.array(z.string()).optional(),
-  // 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()
-});
-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({
-    // 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(),
-    // Auto-instrumentation: automatic tracing of all Effect fibers
-    auto_instrumentation: AutoInstrumentationConfigSchema.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;
-  }
-});
-var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
-  get message() {
-    return this.reason;
-  }
-};
-var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
-  get message() {
-    return this.reason;
-  }
-};
-var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
-  get message() {
-    return this.reason;
-  }
-};
-(class extends Data.TaggedError("ServiceDetectionError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends Data.TaggedError("InitializationError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends Data.TaggedError("ExportError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends Data.TaggedError("ShutdownError") {
-  get message() {
-    return this.reason;
-  }
-});
-var SECURITY_DEFAULTS = {
-  maxConfigSize: 1e6,
-  // 1MB
-  requestTimeout: 5e3
-  // 5 seconds
-};
-var ConfigLoader = class extends Context.Tag("ConfigLoader")() {
-};
-var parseYamlContent = (content, uri) => Effect.gen(function* () {
-  const parsed = yield* Effect.try({
-    try: () => parse(content),
-    catch: (error) => new ConfigValidationError({
-      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
-      cause: error
-    })
-  });
-  return yield* Effect.try({
-    try: () => InstrumentationConfigSchema.parse(parsed),
-    catch: (error) => new ConfigValidationError({
-      reason: uri ? `Invalid configuration schema from ${uri}` : "Invalid configuration schema",
-      cause: error
-    })
-  });
-});
-var loadFromFileWithFs = (fs, path2, uri) => Effect.gen(function* () {
-  const content = yield* fs.readFileString(path2).pipe(
-    Effect.mapError(
-      (error) => new ConfigFileError({
-        reason: `Failed to read config file at ${uri}`,
-        cause: error
-      })
-    )
-  );
-  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* Effect.fail(
-      new ConfigFileError({
-        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  return yield* parseYamlContent(content, uri);
-});
-var loadFromHttpWithClient = (client, url) => Effect.scoped(
-  Effect.gen(function* () {
-    if (url.startsWith("http://")) {
-      return yield* Effect.fail(
-        new ConfigUrlError({
-          reason: "Insecure protocol: only HTTPS URLs are allowed"
-        })
-      );
-    }
-    const request = HttpClientRequest.get(url).pipe(
-      HttpClientRequest.setHeaders({
-        Accept: "application/yaml, text/yaml, application/x-yaml"
-      })
-    );
-    const response = yield* client.execute(request).pipe(
-      Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
-      Effect.mapError((error) => {
-        if (error._tag === "TimeoutException") {
-          return new ConfigUrlError({
-            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms from ${url}`
-          });
-        }
-        return new ConfigUrlError({
-          reason: `Failed to load config from URL: ${url}`,
-          cause: error
-        });
-      })
-    );
-    if (response.status >= 400) {
-      return yield* Effect.fail(
-        new ConfigUrlError({
-          reason: `HTTP ${response.status} from ${url}`
-        })
-      );
-    }
-    const text = yield* response.text.pipe(
-      Effect.mapError(
-        (error) => new ConfigUrlError({
-          reason: `Failed to read response body from ${url}`,
-          cause: error
-        })
-      )
-    );
-    if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
-      return yield* Effect.fail(
-        new ConfigUrlError({
-          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-        })
-      );
-    }
-    return yield* parseYamlContent(text, url);
-  })
-);
-var makeConfigLoader = Effect.gen(function* () {
-  const fs = yield* Effect.serviceOption(FileSystem);
-  const http = yield* HttpClient.HttpClient;
-  const loadFromUriUncached = (uri) => Effect.gen(function* () {
-    if (uri.startsWith("file://")) {
-      const path2 = uri.slice(7);
-      if (fs._tag === "None") {
-        return yield* Effect.fail(
-          new ConfigFileError({
-            reason: "FileSystem not available (browser environment?)",
-            cause: { uri }
-          })
-        );
-      }
-      return yield* loadFromFileWithFs(fs.value, path2, uri);
-    }
-    if (uri.startsWith("http://") || uri.startsWith("https://")) {
-      return yield* loadFromHttpWithClient(http, uri);
-    }
-    if (fs._tag === "Some") {
-      return yield* loadFromFileWithFs(fs.value, uri, uri);
-    } else {
-      return yield* loadFromHttpWithClient(http, uri);
-    }
-  });
-  const loadFromUriCached = yield* Effect.cachedFunction(loadFromUriUncached);
-  return ConfigLoader.of({
-    loadFromUri: loadFromUriCached,
-    loadFromInline: (content) => Effect.gen(function* () {
-      if (typeof content === "string") {
-        return yield* parseYamlContent(content);
-      }
-      return yield* Effect.try({
-        try: () => InstrumentationConfigSchema.parse(content),
-        catch: (error) => new ConfigValidationError({
-          reason: "Invalid configuration schema",
-          cause: error
-        })
-      });
-    })
-  });
-});
-Layer.effect(ConfigLoader, makeConfigLoader);
-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();
-var compiledRulesCache = /* @__PURE__ */ new WeakMap();
-function compileNamingRules(rules) {
-  const cached = compiledRulesCache.get(rules);
-  if (cached) return cached;
-  const compiled = rules.map((rule) => ({
-    original: rule,
-    filePattern: rule.match.file ? new RegExp(rule.match.file) : void 0,
-    functionPattern: rule.match.function ? new RegExp(rule.match.function) : void 0,
-    modulePattern: rule.match.module ? new RegExp(rule.match.module) : void 0
-  }));
-  compiledRulesCache.set(rules, compiled);
-  return compiled;
-}
-function extractModuleName(filePath) {
-  const basename2 = path.basename(filePath, path.extname(filePath));
-  return basename2.replace(/\.(service|controller|handler|util|helper|model|repo|repository)$/i, "").replace(/(Service|Controller|Handler|Util|Helper|Model|Repo|Repository)$/i, "");
-}
-function applyTemplate(template, variables, matchGroups) {
-  let result = template;
-  for (const [key, value] of Object.entries(variables)) {
-    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), value);
-  }
-  if (matchGroups) {
-    result = result.replace(
-      /\{match:(\w+):(\d+)\}/g,
-      (_fullMatch, field, index) => {
-        const groups = matchGroups.get(field);
-        const idx = parseInt(index, 10);
-        if (groups && groups[idx]) {
-          return groups[idx];
-        }
-        return "";
-      }
-    );
-  }
-  return result;
-}
-function findMatchingRule(sourceInfo, config) {
-  const rules = config.span_naming?.rules;
-  if (!rules || rules.length === 0) return void 0;
-  const compiledRules = compileNamingRules(rules);
-  for (const rule of compiledRules) {
-    const matchGroups = /* @__PURE__ */ new Map();
-    let allMatched = true;
-    if (rule.filePattern) {
-      if (sourceInfo?.file) {
-        const match = sourceInfo.file.match(rule.filePattern);
-        if (match) {
-          matchGroups.set("file", match.slice(1));
-        } else {
-          allMatched = false;
-        }
-      } else {
-        allMatched = false;
-      }
-    }
-    if (rule.functionPattern && allMatched) {
-      if (sourceInfo?.function) {
-        const match = sourceInfo.function.match(rule.functionPattern);
-        if (match) {
-          matchGroups.set("function", match.slice(1));
-        } else {
-          allMatched = false;
-        }
-      } else {
-        allMatched = false;
-      }
-    }
-    if (rule.modulePattern && allMatched) {
-      const moduleName = sourceInfo?.file ? extractModuleName(sourceInfo.file) : "";
-      if (moduleName) {
-        const match = moduleName.match(rule.modulePattern);
-        if (match) {
-          matchGroups.set("module", match.slice(1));
-        } else {
-          allMatched = false;
-        }
-      } else {
-        allMatched = false;
-      }
-    }
-    if (allMatched) {
-      return { rule, matchGroups };
-    }
-  }
-  return void 0;
-}
-function inferSpanName(fiberId, sourceInfo, config) {
-  const variables = {
-    fiber_id: String(fiberId),
-    function: sourceInfo?.function || "anonymous",
-    module: sourceInfo?.file ? extractModuleName(sourceInfo.file) : "unknown",
-    file: sourceInfo?.file || "unknown",
-    line: sourceInfo?.line ? String(sourceInfo.line) : "0",
-    operator: "gen"
-    // Default operator, could be enhanced with more context
-  };
-  const match = findMatchingRule(sourceInfo, config);
-  if (match) {
-    return applyTemplate(match.rule.original.name, variables, match.matchGroups);
-  }
-  const defaultTemplate = config.span_naming?.default || "effect.fiber.{fiber_id}";
-  return applyTemplate(defaultTemplate, variables);
-}
-function sanitizeSpanName(name) {
-  if (!name) return "effect.fiber.unknown";
-  let sanitized = name.replace(/[^a-zA-Z0-9._-]/g, "_");
-  sanitized = sanitized.replace(/_+/g, "_");
-  sanitized = sanitized.replace(/^_+|_+$/g, "");
-  if (!sanitized) return "effect.fiber.unknown";
-  if (sanitized.length > 256) {
-    sanitized = sanitized.substring(0, 256);
-  }
-  return sanitized;
-}
-async function loadFromFile(filePath) {
-  const { readFile } = await import('fs/promises');
-  const content = await readFile(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 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) {
-  return parseAndValidateConfig(content);
-}
-async function loadConfigWithOptions(options = {}) {
-  if (options.config) {
-    return loadConfigFromInline(options.config);
-  }
-  const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
-  if (envConfigPath) {
-    return loadConfig(envConfigPath);
-  }
-  if (options.configUrl) {
-    return loadConfig(options.configUrl);
-  }
-  if (options.configPath) {
-    return loadConfig(options.configPath);
-  }
-  const { existsSync } = await import('fs');
-  const { join } = await import('path');
-  const defaultPath = join(process.cwd(), "instrumentation.yaml");
-  if (existsSync(defaultPath)) {
-    return loadConfig(defaultPath);
-  }
-  return defaultConfig;
-}
-
-// src/integrations/effect/auto/config.ts
-var defaultAutoTracingConfig = {
-  enabled: false,
-  granularity: "fiber",
-  span_naming: {
-    default: "effect.fiber.{fiber_id}",
-    infer_from_source: true,
-    rules: []
-  },
-  filter: {
-    include: [],
-    exclude: []
-  },
-  performance: {
-    sampling_rate: 1,
-    min_duration: "0ms",
-    max_concurrent: 0
-  },
-  metadata: {
-    fiber_info: true,
-    source_location: true,
-    parent_fiber: true
-  }
-};
-var AutoTracingConfig = class extends Context.Tag("AutoTracingConfig")() {
-};
-var loadAutoTracingConfig = (options) => Effect.gen(function* () {
-  const config = yield* Effect.tryPromise({
-    try: () => loadConfigWithOptions(options),
-    catch: (error) => {
-      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
-      return error;
-    }
-  }).pipe(Effect.catchAll(() => Effect.succeed(null)));
-  if (!config) {
-    logger.log("@atrim/auto-trace: No config found, using defaults");
-    return defaultAutoTracingConfig;
-  }
-  const autoConfig = config.effect?.auto_instrumentation;
-  if (!autoConfig) {
-    logger.log("@atrim/auto-trace: No auto_instrumentation config, using defaults");
-    return defaultAutoTracingConfig;
-  }
-  const parsed = AutoInstrumentationConfigSchema.safeParse(autoConfig);
-  if (!parsed.success) {
-    logger.log(`@atrim/auto-trace: Invalid config, using defaults: ${parsed.error.message}`);
-    return defaultAutoTracingConfig;
-  }
-  logger.log("@atrim/auto-trace: Loaded config from instrumentation.yaml");
-  return parsed.data;
-});
-var loadAutoTracingConfigSync = () => {
-  return defaultAutoTracingConfig;
-};
-var AutoTracingConfigLive = Layer.effect(AutoTracingConfig, loadAutoTracingConfig());
-var AutoTracingConfigLayer = (config) => Layer.succeed(AutoTracingConfig, config);
-
-// src/integrations/effect/auto/supervisor.ts
-var AutoTracingEnabled = FiberRef.unsafeMake(true);
-var AutoTracingSpanName = FiberRef.unsafeMake(Option.none());
-var AutoTracingSupervisor = class extends Supervisor.AbstractSupervisor {
-  constructor(config) {
-    super();
-    this.config = config;
-    // WeakMap to associate fibers with their OTel spans
-    __publicField(this, "fiberSpans", /* @__PURE__ */ new WeakMap());
-    // WeakMap for fiber start times (for min_duration filtering)
-    __publicField(this, "fiberStartTimes", /* @__PURE__ */ new WeakMap());
-    // OpenTelemetry tracer
-    __publicField(this, "tracer");
-    // Compiled filter patterns
-    __publicField(this, "includePatterns");
-    __publicField(this, "excludePatterns");
-    // Active fiber count (for max_concurrent limiting)
-    __publicField(this, "activeFiberCount", 0);
-    this.tracer = OtelApi.trace.getTracer("@atrim/auto-trace", "1.0.0");
-    this.includePatterns = (config.filter?.include || []).map((p) => new RegExp(p));
-    this.excludePatterns = (config.filter?.exclude || []).map((p) => new RegExp(p));
-    logger.log("@atrim/auto-trace: Supervisor initialized");
-    logger.log(`  Granularity: ${config.granularity || "fiber"}`);
-    logger.log(`  Sampling rate: ${config.performance?.sampling_rate ?? 1}`);
-    logger.log(`  Infer from source: ${config.span_naming?.infer_from_source ?? true}`);
-  }
-  /**
-   * Returns the current value (void for this supervisor)
-   */
-  get value() {
-    return Effect.void;
-  }
-  /**
-   * Called when a fiber starts executing
-   */
-  onStart(_context, _effect, parent, fiber) {
-    const fiberRefsValue = fiber.getFiberRefs();
-    const enabled = FiberRefs.getOrDefault(fiberRefsValue, AutoTracingEnabled);
-    if (!enabled) {
-      return;
-    }
-    const samplingRate = this.config.performance?.sampling_rate ?? 1;
-    if (samplingRate < 1 && Math.random() > samplingRate) {
-      return;
-    }
-    const maxConcurrent = this.config.performance?.max_concurrent ?? 0;
-    if (maxConcurrent > 0 && this.activeFiberCount >= maxConcurrent) {
-      return;
-    }
-    const nameOverride = FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName);
-    let spanName;
-    if (Option.isSome(nameOverride)) {
-      spanName = nameOverride.value;
-    } else {
-      const sourceInfo = this.config.span_naming?.infer_from_source ? this.parseStackTrace() : void 0;
-      spanName = inferSpanName(fiber.id().id, sourceInfo, this.config);
-    }
-    if (!this.shouldTrace(spanName)) {
-      return;
-    }
-    let parentContext = OtelApi.context.active();
-    if (Option.isSome(parent)) {
-      const parentSpan = this.fiberSpans.get(parent.value);
-      if (parentSpan) {
-        parentContext = OtelApi.trace.setSpan(parentContext, parentSpan);
-      }
-    }
-    const span = this.tracer.startSpan(
-      spanName,
-      {
-        kind: OtelApi.SpanKind.INTERNAL,
-        attributes: this.getInitialAttributes(fiber)
-      },
-      parentContext
-    );
-    this.fiberSpans.set(fiber, span);
-    this.fiberStartTimes.set(fiber, process.hrtime.bigint());
-    this.activeFiberCount++;
-  }
-  /**
-   * Called when a fiber completes (success or failure)
-   */
-  onEnd(exit, fiber) {
-    const span = this.fiberSpans.get(fiber);
-    if (!span) {
-      return;
-    }
-    const startTime = this.fiberStartTimes.get(fiber);
-    if (startTime) {
-      const duration = process.hrtime.bigint() - startTime;
-      const minDuration = this.parseMinDuration(this.config.performance?.min_duration);
-      if (minDuration > 0 && duration < minDuration) {
-        this.fiberSpans.delete(fiber);
-        this.fiberStartTimes.delete(fiber);
-        this.activeFiberCount--;
-        return;
-      }
-    }
-    if (Exit.isSuccess(exit)) {
-      span.setStatus({ code: OtelApi.SpanStatusCode.OK });
-    } else {
-      span.setStatus({
-        code: OtelApi.SpanStatusCode.ERROR,
-        message: "Fiber failed"
-      });
-      span.setAttribute("effect.fiber.failed", true);
-    }
-    span.end();
-    this.fiberSpans.delete(fiber);
-    this.fiberStartTimes.delete(fiber);
-    this.activeFiberCount--;
-  }
-  /**
-   * Check if a span name should be traced based on filter patterns
-   */
-  shouldTrace(spanName) {
-    for (const pattern of this.excludePatterns) {
-      if (pattern.test(spanName)) {
-        return false;
-      }
-    }
-    if (this.includePatterns.length > 0) {
-      for (const pattern of this.includePatterns) {
-        if (pattern.test(spanName)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Get initial span attributes for a fiber
-   */
-  getInitialAttributes(fiber) {
-    const attrs = {
-      "effect.auto_traced": true
-    };
-    if (this.config.metadata?.fiber_info !== false) {
-      attrs["effect.fiber.id"] = fiber.id().id;
-    }
-    return attrs;
-  }
-  /**
-   * Parse stack trace to get source info
-   */
-  parseStackTrace() {
-    const stack = new Error().stack;
-    if (!stack) return void 0;
-    const lines = stack.split("\n");
-    for (let i = 3; i < lines.length; i++) {
-      const line = lines[i];
-      if (line === void 0) continue;
-      if (!line.includes("node_modules/effect") && !line.includes("@atrim/instrument") && !line.includes("auto/supervisor")) {
-        const match = line.match(/at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?/);
-        if (match) {
-          const [, funcName, filePath, lineNum, colNum] = match;
-          return {
-            function: funcName ?? "anonymous",
-            file: filePath ?? "unknown",
-            line: parseInt(lineNum ?? "0", 10),
-            column: parseInt(colNum ?? "0", 10)
-          };
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Parse min_duration string to nanoseconds
-   */
-  parseMinDuration(duration) {
-    if (!duration || duration === "0ms") return BigInt(0);
-    const match = duration.match(/^(\d+)\s*(ms|millis|s|sec|seconds|us|micros)?$/i);
-    if (!match) return BigInt(0);
-    const value = parseInt(match[1] ?? "0", 10);
-    const unit = (match[2] ?? "ms").toLowerCase();
-    switch (unit) {
-      case "us":
-      case "micros":
-        return BigInt(value) * BigInt(1e3);
-      case "ms":
-      case "millis":
-        return BigInt(value) * BigInt(1e6);
-      case "s":
-      case "sec":
-      case "seconds":
-        return BigInt(value) * BigInt(1e9);
-      default:
-        return BigInt(value) * BigInt(1e6);
-    }
-  }
-};
-var createAutoTracingSupervisor = (config) => {
-  return new AutoTracingSupervisor(config);
-};
-var createAutoTracingLayer = (options) => {
-  return Layer.unwrapEffect(
-    Effect.gen(function* () {
-      const config = options?.config ?? (yield* loadAutoTracingConfig());
-      if (!config.enabled) {
-        logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
-        return Layer.empty;
-      }
-      const supervisor = createAutoTracingSupervisor(config);
-      return Supervisor.addSupervisor(supervisor);
-    })
-  );
-};
-var AutoTracingLive = createAutoTracingLayer();
-var withoutAutoTracing = (effect) => effect.pipe(Effect.locally(AutoTracingEnabled, false));
-var setSpanName = (name) => (effect) => effect.pipe(Effect.locally(AutoTracingSpanName, Option.some(name)));
-
-export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, AutoTracingLive, AutoTracingSpanName, AutoTracingSupervisor, createAutoTracingLayer, createAutoTracingSupervisor, defaultAutoTracingConfig, inferSpanName, loadAutoTracingConfig, loadAutoTracingConfigSync, sanitizeSpanName, setSpanName, withoutAutoTracing };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map