@atrim/instrument-node 0.7.0 → 0.7.1-dev.14fdea7.20260108220010

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

@@ -0,0 +1,1109 @@
+'use strict';
+
+var effect = require('effect');
+var OtelApi = require('@opentelemetry/api');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var resources = require('@opentelemetry/resources');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var FileSystem = require('@effect/platform/FileSystem');
+var HttpClient = require('@effect/platform/HttpClient');
+var HttpClientRequest = require('@effect/platform/HttpClientRequest');
+var yaml = require('yaml');
+var zod = require('zod');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var OtelApi__namespace = /*#__PURE__*/_interopNamespace(OtelApi);
+var HttpClient__namespace = /*#__PURE__*/_interopNamespace(HttpClient);
+var HttpClientRequest__namespace = /*#__PURE__*/_interopNamespace(HttpClientRequest);
+var path__namespace = /*#__PURE__*/_interopNamespace(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 = zod.z.object({
+  pattern: zod.z.string(),
+  enabled: zod.z.boolean().optional(),
+  description: zod.z.string().optional()
+});
+var AutoIsolationConfigSchema = zod.z.object({
+  // Global enable/disable for auto-isolation
+  enabled: zod.z.boolean().default(false),
+  // Which operators to auto-isolate
+  operators: zod.z.object({
+    fiberset_run: zod.z.boolean().default(true),
+    effect_fork: zod.z.boolean().default(true),
+    effect_fork_daemon: zod.z.boolean().default(true),
+    effect_fork_in: zod.z.boolean().default(false)
+  }).default({}),
+  // Virtual parent tracking configuration
+  tracking: zod.z.object({
+    use_span_links: zod.z.boolean().default(true),
+    use_attributes: zod.z.boolean().default(true),
+    capture_logical_parent: zod.z.boolean().default(true)
+  }).default({}),
+  // Span categorization
+  attributes: zod.z.object({
+    category: zod.z.string().default("background_task"),
+    add_metadata: zod.z.boolean().default(true)
+  }).default({})
+});
+var SpanNamingRuleSchema = zod.z.object({
+  // Match criteria (all specified criteria must match)
+  match: zod.z.object({
+    // Regex pattern to match file path
+    file: zod.z.string().optional(),
+    // Regex pattern to match function name
+    function: zod.z.string().optional(),
+    // Regex pattern to match module name
+    module: zod.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: zod.z.string()
+});
+var AutoInstrumentationConfigSchema = zod.z.object({
+  // Enable/disable auto-instrumentation
+  enabled: zod.z.boolean().default(false),
+  // Tracing granularity
+  // - 'fiber': Trace at fiber creation (recommended, lower overhead)
+  // - 'operator': Trace each Effect operator (higher granularity, more overhead)
+  granularity: zod.z.enum(["fiber", "operator"]).default("fiber"),
+  // Smart span naming configuration
+  span_naming: zod.z.object({
+    // Default span name template when no rules match
+    default: zod.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: zod.z.boolean().default(true),
+    // Naming rules (first match wins)
+    rules: zod.z.array(SpanNamingRuleSchema).default([])
+  }).default({}),
+  // Pattern-based filtering
+  filter: zod.z.object({
+    // Only trace spans matching these patterns (empty = trace all)
+    include: zod.z.array(zod.z.string()).default([]),
+    // Never trace spans matching these patterns
+    exclude: zod.z.array(zod.z.string()).default([])
+  }).default({}),
+  // Performance controls
+  performance: zod.z.object({
+    // Sample rate (0.0 - 1.0)
+    sampling_rate: zod.z.number().min(0).max(1).default(1),
+    // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
+    min_duration: zod.z.string().default("0ms"),
+    // Maximum concurrent traced fibers (0 = unlimited)
+    max_concurrent: zod.z.number().default(0)
+  }).default({}),
+  // Automatic metadata extraction
+  metadata: zod.z.object({
+    // Extract Effect fiber information
+    fiber_info: zod.z.boolean().default(true),
+    // Extract source location (file:line)
+    source_location: zod.z.boolean().default(true),
+    // Extract parent fiber information
+    parent_fiber: zod.z.boolean().default(true)
+  }).default({})
+});
+var HttpFilteringConfigSchema = zod.z.object({
+  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
+  ignore_outgoing_urls: zod.z.array(zod.z.string()).optional(),
+  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
+  ignore_incoming_paths: zod.z.array(zod.z.string()).optional(),
+  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
+  require_parent_for_outgoing_spans: zod.z.boolean().optional(),
+  // Trace context propagation configuration
+  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+  propagate_trace_context: zod.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: zod.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: zod.z.array(zod.z.string()).optional()
+  }).optional()
+});
+var ExporterConfigSchema = zod.z.object({
+  // Exporter type: 'otlp' | 'console' | 'none'
+  // - 'otlp': Export to OTLP endpoint (production)
+  // - 'console': Log spans to console (development)
+  // - 'none': No export (disable tracing)
+  type: zod.z.enum(["otlp", "console", "none"]).default("otlp"),
+  // OTLP endpoint URL (for type: otlp)
+  // Defaults to OTEL_EXPORTER_OTLP_ENDPOINT env var or http://localhost:4318
+  endpoint: zod.z.string().optional(),
+  // Span processor type
+  // - 'batch': Batch spans for export (production, lower overhead)
+  // - 'simple': Export immediately (development, no batching delay)
+  processor: zod.z.enum(["batch", "simple"]).default("batch"),
+  // Batch processor settings (for processor: batch)
+  batch: zod.z.object({
+    // Max time to wait before exporting (milliseconds)
+    scheduled_delay_millis: zod.z.number().default(1e3),
+    // Max batch size
+    max_export_batch_size: zod.z.number().default(100)
+  }).optional()
+});
+var InstrumentationConfigSchema = zod.z.object({
+  version: zod.z.string(),
+  instrumentation: zod.z.object({
+    enabled: zod.z.boolean(),
+    description: zod.z.string().optional(),
+    logging: zod.z.enum(["on", "off", "minimal"]).optional().default("on"),
+    instrument_patterns: zod.z.array(PatternConfigSchema),
+    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 (legacy - use exporter.type instead):
+    // - "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"),
+    // Exporter configuration (for auto-instrumentation)
+    exporter_config: ExporterConfigSchema.optional(),
+    auto_extract_metadata: zod.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 = yaml.parse(content);
+  } else {
+    parsed = content;
+  }
+  return InstrumentationConfigSchema.parse(parsed);
+}
+(class extends effect.Data.TaggedError("ConfigError") {
+  get message() {
+    return this.reason;
+  }
+});
+var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
+  get message() {
+    return this.reason;
+  }
+};
+(class extends effect.Data.TaggedError("ServiceDetectionError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("InitializationError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("ExportError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("ShutdownError") {
+  get message() {
+    return this.reason;
+  }
+});
+var SECURITY_DEFAULTS = {
+  maxConfigSize: 1e6,
+  // 1MB
+  requestTimeout: 5e3
+  // 5 seconds
+};
+var ConfigLoader = class extends effect.Context.Tag("ConfigLoader")() {
+};
+var parseYamlContent = (content, uri) => effect.Effect.gen(function* () {
+  const parsed = yield* effect.Effect.try({
+    try: () => yaml.parse(content),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
+      cause: error
+    })
+  });
+  return yield* effect.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.Effect.gen(function* () {
+  const content = yield* fs.readFileString(path2).pipe(
+    effect.Effect.mapError(
+      (error) => new ConfigFileError({
+        reason: `Failed to read config file at ${uri}`,
+        cause: error
+      })
+    )
+  );
+  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* effect.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.Effect.scoped(
+  effect.Effect.gen(function* () {
+    if (url.startsWith("http://")) {
+      return yield* effect.Effect.fail(
+        new ConfigUrlError({
+          reason: "Insecure protocol: only HTTPS URLs are allowed"
+        })
+      );
+    }
+    const request = HttpClientRequest__namespace.get(url).pipe(
+      HttpClientRequest__namespace.setHeaders({
+        Accept: "application/yaml, text/yaml, application/x-yaml"
+      })
+    );
+    const response = yield* client.execute(request).pipe(
+      effect.Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+      effect.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.Effect.fail(
+        new ConfigUrlError({
+          reason: `HTTP ${response.status} from ${url}`
+        })
+      );
+    }
+    const text = yield* response.text.pipe(
+      effect.Effect.mapError(
+        (error) => new ConfigUrlError({
+          reason: `Failed to read response body from ${url}`,
+          cause: error
+        })
+      )
+    );
+    if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+      return yield* effect.Effect.fail(
+        new ConfigUrlError({
+          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+        })
+      );
+    }
+    return yield* parseYamlContent(text, url);
+  })
+);
+var makeConfigLoader = effect.Effect.gen(function* () {
+  const fs = yield* effect.Effect.serviceOption(FileSystem.FileSystem);
+  const http = yield* HttpClient__namespace.HttpClient;
+  const loadFromUriUncached = (uri) => effect.Effect.gen(function* () {
+    if (uri.startsWith("file://")) {
+      const path2 = uri.slice(7);
+      if (fs._tag === "None") {
+        return yield* effect.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.Effect.cachedFunction(loadFromUriUncached);
+  return ConfigLoader.of({
+    loadFromUri: loadFromUriCached,
+    loadFromInline: (content) => effect.Effect.gen(function* () {
+      if (typeof content === "string") {
+        return yield* parseYamlContent(content);
+      }
+      return yield* effect.Effect.try({
+        try: () => InstrumentationConfigSchema.parse(content),
+        catch: (error) => new ConfigValidationError({
+          reason: "Invalid configuration schema",
+          cause: error
+        })
+      });
+    })
+  });
+});
+effect.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__namespace.basename(filePath, path__namespace.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 effect.Context.Tag("AutoTracingConfig")() {
+};
+var loadAutoTracingConfig = (options) => effect.Effect.gen(function* () {
+  const config = yield* effect.Effect.tryPromise({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => {
+      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+      return error;
+    }
+  }).pipe(effect.Effect.catchAll(() => effect.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 = effect.Layer.effect(AutoTracingConfig, loadAutoTracingConfig());
+var AutoTracingConfigLayer = (config) => effect.Layer.succeed(AutoTracingConfig, config);
+var loadFullConfig = (options) => effect.Effect.gen(function* () {
+  const config = yield* effect.Effect.tryPromise({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => {
+      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+      return error;
+    }
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(null)));
+  if (!config) {
+    logger.log("@atrim/auto-trace: No config found, using defaults");
+    return defaultConfig;
+  }
+  return config;
+});
+
+// src/integrations/effect/auto/supervisor.ts
+var AutoTracingEnabled = effect.FiberRef.unsafeMake(true);
+var AutoTracingSpanName = effect.FiberRef.unsafeMake(effect.Option.none());
+var AutoTracingSupervisor = class extends effect.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 - lazily initialized
+    __publicField(this, "_tracer", null);
+    // Compiled filter patterns
+    __publicField(this, "includePatterns");
+    __publicField(this, "excludePatterns");
+    // Active fiber count (for max_concurrent limiting)
+    __publicField(this, "activeFiberCount", 0);
+    // Root span for parent context (set by withAutoTracing)
+    __publicField(this, "_rootSpan", null);
+    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}`);
+  }
+  /**
+   * Set the root span for parent context propagation
+   */
+  setRootSpan(span) {
+    this._rootSpan = span;
+  }
+  /**
+   * Get the tracer lazily - this allows time for the NodeSdk layer to register the global provider
+   */
+  get tracer() {
+    if (!this._tracer) {
+      this._tracer = OtelApi__namespace.trace.getTracer("@atrim/auto-trace", "1.0.0");
+    }
+    return this._tracer;
+  }
+  /**
+   * Returns the current value (void for this supervisor)
+   */
+  get value() {
+    return effect.Effect.void;
+  }
+  /**
+   * Called when a fiber starts executing
+   */
+  onStart(_context, _effect, parent, fiber) {
+    const fiberRefsValue = fiber.getFiberRefs();
+    const enabled = effect.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 = effect.FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName);
+    const sourceInfo = this.config.span_naming?.infer_from_source ? this.parseStackTrace() : void 0;
+    let spanName;
+    if (effect.Option.isSome(nameOverride)) {
+      spanName = nameOverride.value;
+    } else {
+      spanName = inferSpanName(fiber.id().id, sourceInfo, this.config);
+    }
+    if (!this.shouldTrace(spanName)) {
+      return;
+    }
+    let parentContext = OtelApi__namespace.ROOT_CONTEXT;
+    let parentFiberId;
+    if (effect.Option.isSome(parent)) {
+      parentFiberId = parent.value.id().id;
+      const parentSpan = this.fiberSpans.get(parent.value);
+      if (parentSpan) {
+        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, parentSpan);
+      } else if (this._rootSpan) {
+        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
+      }
+    } else if (this._rootSpan) {
+      parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
+    }
+    const span = this.tracer.startSpan(
+      spanName,
+      {
+        kind: OtelApi__namespace.SpanKind.INTERNAL,
+        attributes: this.getInitialAttributes(fiber, sourceInfo, parentFiberId)
+      },
+      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 (effect.Exit.isSuccess(exit)) {
+      span.setStatus({ code: OtelApi__namespace.SpanStatusCode.OK });
+    } else {
+      span.setStatus({
+        code: OtelApi__namespace.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, sourceInfo, parentFiberId) {
+    const attrs = {
+      "effect.auto_traced": true
+    };
+    if (this.config.metadata?.fiber_info !== false) {
+      attrs["effect.fiber.id"] = fiber.id().id;
+    }
+    if (this.config.metadata?.source_location !== false && sourceInfo) {
+      attrs["code.function"] = sourceInfo.function;
+      attrs["code.filepath"] = sourceInfo.file;
+      attrs["code.lineno"] = sourceInfo.line;
+      attrs["code.column"] = sourceInfo.column;
+    }
+    if (this.config.metadata?.parent_fiber !== false && parentFiberId !== void 0) {
+      attrs["effect.fiber.parent_id"] = parentFiberId;
+    }
+    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 effect.Layer.unwrapEffect(
+    effect.Effect.gen(function* () {
+      const config = options?.config ?? (yield* loadAutoTracingConfig());
+      if (!config.enabled) {
+        logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
+        return effect.Layer.empty;
+      }
+      const supervisor = createAutoTracingSupervisor(config);
+      return effect.Supervisor.addSupervisor(supervisor);
+    })
+  );
+};
+var withAutoTracing = (effect$1, config, mainSpanName) => {
+  if (!config.enabled) {
+    logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
+    return effect$1;
+  }
+  const supervisor = createAutoTracingSupervisor(config);
+  const tracer = OtelApi__namespace.trace.getTracer("@atrim/auto-trace", "1.0.0");
+  const spanName = mainSpanName ?? inferSpanName(0, void 0, config);
+  const mainSpan = tracer.startSpan(spanName, {
+    kind: OtelApi__namespace.SpanKind.INTERNAL,
+    attributes: {
+      "effect.auto_traced": true,
+      "effect.fiber.id": 0,
+      // Main fiber
+      "effect.main_fiber": true
+    }
+  });
+  supervisor.setRootSpan(mainSpan);
+  return effect.Effect.acquireUseRelease(
+    // Acquire: return the span (already started)
+    effect.Effect.succeed(mainSpan),
+    // Use: run the supervised effect
+    () => effect.Effect.supervised(supervisor)(effect$1),
+    // Release: end the span
+    (span, exit) => effect.Effect.sync(() => {
+      if (effect.Exit.isSuccess(exit)) {
+        span.setStatus({ code: OtelApi__namespace.SpanStatusCode.OK });
+      } else {
+        span.setStatus({
+          code: OtelApi__namespace.SpanStatusCode.ERROR,
+          message: "Effect failed"
+        });
+      }
+      span.end();
+    })
+  );
+};
+var AutoTracingLive = createAutoTracingLayer();
+var withoutAutoTracing = (effect$1) => effect$1.pipe(effect.Effect.locally(AutoTracingEnabled, false));
+var setSpanName = (name) => (effect$1) => effect$1.pipe(effect.Effect.locally(AutoTracingSpanName, effect.Option.some(name)));
+var createExporterLayer = (exporterConfig, serviceName, serviceVersion) => {
+  const config = exporterConfig ?? {
+    type: "otlp",
+    processor: "batch",
+    batch: {
+      scheduled_delay_millis: 1e3,
+      max_export_batch_size: 100
+    }
+  };
+  if (config.type === "none") {
+    logger.log('@atrim/auto-trace: Exporter type is "none", no spans will be exported');
+    return effect.Layer.empty;
+  }
+  const createSpanExporter = () => {
+    if (config.type === "console") {
+      logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
+      return new sdkTraceBase.ConsoleSpanExporter();
+    }
+    const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+    logger.log(`@atrim/auto-trace: Using OTLPTraceExporter (${endpoint})`);
+    return new exporterTraceOtlpHttp.OTLPTraceExporter({
+      url: `${endpoint}/v1/traces`
+    });
+  };
+  const createSpanProcessor = () => {
+    const exporter = createSpanExporter();
+    if (config.processor === "simple" || config.type === "console") {
+      logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
+      return new sdkTraceBase.SimpleSpanProcessor(exporter);
+    }
+    const batchConfig = config.batch ?? {
+      scheduled_delay_millis: 1e3,
+      max_export_batch_size: 100
+    };
+    logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
+    return new sdkTraceBase.BatchSpanProcessor(exporter, {
+      scheduledDelayMillis: batchConfig.scheduled_delay_millis,
+      maxExportBatchSize: batchConfig.max_export_batch_size
+    });
+  };
+  return effect.Layer.effectDiscard(
+    effect.Effect.sync(() => {
+      const provider = new sdkTraceBase.BasicTracerProvider({
+        resource: resources.resourceFromAttributes({
+          [semanticConventions.ATTR_SERVICE_NAME]: serviceName,
+          [semanticConventions.ATTR_SERVICE_VERSION]: serviceVersion
+        }),
+        spanProcessors: [createSpanProcessor()]
+      });
+      OtelApi__namespace.trace.setGlobalTracerProvider(provider);
+      logger.log("@atrim/auto-trace: Global TracerProvider registered");
+      return () => {
+        provider.shutdown().catch((err) => {
+          logger.log(`@atrim/auto-trace: Error shutting down provider: ${err}`);
+        });
+      };
+    })
+  );
+};
+var createFullAutoTracingLayer = () => {
+  return effect.Layer.unwrapEffect(
+    effect.Effect.gen(function* () {
+      const config = yield* loadFullConfig();
+      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
+      const serviceVersion = process.env.npm_package_version || "1.0.0";
+      const autoConfig = config.effect?.auto_instrumentation;
+      if (!autoConfig?.enabled) {
+        logger.log("@atrim/auto-trace: Auto-instrumentation disabled via config");
+        return effect.Layer.empty;
+      }
+      const exporterConfig = config.effect?.exporter_config;
+      logger.log("@atrim/auto-trace: Full auto-instrumentation enabled");
+      logger.log(`  Service: ${serviceName}`);
+      logger.log(`  Exporter: ${exporterConfig?.type ?? "otlp"}`);
+      const exporterLayer = createExporterLayer(exporterConfig, serviceName, serviceVersion);
+      const supervisor = createAutoTracingSupervisor(autoConfig);
+      const supervisorLayer = effect.Supervisor.addSupervisor(supervisor);
+      return effect.Layer.mergeAll(exporterLayer, supervisorLayer);
+    })
+  );
+};
+var FullAutoTracingLive = createFullAutoTracingLayer();
+
+exports.AutoTracingConfig = AutoTracingConfig;
+exports.AutoTracingConfigLayer = AutoTracingConfigLayer;
+exports.AutoTracingConfigLive = AutoTracingConfigLive;
+exports.AutoTracingEnabled = AutoTracingEnabled;
+exports.AutoTracingLive = AutoTracingLive;
+exports.AutoTracingSpanName = AutoTracingSpanName;
+exports.AutoTracingSupervisor = AutoTracingSupervisor;
+exports.FullAutoTracingLive = FullAutoTracingLive;
+exports.createAutoTracingLayer = createAutoTracingLayer;
+exports.createAutoTracingSupervisor = createAutoTracingSupervisor;
+exports.createFullAutoTracingLayer = createFullAutoTracingLayer;
+exports.defaultAutoTracingConfig = defaultAutoTracingConfig;
+exports.inferSpanName = inferSpanName;
+exports.loadAutoTracingConfig = loadAutoTracingConfig;
+exports.loadAutoTracingConfigSync = loadAutoTracingConfigSync;
+exports.sanitizeSpanName = sanitizeSpanName;
+exports.setSpanName = setSpanName;
+exports.withAutoTracing = withAutoTracing;
+exports.withoutAutoTracing = withoutAutoTracing;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map