@brizz/sdk 0.1.1 → 0.1.2-rc.0

package/dist/preload.cjs

@@ -0,0 +1,2786 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/internal/logger.ts
+var import_api = require("@opentelemetry/api");
+var import_pino = __toESM(require("pino"), 1);
+var DEFAULT_LOG_LEVEL = 2 /* WARN */;
+var PinoLogger = class {
+  _level = DEFAULT_LOG_LEVEL;
+  _pinoLogger = null;
+  constructor() {
+    const envLevel = this.getLogLevelFromEnv();
+    this._level = envLevel;
+  }
+  /**
+   * Lazy initialization of Pino logger to ensure it's created AFTER Jest spies
+   * are set up during tests. This prevents the pino-pretty transport from
+   * bypassing stdout/stderr spies.
+   */
+  ensurePinoLogger() {
+    if (!this._pinoLogger) {
+      this._pinoLogger = (0, import_pino.default)({
+        name: "Brizz",
+        level: this.logLevelToPino(this._level),
+        // Disable transport in test environment to allow proper spy capture
+        transport: this.isProduction() || this.isTest() ? void 0 : {
+          target: "pino-pretty",
+          options: {
+            singleLine: true,
+            colorize: true,
+            translateTime: "HH:MM:ss",
+            ignore: "pid,hostname",
+            messageFormat: "[{name}] {msg}"
+          }
+        }
+      });
+    }
+    return this._pinoLogger;
+  }
+  isProduction() {
+    return process.env["NODE_ENV"] === "production";
+  }
+  isTest() {
+    return process.env["NODE_ENV"] === "test";
+  }
+  getLogLevelFromEnv() {
+    const envLevel = process.env["BRIZZ_LOG_LEVEL"];
+    return envLevel ? parseLogLevel(envLevel) : DEFAULT_LOG_LEVEL;
+  }
+  logLevelToPino(level) {
+    switch (level) {
+      case 4 /* DEBUG */:
+        return "debug";
+      case 3 /* INFO */:
+        return "info";
+      case 2 /* WARN */:
+        return "warn";
+      case 1 /* ERROR */:
+        return "error";
+      default:
+        return "silent";
+    }
+  }
+  formatMeta(meta) {
+    if (meta.length === 0) {
+      return {};
+    }
+    if (meta.length === 1 && typeof meta[0] === "object" && meta[0] !== null) {
+      return meta[0];
+    }
+    return { metadata: meta };
+  }
+  setLevel(level) {
+    this._level = level;
+    if (this._pinoLogger) {
+      this._pinoLogger.level = this.logLevelToPino(level);
+    }
+  }
+  getLevel() {
+    return this._level;
+  }
+  debug = (msg, ...meta) => {
+    if (this._level >= 4 /* DEBUG */) {
+      this.ensurePinoLogger().debug(this.formatMeta(meta), msg);
+    }
+  };
+  info = (msg, ...meta) => {
+    if (this._level >= 3 /* INFO */) {
+      this.ensurePinoLogger().info(this.formatMeta(meta), msg);
+    }
+  };
+  warn = (msg, ...meta) => {
+    if (this._level >= 2 /* WARN */) {
+      this.ensurePinoLogger().warn(this.formatMeta(meta), msg);
+    }
+  };
+  error = (msg, ...meta) => {
+    if (this._level >= 1 /* ERROR */) {
+      this.ensurePinoLogger().error(this.formatMeta(meta), msg);
+    }
+  };
+};
+function parseLogLevel(level) {
+  if (!level) {
+    return DEFAULT_LOG_LEVEL;
+  }
+  const normalizedLevel = level.toLowerCase().trim();
+  switch (normalizedLevel) {
+    case "debug":
+      return 4 /* DEBUG */;
+    case "info":
+      return 3 /* INFO */;
+    case "warn":
+    case "warning":
+      return 2 /* WARN */;
+    case "error":
+      return 1 /* ERROR */;
+    case "none":
+    case "off":
+    case "silent":
+      return 0 /* NONE */;
+    default: {
+      const numLevel = Number.parseInt(normalizedLevel, 10);
+      if (!Number.isNaN(numLevel) && numLevel >= 0 && numLevel <= 4) {
+        return numLevel;
+      }
+      return DEFAULT_LOG_LEVEL;
+    }
+  }
+}
+var logger = new PinoLogger();
+function setLogLevel(level) {
+  const resolvedLevel = typeof level === "string" ? parseLogLevel(level) : level;
+  logger.setLevel(resolvedLevel);
+}
+
+// src/internal/sdk.ts
+var import_resources2 = require("@opentelemetry/resources");
+var import_sdk_node = require("@opentelemetry/sdk-node");
+
+// src/internal/config.ts
+function resolveConfig(options) {
+  const envLogLevel = process.env["BRIZZ_LOG_LEVEL"] || options.logLevel?.toString() || DEFAULT_LOG_LEVEL.toString();
+  let resolvedLogLevel;
+  if (envLogLevel) {
+    resolvedLogLevel = parseLogLevel(envLogLevel);
+  } else if (typeof options.logLevel === "string") {
+    resolvedLogLevel = parseLogLevel(options.logLevel);
+  } else {
+    resolvedLogLevel = options.logLevel || DEFAULT_LOG_LEVEL;
+  }
+  setLogLevel(resolvedLogLevel);
+  let maskingStatus;
+  if (options.masking === true) {
+    maskingStatus = "enabled";
+  } else if (options.masking === false) {
+    maskingStatus = "disabled";
+  } else if (typeof options.masking === "object") {
+    maskingStatus = "custom";
+  } else {
+    maskingStatus = "default-disabled";
+  }
+  logger.debug("Starting configuration resolution", {
+    appName: options.appName,
+    baseUrl: options.baseUrl,
+    hasApiKey: !!options.apiKey,
+    disableBatch: options.disableBatch,
+    logLevel: resolvedLogLevel,
+    headersCount: Object.keys(options.headers || {}).length,
+    masking: maskingStatus
+  });
+  let resolvedMasking;
+  if (options.masking === true) {
+    resolvedMasking = {
+      spanMasking: {},
+      eventMasking: {}
+    };
+  } else if (options.masking && typeof options.masking === "object") {
+    resolvedMasking = options.masking;
+  }
+  const resolvedConfig = {
+    ...options,
+    appName: process.env["BRIZZ_APP_NAME"] || options.appName || "unknown-app",
+    baseUrl: process.env["BRIZZ_BASE_URL"] || options.baseUrl || "https://telemetry.brizz.dev",
+    headers: { ...options.headers },
+    apiKey: process.env["BRIZZ_API_KEY"] || options.apiKey,
+    disableBatch: process.env["BRIZZ_DISABLE_BATCH"] === "true" || !!options.disableBatch,
+    logLevel: resolvedLogLevel,
+    masking: resolvedMasking
+  };
+  if (resolvedConfig.apiKey) {
+    resolvedConfig.headers["Authorization"] = `Bearer ${resolvedConfig.apiKey}`;
+  }
+  if (process.env["BRIZZ_HEADERS"]) {
+    try {
+      const envHeaders = JSON.parse(process.env["BRIZZ_HEADERS"]);
+      Object.assign(resolvedConfig.headers, envHeaders);
+      logger.debug("Added headers from environment variable", {
+        headers: Object.keys(envHeaders)
+      });
+    } catch (error) {
+      logger.error("Failed to parse BRIZZ_HEADERS environment variable", { error });
+      throw new Error("Invalid JSON in BRIZZ_HEADERS environment variable");
+    }
+  }
+  logger.debug("Configuration resolved with environment variables", {
+    appName: resolvedConfig.appName,
+    baseUrl: resolvedConfig.baseUrl,
+    hasApiKey: !!resolvedConfig.apiKey,
+    disableBatch: resolvedConfig.disableBatch,
+    envOverrides: {
+      hasEnvApiKey: !!process.env["BRIZZ_API_KEY"],
+      hasEnvBaseUrl: !!process.env["BRIZZ_BASE_URL"],
+      hasEnvBatch: !!process.env["BRIZZ_DISABLE_BATCH"],
+      hasEnvHeaders: !!process.env["BRIZZ_HEADERS"]
+    }
+  });
+  return resolvedConfig;
+}
+
+// src/internal/instrumentation/registry.ts
+var import_instrumentation_anthropic = require("@traceloop/instrumentation-anthropic");
+var import_instrumentation_bedrock = require("@traceloop/instrumentation-bedrock");
+var import_instrumentation_chromadb = require("@traceloop/instrumentation-chromadb");
+var import_instrumentation_cohere = require("@traceloop/instrumentation-cohere");
+var import_instrumentation_langchain = require("@traceloop/instrumentation-langchain");
+var import_instrumentation_llamaindex = require("@traceloop/instrumentation-llamaindex");
+var import_instrumentation_openai = require("@traceloop/instrumentation-openai");
+var import_instrumentation_pinecone = require("@traceloop/instrumentation-pinecone");
+var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
+var import_instrumentation_together = require("@traceloop/instrumentation-together");
+var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
+
+// src/internal/instrumentation/vercel-ai/instrumentation.ts
+var import_instrumentation = require("@opentelemetry/instrumentation");
+
+// src/internal/instrumentation/vercel-ai/patchers/base-patcher.ts
+var import_api2 = require("@opentelemetry/api");
+
+// src/internal/instrumentation/vercel-ai/semconv.ts
+var ATTR_GEN_AI_SYSTEM = "gen_ai.system";
+var ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+var ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+var ATTR_GEN_AI_REQUEST_MAX_TOKENS = "gen_ai.request.max_tokens";
+var ATTR_GEN_AI_REQUEST_TEMPERATURE = "gen_ai.request.temperature";
+var ATTR_GEN_AI_REQUEST_TOP_P = "gen_ai.request.top_p";
+var ATTR_GEN_AI_REQUEST_TOP_K = "gen_ai.request.top_k";
+var ATTR_GEN_AI_REQUEST_STOP_SEQUENCES = "gen_ai.request.stop_sequences";
+var ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY = "gen_ai.request.frequency_penalty";
+var ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY = "gen_ai.request.presence_penalty";
+var ATTR_GEN_AI_RESPONSE_ID = "gen_ai.response.id";
+var ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+var ATTR_GEN_AI_RESPONSE_FINISH_REASONS = "gen_ai.response.finish_reasons";
+var ATTR_GEN_AI_TOKEN_TYPE = "gen_ai.token.type";
+var ATTR_GEN_AI_PROMPT = "gen_ai.prompt";
+var ATTR_GEN_AI_COMPLETION = "gen_ai.completion";
+var ATTR_GEN_AI_OPENAI_API_BASE = "gen_ai.openai.api_base";
+var ATTR_EVENT_NAME = "event.name";
+var EVENT_GEN_AI_USER_MESSAGE = "gen_ai.user.message";
+var EVENT_GEN_AI_ASSISTANT_MESSAGE = "gen_ai.assistant.message";
+var EVENT_GEN_AI_SYSTEM_MESSAGE = "gen_ai.system.message";
+var EVENT_GEN_AI_TOOL_MESSAGE = "gen_ai.tool.message";
+var METRIC_GEN_AI_CLIENT_OPERATION_DURATION = "gen_ai.client.operation.duration";
+var METRIC_GEN_AI_CLIENT_TOKEN_USAGE = "gen_ai.client.token.usage";
+var OPERATION_NAME_CHAT = "chat";
+var OPERATION_NAME_EMBEDDINGS = "embeddings";
+var TOKEN_TYPE_INPUT = "input";
+var TOKEN_TYPE_OUTPUT = "output";
+var PROVIDER_OPENAI = "openai";
+var PROVIDER_ANTHROPIC = "anthropic";
+var PROVIDER_GOOGLE = "google";
+var PROVIDER_AMAZON = "amazon";
+var PROVIDER_AZURE = "azure";
+var PROVIDER_VERCEL = "vercel";
+var PROVIDER_UNKNOWN = "unknown";
+var SPAN_NAME_GEN_AI_CHAT = "gen_ai.chat";
+var SPAN_NAME_GEN_AI_EMBEDDINGS = "gen_ai.embeddings";
+
+// src/internal/instrumentation/vercel-ai/utils.ts
+function detectProvider(model) {
+  if (typeof model === "object" && model !== null) {
+    const modelObj = model;
+    if (modelObj.provider) {
+      return {
+        system: normalizeProviderName(modelObj.provider),
+        apiBase: extractApiBase(modelObj)
+      };
+    }
+    if (modelObj.modelId) {
+      return detectProviderFromModelId(modelObj.modelId);
+    }
+  }
+  if (typeof model === "string") {
+    return detectProviderFromModelId(model);
+  }
+  return { system: PROVIDER_UNKNOWN };
+}
+function detectProviderFromModelId(modelId) {
+  const lowerModel = modelId.toLowerCase();
+  if (lowerModel.startsWith("gpt-") || lowerModel.startsWith("text-davinci-") || lowerModel.startsWith("text-embedding-") || lowerModel.startsWith("dall-e") || lowerModel.startsWith("whisper-") || lowerModel.startsWith("tts-")) {
+    return { system: PROVIDER_OPENAI };
+  }
+  if (lowerModel.startsWith("claude-")) {
+    return { system: PROVIDER_ANTHROPIC };
+  }
+  if (lowerModel.startsWith("gemini-") || lowerModel.startsWith("palm-") || lowerModel.includes("bison") || lowerModel.includes("gecko")) {
+    return { system: PROVIDER_GOOGLE };
+  }
+  if (lowerModel.startsWith("amazon.") || lowerModel.startsWith("anthropic.claude-") || lowerModel.startsWith("ai21.") || lowerModel.startsWith("cohere.") || lowerModel.startsWith("meta.llama")) {
+    return { system: PROVIDER_AMAZON };
+  }
+  if (lowerModel.includes("azure") || lowerModel.includes(".openai.azure.com")) {
+    return { system: PROVIDER_AZURE };
+  }
+  const parts = modelId.split(/[-._/]/);
+  if (parts.length > 0 && parts[0]) {
+    return { system: normalizeProviderName(parts[0]) };
+  }
+  return { system: PROVIDER_UNKNOWN };
+}
+function normalizeProviderName(provider) {
+  const normalized = provider.toLowerCase().trim();
+  switch (normalized) {
+    case "openai":
+    case "open-ai":
+    case "open_ai": {
+      return PROVIDER_OPENAI;
+    }
+    case "anthropic":
+    case "claude": {
+      return PROVIDER_ANTHROPIC;
+    }
+    case "google":
+    case "vertex":
+    case "vertexai":
+    case "vertex-ai":
+    case "gemini": {
+      return PROVIDER_GOOGLE;
+    }
+    case "amazon":
+    case "aws":
+    case "bedrock":
+    case "amazon-bedrock": {
+      return PROVIDER_AMAZON;
+    }
+    case "azure":
+    case "azure-openai":
+    case "microsoft": {
+      return PROVIDER_AZURE;
+    }
+    case "vercel":
+    case "vercel-ai": {
+      return PROVIDER_VERCEL;
+    }
+    default: {
+      return normalized;
+    }
+  }
+}
+function extractApiBase(model) {
+  if (typeof model === "object" && model !== null) {
+    const anyModel = model;
+    return anyModel.apiBase || anyModel.baseURL || anyModel.endpoint || void 0;
+  }
+  return void 0;
+}
+function extractModelId(model) {
+  if (typeof model === "string") {
+    return model;
+  }
+  if (typeof model === "object" && model !== null) {
+    return model.modelId || "unknown";
+  }
+  return "unknown";
+}
+function messagesToAttributes(messages, prefix, captureContent) {
+  const attributes = {};
+  for (const [index, msg] of messages.entries()) {
+    const baseKey = `${prefix}.${index}`;
+    attributes[`${baseKey}.role`] = msg.role;
+    if (captureContent && msg.content) {
+      if (typeof msg.content === "string") {
+        attributes[`${baseKey}.content`] = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        const textParts = msg.content.filter((part) => part.type === "text" && part.text).map((part) => part.text).join(" ");
+        if (textParts) {
+          attributes[`${baseKey}.content`] = textParts;
+        }
+      }
+    }
+    if (msg.toolInvocations && msg.toolInvocations.length > 0) {
+      attributes[`${baseKey}.tool_calls`] = msg.toolInvocations.length;
+    }
+  }
+  return attributes;
+}
+function promptToAttributes(prompt, captureContent) {
+  const attributes = {};
+  attributes[`${ATTR_GEN_AI_PROMPT}.0.role`] = "user";
+  if (captureContent) {
+    attributes[`${ATTR_GEN_AI_PROMPT}.0.content`] = prompt;
+  }
+  return attributes;
+}
+function completionToAttributes(text, finishReason, captureContent) {
+  const attributes = {};
+  attributes[`${ATTR_GEN_AI_COMPLETION}.0.role`] = "assistant";
+  if (captureContent) {
+    attributes[`${ATTR_GEN_AI_COMPLETION}.0.content`] = text;
+  }
+  if (finishReason) {
+    attributes[`${ATTR_GEN_AI_COMPLETION}.0.finish_reason`] = finishReason;
+  }
+  return attributes;
+}
+function tokenUsageToAttributes(usage) {
+  if (!usage) {
+    return {};
+  }
+  const attributes = {};
+  if (usage.inputTokens !== void 0) {
+    attributes["gen_ai.usage.prompt_tokens"] = usage.inputTokens;
+    attributes["gen_ai.usage.input_tokens"] = usage.inputTokens;
+    attributes["llm.usage.prompt_tokens"] = usage.inputTokens;
+  } else if (usage.promptTokens !== void 0) {
+    attributes["gen_ai.usage.prompt_tokens"] = usage.promptTokens;
+    attributes["gen_ai.usage.input_tokens"] = usage.promptTokens;
+    attributes["llm.usage.prompt_tokens"] = usage.promptTokens;
+  }
+  if (usage.outputTokens !== void 0) {
+    attributes["gen_ai.usage.completion_tokens"] = usage.outputTokens;
+    attributes["gen_ai.usage.output_tokens"] = usage.outputTokens;
+    attributes["llm.usage.completion_tokens"] = usage.outputTokens;
+  } else if (usage.completionTokens !== void 0) {
+    attributes["gen_ai.usage.completion_tokens"] = usage.completionTokens;
+    attributes["gen_ai.usage.output_tokens"] = usage.completionTokens;
+    attributes["llm.usage.completion_tokens"] = usage.completionTokens;
+  }
+  if (usage.totalTokens === void 0) {
+    const inputTokens = usage.inputTokens || usage.promptTokens;
+    const outputTokens = usage.outputTokens || usage.completionTokens;
+    if (inputTokens !== void 0 && outputTokens !== void 0) {
+      const totalTokens = inputTokens + outputTokens;
+      attributes["gen_ai.usage.total_tokens"] = totalTokens;
+      attributes["llm.usage.total_tokens"] = totalTokens;
+    }
+  } else {
+    attributes["gen_ai.usage.total_tokens"] = usage.totalTokens;
+    attributes["llm.usage.total_tokens"] = usage.totalTokens;
+  }
+  return attributes;
+}
+function shouldRecordError(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("abort") || message.includes("cancel")) {
+      return false;
+    }
+  }
+  return true;
+}
+function getEnvBool(name) {
+  const value = process.env[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  return value.toLowerCase() === "true" || value === "1";
+}
+
+// src/internal/instrumentation/vercel-ai/patchers/base-patcher.ts
+var BasePatcher = class {
+  constructor(context8) {
+    this.context = context8;
+  }
+  createSpan(spanName, params, operationName, additionalAttributes) {
+    const provider = detectProvider(params.model);
+    const modelId = extractModelId(params.model);
+    const span = this.context.tracer.startSpan(spanName, {
+      kind: import_api2.SpanKind.CLIENT,
+      attributes: {
+        [ATTR_GEN_AI_SYSTEM]: provider.system,
+        [ATTR_GEN_AI_OPERATION_NAME]: operationName,
+        [ATTR_GEN_AI_REQUEST_MODEL]: modelId,
+        ...params.maxTokens && { [ATTR_GEN_AI_REQUEST_MAX_TOKENS]: params.maxTokens },
+        ...params.temperature !== void 0 && {
+          [ATTR_GEN_AI_REQUEST_TEMPERATURE]: params.temperature
+        },
+        ...params.topP !== void 0 && { [ATTR_GEN_AI_REQUEST_TOP_P]: params.topP },
+        ...params.topK !== void 0 && { [ATTR_GEN_AI_REQUEST_TOP_K]: params.topK },
+        ...params.frequencyPenalty !== void 0 && {
+          [ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY]: params.frequencyPenalty
+        },
+        ...params.presencePenalty !== void 0 && {
+          [ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY]: params.presencePenalty
+        },
+        ...params.stopSequences && {
+          [ATTR_GEN_AI_REQUEST_STOP_SEQUENCES]: params.stopSequences
+        },
+        ...provider.apiBase && { [ATTR_GEN_AI_OPENAI_API_BASE]: provider.apiBase },
+        ...additionalAttributes
+      }
+    });
+    return { span, provider, modelId };
+  }
+  handleError(error, span) {
+    if (shouldRecordError(error)) {
+      span.recordException(error);
+      span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: error.message });
+    }
+  }
+  finalizeDuration(span, startTime, config, provider, modelId, operationName) {
+    if (config.enableMetrics) {
+      const duration = (globalThis.performance.now() - startTime) / 1e3;
+      this.context.recordDurationMetric(duration, provider.system, modelId, operationName);
+    }
+    span.end();
+  }
+};
+
+// src/internal/instrumentation/vercel-ai/patchers/generate-text-patcher.ts
+var import_api3 = require("@opentelemetry/api");
+var GenerateTextPatcher = class extends BasePatcher {
+  patch(original) {
+    return async (params) => {
+      const config = this.context.getConfig();
+      const startTime = globalThis.performance.now();
+      const { span, provider, modelId } = this.createSpan(
+        SPAN_NAME_GEN_AI_CHAT,
+        params,
+        OPERATION_NAME_CHAT
+      );
+      if (params.prompt) {
+        span.setAttributes(
+          promptToAttributes(params.prompt, config.captureMessageContent || false)
+        );
+      } else if (params.messages) {
+        span.setAttributes(
+          messagesToAttributes(
+            params.messages,
+            "gen_ai.prompt",
+            config.captureMessageContent || false
+          )
+        );
+        if (config.emitEvents) {
+          this.context.emitMessageEvents(params.messages, provider.system, span);
+        }
+      }
+      try {
+        const result = await import_api3.context.with(
+          import_api3.trace.setSpan(import_api3.context.active(), span),
+          () => original(params)
+        );
+        if (result.response) {
+          span.setAttributes({
+            ...result.response.id && { [ATTR_GEN_AI_RESPONSE_ID]: result.response.id },
+            ...result.response.model && { [ATTR_GEN_AI_RESPONSE_MODEL]: result.response.model }
+          });
+        }
+        if (result.finishReason) {
+          span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [result.finishReason]);
+        }
+        span.setAttributes(
+          completionToAttributes(
+            result.text,
+            result.finishReason,
+            config.captureMessageContent || false
+          )
+        );
+        const usage = result.usage || result.totalUsage || result.steps?.[0]?.usage;
+        if (usage) {
+          span.setAttributes(tokenUsageToAttributes(usage));
+          if (config.enableMetrics) {
+            this.context.recordTokenMetrics(usage, provider.system, modelId);
+          }
+        }
+        if (config.emitEvents) {
+          this.context.emitAssistantMessageEvent(result.text, provider.system, span);
+        }
+        span.setStatus({ code: import_api3.SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        this.handleError(error, span);
+        throw error;
+      } finally {
+        this.finalizeDuration(span, startTime, config, provider, modelId, OPERATION_NAME_CHAT);
+      }
+    };
+  }
+};
+
+// src/internal/instrumentation/vercel-ai/patchers/stream-text-patcher.ts
+var import_api4 = require("@opentelemetry/api");
+var StreamTextPatcher = class extends BasePatcher {
+  constructor(context8, streamHandler) {
+    super(context8);
+    this.streamHandler = streamHandler;
+  }
+  patch(original) {
+    return async (params) => {
+      const config = this.context.getConfig();
+      const startTime = globalThis.performance.now();
+      const { span, provider, modelId } = this.createSpan(
+        SPAN_NAME_GEN_AI_CHAT,
+        params,
+        OPERATION_NAME_CHAT,
+        { "gen_ai.streaming": true }
+      );
+      if (params.prompt) {
+        span.setAttributes(
+          promptToAttributes(params.prompt, config.captureMessageContent || false)
+        );
+      } else if (params.messages) {
+        span.setAttributes(
+          messagesToAttributes(
+            params.messages,
+            "gen_ai.prompt",
+            config.captureMessageContent || false
+          )
+        );
+        if (config.emitEvents) {
+          this.context.emitMessageEvents(params.messages, provider.system, span);
+        }
+      }
+      try {
+        const stream = await import_api4.context.with(
+          import_api4.trace.setSpan(import_api4.context.active(), span),
+          () => original(params)
+        );
+        return this.streamHandler.wrapStream(stream, span, config, provider, modelId, startTime);
+      } catch (error) {
+        this.handleError(error, span);
+        span.end();
+        throw error;
+      }
+    };
+  }
+};
+
+// src/internal/instrumentation/vercel-ai/patchers/embeddings-patcher.ts
+var import_api5 = require("@opentelemetry/api");
+var EmbeddingsPatcher = class extends BasePatcher {
+  patch(original, isMany = false) {
+    return async (params) => {
+      const config = this.context.getConfig();
+      const startTime = globalThis.performance.now();
+      const additionalAttributes = isMany ? { "gen_ai.embeddings.count": params.values ? params.values.length : 0 } : {};
+      const { span, provider, modelId } = this.createSpan(
+        SPAN_NAME_GEN_AI_EMBEDDINGS,
+        params,
+        OPERATION_NAME_EMBEDDINGS,
+        additionalAttributes
+      );
+      if (!isMany && config.captureMessageContent && params.value) {
+        span.setAttribute("gen_ai.prompt.0.content", params.value);
+      }
+      try {
+        const result = await import_api5.context.with(
+          import_api5.trace.setSpan(import_api5.context.active(), span),
+          () => original(params)
+        );
+        if (result.response) {
+          span.setAttributes({
+            ...result.response.id && { [ATTR_GEN_AI_RESPONSE_ID]: result.response.id },
+            ...result.response.model && { [ATTR_GEN_AI_RESPONSE_MODEL]: result.response.model }
+          });
+        }
+        if (isMany) {
+          if (result.embeddings && result.embeddings.length > 0 && result.embeddings[0]) {
+            span.setAttribute("gen_ai.response.embedding_dimensions", result.embeddings[0].length);
+          }
+        } else {
+          if (result.embedding) {
+            span.setAttribute("gen_ai.response.embedding_dimensions", result.embedding.length);
+          }
+        }
+        if (result.usage) {
+          span.setAttributes(tokenUsageToAttributes(result.usage));
+          if (config.enableMetrics) {
+            this.context.recordTokenMetrics(result.usage, provider.system, modelId);
+          }
+        }
+        span.setStatus({ code: import_api5.SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        this.handleError(error, span);
+        throw error;
+      } finally {
+        this.finalizeDuration(span, startTime, config, provider, modelId, OPERATION_NAME_EMBEDDINGS);
+      }
+    };
+  }
+};
+
+// src/internal/instrumentation/vercel-ai/stream-handler.ts
+var import_api6 = require("@opentelemetry/api");
+var StreamHandler = class {
+  constructor(context8) {
+    this.context = context8;
+  }
+  wrapStream(stream, span, config, provider, modelId, startTime) {
+    const self = this;
+    let fullText = "";
+    let finishReason;
+    let usage;
+    let response;
+    const wrappedStream = new Proxy(stream, {
+      get(target, prop) {
+        if (prop === Symbol.asyncIterator) {
+          return async function* () {
+            try {
+              for await (const chunk of target) {
+                if (chunk.type === "text-delta" && chunk.textDelta) {
+                  fullText += chunk.textDelta;
+                } else if (chunk.type === "finish") {
+                  finishReason = chunk.finishReason;
+                  usage = chunk.usage;
+                } else if (chunk.type === "response-metadata") {
+                  response = chunk.response;
+                }
+                yield chunk;
+              }
+            } finally {
+              self.finalizeStream(
+                span,
+                config,
+                provider,
+                modelId,
+                startTime,
+                fullText,
+                finishReason,
+                usage,
+                response
+              );
+            }
+          };
+        }
+        if (prop === "textStream" || prop === "fullStream") {
+          const originalStream = target[prop];
+          return {
+            [Symbol.asyncIterator]: async function* () {
+              try {
+                for await (const chunk of originalStream) {
+                  if (prop === "textStream") {
+                    fullText += chunk;
+                  }
+                  yield chunk;
+                }
+              } finally {
+                const streamUsage = await target.usage.catch(() => null);
+                if (streamUsage) {
+                  usage = streamUsage;
+                }
+                self.finalizeStream(
+                  span,
+                  config,
+                  provider,
+                  modelId,
+                  startTime,
+                  fullText,
+                  finishReason,
+                  usage,
+                  response
+                );
+              }
+            }
+          };
+        }
+        const value = target[prop];
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+    });
+    return wrappedStream;
+  }
+  finalizeStream(span, config, provider, modelId, startTime, fullText, finishReason, usage, response) {
+    if (response) {
+      span.setAttributes({
+        ...response.id && { [ATTR_GEN_AI_RESPONSE_ID]: response.id },
+        ...response.model && { [ATTR_GEN_AI_RESPONSE_MODEL]: response.model }
+      });
+    }
+    if (finishReason) {
+      span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [finishReason]);
+    }
+    if (fullText) {
+      span.setAttributes(
+        completionToAttributes(
+          fullText,
+          finishReason,
+          config.captureMessageContent || false
+        )
+      );
+    }
+    if (usage) {
+      span.setAttributes(tokenUsageToAttributes(usage));
+      if (config.enableMetrics) {
+        this.context.recordTokenMetrics(usage, provider.system, modelId);
+      }
+    }
+    if (config.enableMetrics) {
+      const duration = (performance.now() - startTime) / 1e3;
+      this.context.recordDurationMetric(duration, provider.system, modelId, OPERATION_NAME_CHAT);
+    }
+    span.setStatus({ code: import_api6.SpanStatusCode.OK });
+    span.end();
+  }
+};
+
+// src/internal/instrumentation/vercel-ai/telemetry-recorder.ts
+var import_api7 = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
+var TelemetryRecorder = class {
+  constructor(genaiClientOperationDuration, genaiClientTokenUsage, logger2) {
+    this.genaiClientOperationDuration = genaiClientOperationDuration;
+    this.genaiClientTokenUsage = genaiClientTokenUsage;
+    this.logger = logger2;
+  }
+  /**
+   * Record token usage metrics
+   */
+  recordTokenMetrics(usage, system, model) {
+    if (!this.genaiClientTokenUsage) {
+      return;
+    }
+    const commonAttrs = {
+      [ATTR_GEN_AI_SYSTEM]: system,
+      [ATTR_GEN_AI_REQUEST_MODEL]: model
+    };
+    const inputTokens = usage.inputTokens || usage.promptTokens;
+    const outputTokens = usage.outputTokens || usage.completionTokens;
+    if (inputTokens !== void 0) {
+      this.genaiClientTokenUsage.record(inputTokens, {
+        ...commonAttrs,
+        [ATTR_GEN_AI_TOKEN_TYPE]: TOKEN_TYPE_INPUT
+      });
+    }
+    if (outputTokens !== void 0) {
+      this.genaiClientTokenUsage.record(outputTokens, {
+        ...commonAttrs,
+        [ATTR_GEN_AI_TOKEN_TYPE]: TOKEN_TYPE_OUTPUT
+      });
+    }
+  }
+  /**
+   * Record operation duration metric
+   */
+  recordDurationMetric(duration, system, model, operation) {
+    if (!this.genaiClientOperationDuration) {
+      return;
+    }
+    this.genaiClientOperationDuration.record(duration, {
+      [ATTR_GEN_AI_SYSTEM]: system,
+      [ATTR_GEN_AI_REQUEST_MODEL]: model,
+      [ATTR_GEN_AI_OPERATION_NAME]: operation
+    });
+  }
+  /**
+   * Emit message events
+   */
+  emitMessageEvents(messages, system, span) {
+    if (!this.logger) {
+      return;
+    }
+    const ctx = import_api7.trace.setSpan(import_api7.context.active(), span);
+    for (const msg of messages) {
+      let eventName;
+      switch (msg.role) {
+        case "system": {
+          eventName = EVENT_GEN_AI_SYSTEM_MESSAGE;
+          break;
+        }
+        case "user": {
+          eventName = EVENT_GEN_AI_USER_MESSAGE;
+          break;
+        }
+        case "assistant": {
+          eventName = EVENT_GEN_AI_ASSISTANT_MESSAGE;
+          break;
+        }
+        case "tool":
+        case "function": {
+          eventName = EVENT_GEN_AI_TOOL_MESSAGE;
+          break;
+        }
+        default: {
+          continue;
+        }
+      }
+      this.logger.emit({
+        timestamp: Date.now(),
+        context: ctx,
+        severityNumber: import_api_logs.SeverityNumber.INFO,
+        attributes: {
+          [ATTR_EVENT_NAME]: eventName,
+          [ATTR_GEN_AI_SYSTEM]: system
+        },
+        body: {
+          role: msg.role,
+          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+          name: msg.name
+        }
+      });
+    }
+  }
+  /**
+   * Emit assistant message event
+   */
+  emitAssistantMessageEvent(text, system, span) {
+    if (!this.logger) {
+      return;
+    }
+    const ctx = import_api7.trace.setSpan(import_api7.context.active(), span);
+    this.logger.emit({
+      timestamp: Date.now(),
+      context: ctx,
+      severityNumber: import_api_logs.SeverityNumber.INFO,
+      attributes: {
+        [ATTR_EVENT_NAME]: EVENT_GEN_AI_ASSISTANT_MESSAGE,
+        [ATTR_GEN_AI_SYSTEM]: system
+      },
+      body: {
+        role: "assistant",
+        content: text
+      }
+    });
+  }
+};
+
+// src/internal/instrumentation/vercel-ai/instrumentation.ts
+var PACKAGE_NAME = "@brizz/vercel-ai-instrumentation";
+var PACKAGE_VERSION = "0.1.0";
+var VercelAIInstrumentation = class _VercelAIInstrumentation extends import_instrumentation.InstrumentationBase {
+  _genaiClientOperationDuration;
+  _genaiClientTokenUsage;
+  _telemetryRecorder;
+  _streamHandler;
+  _patchers = /* @__PURE__ */ new Map();
+  // Holds last patched namespace when available (reserved for future factory wrapping)
+  _vercelAiNamespace = null;
+  static _WRAPPED_SYMBOL = Symbol.for("brizz.vercel-ai.patched");
+  constructor(config = {}) {
+    super(PACKAGE_NAME, PACKAGE_VERSION, config);
+    const cfg = this.getConfig();
+    const envCC = getEnvBool("OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT");
+    if (envCC !== void 0) {
+      cfg.captureMessageContent = envCC;
+    }
+    this._initializeComponents();
+  }
+  setConfig(config = {}) {
+    const {
+      captureMessageContent = true,
+      enableMetrics = true,
+      emitEvents = true,
+      ...validConfig
+    } = config;
+    const fullConfig = {
+      ...validConfig,
+      captureMessageContent,
+      enableMetrics,
+      emitEvents
+    };
+    super.setConfig(fullConfig);
+  }
+  _initializeComponents() {
+    this._telemetryRecorder = new TelemetryRecorder(
+      this._genaiClientOperationDuration,
+      this._genaiClientTokenUsage,
+      this.logger
+    );
+    this._streamHandler = new StreamHandler({
+      recordTokenMetrics: this._telemetryRecorder.recordTokenMetrics.bind(this._telemetryRecorder),
+      recordDurationMetric: this._telemetryRecorder.recordDurationMetric.bind(
+        this._telemetryRecorder
+      )
+    });
+    const patcherContext = {
+      tracer: this.tracer,
+      getConfig: this.getConfig.bind(this),
+      recordTokenMetrics: this._telemetryRecorder.recordTokenMetrics.bind(this._telemetryRecorder),
+      recordDurationMetric: this._telemetryRecorder.recordDurationMetric.bind(
+        this._telemetryRecorder
+      ),
+      emitMessageEvents: this._telemetryRecorder.emitMessageEvents.bind(this._telemetryRecorder),
+      emitAssistantMessageEvent: this._telemetryRecorder.emitAssistantMessageEvent.bind(
+        this._telemetryRecorder
+      )
+    };
+    this._patchers.set("generateText", new GenerateTextPatcher(patcherContext));
+    this._patchers.set("streamText", new StreamTextPatcher(patcherContext, this._streamHandler));
+    this._patchers.set("embed", new EmbeddingsPatcher(patcherContext));
+    this._patchers.set("embedMany", new EmbeddingsPatcher(patcherContext));
+  }
+  init() {
+    return [
+      new import_instrumentation.InstrumentationNodeModuleDefinition(
+        "ai",
+        [">=4.0.0 <6"],
+        (moduleExports) => {
+          logger.info("Starting instrumentation of Vercel AI SDK module");
+          this._vercelAiNamespace = moduleExports;
+          const patched = this._patchModuleExports(moduleExports);
+          return patched ?? moduleExports;
+        },
+        (moduleExports) => {
+          logger.debug("Uninstrumenting @vercel/ai module");
+          return moduleExports;
+        }
+      )
+    ];
+  }
+  _updateMetricInstruments() {
+    const config = this.getConfig();
+    if (!config.enableMetrics) {
+      return;
+    }
+    this._genaiClientOperationDuration = this.meter.createHistogram(
+      METRIC_GEN_AI_CLIENT_OPERATION_DURATION,
+      {
+        description: "GenAI operation duration",
+        unit: "s",
+        advice: {
+          explicitBucketBoundaries: [
+            0.01,
+            0.02,
+            0.04,
+            0.08,
+            0.16,
+            0.32,
+            0.64,
+            1.28,
+            2.56,
+            5.12,
+            10.24,
+            20.48,
+            40.96,
+            81.92
+          ]
+        }
+      }
+    );
+    this._genaiClientTokenUsage = this.meter.createHistogram(METRIC_GEN_AI_CLIENT_TOKEN_USAGE, {
+      description: "Measures number of input and output tokens used",
+      unit: "{token}",
+      advice: {
+        explicitBucketBoundaries: [
+          1,
+          4,
+          16,
+          64,
+          256,
+          1024,
+          4096,
+          16384,
+          65536,
+          262144,
+          1048576,
+          4194304,
+          16777216,
+          67108864
+        ]
+      }
+    });
+    this._telemetryRecorder = new TelemetryRecorder(
+      this._genaiClientOperationDuration,
+      this._genaiClientTokenUsage,
+      this.logger
+    );
+  }
+  /**
+   * Patch known AI SDK functions in-place on the provided module exports object.
+   * This approach is compatible with both CJS and ESM module loaders.
+   */
+  _patchModuleExports(moduleExports) {
+    if (!moduleExports || typeof moduleExports !== "object") {
+      return null;
+    }
+    let inPlacePatched = true;
+    const wrapFunction = (name, isEmbedMany = false) => {
+      const current = moduleExports[name];
+      if (typeof current !== "function") {
+        return;
+      }
+      const currentFn = current;
+      if (currentFn[_VercelAIInstrumentation._WRAPPED_SYMBOL]) {
+        return;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(moduleExports, name);
+      if (descriptor && (!descriptor.writable || !descriptor.configurable) && !descriptor.set) {
+        inPlacePatched = false;
+        return;
+      }
+      const patcher = this._patchers.get(name);
+      if (!patcher) {
+        return;
+      }
+      const patched = isEmbedMany ? patcher.patch(currentFn, true) : patcher.patch(currentFn);
+      try {
+        Object.defineProperty(patched, _VercelAIInstrumentation._WRAPPED_SYMBOL, {
+          value: true,
+          enumerable: false,
+          configurable: false
+        });
+      } catch {
+      }
+      try {
+        moduleExports[name] = patched;
+      } catch {
+        inPlacePatched = false;
+      }
+    };
+    wrapFunction("generateText");
+    wrapFunction("streamText");
+    wrapFunction("embed");
+    wrapFunction("embedMany", true);
+    if (!inPlacePatched) {
+      const proxiedModule = new Proxy(moduleExports, {
+        get: (target, prop, receiver) => {
+          const originalValue = Reflect.get(target, prop, receiver);
+          if (typeof originalValue === "function" && typeof prop === "string" && this._patchers.has(prop)) {
+            const patcher = this._patchers.get(prop);
+            const isEmbedMany = prop === "embedMany";
+            const wrapped = isEmbedMany ? patcher.patch(originalValue, true) : patcher.patch(originalValue);
+            return wrapped;
+          }
+          return originalValue;
+        }
+      });
+      return proxiedModule;
+    }
+    return moduleExports;
+  }
+  /**
+   * Manual instrumentation hook for bundlers/Next.js. Applies in-place wrapping
+   * on the provided module namespace.
+   */
+  manuallyInstrument(module3) {
+    try {
+      const result = this._patchModuleExports(module3);
+      if (result !== null) {
+        logger.debug("Applied manual Vercel AI instrumentation");
+        this._vercelAiNamespace = result;
+        return result;
+      }
+      logger.warn("Manual Vercel AI instrumentation received invalid module");
+      return module3;
+    } catch (error) {
+      logger.error(`Failed manual Vercel AI instrumentation: ${String(error)}`);
+      return this._vercelAiNamespace || module3;
+    }
+  }
+  /**
+   * Wrap a created provider/client instance (factory return) when possible.
+   * Call this from wrappers that construct provider clients (e.g., OpenAI SDK).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  wrapFactoryReturn(instance) {
+    return instance;
+  }
+};
+
+// src/internal/instrumentation/registry.ts
+var InstrumentationRegistry = class _InstrumentationRegistry {
+  static instance;
+  manualModules = null;
+  static getInstance() {
+    if (!_InstrumentationRegistry.instance) {
+      _InstrumentationRegistry.instance = new _InstrumentationRegistry();
+    }
+    return _InstrumentationRegistry.instance;
+  }
+  /**
+   * Set manual instrumentation modules for Next.js/Webpack environments
+   */
+  setManualModules(modules) {
+    this.manualModules = modules;
+    logger.info("Manual instrumentation modules configured for Next.js/Webpack compatibility");
+  }
+  /**
+   * Helper to load instrumentation with optional manual module
+   */
+  loadInstrumentation(InstrumentationClass, name, manualModule, exceptionLogger) {
+    try {
+      const inst = new InstrumentationClass({
+        exceptionLogger: exceptionLogger || ((error) => logger.error(`Exception in instrumentation: ${String(error)}`))
+      });
+      if (manualModule) {
+        inst.manuallyInstrument(manualModule);
+        logger.debug(`Manual instrumentation enabled for ${name}`);
+      }
+      return inst;
+    } catch (error) {
+      logger.error(`Failed to load ${name} instrumentation: ${String(error)}`);
+      return null;
+    }
+  }
+  /**
+   * Get manual instrumentations only.
+   * Auto-instrumentations are handled at import time.
+   */
+  getManualInstrumentations() {
+    if (!this.manualModules || Object.keys(this.manualModules).length === 0) {
+      logger.debug("No manual instrumentation modules configured");
+      return [];
+    }
+    const instrumentations = [];
+    const exceptionLogger = (error) => {
+      logger.error(`Exception in manual instrumentation: ${String(error)}`);
+    };
+    this.loadManualInstrumentations(instrumentations, exceptionLogger);
+    logger.info(`Loaded ${instrumentations.length} manual instrumentations`);
+    return instrumentations;
+  }
+  /**
+   * Load manual instrumentations only (with modules provided by user).
+   * @private
+   */
+  loadManualInstrumentations(instrumentations, exceptionLogger) {
+    const instrumentationConfigs = [
+      { class: import_instrumentation_openai.OpenAIInstrumentation, name: "OpenAI", module: this.manualModules?.openAI },
+      { class: import_instrumentation_anthropic.AnthropicInstrumentation, name: "Anthropic", module: this.manualModules?.anthropic },
+      { class: import_instrumentation_cohere.CohereInstrumentation, name: "Cohere", module: this.manualModules?.cohere },
+      {
+        class: import_instrumentation_vertexai.VertexAIInstrumentation,
+        name: "Vertex AI",
+        module: this.manualModules?.google_vertexai
+      },
+      { class: import_instrumentation_bedrock.BedrockInstrumentation, name: "Bedrock", module: this.manualModules?.bedrock },
+      { class: import_instrumentation_pinecone.PineconeInstrumentation, name: "Pinecone", module: this.manualModules?.pinecone },
+      { class: import_instrumentation_langchain.LangChainInstrumentation, name: "LangChain", module: this.manualModules?.langchain },
+      {
+        class: import_instrumentation_llamaindex.LlamaIndexInstrumentation,
+        name: "LlamaIndex",
+        module: this.manualModules?.llamaindex
+      },
+      { class: import_instrumentation_chromadb.ChromaDBInstrumentation, name: "ChromaDB", module: this.manualModules?.chromadb },
+      { class: import_instrumentation_qdrant.QdrantInstrumentation, name: "Qdrant", module: this.manualModules?.qdrant },
+      { class: import_instrumentation_together.TogetherInstrumentation, name: "Together", module: this.manualModules?.together },
+      { class: VercelAIInstrumentation, name: "Vercel AI", module: this.manualModules?.vercelAI }
+    ];
+    for (const config of instrumentationConfigs) {
+      if (config.module) {
+        const instrumentation = this.loadInstrumentation(
+          config.class,
+          config.name,
+          config.module,
+          exceptionLogger
+        );
+        if (instrumentation) {
+          instrumentations.push(instrumentation);
+        }
+      }
+    }
+  }
+};
+
+// src/internal/log/logging.ts
+var import_api_logs2 = require("@opentelemetry/api-logs");
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
+var import_resources = require("@opentelemetry/resources");
+var import_sdk_logs2 = require("@opentelemetry/sdk-logs");
+
+// src/internal/log/processors/log-processor.ts
+var import_api9 = require("@opentelemetry/api");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+
+// src/internal/masking/patterns.ts
+var DEFAULT_PII_PATTERNS = [
+  // Email addresses
+  {
+    name: "email_addresses",
+    pattern: String.raw`\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b`
+  },
+  // Phone numbers (US format)
+  {
+    name: "us_phone_numbers",
+    pattern: String.raw`(?:^|[\s])(?:\+?1[-.\s]*)?(?:\([0-9]{3}\)\s?[0-9]{3}[-.\s]?[0-9]{4}|[0-9]{3}[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}|[0-9]{10})(?=[\s]|$)`
+  },
+  // Social Security Numbers
+  {
+    name: "ssn",
+    pattern: String.raw`\b(?!000|666|9\d{2})\d{3}[-\s]?(?!00)\d{2}[-\s]?(?!0000)\d{4}\b`
+  },
+  // Credit card numbers
+  {
+    name: "credit_cards",
+    pattern: String.raw`\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|6(?:011|5[0-9]{2})[0-9]{12}|(?:2131|1800|35\\d{3})\\d{11})\b`
+  },
+  {
+    name: "credit_cards_with_separators",
+    pattern: String.raw`\b(?:4\\d{3}|5[1-5]\\d{2}|3[47]\\d{2})[-\s]?\\d{4}[-\s]?\\d{4}[-\s]?\\d{4}\b`
+  },
+  // IP addresses (IPv4)
+  {
+    name: "ipv4_addresses",
+    pattern: String.raw`\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?!\.[0-9])\b`
+  },
+  // API keys/tokens
+  {
+    name: "generic_api_keys",
+    pattern: String.raw`\b(?:[Aa][Pp][Ii][_-]?[Kk][Ee][Yy]|[Tt][Oo][Kk][Ee][Nn]|[Ss][Ee][Cc][Rr][Ee][Tt])[_-]?[=:]?\s*["']?(?:[a-zA-Z0-9\-_.]{20,})["']?\b`
+  },
+  {
+    name: "openai_keys",
+    pattern: String.raw`\bsk[-_][a-zA-Z0-9]{20,}\b`
+  },
+  {
+    name: "base64_secrets",
+    pattern: String.raw`\b[A-Za-z0-9+/]{64,}={0,2}\b`
+  },
+  // AWS Keys
+  {
+    name: "aws_access_keys",
+    pattern: String.raw`\b(?:AKIA|ABIA|ACCA|ASIA)[0-9A-Z]{16}\b`
+  },
+  {
+    name: "aws_secret_keys",
+    pattern: String.raw`\b[A-Za-z0-9/+=]*[A-Z][A-Za-z0-9/+=]*[a-z][A-Za-z0-9/+=]*[/+=][A-Za-z0-9/+=]{30,}\b`
+  },
+  // GitHub tokens
+  {
+    name: "github_tokens",
+    pattern: String.raw`\bghp_[a-zA-Z0-9]{36}\b`
+  },
+  // Slack tokens
+  {
+    name: "slack_tokens",
+    pattern: String.raw`\bxox[baprs]-[0-9]{10,13}-[0-9]{10,13}-[a-zA-Z0-9]{24,34}\b`
+  },
+  // Stripe keys
+  {
+    name: "stripe_keys",
+    pattern: String.raw`\b(?:sk|pk)_(?:test|live)_[a-zA-Z0-9]{24,}\b`
+  },
+  // JWT tokens
+  {
+    name: "jwt_tokens",
+    pattern: String.raw`\beyJ[A-Za-z0-9_-]{2,}\\.[A-Za-z0-9_-]{2,}\\.[A-Za-z0-9_-]{2,}\b`
+  },
+  // MAC addresses
+  {
+    name: "mac_addresses",
+    pattern: String.raw`\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\b`
+  },
+  // IPv6 addresses
+  {
+    name: "ipv6_addresses",
+    pattern: String.raw`\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b`
+  },
+  // Medical records
+  {
+    name: "medical_record_numbers",
+    pattern: String.raw`\b(?:[Mm][Rr][Nn])[-\s]?\d{6,10}\b`
+  },
+  // Bitcoin addresses
+  {
+    name: "bitcoin_addresses",
+    pattern: String.raw`\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b`
+  },
+  // Ethereum addresses
+  {
+    name: "ethereum_addresses",
+    pattern: String.raw`\b0x[a-fA-F0-9]{40}(?![a-fA-F0-9])\b`
+  },
+  // UUIDs
+  {
+    name: "uuids",
+    pattern: String.raw`\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(?![0-9a-fA-F-])\b`
+  },
+  // Database connection strings
+  {
+    name: "database_connections",
+    pattern: String.raw`\b(?:[Mm][Oo][Nn][Gg][Oo][Dd][Bb]|[Pp][Oo][Ss][Tt][Gg][Rr][Ee][Ss]|[Mm][Yy][Ss][Qq][Ll]|[Rr][Ee][Dd][Ii][Ss]|[Mm][Ss][Ss][Qq][Ll]|[Oo][Rr][Aa][Cc][Ll][Ee]):\\/\\/[^\\s]+\b`
+  },
+  // Private keys
+  {
+    name: "rsa_private_keys",
+    pattern: "-----BEGIN (?:RSA )?PRIVATE KEY-----"
+  },
+  {
+    name: "pgp_private_keys",
+    pattern: "-----BEGIN PGP PRIVATE KEY BLOCK-----"
+  },
+  {
+    name: "certificates",
+    pattern: "-----BEGIN CERTIFICATE-----"
+  },
+  // Date of birth patterns
+  {
+    name: "date_of_birth_us",
+    pattern: String.raw`\b(?:0[1-9]|1[0-2])[-/](?:0[1-9]|[12]\\d|3[01])[-/](?:19|20)\\d{2}\b`
+  },
+  {
+    name: "date_of_birth_iso",
+    pattern: String.raw`\b(?:19|20)\\d{2}[-/](?:0[1-9]|1[0-2])[-/](?:0[1-9]|[12]\\d|3[01])\b`
+  },
+  // US Identification Numbers
+  {
+    name: "us_passport_numbers",
+    pattern: String.raw`\b[A-Z]?\\d{6,9}\b`
+  },
+  {
+    name: "drivers_license",
+    pattern: String.raw`\b[A-Z]{1,2}\\d{3,8}[-\s]?\\d{2,5}[-\s]?\\d{2,5}[-\s]?\\d{1,5}[-\s]?\\d?\b`
+  },
+  {
+    name: "bank_account_numbers",
+    pattern: String.raw`\b\\d{10,17}\b`
+  },
+  {
+    name: "aba_routing_numbers",
+    pattern: String.raw`\b((0[0-9])|(1[0-2])|(2[1-9])|(3[0-2])|(6[1-9])|(7[0-2])|80)([0-9]{7})\b`
+  },
+  {
+    name: "health_insurance_numbers",
+    pattern: String.raw`\b\\d{10}[A-Z]\b`
+  },
+  {
+    name: "employee_ids",
+    pattern: String.raw`\b(?:[Ee][Mm][Pp]|[Ee][Mm][Pp][Ll][Oo][Yy][Ee][Ee]|[Ee])[-\s]?\\d{5,8}\b`
+  },
+  {
+    name: "tax_ein",
+    pattern: String.raw`\b\\d{2}-\\d{7}\b`
+  },
+  {
+    name: "medicare_beneficiary_id",
+    pattern: String.raw`\b[1-9][A-Z][A-Z0-9]\\d-[A-Z][A-Z0-9]\\d-[A-Z][A-Z0-9]\\d{2}\b`
+  },
+  {
+    name: "national_provider_id",
+    pattern: String.raw`\b1\\d{9}\b`
+  },
+  {
+    name: "dea_numbers",
+    pattern: String.raw`\b[A-Z]{2}\\d{7}\b`
+  },
+  {
+    name: "itin",
+    pattern: String.raw`\b9\\d{2}(?:[ \\-]?)[7,8]\\d(?:[ \\-]?)\\d{4}\b`
+  },
+  // Vehicle and Location
+  {
+    name: "vin_numbers",
+    pattern: String.raw`\b[A-HJ-NPR-Z0-9]{17}\b`
+  },
+  {
+    name: "coordinates",
+    pattern: String.raw`\b[-+]?(?:[0-8]?\\d(?:\\.\\d+)?|90(?:\\.0+)?),\\s*[-+]?(?:1[0-7]\\d(?:\\.\\d+)?|180(?:\\.0+)?|[0-9]?\\d(?:\\.\\d+)?)\b`
+  },
+  {
+    name: "us_license_plates",
+    pattern: String.raw`\b[A-Z]{1,3}[-\s]\\d{1,4}[A-Z]?\b|\b\\d{1,2}[A-Z]{1,3}\\d{1,4}\b`
+  },
+  {
+    name: "us_zip_codes",
+    pattern: String.raw`\b(\\d{5}-\\d{4}|\\d{5})\b`
+  },
+  {
+    name: "us_street_addresses",
+    pattern: String.raw`\b\\d{1,8}\b[\\s\\S]{10,100}?\b(AK|AL|AR|AZ|CA|CO|CT|DC|DE|FL|GA|HI|IA|ID|IL|IN|KS|KY|LA|MA|MD|ME|MI|MN|MO|MS|MT|NC|ND|NE|NH|NJ|NM|NV|NY|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VA|VT|WA|WI|WV|WY)\b\\s\\d{5}\b`
+  },
+  // International Banking
+  {
+    name: "iban",
+    pattern: String.raw`\b[A-Z]{2}\d{2}[A-Z0-9]{4}\d{7}([A-Z0-9]?){0,16}\b`
+  },
+  {
+    name: "swift_bic",
+    pattern: String.raw`\b[A-Z]{4}[A-Z]{2}[A-Z0-9]{2}([A-Z0-9]{3})?\b`
+  },
+  // Additional API Keys and Tokens
+  {
+    name: "google_oauth",
+    pattern: String.raw`\bya29\\.[a-zA-Z0-9_-]{60,}\b`
+  },
+  {
+    name: "firebase_tokens",
+    pattern: String.raw`\bAAAA[A-Za-z0-9_-]{100,}\b`
+  },
+  {
+    name: "google_app_ids",
+    pattern: String.raw`\b[0-9]+-\w+\.apps\.googleusercontent\.com\b`
+  },
+  {
+    name: "facebook_secrets",
+    pattern: String.raw`\b(facebook_secret|FACEBOOK_SECRET|facebook_app_secret|FACEBOOK_APP_SECRET)[a-z_ =\\s"'\\:]{0,5}[^a-zA-Z0-9][a-f0-9]{32}[^a-zA-Z0-9]`
+  },
+  {
+    name: "github_keys",
+    pattern: String.raw`\b(GITHUB_SECRET|GITHUB_KEY|github_secret|github_key|github_token|GITHUB_TOKEN|github_api_key|GITHUB_API_KEY)[a-z_ =\\s\"'\\:]{0,10}[^a-zA-Z0-9][a-zA-Z0-9]{40}[^a-zA-Z0-9]`
+  },
+  {
+    name: "heroku_keys",
+    pattern: String.raw`\b(heroku_api_key|HEROKU_API_KEY|heroku_secret|HEROKU_SECRET)[a-z_ =\\s\"'\\:]{0,10}[^a-zA-Z0-9-]\\w{8}(?:-\\w{4}){3}-\\w{12}[^a-zA-Z0-9\\-]`
+  },
+  {
+    name: "slack_api_keys",
+    pattern: String.raw`\b(slack_api_key|SLACK_API_KEY|slack_key|SLACK_KEY)[a-z_ =\\s\"'\\:]{0,10}[^a-f0-9][a-f0-9]{32}[^a-f0-9]`
+  },
+  {
+    name: "slack_api_tokens",
+    pattern: String.raw`\b(xox[pb](?:-[a-zA-Z0-9]+){4,})\b`
+  },
+  // Extended Private Keys and Certificates
+  {
+    name: "dsa_private_keys",
+    pattern: String.raw`-----BEGIN DSA PRIVATE KEY-----(?:[a-zA-Z0-9\+\=\/"']|\s)+?-----END DSA PRIVATE KEY-----`
+  },
+  {
+    name: "ec_private_keys",
+    pattern: String.raw`-----BEGIN (?:EC|ECDSA) PRIVATE KEY-----(?:[a-zA-Z0-9\+\=\/"']|\s)+?-----END (?:EC|ECDSA) PRIVATE KEY-----`
+  },
+  {
+    name: "encrypted_private_keys",
+    pattern: String.raw`-----BEGIN ENCRYPTED PRIVATE KEY-----(?:.|\s)+?-----END ENCRYPTED PRIVATE KEY-----`
+  },
+  {
+    name: "ssl_certificates",
+    pattern: String.raw`-----BEGIN CERTIFICATE-----(?:.|\n)+?\s-----END CERTIFICATE-----`
+  },
+  {
+    name: "ssh_dss_public",
+    pattern: String.raw`\bssh-dss [0-9A-Za-z+/]+[=]{2}\b`
+  },
+  {
+    name: "ssh_rsa_public",
+    pattern: String.raw`\bssh-rsa AAAA[0-9A-Za-z+/]+[=]{0,3} [^@]+@[^@]+\b`
+  },
+  {
+    name: "putty_ssh_keys",
+    pattern: String.raw`PuTTY-User-Key-File-2: ssh-(?:rsa|dss)\s*Encryption: none(?:.|\s?)*?Private-MAC:`
+  },
+  // International Phone Numbers
+  {
+    name: "france_phone_numbers",
+    pattern: String.raw`\b([0O]?[1lI][1lI])?[3E][3E][0O]?[\\dOIlZEASB]{9}\b`
+  },
+  {
+    name: "german_phone_numbers",
+    pattern: String.raw`\b[\d\w]\d{2}[\d\w]{6}\d[\d\w]\b`
+  },
+  {
+    name: "uk_phone_numbers",
+    pattern: String.raw`\b([0O]?[1lI][1lI])?[4A][4A][\\dOIlZEASB]{10,11}\b`
+  },
+  // International IDs
+  {
+    name: "uk_drivers_license",
+    pattern: String.raw`\b[A-Z]{5}\d{6}[A-Z]{2}\d{1}[A-Z]{2}\b`
+  },
+  {
+    name: "uk_passport",
+    pattern: String.raw`\b\\d{10}GB[RP]\\d{7}[UMF]{1}\\d{9}\b`
+  },
+  {
+    name: "argentina_dni",
+    pattern: String.raw`\b\\d{2}\\.\\d{3}\\.\\d{3}\b`
+  },
+  {
+    name: "australia_tfn",
+    pattern: String.raw`\b[Tt][Ff][Nn](:|:\\s|\\s|)(\\d{8,9})\b`
+  },
+  {
+    name: "canada_passport",
+    pattern: String.raw`\b[\\w]{2}[\\d]{6}\b`
+  },
+  {
+    name: "croatia_vat",
+    pattern: String.raw`\bHR\\d{11}\b`
+  },
+  {
+    name: "czech_vat",
+    pattern: String.raw`\bCZ\\d{8,10}\b`
+  },
+  {
+    name: "denmark_personal_id",
+    pattern: String.raw`\b(?:\\d{10}|\\d{6}[-\\s]\\d{4})\b`
+  },
+  {
+    name: "france_national_id",
+    pattern: String.raw`\b\\d{12}\b`
+  },
+  {
+    name: "france_ssn",
+    pattern: String.raw`\b(?:\\d{13}|\\d{13}\\s\\d{2})\b`
+  },
+  {
+    name: "france_passport",
+    pattern: String.raw`\b\\d{2}11\\d{5}\b`
+  },
+  {
+    name: "california_drivers_license",
+    pattern: String.raw`\b[A-Z]{1}\\d{7}\b`
+  },
+  // Medical and Healthcare
+  {
+    name: "hipaa_ndc",
+    pattern: String.raw`\b\\d{4,5}-\\d{3,4}-\\d{1,2}\b`
+  },
+  // Security and Network
+  {
+    name: "cve_numbers",
+    pattern: String.raw`\b[Cc][Vv][Ee]-\\d{4}-\\d{4,7}\b`
+  },
+  {
+    name: "microsoft_oauth",
+    pattern: String.raw`https://login\.microsoftonline\.com/common/oauth2/v2\.0/token|https://login\.windows\.net/common/oauth2/token`
+  },
+  {
+    name: "postgres_connections",
+    pattern: String.raw`\b(?:[Pp][Oo][Ss][Tt][Gg][Rr][Ee][Ss]|[Pp][Gg][Ss][Qq][Ll])\\:\\/\\/`
+  },
+  {
+    name: "box_links",
+    pattern: String.raw`https://app\.box\.com/[s|l]/\S+`
+  },
+  {
+    name: "dropbox_links",
+    pattern: String.raw`https://www\.dropbox\.com/(?:s|l)/\S+`
+  },
+  // Credit Card Variants
+  {
+    name: "amex_cards",
+    pattern: String.raw`\b3[47][0-9]{13}\b`
+  },
+  {
+    name: "visa_cards",
+    pattern: String.raw`\b4[0-9]{12}(?:[0-9]{3})?\b`
+  },
+  {
+    name: "discover_cards",
+    pattern: String.raw`\b65[4-9][0-9]{13}|64[4-9][0-9]{13}|6011[0-9]{12}\b`
+  },
+  {
+    name: "enhanced_credit_cards",
+    pattern: String.raw`\b((4\\d{3}|5[1-5]\\d{2}|2\\d{3}|3[47]\\d{1,2})[\\s\\-]?\\d{4,6}[\\s\\-]?\\d{4,6}?([\\s\\-]\\d{3,4})?(\\d{3})?)\b`
+  },
+  // Bank Routing Numbers (US specific)
+  {
+    name: "bbva_routing_ca",
+    pattern: String.raw`\\b321170538\\b`
+  },
+  {
+    name: "boa_routing_ca",
+    pattern: String.raw`\\b(?:121|026)00(?:0|9)(?:358|593)\\b`
+  },
+  {
+    name: "chase_routing_ca",
+    pattern: String.raw`\\b322271627\\b`
+  },
+  {
+    name: "citibank_routing_ca",
+    pattern: String.raw`\\b32(?:11|22)71(?:18|72)4\\b`
+  },
+  {
+    name: "usbank_routing_ca",
+    pattern: String.raw`\\b12(?:1122676|2235821)\\b`
+  },
+  {
+    name: "united_bank_routing_ca",
+    pattern: String.raw`\\b122243350\\b`
+  },
+  {
+    name: "wells_fargo_routing_ca",
+    pattern: String.raw`\\b121042882\\b`
+  },
+  // Unrealistic alphanumeric identifiers
+  {
+    name: "generic_non_usual",
+    pattern: String.raw`(?:^|\s)(?=[A-Za-z0-9_\)\*\=@]*[A-Za-z])(?=[A-Za-z0-9_\)\*\=@]*[0-9])([A-Za-z0-9_\)\*\=@]{5,})(?=\s|$)`
+  }
+];
+
+// src/internal/masking/utils.ts
+function isValidPatternName(name) {
+  return /^[a-zA-Z0-9_]+$/.test(name);
+}
+function isLikelyReDoSPattern(pattern) {
+  const dangerousPatterns = [
+    // Nested quantifiers like (a+)+, (a*)+, (a+)*
+    /\([^)]*[+*]\)[+*]/,
+    // Alternation with overlapping groups like (a|a)*
+    /\([^)]*\|[^)]*\)[+*]/,
+    // Complex backtracking patterns - but more specific
+    /\([^)]*[+*][^)]*[+*][^)]*\)[+*]/
+  ];
+  return dangerousPatterns.some((dangerous) => dangerous.test(pattern));
+}
+function getGroupedPattern(patternEntry) {
+  let name = patternEntry.name;
+  if (!name || name === "") {
+    name = `pattern_${Math.random().toString(16).slice(2)}`;
+  }
+  if (!isValidPatternName(name)) {
+    throw new Error(
+      `Pattern name '${name}' must only contain alphanumeric characters and underscores`
+    );
+  }
+  if (isLikelyReDoSPattern(patternEntry.pattern)) {
+    throw new Error(`Potentially dangerous ReDoS pattern detected: '${patternEntry.pattern}'`);
+  }
+  try {
+    new RegExp(patternEntry.pattern);
+  } catch (error) {
+    throw new Error(`Invalid regex pattern '${patternEntry.pattern}': ${String(error)}`);
+  }
+  return `(?<${name}>${patternEntry.pattern})`;
+}
+function isIPatternEntry(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.pattern === "string" && (obj.name === void 0 || typeof obj.name === "string");
+}
+function isIEventMaskingRule(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.mode === "string" && Array.isArray(obj.patterns) && obj.patterns.every(
+    (p) => isIPatternEntry(p) || typeof p === "string"
+  ) && (obj.attributePattern === void 0 || typeof obj.attributePattern === "string");
+}
+function convertPatternsToPatternEntries(patterns) {
+  const patternEntries = [];
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      patternEntries.push({ pattern, name: "" });
+    } else if (isIPatternEntry(pattern)) {
+      patternEntries.push(pattern);
+    } else {
+      throw new Error("Patterns must be either strings or PatternEntry instances");
+    }
+  }
+  return patternEntries;
+}
+function compilePatternEntries(patternEntries) {
+  const patternGroups = [];
+  for (const patternEntry of patternEntries) {
+    try {
+      patternGroups.push(getGroupedPattern(patternEntry));
+    } catch (error) {
+      logger.warn(`Invalid pattern '${patternEntry.name}': ${patternEntry.pattern}`, error);
+      continue;
+    }
+  }
+  if (patternGroups.length === 0) {
+    return null;
+  }
+  try {
+    return new RegExp(patternGroups.join("|"));
+  } catch (error) {
+    logger.warn("Failed to compile pattern entries into regex", error);
+    return null;
+  }
+}
+function getCompiledAttributeNamePattern(rule) {
+  if (!rule.attributePattern) {
+    logger.debug("No attribute pattern provided, using default .*");
+    return /.*/;
+  }
+  let compiledPatternString = rule.attributePattern;
+  if (isIEventMaskingRule(rule) && rule.eventNamePattern) {
+    compiledPatternString = `(${compiledPatternString})|(${rule.eventNamePattern})`;
+  }
+  return new RegExp(compiledPatternString);
+}
+function shouldContinueExecution(startTime, iterations, timeoutMs) {
+  if (Date.now() - startTime > timeoutMs) {
+    logger.warn("Regex execution timed out - potential ReDoS pattern detected");
+    return false;
+  }
+  const maxIterations = 1e3;
+  if (iterations > maxIterations) {
+    logger.warn("Regex execution exceeded maximum iterations - potential ReDoS pattern detected");
+    return false;
+  }
+  return true;
+}
+function createGlobalPattern(pattern) {
+  return new RegExp(
+    pattern.source,
+    pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g"
+  );
+}
+function executeRegexWithTimeout(pattern, value, timeoutMs = 100) {
+  const matches = [];
+  const globalPattern = createGlobalPattern(pattern);
+  const startTime = Date.now();
+  let match;
+  let iterations = 0;
+  while ((match = globalPattern.exec(value)) !== null) {
+    if (!shouldContinueExecution(startTime, ++iterations, timeoutMs)) {
+      break;
+    }
+    matches.push(match);
+    if (match[0].length === 0) {
+      globalPattern.lastIndex = match.index + 1;
+    }
+  }
+  return matches;
+}
+function maskStringByPattern(value, pattern, mode = "full") {
+  const matches = [];
+  try {
+    const regexMatches = executeRegexWithTimeout(pattern, value);
+    for (const match of regexMatches) {
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        text: match[0],
+        groups: match.groups
+      });
+    }
+  } catch (error) {
+    logger.warn("Regex execution failed, skipping masking", error);
+    return value;
+  }
+  for (const matchInfo of matches.reverse()) {
+    let patternName = "unknown";
+    if (matchInfo.groups) {
+      for (const [groupName, groupValue] of Object.entries(matchInfo.groups)) {
+        if (groupValue !== void 0) {
+          if (groupName.includes("_") && /\d$/.test(groupName)) {
+            const parts = groupName.split("_");
+            patternName = parts[0] || groupName;
+          } else {
+            patternName = groupName;
+          }
+          break;
+        }
+      }
+    }
+    logger.info(`Masking detected: pattern '${patternName}' found match in value`);
+    const masked = mode === "partial" ? matchInfo.text[0] + "*****" : "*****";
+    value = value.slice(0, matchInfo.start) + masked + value.slice(matchInfo.end);
+  }
+  return value;
+}
+function maskStringByPatternBasedRule(value, rule) {
+  const patternEntries = convertPatternsToPatternEntries(rule.patterns);
+  if (patternEntries.length === 0) {
+    logger.warn("No patterns provided for masking rule, returning original value");
+    return value;
+  }
+  const mode = rule.mode;
+  if (!patternEntries || patternEntries.length === 0) {
+    return mode === "partial" && value ? value[0] + "*****" : "*****";
+  }
+  const compiledPatterns = compilePatternEntries(patternEntries);
+  if (!compiledPatterns) {
+    return value;
+  }
+  return maskStringByPattern(value, compiledPatterns, mode);
+}
+function maskValue(value, rule) {
+  if (typeof value === "string") {
+    return maskStringByPatternBasedRule(value, rule);
+  } else if (typeof value === "boolean" || typeof value === "number") {
+    return maskStringByPatternBasedRule(String(value), rule);
+  } else if (Array.isArray(value)) {
+    return value.map((v) => maskStringByPatternBasedRule(String(v), rule));
+  } else if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = maskValue(v, rule);
+    }
+    return result;
+  } else {
+    throw new Error(`Unsupported value type for masking: ${typeof value}`);
+  }
+}
+function maskAttributes(attributes, rules, outputOriginalValue = false) {
+  if (!attributes || Object.keys(attributes).length === 0) {
+    return {};
+  }
+  const maskedAttributes = { ...attributes };
+  for (const rule of rules) {
+    const compiledAttributeNamePattern = getCompiledAttributeNamePattern(rule);
+    const attributesToMask = compiledAttributeNamePattern ? Object.keys(maskedAttributes).filter((attr) => compiledAttributeNamePattern.test(attr)) : Object.keys(maskedAttributes);
+    for (const attribute of attributesToMask) {
+      const value = maskedAttributes[attribute];
+      if (value === null || value === void 0) {
+        continue;
+      }
+      if (outputOriginalValue) {
+        logger.debug(`Masking attribute '${attribute}' with original value`, { value });
+      }
+      maskedAttributes[attribute] = maskValue(value, rule);
+    }
+  }
+  return maskedAttributes;
+}
+
+// src/internal/semantic-conventions.ts
+var import_api8 = require("@opentelemetry/api");
+var BRIZZ = "brizz";
+var PROPERTIES = "properties";
+var PROPERTIES_CONTEXT_KEY = (0, import_api8.createContextKey)(PROPERTIES);
+
+// src/internal/log/processors/log-processor.ts
+var DEFAULT_LOG_MASKING_RULES = [
+  {
+    mode: "partial",
+    attributePattern: "event.name",
+    patterns: DEFAULT_PII_PATTERNS
+  }
+];
+var BrizzSimpleLogRecordProcessor = class extends import_sdk_logs.SimpleLogRecordProcessor {
+  config;
+  constructor(exporter, config) {
+    super(exporter);
+    this.config = config;
+  }
+  onEmit(logRecord) {
+    const maskingConfig = this.config.masking?.eventMasking;
+    if (maskingConfig) {
+      maskLog(logRecord, maskingConfig);
+    }
+    const associationProperties = import_api9.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    if (associationProperties) {
+      for (const [key, value] of Object.entries(associationProperties)) {
+        logRecord.setAttribute(`${BRIZZ}.${key}`, value);
+      }
+    }
+    super.onEmit(logRecord);
+  }
+};
+var BrizzBatchLogRecordProcessor = class extends import_sdk_logs.BatchLogRecordProcessor {
+  config;
+  constructor(exporter, config) {
+    super(exporter);
+    this.config = config;
+  }
+  onEmit(logRecord) {
+    const maskingConfig = this.config.masking?.eventMasking;
+    if (maskingConfig) {
+      maskLog(logRecord, maskingConfig);
+    }
+    const associationProperties = import_api9.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    if (associationProperties) {
+      for (const [key, value] of Object.entries(associationProperties)) {
+        logRecord.setAttribute(`${BRIZZ}.${key}`, value);
+      }
+    }
+    super.onEmit(logRecord);
+  }
+};
+function maskLog(logRecord, config) {
+  if (!logRecord.attributes) {
+    return logRecord;
+  }
+  let rules = config.rules || [];
+  if (!config.disableDefaultRules) {
+    rules = [...DEFAULT_LOG_MASKING_RULES, ...rules];
+  }
+  try {
+    if (logRecord.attributes && Object.keys(logRecord.attributes).length > 0) {
+      const attributesRecord = {};
+      for (const [key, value] of Object.entries(logRecord.attributes)) {
+        attributesRecord[key] = value;
+      }
+      const maskedAttributes = maskAttributes(attributesRecord, rules);
+      if (maskedAttributes) {
+        const newAttributes = {};
+        for (const [key, value] of Object.entries(maskedAttributes)) {
+          newAttributes[key] = value;
+        }
+        logRecord.setAttributes(newAttributes);
+      }
+    }
+    if (config.maskBody && logRecord.body !== void 0 && logRecord.body !== null) {
+      let maskedBody = logRecord.body;
+      for (const rule of rules) {
+        maskedBody = maskValue(maskedBody, rule);
+      }
+      logRecord.setBody(maskedBody);
+    }
+    return logRecord;
+  } catch (error) {
+    logger.error("Error masking log record:", error);
+    return logRecord;
+  }
+}
+
+// src/internal/log/logging.ts
+var LoggingModule = class _LoggingModule {
+  static instance = null;
+  logExporter = null;
+  logProcessor = null;
+  loggerProvider = null;
+  static getInstance() {
+    if (!_LoggingModule.instance) {
+      throw new Error("Brizz must be initialized before accessing LoggingModule");
+    }
+    return _LoggingModule.instance;
+  }
+  /**
+   * Initialize the logging module with the provided configuration
+   */
+  setup(config) {
+    logger.info("Setting up logging module");
+    this.initLogExporter(config);
+    this.initLogProcessor(config);
+    this.initLoggerProvider(config);
+    _LoggingModule.instance = this;
+    logger.info("Logging module setup completed");
+  }
+  /**
+   * Initialize the log exporter
+   */
+  initLogExporter(config) {
+    if (this.logExporter) {
+      logger.debug("Log exporter already initialized, skipping re-initialization");
+      return;
+    }
+    if (config.customLogExporter) {
+      logger.debug("Using custom log exporter");
+      this.logExporter = config.customLogExporter;
+      logger.debug("Custom log exporter initialized successfully");
+      return;
+    }
+    const logsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/logs";
+    logger.debug("Initializing default OTLP log exporter", { url: logsUrl });
+    const headers = { ...config.headers };
+    this.logExporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
+      url: logsUrl,
+      headers
+    });
+    logger.debug("OTLP log exporter initialized successfully");
+  }
+  /**
+   * Initialize the log processor with masking support
+   */
+  initLogProcessor(config) {
+    if (this.logProcessor) {
+      logger.debug("Log processor already initialized, skipping re-initialization");
+      return;
+    }
+    if (!this.logExporter) {
+      throw new Error("Log exporter must be initialized before processor");
+    }
+    logger.debug("Initializing log processor", {
+      disableBatch: config.disableBatch,
+      hasMasking: !!config.masking?.eventMasking
+    });
+    this.logProcessor = config.disableBatch ? new BrizzSimpleLogRecordProcessor(this.logExporter, config) : new BrizzBatchLogRecordProcessor(this.logExporter, config);
+    logger.debug("Log processor initialized successfully");
+  }
+  /**
+   * Initialize the logger provider
+   */
+  initLoggerProvider(config) {
+    if (this.loggerProvider) {
+      logger.debug("Logger provider already initialized, skipping re-initialization");
+      return;
+    }
+    if (!this.logProcessor) {
+      throw new Error("Log processor must be initialized before logger provider");
+    }
+    logger.debug("Creating resource with service name", {
+      serviceName: config.appName
+    });
+    const resource = (0, import_resources.resourceFromAttributes)({
+      "service.name": config.appName
+    });
+    logger.debug("Creating logger provider with resource");
+    this.loggerProvider = new import_sdk_logs2.LoggerProvider({
+      resource,
+      processors: [this.logProcessor]
+    });
+    logger.debug("Logger provider initialization completed");
+  }
+  /**
+   * Emit a custom event to the telemetry pipeline
+   */
+  emitEvent(name, attributes, body, severityNumber = import_api_logs2.SeverityNumber.INFO) {
+    logger.debug("Attempting to emit event", {
+      name,
+      hasAttributes: !!attributes,
+      attributesCount: attributes ? Object.keys(attributes).length : 0,
+      hasBody: !!body,
+      severityNumber
+    });
+    if (!this.loggerProvider) {
+      logger.error("Cannot emit event: Logger provider not initialized");
+      throw new Error("Logging module not initialized");
+    }
+    const logAttributes = { "event.name": name };
+    if (attributes) {
+      Object.assign(logAttributes, attributes);
+      logger.debug("Combined log attributes", { attributes: Object.keys(logAttributes) });
+    }
+    logger.debug("Getting logger instance for brizz_events");
+    const eventLogger = this.loggerProvider.getLogger("brizz.events");
+    logger.debug("Emitting log record with eventName", { eventName: name });
+    try {
+      eventLogger.emit({
+        eventName: name,
+        attributes: logAttributes,
+        severityNumber,
+        body
+      });
+      logger.debug("Event successfully emitted", { eventName: name });
+    } catch (error) {
+      logger.error(`Failed to emit event '${name}'`, { error, eventName: name });
+      logger.error("Log record that failed", {
+        eventName: name,
+        hasAttributes: logAttributes,
+        severityNumber,
+        hasBody: body
+      });
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+  }
+  /**
+   * Check if the module is initialized
+   */
+  isInitialized() {
+    return this.loggerProvider !== null;
+  }
+  /**
+   * Get the logger provider
+   */
+  getLoggerProvider() {
+    return this.loggerProvider;
+  }
+  /**
+   * Shutdown the logging module
+   */
+  async shutdown() {
+    logger.debug("Shutting down logging module");
+    if (this.loggerProvider) {
+      await this.loggerProvider.shutdown();
+      this.loggerProvider = null;
+    }
+    this.logProcessor = null;
+    this.logExporter = null;
+    if (_LoggingModule.instance === this) {
+      _LoggingModule.instance = null;
+    }
+    logger.debug("Logging module shutdown completed");
+  }
+};
+
+// src/internal/metric/metrics.ts
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var MetricsModule = class _MetricsModule {
+  static instance = null;
+  metricsExporter = null;
+  metricsReader = null;
+  static getInstance() {
+    if (!_MetricsModule.instance) {
+      throw new Error("Brizz must be initialized before accessing MetricsModule");
+    }
+    return _MetricsModule.instance;
+  }
+  /**
+   * Initialize the metrics module with the provided configuration
+   */
+  setup(config) {
+    logger.info("Setting up metrics module");
+    this.initMetricsReader(config);
+    _MetricsModule.instance = this;
+    logger.info("Metrics module setup completed");
+  }
+  /**
+   * Initialize the metrics exporter
+   */
+  initMetricsExporter(config) {
+    if (this.metricsExporter) {
+      logger.debug("Metrics exporter already initialized, skipping re-initialization");
+      return;
+    }
+    const metricsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/metrics";
+    logger.debug("Initializing metrics exporter", { url: metricsUrl });
+    this.metricsExporter = new import_exporter_metrics_otlp_http.OTLPMetricExporter({
+      url: metricsUrl,
+      headers: config.headers
+    });
+    logger.debug("Metrics exporter initialized successfully");
+  }
+  /**
+   * Initialize the metrics reader
+   */
+  initMetricsReader(config) {
+    if (this.metricsReader) {
+      logger.debug("Metrics reader already initialized, skipping re-initialization");
+      return;
+    }
+    if (config.customMetricReader) {
+      logger.debug("Using custom metric reader");
+      this.metricsReader = config.customMetricReader;
+      logger.debug("Custom metric reader initialized successfully");
+      return;
+    }
+    logger.debug(
+      "Using default metrics flow - creating OTLP exporter and PeriodicExportingMetricReader"
+    );
+    this.initMetricsExporter(config);
+    if (!this.metricsExporter) {
+      throw new Error("Failed to initialize metrics exporter");
+    }
+    this.metricsReader = new import_sdk_metrics.PeriodicExportingMetricReader({
+      exporter: this.metricsExporter
+    });
+    logger.debug("Default metrics reader initialized successfully");
+  }
+  /**
+   * Get the metrics exporter
+   */
+  getMetricsExporter() {
+    if (!this.metricsExporter) {
+      throw new Error("Metrics module not initialized");
+    }
+    return this.metricsExporter;
+  }
+  /**
+   * Get the metrics reader
+   */
+  getMetricsReader() {
+    if (!this.metricsReader) {
+      throw new Error("Metrics module not initialized");
+    }
+    return this.metricsReader;
+  }
+  /**
+   * Shutdown the metrics module
+   */
+  shutdown() {
+    logger.debug("Shutting down metrics module");
+    this.metricsReader = null;
+    this.metricsExporter = null;
+    if (_MetricsModule.instance === this) {
+      _MetricsModule.instance = null;
+    }
+    logger.debug("Metrics module shutdown completed");
+  }
+};
+function getMetricsReader() {
+  return MetricsModule.getInstance().getMetricsReader();
+}
+
+// src/internal/trace/tracing.ts
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+
+// src/internal/trace/processors/span-processor.ts
+var import_api10 = require("@opentelemetry/api");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var DEFAULT_MASKING_RULES = [
+  {
+    mode: "partial",
+    attributePattern: "gen_ai.prompt",
+    patterns: DEFAULT_PII_PATTERNS
+  },
+  {
+    mode: "partial",
+    attributePattern: "gen_ai.completion",
+    patterns: DEFAULT_PII_PATTERNS
+  },
+  {
+    mode: "partial",
+    attributePattern: "traceloop.entity.input",
+    patterns: DEFAULT_PII_PATTERNS
+  },
+  {
+    mode: "partial",
+    attributePattern: "traceloop.entity.output",
+    patterns: DEFAULT_PII_PATTERNS
+  }
+];
+var BrizzSimpleSpanProcessor = class extends import_sdk_trace_base.SimpleSpanProcessor {
+  config;
+  constructor(spanExporter, config) {
+    super(spanExporter);
+    this.config = config;
+  }
+  // Will work with the following code:
+  // const span = tracer.startSpan('sensitive-operation',{attributes:{
+  //     'user.password': 'secret123',
+  //     'user.email': 'user@example.com',
+  //   }});
+  //
+  // Won't work because onStart is called before attributes are set:
+  // span.setAttributes({
+  //    'user.password': 'secret123',
+  //    'user.email': 'user@example.com'
+  //  });
+  onStart(span, parentContext) {
+    const maskingConfig = this.config.masking?.spanMasking;
+    if (maskingConfig) {
+      maskSpan(span, maskingConfig);
+    }
+    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    if (associationProperties) {
+      for (const [key, value] of Object.entries(associationProperties)) {
+        span.setAttribute(`${BRIZZ}.${key}`, value);
+      }
+    }
+    super.onStart(span, parentContext);
+  }
+};
+var BrizzBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpanProcessor {
+  config;
+  constructor(spanExporter, config) {
+    super(spanExporter);
+    this.config = config;
+  }
+  onStart(span, parentContext) {
+    const maskingConfig = this.config.masking?.spanMasking;
+    if (maskingConfig) {
+      maskSpan(span, maskingConfig);
+    }
+    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    if (associationProperties) {
+      for (const [key, value] of Object.entries(associationProperties)) {
+        span.setAttribute(`${BRIZZ}.${key}`, value);
+      }
+    }
+    super.onStart(span, parentContext);
+  }
+};
+function maskSpan(span, config) {
+  if (!span.attributes || Object.keys(span.attributes).length === 0) {
+    return span;
+  }
+  let rules = config.rules || [];
+  if (!config.disableDefaultRules) {
+    rules = [...DEFAULT_MASKING_RULES, ...rules];
+  }
+  try {
+    const attributesRecord = {};
+    for (const [key, value] of Object.entries(span.attributes)) {
+      attributesRecord[key] = value;
+    }
+    const maskedAttributes = maskAttributes(attributesRecord, rules);
+    if (maskedAttributes && Object.keys(maskedAttributes).length > 0) {
+      const merged = { ...span.attributes };
+      for (const [key, value] of Object.entries(maskedAttributes)) {
+        merged[key] = value;
+      }
+      span.setAttributes(merged);
+    }
+    return span;
+  } catch (error) {
+    logger.error("Error masking span:", error);
+    return span;
+  }
+}
+
+// src/internal/trace/tracing.ts
+var TracingModule = class _TracingModule {
+  static instance = null;
+  spanExporter = null;
+  spanProcessor = null;
+  static getInstance() {
+    if (!_TracingModule.instance) {
+      throw new Error("Brizz must be initialized before accessing TracingModule");
+    }
+    return _TracingModule.instance;
+  }
+  /**
+   * Initialize the tracing module with the provided configuration
+   */
+  setup(config) {
+    logger.info("Setting up tracing module");
+    this.initSpanExporter(config);
+    this.initSpanProcessor(config);
+    _TracingModule.instance = this;
+    logger.info("Tracing module setup completed");
+  }
+  /**
+   * Initialize the span exporter
+   */
+  initSpanExporter(config) {
+    if (this.spanExporter) {
+      logger.debug("Span exporter already initialized, skipping re-initialization");
+      return;
+    }
+    if (config.customSpanExporter) {
+      logger.debug("Using custom span exporter");
+      this.spanExporter = config.customSpanExporter;
+      logger.debug("Custom span exporter initialized successfully");
+      return;
+    }
+    const tracesUrl = config.baseUrl.replace(/\/$/, "") + "/v1/traces";
+    logger.debug("Initializing default OTLP span exporter", { url: tracesUrl });
+    this.spanExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: tracesUrl,
+      headers: config.headers
+    });
+    logger.debug("OTLP span exporter initialized successfully");
+  }
+  /**
+   * Initialize the span processor with masking support
+   */
+  initSpanProcessor(config) {
+    if (this.spanProcessor) {
+      logger.debug("Span processor already initialized, skipping re-initialization");
+      return;
+    }
+    if (!this.spanExporter) {
+      throw new Error("Span exporter must be initialized before processor");
+    }
+    logger.debug("Initializing span processor", {
+      disableBatch: config.disableBatch,
+      hasMasking: !!config.masking?.spanMasking
+    });
+    this.spanProcessor = config.disableBatch ? new BrizzSimpleSpanProcessor(this.spanExporter, config) : new BrizzBatchSpanProcessor(this.spanExporter, config);
+    logger.debug("Span processor initialized successfully");
+  }
+  /**
+   * Get the span exporter
+   */
+  getSpanExporter() {
+    if (!this.spanExporter) {
+      throw new Error("Tracing module not initialized");
+    }
+    return this.spanExporter;
+  }
+  /**
+   * Get the span processor
+   */
+  getSpanProcessor() {
+    if (!this.spanProcessor) {
+      throw new Error("Tracing module not initialized");
+    }
+    return this.spanProcessor;
+  }
+  async shutdown() {
+    logger.debug("Shutting down tracing module");
+    if (this.spanProcessor) {
+      await this.spanProcessor.shutdown();
+      this.spanProcessor = null;
+    }
+    if (this.spanExporter) {
+      await this.spanExporter.shutdown();
+      this.spanExporter = null;
+    }
+    _TracingModule.instance = null;
+    logger.debug("Tracing module shutdown completed");
+  }
+};
+function getSpanProcessor() {
+  return TracingModule.getInstance().getSpanProcessor();
+}
+
+// src/internal/trace/session.ts
+var import_api11 = require("@opentelemetry/api");
+
+// src/internal/sdk.ts
+var _Brizz = class __Brizz {
+  static instance = null;
+  /** Flag indicating if SDK initialization has completed successfully */
+  _initialized = false;
+  /** OpenTelemetry sdk instance */
+  _sdk = null;
+  static getInstance() {
+    if (!__Brizz.instance) {
+      throw new Error("Brizz must be initialized before accessing TracingModule");
+    }
+    return __Brizz.instance;
+  }
+  /**
+   * Initialize the Brizz SDK with the provided configuration.
+   *
+   * @param {IBrizzInitializeOptions} options - Configuration options for the SDK
+   * @throws {Error} - If initialization fails
+   *
+   * @example
+   * ```typescript
+   * Brizz.initialize({
+   *   appName: 'my-app',
+   *   baseUrl: 'http://localhost:4318',
+   *   apiKey: 'your-api-key'
+   * });
+   * ```
+   */
+  initialize(options) {
+    if (this._initialized) {
+      logger.warn("Brizz SDK already initialized");
+      return;
+    }
+    logger.info("Starting Brizz SDK initialization");
+    try {
+      const resolvedConfig = resolveConfig(options);
+      this.initializeModules(resolvedConfig);
+      this.setupInstrumentation(options);
+      this.createAndStartNodeSDK(options, resolvedConfig);
+      this._initialized = true;
+      logger.info("Brizz SDK initialization completed successfully", {
+        moduleSystem: this.detectModuleSystem()
+      });
+    } catch (error) {
+      logger.error("Failed to initialize Brizz SDK", { error });
+      throw new Error(`Failed to initialize SDK: ${String(error)}`);
+    }
+  }
+  /**
+   * Set up instrumentation registry and configure manual modules.
+   * @private
+   */
+  setupInstrumentation(options) {
+    const registry = InstrumentationRegistry.getInstance();
+    if (options.instrumentModules && Object.keys(options.instrumentModules).length > 0) {
+      registry.setManualModules(options.instrumentModules);
+    }
+  }
+  /**
+   * Create and start NodeSDK if not disabled.
+   * Only handles manual instrumentations now - auto instrumentations are loaded at import time.
+   * @private
+   */
+  createAndStartNodeSDK(options, resolvedConfig) {
+    if (options.disableNodeSdk) {
+      logger.info("NodeSDK disabled - only telemetry modules initialized");
+      return;
+    }
+    const registry = InstrumentationRegistry.getInstance();
+    const manualInstrumentations = registry.getManualInstrumentations();
+    this._sdk = new import_sdk_node.NodeSDK({
+      spanProcessors: [getSpanProcessor()],
+      metricReader: getMetricsReader(),
+      resource: (0, import_resources2.resourceFromAttributes)({
+        "service.name": resolvedConfig.appName
+      }),
+      instrumentations: manualInstrumentations
+    });
+    this._sdk.start();
+    if (manualInstrumentations.length > 0) {
+      logger.info(`NodeSDK started with ${manualInstrumentations.length} manual instrumentations`);
+    } else {
+      logger.info("NodeSDK started - using auto-instrumentations loaded at import time");
+    }
+  }
+  /**
+   * Initialize telemetry modules.
+   *
+   * Sets up the tracing, metrics, and logging modules with their
+   * respective exporters and processors.
+   *
+   * @param {IResolvedBrizzConfig} config - Resolved configuration
+   * @private
+   */
+  initializeModules(config) {
+    logger.info("Initializing telemetry modules");
+    logger.debug("Initializing tracing module");
+    const tracingModule = new TracingModule();
+    tracingModule.setup(config);
+    logger.debug("Initializing metrics module");
+    const metricsModule = new MetricsModule();
+    metricsModule.setup(config);
+    logger.debug("Initializing logging module");
+    const loggingModule = new LoggingModule();
+    loggingModule.setup(config);
+    logger.info("All telemetry modules initialized successfully");
+  }
+  /**
+   * Detect the current module system (ESM or CJS) using reliable indicators
+   *
+   * @returns {string} - 'ESM' or 'CJS'
+   * @private
+   */
+  detectModuleSystem() {
+    const inCJS = typeof module !== "undefined" && typeof exports !== "undefined" && typeof require === "function" && typeof __filename === "string" && typeof __dirname === "string" && this === (typeof exports !== "undefined" ? exports : void 0);
+    return inCJS ? "CJS" : "ESM";
+  }
+  /**
+   * Gracefully shutdown the Brizz SDK.
+   *
+   * This method stops all telemetry collection, flushes any pending data,
+   * and releases resources. Should be called before application termination.
+   *
+   * @returns {Promise<void>} - Resolves when shutdown is complete
+   * @throws {Error} - If shutdown fails
+   *
+   * @example
+   * ```typescript
+   * // Shutdown before app exit
+   * await Brizz.shutdown();
+   * ```
+   */
+  async shutdown() {
+    if (!this._initialized) {
+      logger.warn("Brizz SDK not initialized");
+      return;
+    }
+    try {
+      await this.shutdownModules();
+      await this._sdk?.shutdown();
+      this._initialized = false;
+      this._sdk = null;
+      __Brizz.instance = null;
+      logger.info("Brizz SDK shut down successfully");
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ENOTFOUND")) {
+        logger.debug(`Network error during shutdown (expected in tests): ${error.message}`);
+      } else {
+        logger.error(`Failed to shutdown Brizz SDK: ${String(error)}`);
+        throw error;
+      }
+    }
+  }
+  /**
+   * Shutdown all telemetry modules.
+   * @private
+   */
+  async shutdownModules() {
+    logger.info("Shutting down telemetry modules");
+    try {
+      try {
+        const tracingModule = TracingModule.getInstance();
+        await tracingModule.shutdown();
+      } catch {
+        logger.debug("Tracing module already shut down or not initialized");
+      }
+      try {
+        const metricsModule = MetricsModule.getInstance();
+        metricsModule.shutdown();
+      } catch {
+        logger.debug("Metrics module already shut down or not initialized");
+      }
+      try {
+        const loggingModule = LoggingModule.getInstance();
+        await loggingModule.shutdown();
+      } catch {
+        logger.debug("Logging module already shut down or not initialized");
+      }
+      logger.info("All telemetry modules shut down successfully");
+    } catch (error) {
+      logger.error("Error shutting down modules", { error });
+      throw error;
+    }
+  }
+};
+var Brizz = new _Brizz();
+
+// src/node/loader.ts
+var import_node_module = __toESM(require("module"), 1);
+var import_import_in_the_middle = require("import-in-the-middle");
+var loaderDebug = (() => {
+  const isDebug = process.env["BRIZZ_ESM_DEBUG"] === "true" || process.env["BRIZZ_LOG_LEVEL"] === "debug";
+  return {
+    log: (msg, data) => {
+      if (!isDebug) {
+        return;
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+      console.log(`[${timestamp}] [ESM-LOADER] ${msg}${dataStr}`);
+    },
+    error: (msg, error) => {
+      if (!isDebug) {
+        return;
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const errorStr = error instanceof Error ? ` ${error.message}` : error ? ` ${JSON.stringify(error)}` : "";
+      console.error(`[${timestamp}] [ESM-LOADER] ERROR: ${msg}${errorStr}`);
+    }
+  };
+})();
+var LOADER_REGISTERED_KEY = Symbol.for("__brizz_esm_loader_registered__");
+function checkLoaderAPISupport() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major === void 0 || minor === void 0) {
+    loaderDebug.log("Failed to detect Node version, assuming loader API is supported");
+    return true;
+  }
+  const supported = major >= 21 || major === 20 && minor >= 6 || major === 18 && minor >= 19;
+  loaderDebug.log("Loader API support check:", {
+    nodeVersion: `${major}.${minor}`,
+    supportsLoaderAPI: supported
+  });
+  return supported;
+}
+function maybeRegisterESMLoader() {
+  if (globalThis[LOADER_REGISTERED_KEY] === true) {
+    loaderDebug.log("ESM loader already registered, skipping");
+    return false;
+  }
+  globalThis[LOADER_REGISTERED_KEY] = true;
+  loaderDebug.log("Starting ESM loader registration...");
+  if (!checkLoaderAPISupport()) {
+    loaderDebug.log("Node.js version does not support loader API, skipping");
+    return false;
+  }
+  try {
+    loaderDebug.log("Creating MessageChannel for import-in-the-middle...");
+    const { addHookMessagePort } = (0, import_import_in_the_middle.createAddHookMessageChannel)();
+    loaderDebug.log("Registering import-in-the-middle/hook.mjs...");
+    import_node_module.default.register("import-in-the-middle/hook.mjs", {
+      data: { addHookMessagePort },
+      transferList: [addHookMessagePort]
+    });
+    loaderDebug.log("ESM loader successfully registered!");
+    return true;
+  } catch (error) {
+    loaderDebug.error("Failed to register ESM loader:", error);
+    globalThis[LOADER_REGISTERED_KEY] = false;
+    return false;
+  }
+}
+if (globalThis[LOADER_REGISTERED_KEY] !== true) {
+  loaderDebug.log("Loader module imported, attempting to register...");
+  maybeRegisterESMLoader();
+}
+
+// src/node/runtime.ts
+function detectRuntime() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  const noNodeJSGlobals = typeof __filename === "undefined" && typeof __dirname === "undefined";
+  const noModuleSystem = typeof module === "undefined" && typeof exports === "undefined";
+  const hasRequire = typeof require === "function";
+  const isESM = noNodeJSGlobals && noModuleSystem;
+  const isCJS = hasRequire && typeof module !== "undefined" && typeof exports !== "undefined" && typeof __filename === "string" && typeof __dirname === "string";
+  const supportsLoaderAPI = (major ?? 0) >= 21 || (major ?? 0) === 20 && (minor ?? 0) >= 6 || (major ?? 0) === 18 && (minor ?? 0) >= 19;
+  const supportsRegister = !!process.features?.typescript || !!globalThis.module?.register;
+  logger.debug("Runtime detection results:", {
+    nodeVersion: `${major ?? 0}.${minor ?? 0}`,
+    isESM,
+    isCJS,
+    supportsLoaderAPI,
+    supportsRegister,
+    detectionLogic: {
+      noNodeJSGlobals,
+      noModuleSystem,
+      hasRequire,
+      esmCondition: `${noNodeJSGlobals} && ${noModuleSystem} = ${isESM}`,
+      cjsCondition: `require && module && exports && __filename && __dirname = ${isCJS}`
+    },
+    checks: {
+      __filename: typeof __filename,
+      __dirname: typeof __dirname,
+      require: typeof require,
+      module: typeof module,
+      exports: typeof exports,
+      "process.features": process.features,
+      "globalThis.module": globalThis.module
+    }
+  });
+  return {
+    isESM,
+    isCJS,
+    nodeVersion: process.versions.node,
+    supportsLoaderAPI,
+    supportsRegister
+  };
+}
+
+// src/preload.ts
+var runtime = detectRuntime();
+if (runtime.isESM && runtime.supportsLoaderAPI) {
+  maybeRegisterESMLoader();
+}
+try {
+  Brizz.initialize({
+    apiKey: process.env["BRIZZ_API_KEY"],
+    baseUrl: process.env["BRIZZ_BASE_URL"],
+    appName: process.env["BRIZZ_APP_NAME"] || process.env["OTEL_SERVICE_NAME"],
+    logLevel: process.env["BRIZZ_LOG_LEVEL"] || DEFAULT_LOG_LEVEL.toString(),
+    // Enable auto-instrumentation by default in preload mode
+    disableNodeSdk: false
+  });
+  logger.info(`SDK auto-initialized for ${runtime.isESM ? "ESM" : "CJS"} runtime`);
+} catch (error) {
+  logger.warn("Failed to auto-initialize SDK:", { error });
+}
+//# sourceMappingURL=preload.cjs.map