@atrim/instrument-node 1.0.0

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

@@ -0,0 +1,705 @@
+'use strict';
+
+var effect = require('effect');
+var Otlp = require('@effect/opentelemetry/Otlp');
+var platform = require('@effect/platform');
+var api = require('@opentelemetry/api');
+var fs = require('fs');
+var path = require('path');
+var yaml = require('yaml');
+var zod = require('zod');
+
+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 Otlp__namespace = /*#__PURE__*/_interopNamespace(Otlp);
+
+// src/integrations/effect/effect-tracer.ts
+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 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 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({
+    auto_extract_metadata: zod.z.boolean(),
+    auto_isolation: AutoIsolationConfigSchema.optional()
+  }).optional()
+});
+(class extends effect.Data.TaggedError("ConfigError") {
+});
+var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
+};
+var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
+};
+var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
+};
+(class extends effect.Data.TaggedError("ServiceDetectionError") {
+});
+(class extends effect.Data.TaggedError("InitializationError") {
+});
+(class extends effect.Data.TaggedError("ExportError") {
+});
+(class extends effect.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.Effect.try({
+  try: () => InstrumentationConfigSchema.parse(rawConfig),
+  catch: (error) => new ConfigValidationError({
+    reason: "Invalid configuration schema",
+    cause: error
+  })
+});
+var loadConfigFromFileEffect = (filePath) => effect.Effect.gen(function* () {
+  const fileContents = yield* effect.Effect.try({
+    try: () => fs.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.Effect.fail(
+      new ConfigFileError({
+        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  let rawConfig;
+  try {
+    rawConfig = yaml.parse(fileContents);
+  } catch (error) {
+    return yield* effect.Effect.fail(
+      new ConfigValidationError({
+        reason: "Invalid YAML syntax",
+        cause: error
+      })
+    );
+  }
+  return yield* validateConfigEffect(rawConfig);
+});
+var fetchAndParseConfig = (url) => effect.Effect.gen(function* () {
+  let urlObj;
+  try {
+    urlObj = new URL(url);
+  } catch (error) {
+    return yield* effect.Effect.fail(
+      new ConfigUrlError({
+        reason: `Invalid URL: ${url}`,
+        cause: error
+      })
+    );
+  }
+  if (!SECURITY_DEFAULTS.allowedProtocols.includes(urlObj.protocol)) {
+    return yield* effect.Effect.fail(
+      new ConfigUrlError({
+        reason: `Insecure protocol ${urlObj.protocol}. Only ${SECURITY_DEFAULTS.allowedProtocols.join(", ")} are allowed`
+      })
+    );
+  }
+  const response = yield* effect.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.Effect.timeout(effect.Duration.millis(SECURITY_DEFAULTS.requestTimeout)),
+    effect.Effect.retry({
+      times: 3,
+      schedule: effect.Schedule.exponential(effect.Duration.millis(100))
+    }),
+    effect.Effect.catchAll((error) => {
+      if (error._tag === "TimeoutException") {
+        return effect.Effect.fail(
+          new ConfigUrlError({
+            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms`
+          })
+        );
+      }
+      return effect.Effect.fail(error);
+    })
+  );
+  if (!response.ok) {
+    return yield* effect.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.Effect.fail(
+      new ConfigUrlError({
+        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  const text = yield* effect.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.Effect.fail(
+      new ConfigUrlError({
+        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  let rawConfig;
+  try {
+    rawConfig = yaml.parse(text);
+  } catch (error) {
+    return yield* effect.Effect.fail(
+      new ConfigValidationError({
+        reason: "Invalid YAML syntax",
+        cause: error
+      })
+    );
+  }
+  return yield* validateConfigEffect(rawConfig);
+});
+var makeConfigCache = () => effect.Cache.make({
+  capacity: 100,
+  timeToLive: effect.Duration.minutes(5),
+  lookup: (url) => fetchAndParseConfig(url)
+});
+var cacheInstance = null;
+var getCache = effect.Effect.gen(function* () {
+  if (!cacheInstance) {
+    cacheInstance = yield* makeConfigCache();
+  }
+  return cacheInstance;
+});
+var loadConfigFromUrlEffect = (url, cacheTimeout = SECURITY_DEFAULTS.cacheTimeout) => effect.Effect.gen(function* () {
+  if (cacheTimeout === 0) {
+    return yield* fetchAndParseConfig(url);
+  }
+  const cache = yield* getCache;
+  return yield* cache.get(url);
+});
+var loadConfigEffect = (options = {}) => effect.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 = path.join(process.cwd(), "instrumentation.yaml");
+  const exists = yield* effect.Effect.sync(() => fs.existsSync(defaultPath));
+  if (exists) {
+    return yield* loadConfigFromFileEffect(defaultPath);
+  }
+  return getDefaultConfig();
+});
+async function loadConfig(options = {}) {
+  return effect.Effect.runPromise(
+    loadConfigEffect(options).pipe(
+      // Convert typed errors to regular Error with reason message for backward compatibility
+      effect.Effect.mapError((error) => {
+        const message = error.reason;
+        const newError = new Error(message);
+        newError.cause = error.cause;
+        return newError;
+      })
+    )
+  );
+}
+var PatternMatcher = class {
+  constructor(config) {
+    __publicField(this, "ignorePatterns", []);
+    __publicField(this, "instrumentPatterns", []);
+    __publicField(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
+    };
+  }
+};
+function initializePatternMatcher(config) {
+  new PatternMatcher(config);
+}
+var Logger = class {
+  constructor() {
+    __publicField(this, "level", "on");
+    __publicField(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/integrations/effect/effect-tracer.ts
+function createEffectInstrumentation(options = {}) {
+  return effect.Layer.unwrapEffect(
+    effect.Effect.gen(function* () {
+      const config = yield* effect.Effect.tryPromise({
+        try: () => loadConfig(options),
+        catch: (error) => ({
+          _tag: "ConfigError",
+          message: error instanceof Error ? error.message : String(error)
+        })
+      });
+      yield* effect.Effect.sync(() => {
+        const loggingLevel = config.instrumentation.logging || "on";
+        logger.setLevel(loggingLevel);
+      });
+      yield* effect.Effect.sync(() => initializePatternMatcher(config));
+      const otlpEndpoint = options.otlpEndpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+      const serviceName = options.serviceName || process.env.OTEL_SERVICE_NAME || "effect-service";
+      const serviceVersion = options.serviceVersion || process.env.npm_package_version || "1.0.0";
+      const autoExtractMetadata = options.autoExtractMetadata ?? config.effect?.auto_extract_metadata ?? true;
+      const continueExistingTraces = options.continueExistingTraces ?? true;
+      logger.log("\u{1F50D} Effect OpenTelemetry instrumentation");
+      logger.log(`   \u{1F4E1} Endpoint: ${otlpEndpoint}`);
+      logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
+      logger.log(`   \u2705 Auto metadata extraction: ${autoExtractMetadata}`);
+      logger.log(`   \u2705 Continue existing traces: ${continueExistingTraces}`);
+      const otlpLayer = Otlp__namespace.layer({
+        baseUrl: otlpEndpoint,
+        resource: {
+          serviceName,
+          serviceVersion,
+          attributes: {
+            "platform.component": "effect",
+            "effect.auto_metadata": autoExtractMetadata,
+            "effect.context_propagation": continueExistingTraces
+          }
+        },
+        // Bridge Effect context to OpenTelemetry global context
+        // This is essential for context propagation to work properly
+        tracerContext: (f, span) => {
+          if (span._tag !== "Span") {
+            return f();
+          }
+          const spanContext = {
+            traceId: span.traceId,
+            spanId: span.spanId,
+            traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
+          };
+          const otelSpan = api.trace.wrapSpanContext(spanContext);
+          return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
+        }
+      }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
+      if (autoExtractMetadata) {
+        return otlpLayer;
+      }
+      return otlpLayer;
+    })
+  ).pipe(effect.Layer.orDie);
+}
+var EffectInstrumentationLive = effect.Effect.sync(() => {
+  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+  const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
+  const serviceVersion = process.env.npm_package_version || "1.0.0";
+  logger.log("\u{1F50D} Effect OpenTelemetry tracer (Otlp.layer)");
+  logger.log(`   \u{1F4E1} Endpoint: ${endpoint}`);
+  logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
+  return Otlp__namespace.layer({
+    baseUrl: endpoint,
+    resource: {
+      serviceName,
+      serviceVersion,
+      attributes: {
+        "platform.component": "effect"
+      }
+    },
+    // CRITICAL: Bridge Effect context to OpenTelemetry global context
+    // This allows NodeSDK auto-instrumentation to see Effect spans as parent spans
+    tracerContext: (f, span) => {
+      if (span._tag !== "Span") {
+        return f();
+      }
+      const spanContext = {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
+      };
+      const otelSpan = api.trace.wrapSpanContext(spanContext);
+      return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
+    }
+  }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
+}).pipe(effect.Layer.unwrapEffect);
+
+// src/integrations/effect/effect-helpers.ts
+function annotateUser(_userId, _email) {
+}
+function annotateDataSize(_bytes, _count) {
+}
+function annotateBatch(_size, _batchSize) {
+}
+function annotateLLM(_model, _operation, _inputTokens, _outputTokens) {
+}
+function annotateQuery(_query, _database) {
+}
+function annotateHttpRequest(_method, _url, _statusCode) {
+}
+function annotateError(_error, _context) {
+}
+function annotatePriority(_priority) {
+}
+function annotateCache(_operation, _hit) {
+}
+var createLogicalParentLink = (parentSpan, useSpanLinks) => {
+  if (!useSpanLinks) {
+    return [];
+  }
+  return [
+    {
+      _tag: "SpanLink",
+      span: parentSpan,
+      attributes: {
+        "link.type": "logical_parent",
+        "atrim.relationship": "spawned_by",
+        description: "Logical parent (isolated to prevent context leakage)"
+      }
+    }
+  ];
+};
+var createLogicalParentAttributes = (parentSpan, useAttributes, category, useSpanLinks, customAttributes) => {
+  if (!useAttributes) {
+    return customAttributes;
+  }
+  return {
+    // Logical parent tracking (works in ALL tools)
+    "atrim.logical_parent.span_id": parentSpan.spanId,
+    "atrim.logical_parent.trace_id": parentSpan.traceId,
+    "atrim.logical_parent.name": parentSpan._tag === "Span" ? parentSpan.name : "external",
+    // Categorization and metadata
+    "atrim.fiberset.isolated": true,
+    "atrim.span.category": category,
+    "atrim.has_logical_parent": true,
+    "atrim.isolation.method": useSpanLinks ? "hybrid" : "attributes_only",
+    // User-provided attributes
+    ...customAttributes
+  };
+};
+var runIsolated = (set, effect$1, name, options) => {
+  const {
+    createRoot = true,
+    captureLogicalParent = true,
+    useSpanLinks = true,
+    useAttributes = true,
+    propagateInterruption,
+    attributes = {},
+    category = "background_task"
+  } = options ?? {};
+  if (!createRoot && !captureLogicalParent) {
+    return effect.FiberSet.run(set, effect$1, { propagateInterruption });
+  }
+  return effect.Effect.gen(function* () {
+    const maybeParent = yield* effect.Effect.serviceOption(effect.Tracer.ParentSpan);
+    if (maybeParent._tag === "None" || !captureLogicalParent) {
+      const isolated2 = effect$1.pipe(
+        effect.Effect.withSpan(name, {
+          root: createRoot,
+          attributes: {
+            "atrim.fiberset.isolated": createRoot,
+            "atrim.span.category": category,
+            "atrim.has_logical_parent": false,
+            ...attributes
+          }
+        })
+      );
+      return yield* effect.FiberSet.run(set, isolated2, { propagateInterruption });
+    }
+    const parent = maybeParent.value;
+    const links = createLogicalParentLink(parent, useSpanLinks);
+    const spanAttributes = createLogicalParentAttributes(
+      parent,
+      useAttributes,
+      category,
+      useSpanLinks,
+      attributes
+    );
+    const isolated = effect$1.pipe(
+      effect.Effect.withSpan(name, {
+        root: createRoot,
+        links: links.length > 0 ? links : void 0,
+        attributes: spanAttributes
+      })
+    );
+    return yield* effect.FiberSet.run(set, isolated, { propagateInterruption });
+  });
+};
+var runWithSpan = (set, name, effect, options) => {
+  return runIsolated(set, effect, name, {
+    createRoot: true,
+    captureLogicalParent: true,
+    useSpanLinks: true,
+    useAttributes: true,
+    ...options
+  });
+};
+var annotateSpawnedTasks = (tasks) => {
+  return effect.Effect.annotateCurrentSpan({
+    "atrim.fiberset.spawned_count": tasks.length,
+    "atrim.fiberset.task_names": tasks.map((t) => t.name).join(","),
+    "atrim.has_background_tasks": true,
+    "atrim.spawned_tasks": JSON.stringify(
+      tasks.map((t) => ({
+        name: t.name,
+        ...t.spanId && { span_id: t.spanId },
+        ...t.category && { category: t.category }
+      }))
+    )
+  });
+};
+var FiberSet = {
+  // Re-export all original FiberSet functions
+  make: effect.FiberSet.make,
+  add: effect.FiberSet.add,
+  unsafeAdd: effect.FiberSet.unsafeAdd,
+  run: effect.FiberSet.run,
+  clear: effect.FiberSet.clear,
+  join: effect.FiberSet.join,
+  awaitEmpty: effect.FiberSet.awaitEmpty,
+  size: effect.FiberSet.size,
+  runtime: effect.FiberSet.runtime,
+  runtimePromise: effect.FiberSet.runtimePromise,
+  makeRuntime: effect.FiberSet.makeRuntime,
+  makeRuntimePromise: effect.FiberSet.makeRuntimePromise,
+  isFiberSet: effect.FiberSet.isFiberSet,
+  // Add our isolation helpers
+  runIsolated,
+  runWithSpan
+};
+
+exports.EffectInstrumentationLive = EffectInstrumentationLive;
+exports.FiberSet = FiberSet;
+exports.annotateBatch = annotateBatch;
+exports.annotateCache = annotateCache;
+exports.annotateDataSize = annotateDataSize;
+exports.annotateError = annotateError;
+exports.annotateHttpRequest = annotateHttpRequest;
+exports.annotateLLM = annotateLLM;
+exports.annotatePriority = annotatePriority;
+exports.annotateQuery = annotateQuery;
+exports.annotateSpawnedTasks = annotateSpawnedTasks;
+exports.annotateUser = annotateUser;
+exports.createEffectInstrumentation = createEffectInstrumentation;
+exports.runIsolated = runIsolated;
+exports.runWithSpan = runWithSpan;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map