@brizz/sdk 0.1.29 → 0.1.30

package/dist/chunk-NUTJMVD4.cjs

@@ -0,0 +1,1970 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
+
+
+
+
+
+var _chunkJB6MA2RVcjs = require('./chunk-JB6MA2RV.cjs');
+
+
+var _chunkLTXMCGVQcjs = require('./chunk-LTXMCGVQ.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkGCORRK6Bcjs = require('./chunk-GCORRK6B.cjs');
+
+// src/internal/instrumentation/registry.ts
+var _instrumentationanthropic = require('@traceloop/instrumentation-anthropic');
+var _instrumentationbedrock = require('@traceloop/instrumentation-bedrock');
+var _instrumentationchromadb = require('@traceloop/instrumentation-chromadb');
+var _instrumentationcohere = require('@traceloop/instrumentation-cohere');
+var _instrumentationllamaindex = require('@traceloop/instrumentation-llamaindex');
+var _instrumentationopenai = require('@traceloop/instrumentation-openai');
+var _instrumentationpinecone = require('@traceloop/instrumentation-pinecone');
+var _instrumentationqdrant = require('@traceloop/instrumentation-qdrant');
+var _instrumentationtogether = require('@traceloop/instrumentation-together');
+var InstrumentationRegistry = (_class = class _InstrumentationRegistry {constructor() { _class.prototype.__init.call(this); }
+  
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new _InstrumentationRegistry();
+    }
+    return this.instance;
+  }
+  __init() {this.manualModules = null}
+  /**
+   * Helper to load instrumentation with optional manual module
+   */
+  loadInstrumentation(InstrumentationClass, name, manualModule, exceptionLogger) {
+    try {
+      const inst = new InstrumentationClass({
+        exceptionLogger: exceptionLogger || ((error) => _chunkJB6MA2RVcjs.logger.error(`Exception in instrumentation: ${String(error)}`))
+      });
+      if (manualModule) {
+        inst.manuallyInstrument(manualModule);
+        _chunkJB6MA2RVcjs.logger.debug(`Manual instrumentation enabled for ${name}`);
+      }
+      return inst;
+    } catch (error) {
+      _chunkJB6MA2RVcjs.logger.error(`Failed to load ${name} instrumentation: ${String(error)}`);
+      return null;
+    }
+  }
+  /**
+   * Load manual instrumentations only (with modules provided by user).
+   * @private
+   */
+  loadManualInstrumentations(instrumentations, exceptionLogger) {
+    const instrumentationConfigs = [
+      { class: _instrumentationopenai.OpenAIInstrumentation, name: "OpenAI", module: _optionalChain([this, 'access', _2 => _2.manualModules, 'optionalAccess', _3 => _3.openAI]) },
+      { class: _instrumentationanthropic.AnthropicInstrumentation, name: "Anthropic", module: _optionalChain([this, 'access', _4 => _4.manualModules, 'optionalAccess', _5 => _5.anthropic]) },
+      { class: _instrumentationcohere.CohereInstrumentation, name: "Cohere", module: _optionalChain([this, 'access', _6 => _6.manualModules, 'optionalAccess', _7 => _7.cohere]) },
+      { class: _instrumentationbedrock.BedrockInstrumentation, name: "Bedrock", module: _optionalChain([this, 'access', _8 => _8.manualModules, 'optionalAccess', _9 => _9.bedrock]) },
+      { class: _instrumentationpinecone.PineconeInstrumentation, name: "Pinecone", module: _optionalChain([this, 'access', _10 => _10.manualModules, 'optionalAccess', _11 => _11.pinecone]) },
+      {
+        class: _instrumentationllamaindex.LlamaIndexInstrumentation,
+        name: "LlamaIndex",
+        module: _optionalChain([this, 'access', _12 => _12.manualModules, 'optionalAccess', _13 => _13.llamaindex])
+      },
+      { class: _instrumentationchromadb.ChromaDBInstrumentation, name: "ChromaDB", module: _optionalChain([this, 'access', _14 => _14.manualModules, 'optionalAccess', _15 => _15.chromadb]) },
+      { class: _instrumentationqdrant.QdrantInstrumentation, name: "Qdrant", module: _optionalChain([this, 'access', _16 => _16.manualModules, 'optionalAccess', _17 => _17.qdrant]) },
+      { class: _instrumentationtogether.TogetherInstrumentation, name: "Together", module: _optionalChain([this, 'access', _18 => _18.manualModules, 'optionalAccess', _19 => _19.together]) }
+    ];
+    for (const config of instrumentationConfigs) {
+      if (!config.module) {
+        continue;
+      }
+      const instrumentation = this.loadInstrumentation(
+        config.class,
+        config.name,
+        config.module,
+        exceptionLogger
+      );
+      if (instrumentation) {
+        instrumentations.push(instrumentation);
+      }
+    }
+    if (_optionalChain([this, 'access', _20 => _20.manualModules, 'optionalAccess', _21 => _21.langchain, 'optionalAccess', _22 => _22.callbackManagerModule])) {
+      const callbackManagerModule = this.manualModules.langchain.callbackManagerModule;
+      void (async () => {
+        try {
+          const { LangChainInstrumentation } = await Promise.resolve().then(() => _interopRequireWildcard(require("@arizeai/openinference-instrumentation-langchain")));
+          const lcInst = new LangChainInstrumentation();
+          lcInst.manuallyInstrument(callbackManagerModule);
+          _chunkJB6MA2RVcjs.logger.debug("Manual instrumentation enabled for LangChain");
+        } catch (error) {
+          _chunkJB6MA2RVcjs.logger.error(
+            `Failed to load LangChain instrumentation. Ensure @langchain/core is installed: ${String(error)}`
+          );
+        }
+      })();
+    }
+    if (_optionalChain([this, 'access', _23 => _23.manualModules, 'optionalAccess', _24 => _24.google_vertexai])) {
+      const vertexModule = this.manualModules.google_vertexai;
+      void (async () => {
+        try {
+          const { VertexAIInstrumentation } = await Promise.resolve().then(() => _interopRequireWildcard(require("@traceloop/instrumentation-vertexai")));
+          const vertexInst = new VertexAIInstrumentation({ exceptionLogger });
+          vertexInst.manuallyInstrument(vertexModule);
+          _chunkJB6MA2RVcjs.logger.debug("Manual instrumentation enabled for Vertex AI");
+        } catch (error) {
+          _chunkJB6MA2RVcjs.logger.error(
+            `Failed to load Vertex AI instrumentation. Ensure @traceloop/instrumentation-vertexai is installed: ${String(error)}`
+          );
+        }
+      })();
+    }
+    if (_optionalChain([this, 'access', _25 => _25.manualModules, 'optionalAccess', _26 => _26.mcp])) {
+      const mcpModules = this.manualModules.mcp;
+      void (async () => {
+        try {
+          const { MCPInstrumentation } = await Promise.resolve().then(() => _interopRequireWildcard(require("./mcp-6BDG4SWY.cjs")));
+          const instrumentation = new MCPInstrumentation({ exceptionLogger });
+          instrumentation.manuallyInstrument(mcpModules);
+          _chunkJB6MA2RVcjs.logger.debug("Manual instrumentation enabled for MCP");
+        } catch (error) {
+          _chunkJB6MA2RVcjs.logger.error(`Failed to apply MCP instrumentation: ${String(error)}`);
+        }
+      })();
+    }
+  }
+  /**
+   * Set manual instrumentation modules for Next.js/Webpack environments
+   */
+  setManualModules(modules) {
+    this.manualModules = modules;
+    _chunkJB6MA2RVcjs.logger.info("Manual instrumentation modules configured for Next.js/Webpack compatibility");
+  }
+  /**
+   * Get manual instrumentations only.
+   * Auto-instrumentations are handled at import time.
+   */
+  getManualInstrumentations() {
+    if (!this.manualModules || Object.keys(this.manualModules).length === 0) {
+      _chunkJB6MA2RVcjs.logger.debug("No manual instrumentation modules configured");
+      return [];
+    }
+    const instrumentations = [];
+    const exceptionLogger = (error) => {
+      _chunkJB6MA2RVcjs.logger.error(`Exception in manual instrumentation: ${String(error)}`);
+    };
+    this.loadManualInstrumentations(instrumentations, exceptionLogger);
+    _chunkJB6MA2RVcjs.logger.info(`Loaded ${instrumentations.length} manual instrumentations`);
+    return instrumentations;
+  }
+}, _class);
+
+// src/internal/trace/session.ts
+var _api = require('@opentelemetry/api');
+
+// src/internal/log/logging.ts
+var _apilogs = require('@opentelemetry/api-logs');
+var _exporterlogsotlphttp = require('@opentelemetry/exporter-logs-otlp-http');
+var _resources = require('@opentelemetry/resources');
+
+
+var _sdklogs = require('@opentelemetry/sdk-logs');
+
+// src/internal/constants.ts
+var BRIZZ_SDK_VERSION = "brizz.sdk.version";
+var BRIZZ_SDK_LANGUAGE = "brizz.sdk.language";
+var SDK_LANGUAGE = "typescript";
+
+// src/internal/log/processors/log-processor.ts
+
+
+
+// src/internal/masking/patterns.ts
+var DEFAULT_PII_PATTERNS = [
+  // 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]|$)`
+  },
+  // 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`
+  },
+  // AWS Keys
+  {
+    name: "aws_access_keys",
+    pattern: String.raw`\b(?:AKIA|ABIA|ACCA|ASIA)[0-9A-Z]{16}\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`
+  },
+  // 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`
+  },
+  // 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-----"
+  },
+  // 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:`
+  },
+  // 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`
+  }
+];
+
+// 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+)*
+    /\([^)]*[+*]\)[+*]/,
+    // Overlapping alternation under an outer quantifier like (a|a)+, (\w|\d)+. Scoped to
+    // capturing groups so the lazy (?:…)+? built-ins aren't false-flagged.
+    /\((?!\?)[^)]*\|[^)]*\)[+*]/,
+    // 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)}`, {
+      cause: 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) {
+      _chunkJB6MA2RVcjs.logger.warn(`Invalid pattern '${patternEntry.name}': ${patternEntry.pattern}`, error);
+      continue;
+    }
+  }
+  if (patternGroups.length === 0) {
+    return null;
+  }
+  try {
+    return new RegExp(patternGroups.join("|"));
+  } catch (error) {
+    _chunkJB6MA2RVcjs.logger.warn("Failed to compile pattern entries into regex", error);
+    return null;
+  }
+}
+var compiledPatternCache = /* @__PURE__ */ new WeakMap();
+function getCompiledPatternsForRule(rule) {
+  const key = rule.patterns;
+  if (compiledPatternCache.has(key)) {
+    return _nullishCoalesce(compiledPatternCache.get(key), () => ( null));
+  }
+  const compiled = compilePatternEntries(convertPatternsToPatternEntries(rule.patterns));
+  compiledPatternCache.set(key, compiled);
+  return compiled;
+}
+function getCompiledAttributeNamePattern(rule) {
+  if (!rule.attributePattern) {
+    _chunkJB6MA2RVcjs.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) {
+    _chunkJB6MA2RVcjs.logger.warn("Regex execution timed out - potential ReDoS pattern detected");
+    return false;
+  }
+  const maxIterations = 1e3;
+  if (iterations > maxIterations) {
+    _chunkJB6MA2RVcjs.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) {
+    _chunkJB6MA2RVcjs.logger.warn("Regex execution failed, skipping masking", error);
+    return value;
+  }
+  for (const matchInfo of matches.toReversed()) {
+    let patternName = "unknown";
+    if (matchInfo.groups) {
+      const firstDefined = Object.entries(matchInfo.groups).find(
+        ([, groupValue]) => groupValue !== void 0
+      );
+      if (firstDefined) {
+        const [groupName] = firstDefined;
+        if (groupName.includes("_") && /\d$/.test(groupName)) {
+          const parts = groupName.split("_");
+          patternName = parts[0] || groupName;
+        } else {
+          patternName = groupName;
+        }
+      }
+    }
+    _chunkJB6MA2RVcjs.logger.info(`Masking detected: pattern '${patternName}' found match in value`);
+    const masked = mode === "partial" ? matchInfo.text.at(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) {
+    _chunkJB6MA2RVcjs.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.at(0) + "*****" : "*****";
+  }
+  const compiledPatterns = getCompiledPatternsForRule(rule);
+  if (!compiledPatterns) {
+    return value;
+  }
+  return maskStringByPattern(value, compiledPatterns, mode);
+}
+function maskValue(value, rule) {
+  if (typeof value === "string") {
+    return maskStringByPatternBasedRule(value, rule);
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return maskStringByPatternBasedRule(String(value), rule);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => maskStringByPatternBasedRule(String(v), rule));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = maskValue(v, rule);
+    }
+    return result;
+  }
+  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) {
+        if (outputOriginalValue) {
+          _chunkJB6MA2RVcjs.logger.debug(`Masking attribute '${attribute}' with original value`, { value });
+        }
+        maskedAttributes[attribute] = maskValue(value, rule);
+      }
+    }
+  }
+  return maskedAttributes;
+}
+
+// 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 _sdklogs.SimpleLogRecordProcessor {
+  
+  constructor(exporter, config) {
+    super(exporter);
+    this.config = config;
+  }
+  onEmit(logRecord) {
+    const maskingConfig = _optionalChain([this, 'access', _27 => _27.config, 'access', _28 => _28.masking, 'optionalAccess', _29 => _29.eventMasking]);
+    if (maskingConfig) {
+      maskLog(logRecord, maskingConfig);
+    }
+    const associationProperties = _api.context.active().getValue(_chunkGCORRK6Bcjs.PROPERTIES_CONTEXT_KEY);
+    if (associationProperties) {
+      for (const [key, value] of Object.entries(associationProperties)) {
+        logRecord.setAttribute(`${_chunkGCORRK6Bcjs.BRIZZ}.${key}`, value);
+      }
+    }
+    super.onEmit(logRecord);
+  }
+};
+var BrizzBatchLogRecordProcessor = class extends _sdklogs.BatchLogRecordProcessor {
+  
+  constructor(exporter, config) {
+    super(exporter);
+    this.config = config;
+  }
+  onEmit(logRecord) {
+    const maskingConfig = _optionalChain([this, 'access', _30 => _30.config, 'access', _31 => _31.masking, 'optionalAccess', _32 => _32.eventMasking]);
+    if (maskingConfig) {
+      maskLog(logRecord, maskingConfig);
+    }
+    const associationProperties = _api.context.active().getValue(_chunkGCORRK6Bcjs.PROPERTIES_CONTEXT_KEY);
+    if (associationProperties) {
+      for (const [key, value] of Object.entries(associationProperties)) {
+        logRecord.setAttribute(`${_chunkGCORRK6Bcjs.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;
+        }
+        for (const [key, value] of Object.entries(logRecord.attributes)) {
+          if (key.startsWith(_chunkGCORRK6Bcjs.INTERNAL_EVENT_PREFIX)) {
+            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) {
+    _chunkJB6MA2RVcjs.logger.error("Error masking log record:", error);
+    return logRecord;
+  }
+}
+
+// src/internal/log/logging.ts
+var LoggingModule = (_class2 = class _LoggingModule {constructor() { _class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this); }
+  static __initStatic() {this.instance = null}
+  static getInstance() {
+    if (!this.instance) {
+      throw new Error("Brizz must be initialized before accessing LoggingModule");
+    }
+    return this.instance;
+  }
+  __init2() {this.logExporter = null}
+  __init3() {this.logProcessor = null}
+  __init4() {this.loggerProvider = null}
+  /**
+   * Initialize the log exporter
+   */
+  initLogExporter(config) {
+    if (this.logExporter) {
+      _chunkJB6MA2RVcjs.logger.debug("Log exporter already initialized, skipping re-initialization");
+      return;
+    }
+    if (config.customLogExporter) {
+      _chunkJB6MA2RVcjs.logger.debug("Using custom log exporter");
+      this.logExporter = config.customLogExporter;
+      _chunkJB6MA2RVcjs.logger.debug("Custom log exporter initialized successfully");
+      return;
+    }
+    const logsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/logs";
+    _chunkJB6MA2RVcjs.logger.debug("Initializing default OTLP log exporter", { url: logsUrl });
+    const headers = { ...config.headers };
+    this.logExporter = new (0, _exporterlogsotlphttp.OTLPLogExporter)({
+      url: logsUrl,
+      headers
+    });
+    _chunkJB6MA2RVcjs.logger.debug("OTLP log exporter initialized successfully");
+  }
+  /**
+   * Initialize the log processor with masking support
+   */
+  initLogProcessor(config) {
+    if (this.logProcessor) {
+      _chunkJB6MA2RVcjs.logger.debug("Log processor already initialized, skipping re-initialization");
+      return;
+    }
+    if (!this.logExporter) {
+      throw new Error("Log exporter must be initialized before processor");
+    }
+    _chunkJB6MA2RVcjs.logger.debug("Initializing log processor", {
+      disableBatch: config.disableBatch,
+      hasMasking: !!_optionalChain([config, 'access', _33 => _33.masking, 'optionalAccess', _34 => _34.eventMasking])
+    });
+    this.logProcessor = config.disableBatch ? new BrizzSimpleLogRecordProcessor(this.logExporter, config) : new BrizzBatchLogRecordProcessor(this.logExporter, config);
+    _chunkJB6MA2RVcjs.logger.debug("Log processor initialized successfully");
+  }
+  /**
+   * Initialize the logger provider
+   */
+  initLoggerProvider(config) {
+    if (this.loggerProvider) {
+      _chunkJB6MA2RVcjs.logger.debug("Logger provider already initialized, skipping re-initialization");
+      return;
+    }
+    if (!this.logProcessor) {
+      throw new Error("Log processor must be initialized before logger provider");
+    }
+    _chunkJB6MA2RVcjs.logger.debug("Creating resource with service name", {
+      serviceName: config.appName
+    });
+    const resourceAttributes = {
+      ...config.resourceAttributes,
+      "service.name": config.appName,
+      [BRIZZ_SDK_VERSION]: _chunkJB6MA2RVcjs.getSDKVersion.call(void 0, ),
+      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
+    };
+    if (config.environment) {
+      resourceAttributes["deployment.environment"] = config.environment;
+    }
+    if (config.appVersion) {
+      resourceAttributes["service.version"] = config.appVersion;
+    }
+    const resource = _resources.resourceFromAttributes.call(void 0, resourceAttributes);
+    _chunkJB6MA2RVcjs.logger.debug("Creating logger provider with resource");
+    this.loggerProvider = new (0, _sdklogs.LoggerProvider)({
+      resource,
+      processors: [this.logProcessor]
+    });
+    _chunkJB6MA2RVcjs.logger.debug("Logger provider initialization completed");
+  }
+  /**
+   * Initialize the logging module with the provided configuration
+   */
+  setup(config) {
+    _chunkJB6MA2RVcjs.logger.info("Setting up logging module");
+    this.initLogExporter(config);
+    this.initLogProcessor(config);
+    this.initLoggerProvider(config);
+    _LoggingModule.instance = this;
+    _chunkJB6MA2RVcjs.logger.info("Logging module setup completed");
+  }
+  /**
+   * Emit a custom event to the telemetry pipeline
+   */
+  emitEvent(name, attributes, body, severityNumber = _apilogs.SeverityNumber.INFO) {
+    _chunkJB6MA2RVcjs.logger.debug("Attempting to emit event", {
+      name,
+      hasAttributes: !!attributes,
+      attributesCount: attributes ? Object.keys(attributes).length : 0,
+      hasBody: !!body,
+      severityNumber
+    });
+    if (!this.loggerProvider) {
+      _chunkJB6MA2RVcjs.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);
+      _chunkJB6MA2RVcjs.logger.debug("Combined log attributes", { attributes: Object.keys(logAttributes) });
+    }
+    _chunkJB6MA2RVcjs.logger.debug("Getting logger instance for brizz_events");
+    const eventLogger = this.loggerProvider.getLogger("brizz.events");
+    _chunkJB6MA2RVcjs.logger.debug("Emitting log record with eventName", { eventName: name });
+    try {
+      eventLogger.emit({
+        eventName: name,
+        attributes: logAttributes,
+        severityNumber,
+        body
+      });
+      _chunkJB6MA2RVcjs.logger.debug("Event successfully emitted", { eventName: name });
+    } catch (error) {
+      _chunkJB6MA2RVcjs.logger.error(`Failed to emit event '${name}'`, { error, eventName: name });
+      _chunkJB6MA2RVcjs.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() {
+    _chunkJB6MA2RVcjs.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;
+    }
+    _chunkJB6MA2RVcjs.logger.debug("Logging module shutdown completed");
+  }
+}, _class2.__initStatic(), _class2);
+function emitEvent(name, attributes, body, severityNumber = _apilogs.SeverityNumber.INFO) {
+  return LoggingModule.getInstance().emitEvent(name, attributes, body, severityNumber);
+}
+function emitEventWithSessionId(sessionId, name, attributes, body, severityNumber = _apilogs.SeverityNumber.INFO) {
+  return callWithSessionId(sessionId, () => {
+    LoggingModule.getInstance().emitEvent(name, attributes, body, severityNumber);
+  });
+}
+
+// src/internal/trace/session.ts
+function setCurrentSpanCustomProperties(properties) {
+  const current = _api.trace.getActiveSpan();
+  if (!current || !current.isRecording()) {
+    return;
+  }
+  for (const [key, value] of Object.entries(properties)) {
+    try {
+      current.setAttribute(`${_chunkGCORRK6Bcjs.BRIZZ}.${key}`, value);
+    } catch (e) {
+    }
+  }
+}
+function callWithProperties(properties, fn, thisArg, ...args) {
+  const base = _api.context.active();
+  const prev = base.getValue(_chunkGCORRK6Bcjs.PROPERTIES_CONTEXT_KEY);
+  const merged = prev ? { ...prev, ...properties } : properties;
+  const next = base.setValue(_chunkGCORRK6Bcjs.PROPERTIES_CONTEXT_KEY, merged);
+  return _api.context.with(next, fn, thisArg, ...args);
+}
+function withProperties(properties, fn, thisArg) {
+  return function wrapped(...args) {
+    return callWithProperties(
+      properties,
+      fn,
+      thisArg !== void 0 ? thisArg : this,
+      ...args
+    );
+  };
+}
+function muteProperties(options) {
+  const { input = true, output = true } = options;
+  const properties = {};
+  if (input) {
+    properties[_chunkGCORRK6Bcjs.MUTE_INPUT] = "true";
+  }
+  if (output) {
+    properties[_chunkGCORRK6Bcjs.MUTE_OUTPUT] = "true";
+  }
+  return properties;
+}
+function callWithMute(options, fn, thisArg, ...args) {
+  return callWithProperties(muteProperties(options), fn, thisArg, ...args);
+}
+function withMute(options, fn, thisArg) {
+  return withProperties(muteProperties(options), fn, thisArg);
+}
+function withSessionId(sessionId, fn, thisArg, extraProperties) {
+  const properties = { [_chunkGCORRK6Bcjs.SESSION_ID]: sessionId, ...extraProperties };
+  return withProperties(properties, fn, thisArg);
+}
+function callWithSessionId(sessionId, fn, thisArg, ...args) {
+  return callWithProperties({ [_chunkGCORRK6Bcjs.SESSION_ID]: sessionId }, fn, thisArg, ...args);
+}
+var Session = (_class3 = class {
+  
+  __init5() {this.inputs = []}
+  __init6() {this.outputs = []}
+  __init7() {this.inputContexts = []}
+  __init8() {this.outputContexts = []}
+  
+  constructor(sessionId, span) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);
+    this.sessionId = sessionId;
+    this.span = span;
+  }
+  /**
+   * Append a user turn to session input tracking.
+   *
+   * Each call appends one element to `brizz.session.input` (the text) AND one
+   * element to `brizz.session.input.context` (the per-turn context bag). The
+   * two arrays stay index-aligned — the ingestion pipeline zips them together
+   * so the i-th context bag lands on the i-th user_display conversation item's
+   * `span_attributes` map.
+   *
+   * @param text - Text to append (null becomes a null/"hide marker")
+   * @param context - Optional per-turn context bag to attach to this turn
+   */
+  setInput(text, context4) {
+    this.inputs.push(text);
+    this.inputContexts.push(_nullishCoalesce(context4, () => ( {})));
+    this.span.setAttribute(_chunkGCORRK6Bcjs.SESSION_INPUT, JSON.stringify(this.inputs));
+    this.span.setAttribute(_chunkGCORRK6Bcjs.SESSION_INPUT_CONTEXT, JSON.stringify(this.inputContexts));
+  }
+  /**
+   * Append an assistant turn to session output tracking.
+   *
+   * Symmetric to {@link setInput} — appends one text element and one
+   * context-bag element to the index-aligned `brizz.session.output` /
+   * `brizz.session.output.context` arrays.
+   *
+   * @param text - Text to append (null becomes a null/"hide marker")
+   * @param context - Optional per-turn context bag to attach to this turn
+   */
+  setOutput(text, context4) {
+    this.outputs.push(text);
+    this.outputContexts.push(_nullishCoalesce(context4, () => ( {})));
+    this.span.setAttribute(_chunkGCORRK6Bcjs.SESSION_OUTPUT, JSON.stringify(this.outputs));
+    this.span.setAttribute(_chunkGCORRK6Bcjs.SESSION_OUTPUT_CONTEXT, JSON.stringify(this.outputContexts));
+  }
+  /**
+   * Set the session title on the span.
+   *
+   * @param title - The generated title string
+   */
+  setTitle(title) {
+    this.span.setAttribute(_chunkGCORRK6Bcjs.SESSION_TITLE, title);
+  }
+  /**
+   * Update custom properties on the session span.
+   * Properties are prefixed with 'brizz.'.
+   *
+   * @param properties - Key-value properties to set on the session
+   */
+  updateProperties(properties) {
+    for (const [key, value] of Object.entries(properties)) {
+      this.span.setAttribute(`${_chunkGCORRK6Bcjs.BRIZZ}.${key}`, value);
+    }
+  }
+  /**
+   * Attach an external link (URL) to this session.
+   *
+   * The link surfaces on the session's detail panel in Brizz — use it to
+   * correlate a session with an external record such as a Datadog trace,
+   * Sentry issue, or internal dashboard. Re-sending the same URL is idempotent;
+   * distinct URLs add separate links.
+   *
+   * @param url - The link target
+   * @param options - Optional `title` (defaults to the URL host) and `linkType`
+   *   (free-form category, defaults to `'generic'`)
+   */
+  addExternalLink(url, options) {
+    emitExternalLink(this.sessionId, url, _optionalChain([options, 'optionalAccess', _35 => _35.title]), _optionalChain([options, 'optionalAccess', _36 => _36.linkType]));
+  }
+}, _class3);
+var SessionTitle = class {
+  
+  constructor(span) {
+    this.span = span;
+  }
+  /**
+   * Set the generated title on the wrapper span.
+   *
+   * @param title - The generated title string
+   */
+  setTitle(title) {
+    this.span.setAttribute(_chunkGCORRK6Bcjs.SESSION_TITLE, title);
+  }
+};
+function getActiveSession() {
+  return _api.context.active().getValue(_chunkGCORRK6Bcjs.SESSION_OBJECT_CONTEXT_KEY);
+}
+function resolveSessionIdFromContext() {
+  const active = getActiveSession();
+  if (active) {
+    return active.sessionId;
+  }
+  const props = _api.context.active().getValue(_chunkGCORRK6Bcjs.PROPERTIES_CONTEXT_KEY);
+  return _optionalChain([props, 'optionalAccess', _37 => _37[_chunkGCORRK6Bcjs.SESSION_ID]]);
+}
+function emitExternalLink(sessionId, url, title, linkType) {
+  try {
+    emitEventWithSessionId(sessionId, _chunkGCORRK6Bcjs.EXTERNAL_LINK_EVENT_NAME, {
+      [_chunkGCORRK6Bcjs.EXTERNAL_LINK_URL]: url,
+      [_chunkGCORRK6Bcjs.EXTERNAL_LINK_TITLE]: _nullishCoalesce(title, () => ( "")),
+      [_chunkGCORRK6Bcjs.EXTERNAL_LINK_TYPE]: _nullishCoalesce(linkType, () => ( "generic"))
+    });
+  } catch (error) {
+    _chunkJB6MA2RVcjs.logger.warn("addExternalLink: failed to emit external link", error);
+  }
+}
+function addExternalLink(url, options) {
+  const sessionId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _38 => _38.sessionId]), () => ( resolveSessionIdFromContext()));
+  if (!sessionId) {
+    _chunkJB6MA2RVcjs.logger.warn(
+      "addExternalLink called without a resolvable session id; link dropped. Pass options.sessionId or call inside a startSession/callWithSessionId scope."
+    );
+    return;
+  }
+  emitExternalLink(sessionId, url, _optionalChain([options, 'optionalAccess', _39 => _39.title]), _optionalChain([options, 'optionalAccess', _40 => _40.linkType]));
+}
+function startSession(sessionId, callback, extraProperties, options) {
+  const isTitle = _optionalChain([options, 'optionalAccess', _41 => _41.mode]) === "title";
+  const spanName = isTitle ? _chunkGCORRK6Bcjs.SESSION_TITLE_SPAN_NAME : _chunkGCORRK6Bcjs.SESSION_SPAN_NAME;
+  const tracer = _api.trace.getTracer("@brizz/sdk");
+  return tracer.startActiveSpan(spanName, (span) => {
+    span.setAttribute(`${_chunkGCORRK6Bcjs.BRIZZ}.${_chunkGCORRK6Bcjs.SESSION_ID}`, sessionId);
+    if (extraProperties) {
+      for (const [key, value] of Object.entries(extraProperties)) {
+        span.setAttribute(`${_chunkGCORRK6Bcjs.BRIZZ}.${key}`, value);
+      }
+    }
+    const session = new Session(sessionId, span);
+    const contextProperties = { [_chunkGCORRK6Bcjs.SESSION_ID]: sessionId };
+    if (isTitle) {
+      contextProperties[_chunkGCORRK6Bcjs.SESSION_TITLE_GENERATION] = "true";
+    }
+    if (extraProperties) {
+      for (const [key, value] of Object.entries(extraProperties)) {
+        contextProperties[key] = String(value);
+      }
+    }
+    return callWithProperties(contextProperties, () => {
+      const sessionCtx = _api.context.active().setValue(_chunkGCORRK6Bcjs.SESSION_OBJECT_CONTEXT_KEY, session);
+      return _api.context.with(sessionCtx, () => {
+        try {
+          const result = callback(session);
+          if (result && typeof result.then === "function") {
+            return result.then((value) => {
+              span.end();
+              return value;
+            }).catch((error) => {
+              span.recordException(error);
+              span.setStatus({ code: _api.SpanStatusCode.ERROR });
+              span.end();
+              throw error;
+            });
+          }
+          span.end();
+          return result;
+        } catch (error) {
+          span.recordException(error);
+          span.setStatus({ code: _api.SpanStatusCode.ERROR });
+          span.end();
+          throw error;
+        }
+      });
+    });
+  });
+}
+function startSessionTitle(callback, options) {
+  const resolvedSessionId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _42 => _42.sessionId]), () => ( _optionalChain([getActiveSession, 'call', _43 => _43(), 'optionalAccess', _44 => _44.sessionId])));
+  const tracer = _api.trace.getTracer("@brizz/sdk");
+  return tracer.startActiveSpan(_chunkGCORRK6Bcjs.SESSION_TITLE_SPAN_NAME, (span) => {
+    if (resolvedSessionId) {
+      span.setAttribute(`${_chunkGCORRK6Bcjs.BRIZZ}.${_chunkGCORRK6Bcjs.SESSION_ID}`, resolvedSessionId);
+    }
+    const sessionTitle = new SessionTitle(span);
+    const properties = { [_chunkGCORRK6Bcjs.SESSION_TITLE_GENERATION]: "true" };
+    if (resolvedSessionId) {
+      properties[_chunkGCORRK6Bcjs.SESSION_ID] = resolvedSessionId;
+    }
+    return callWithProperties(properties, () => {
+      try {
+        const result = callback(sessionTitle);
+        if (result && typeof result.then === "function") {
+          return result.then((value) => {
+            span.end();
+            return value;
+          }).catch((error) => {
+            span.recordException(error);
+            span.setStatus({ code: _api.SpanStatusCode.ERROR });
+            span.end();
+            throw error;
+          });
+        }
+        span.end();
+        return result;
+      } catch (error) {
+        span.recordException(error);
+        span.setStatus({ code: _api.SpanStatusCode.ERROR });
+        span.end();
+        throw error;
+      }
+    });
+  });
+}
+
+// src/internal/metric/metrics.ts
+var _exportermetricsotlphttp = require('@opentelemetry/exporter-metrics-otlp-http');
+var _sdkmetrics = require('@opentelemetry/sdk-metrics');
+var MetricsModule = (_class4 = class _MetricsModule {constructor() { _class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this); }
+  static __initStatic2() {this.instance = null}
+  static getInstance() {
+    if (!this.instance) {
+      throw new Error("Brizz must be initialized before accessing MetricsModule");
+    }
+    return this.instance;
+  }
+  __init9() {this.metricsExporter = null}
+  __init10() {this.metricsReader = null}
+  /**
+   * Initialize the metrics exporter
+   */
+  initMetricsExporter(config) {
+    if (this.metricsExporter) {
+      _chunkJB6MA2RVcjs.logger.debug("Metrics exporter already initialized, skipping re-initialization");
+      return;
+    }
+    const metricsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/metrics";
+    _chunkJB6MA2RVcjs.logger.debug("Initializing metrics exporter", { url: metricsUrl });
+    this.metricsExporter = new (0, _exportermetricsotlphttp.OTLPMetricExporter)({
+      url: metricsUrl,
+      headers: config.headers
+    });
+    _chunkJB6MA2RVcjs.logger.debug("Metrics exporter initialized successfully");
+  }
+  /**
+   * Initialize the metrics reader
+   */
+  initMetricsReader(config) {
+    if (this.metricsReader) {
+      _chunkJB6MA2RVcjs.logger.debug("Metrics reader already initialized, skipping re-initialization");
+      return;
+    }
+    if (config.customMetricReader) {
+      _chunkJB6MA2RVcjs.logger.debug("Using custom metric reader");
+      this.metricsReader = config.customMetricReader;
+      _chunkJB6MA2RVcjs.logger.debug("Custom metric reader initialized successfully");
+      return;
+    }
+    _chunkJB6MA2RVcjs.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 (0, _sdkmetrics.PeriodicExportingMetricReader)({
+      exporter: this.metricsExporter
+    });
+    _chunkJB6MA2RVcjs.logger.debug("Default metrics reader initialized successfully");
+  }
+  /**
+   * Initialize the metrics module with the provided configuration
+   */
+  setup(config) {
+    _chunkJB6MA2RVcjs.logger.info("Setting up metrics module");
+    this.initMetricsReader(config);
+    _MetricsModule.instance = this;
+    _chunkJB6MA2RVcjs.logger.info("Metrics module setup completed");
+  }
+  /**
+   * 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() {
+    _chunkJB6MA2RVcjs.logger.debug("Shutting down metrics module");
+    this.metricsReader = null;
+    this.metricsExporter = null;
+    if (_MetricsModule.instance === this) {
+      _MetricsModule.instance = null;
+    }
+    _chunkJB6MA2RVcjs.logger.debug("Metrics module shutdown completed");
+  }
+}, _class4.__initStatic2(), _class4);
+function getMetricsExporter() {
+  return MetricsModule.getInstance().getMetricsExporter();
+}
+function getMetricsReader() {
+  return MetricsModule.getInstance().getMetricsReader();
+}
+
+// src/internal/trace/tracing.ts
+var _exportertraceotlpproto = require('@opentelemetry/exporter-trace-otlp-proto');
+
+// src/internal/trace/exporters/span-exporter.ts
+var _core = require('@opentelemetry/core');
+
+var BrizzSpanExporter = class {
+  
+  
+  
+  constructor(delegate, config) {
+    this._delegate = delegate;
+    const resourceAttrs = {
+      ...config.resourceAttributes,
+      "service.name": config.appName,
+      [BRIZZ_SDK_VERSION]: _chunkJB6MA2RVcjs.getSDKVersion.call(void 0, ),
+      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
+    };
+    if (config.environment) {
+      resourceAttrs["deployment.environment"] = config.environment;
+    }
+    if (config.appVersion) {
+      resourceAttrs["service.version"] = config.appVersion;
+    }
+    this._brizzResource = _resources.resourceFromAttributes.call(void 0, resourceAttrs);
+    this._beforeSendSpan = config.beforeSendSpan;
+  }
+  export(spans, resultCallback) {
+    if (spans.length === 0) {
+      resultCallback({ code: _core.ExportResultCode.SUCCESS });
+      return;
+    }
+    const patchedSpans = spans.map((span) => ({
+      ...span,
+      resource: span.resource.merge(this._brizzResource),
+      spanContext: span.spanContext.bind(span)
+    }));
+    const filter = this._beforeSendSpan;
+    if (!filter) {
+      this._delegate.export(patchedSpans, resultCallback);
+      return;
+    }
+    const verdicts = patchedSpans.map((span) => {
+      try {
+        return Promise.resolve(filter(span));
+      } catch (error) {
+        _chunkJB6MA2RVcjs.logger.warn("beforeSendSpan threw; span will be kept", { error });
+        return Promise.resolve(true);
+      }
+    });
+    Promise.all(verdicts).then((keep) => {
+      const filtered = patchedSpans.filter((_, i) => keep[i] !== false);
+      if (filtered.length === 0) {
+        resultCallback({ code: _core.ExportResultCode.SUCCESS });
+        return;
+      }
+      this._delegate.export(filtered, resultCallback);
+      return;
+    }).catch((error) => {
+      _chunkJB6MA2RVcjs.logger.warn("beforeSendSpan rejected; all spans will be kept", { error });
+      this._delegate.export(patchedSpans, resultCallback);
+    });
+  }
+  async shutdown() {
+    return this._delegate.shutdown();
+  }
+  async forceFlush() {
+    return _optionalChain([this, 'access', _45 => _45._delegate, 'access', _46 => _46.forceFlush, 'optionalCall', _47 => _47()]);
+  }
+};
+
+// src/internal/trace/processors/span-processor.ts
+
+
+
+
+var _sdktracebase = require('@opentelemetry/sdk-trace-base');
+function applyContextAttributes(span) {
+  const sessionProperties = _api.context.active().getValue(_chunkGCORRK6Bcjs.PROPERTIES_CONTEXT_KEY);
+  if (sessionProperties) {
+    for (const [key, value] of Object.entries(sessionProperties)) {
+      span.setAttribute(`${_chunkGCORRK6Bcjs.BRIZZ}.${key}`, value);
+    }
+  }
+}
+var DEFAULT_MASKING_RULES = [
+  {
+    mode: "partial",
+    patterns: DEFAULT_PII_PATTERNS
+  }
+];
+var BrizzSimpleSpanProcessor = class extends _sdktracebase.SimpleSpanProcessor {
+  
+  constructor(spanExporter, config) {
+    super(spanExporter);
+    this.config = config;
+  }
+  onStart(span, parentContext) {
+    applyContextAttributes(span);
+    super.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    const maskingConfig = _optionalChain([this, 'access', _48 => _48.config, 'access', _49 => _49.masking, 'optionalAccess', _50 => _50.spanMasking]);
+    if (maskingConfig) {
+      maskReadableSpan(span, maskingConfig);
+    }
+    super.onEnd(span);
+  }
+};
+var BrizzBatchSpanProcessor = class extends _sdktracebase.BatchSpanProcessor {
+  
+  constructor(spanExporter, config) {
+    super(spanExporter);
+    this.config = config;
+  }
+  onStart(span, parentContext) {
+    applyContextAttributes(span);
+    super.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    const maskingConfig = _optionalChain([this, 'access', _51 => _51.config, 'access', _52 => _52.masking, 'optionalAccess', _53 => _53.spanMasking]);
+    if (maskingConfig) {
+      maskReadableSpan(span, maskingConfig);
+    }
+    super.onEnd(span);
+  }
+};
+function maskReadableSpan(span, config) {
+  const attrs = span.attributes;
+  if (!attrs || Object.keys(attrs).length === 0) {
+    return;
+  }
+  let rules = config.rules ? [...config.rules] : [];
+  if (!config.disableDefaultRules) {
+    rules = [...rules, ...DEFAULT_MASKING_RULES];
+  }
+  try {
+    const input = {};
+    for (const [k, v] of Object.entries(attrs)) {
+      input[k] = v;
+    }
+    const masked = maskAttributes(input, rules);
+    const maskedEntries = Object.entries(_nullishCoalesce(masked, () => ( {})));
+    for (const [k, v] of maskedEntries) {
+      if (attrs[k] !== v) {
+        attrs[k] = v;
+      }
+    }
+  } catch (error) {
+    _chunkJB6MA2RVcjs.logger.error("Error masking span", { err: error });
+  }
+}
+
+// src/internal/trace/tracing.ts
+var TracingModule = (_class5 = class _TracingModule {constructor() { _class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this); }
+  static __initStatic3() {this.instance = null}
+  static getInstance() {
+    if (!this.instance) {
+      throw new Error("Brizz must be initialized before accessing TracingModule");
+    }
+    return this.instance;
+  }
+  __init11() {this.spanExporter = null}
+  __init12() {this.spanProcessor = null}
+  /**
+   * Initialize the span exporter
+   */
+  initSpanExporter(config) {
+    if (this.spanExporter) {
+      _chunkJB6MA2RVcjs.logger.debug("Span exporter already initialized, skipping re-initialization");
+      return;
+    }
+    if (config.customSpanExporter) {
+      _chunkJB6MA2RVcjs.logger.debug("Using custom span exporter");
+      this.spanExporter = new BrizzSpanExporter(config.customSpanExporter, config);
+      _chunkJB6MA2RVcjs.logger.debug("Custom span exporter initialized successfully");
+      return;
+    }
+    const tracesUrl = config.baseUrl.replace(/\/$/, "") + "/v1/traces";
+    _chunkJB6MA2RVcjs.logger.debug("Initializing default OTLP span exporter", { url: tracesUrl });
+    const otlpExporter = new (0, _exportertraceotlpproto.OTLPTraceExporter)({
+      url: tracesUrl,
+      headers: config.headers
+    });
+    this.spanExporter = new BrizzSpanExporter(otlpExporter, config);
+    _chunkJB6MA2RVcjs.logger.debug("OTLP span exporter initialized successfully");
+  }
+  /**
+   * Initialize the span processor with masking support
+   */
+  initSpanProcessor(config) {
+    if (this.spanProcessor) {
+      _chunkJB6MA2RVcjs.logger.debug("Span processor already initialized, skipping re-initialization");
+      return;
+    }
+    if (!this.spanExporter) {
+      throw new Error("Span exporter must be initialized before processor");
+    }
+    _chunkJB6MA2RVcjs.logger.debug("Initializing span processor", {
+      disableBatch: config.disableBatch,
+      hasMasking: !!_optionalChain([config, 'access', _54 => _54.masking, 'optionalAccess', _55 => _55.spanMasking])
+    });
+    const spanProcessor = config.disableBatch ? new BrizzSimpleSpanProcessor(this.spanExporter, config) : new BrizzBatchSpanProcessor(this.spanExporter, config);
+    _chunkJB6MA2RVcjs.logger.debug("Span processor initialized successfully");
+    this.spanProcessor = spanProcessor;
+  }
+  /**
+   * Initialize the tracing module with the provided configuration
+   */
+  setup(config) {
+    _chunkJB6MA2RVcjs.logger.info("Setting up tracing module");
+    if (config.disableSpanExporter) {
+      _chunkJB6MA2RVcjs.logger.info(
+        "Span exporter disabled via disableSpanExporter; skipping exporter and processor setup"
+      );
+      this.spanExporter = null;
+      this.spanProcessor = null;
+      _TracingModule.instance = this;
+      return;
+    }
+    this.initSpanExporter(config);
+    this.initSpanProcessor(config);
+    _TracingModule.instance = this;
+    _chunkJB6MA2RVcjs.logger.info("Tracing module setup completed");
+  }
+  /**
+   * 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() {
+    _chunkJB6MA2RVcjs.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;
+    _chunkJB6MA2RVcjs.logger.debug("Tracing module shutdown completed");
+  }
+}, _class5.__initStatic3(), _class5);
+function getSpanExporter() {
+  return TracingModule.getInstance().getSpanExporter();
+}
+function getSpanProcessor() {
+  return TracingModule.getInstance().getSpanProcessor();
+}
+
+// src/internal/sdk.ts
+
+var _instrumentation = require('@opentelemetry/instrumentation');
+
+
+
+
+
+
+
+
+
+var _sdktracenode = require('@opentelemetry/sdk-trace-node');
+
+// src/internal/dsn.ts
+var PLACEHOLDER_SERVICE = "<service-name>";
+var SERVICE_NAME_HEADER = "X-Brizz-Service-Name";
+function parseDSN(dsn) {
+  let parsed;
+  try {
+    parsed = new globalThis.URL(dsn);
+  } catch (e2) {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || !parsed.username || !parsed.host) {
+    return null;
+  }
+  const scheme = parsed.protocol === "https:" ? "https" : "http";
+  let service;
+  try {
+    service = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
+  } catch (e3) {
+    return null;
+  }
+  if (service === "" || service === PLACEHOLDER_SERVICE) {
+    return null;
+  }
+  return {
+    scheme,
+    host: parsed.host,
+    bearer: decodeURIComponent(parsed.username),
+    service,
+    baseUrl: `${scheme}://${parsed.host}`
+  };
+}
+
+// src/internal/config.ts
+function resolveConfig(options) {
+  const envLogLevel = process.env["BRIZZ_LOG_LEVEL"] || _optionalChain([options, 'access', _56 => _56.logLevel, 'optionalAccess', _57 => _57.toString, 'call', _58 => _58()]) || _chunkJB6MA2RVcjs.DEFAULT_LOG_LEVEL.toString();
+  let resolvedLogLevel;
+  if (envLogLevel) {
+    resolvedLogLevel = _chunkJB6MA2RVcjs.parseLogLevel.call(void 0, envLogLevel);
+  } else if (typeof options.logLevel === "string") {
+    resolvedLogLevel = _chunkJB6MA2RVcjs.parseLogLevel.call(void 0, options.logLevel);
+  } else {
+    resolvedLogLevel = options.logLevel || _chunkJB6MA2RVcjs.DEFAULT_LOG_LEVEL;
+  }
+  _chunkJB6MA2RVcjs.setLogLevel.call(void 0, 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";
+  }
+  _chunkJB6MA2RVcjs.logger.debug("Starting configuration resolution", {
+    appName: options.appName,
+    baseUrl: options.baseUrl,
+    hasApiKey: !!options.apiKey,
+    dsnProvided: !!(process.env["BRIZZ_DSN"] || options.dsn),
+    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",
+    appVersion: process.env["BRIZZ_APP_VERSION"] || options.appVersion,
+    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,
+    disableSpanExporter: process.env["BRIZZ_DISABLE_SPAN_EXPORTER"] === "true" || !!options.disableSpanExporter,
+    environment: process.env["BRIZZ_ENVIRONMENT"] || options.environment,
+    logLevel: resolvedLogLevel,
+    masking: resolvedMasking
+  };
+  const dsnInput = process.env["BRIZZ_DSN"] || options.dsn;
+  let parsedDSN = null;
+  if (dsnInput) {
+    const kwargConflicts = [];
+    if (options.apiKey !== void 0) {
+      kwargConflicts.push("apiKey");
+    }
+    if (options.baseUrl !== void 0) {
+      kwargConflicts.push("baseUrl");
+    }
+    if (options.appName !== void 0) {
+      kwargConflicts.push("appName");
+    }
+    if (kwargConflicts.length > 0) {
+      throw new Error(
+        `dsn cannot be combined with kwargs ${kwargConflicts.join(", ")}. The DSN bundles bearer, gateway URL, and service name \u2014 choose one configuration style.`
+      );
+    }
+    const envConflicts = ["BRIZZ_API_KEY", "BRIZZ_BASE_URL", "BRIZZ_APP_NAME"].filter(
+      (name) => process.env[name] !== void 0
+    );
+    if (envConflicts.length > 0) {
+      _chunkJB6MA2RVcjs.logger.warn(
+        `Ignoring ${envConflicts.join(", ")} \u2014 dsn / BRIZZ_DSN takes precedence.`
+      );
+    }
+    resolvedConfig.apiKey = void 0;
+    resolvedConfig.baseUrl = "https://telemetry.brizz.dev";
+    resolvedConfig.appName = "unknown-app";
+    parsedDSN = parseDSN(dsnInput);
+    if (parsedDSN) {
+      resolvedConfig.appName = parsedDSN.service;
+      resolvedConfig.baseUrl = parsedDSN.baseUrl;
+      resolvedConfig.apiKey = parsedDSN.bearer;
+    }
+  } else 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);
+      _chunkJB6MA2RVcjs.logger.debug("Added headers from environment variable", {
+        headers: Object.keys(envHeaders)
+      });
+    } catch (error) {
+      _chunkJB6MA2RVcjs.logger.error("Failed to parse BRIZZ_HEADERS environment variable", { error });
+      throw new Error("Invalid JSON in BRIZZ_HEADERS environment variable", { cause: error });
+    }
+  }
+  if (dsnInput) {
+    const authHeaderKeys = /* @__PURE__ */ new Set(["authorization", SERVICE_NAME_HEADER.toLowerCase()]);
+    resolvedConfig.headers = Object.fromEntries(
+      Object.entries(resolvedConfig.headers).filter(
+        ([key]) => !authHeaderKeys.has(key.toLowerCase())
+      )
+    );
+    if (parsedDSN) {
+      resolvedConfig.headers["Authorization"] = `Bearer ${parsedDSN.bearer}`;
+      resolvedConfig.headers[SERVICE_NAME_HEADER] = parsedDSN.service;
+    }
+  }
+  _chunkJB6MA2RVcjs.logger.debug("Configuration resolved with environment variables", {
+    appName: resolvedConfig.appName,
+    baseUrl: resolvedConfig.baseUrl,
+    hasApiKey: !!resolvedConfig.apiKey,
+    dsnProvided: !!dsnInput,
+    disableBatch: resolvedConfig.disableBatch,
+    envOverrides: {
+      hasEnvApiKey: !!process.env["BRIZZ_API_KEY"],
+      hasEnvBaseUrl: !!process.env["BRIZZ_BASE_URL"],
+      hasEnvDsn: !!process.env["BRIZZ_DSN"],
+      hasEnvBatch: !!process.env["BRIZZ_DISABLE_BATCH"],
+      hasEnvHeaders: !!process.env["BRIZZ_HEADERS"]
+    }
+  });
+  return resolvedConfig;
+}
+
+// src/internal/sdk.ts
+var _Brizz = (_class6 = class __Brizz {constructor() { _class6.prototype.__init13.call(this);_class6.prototype.__init14.call(this);_class6.prototype.__init15.call(this); }
+  static __initStatic4() {this.instance = null}
+  static getInstance() {
+    if (!this.instance) {
+      throw new Error("Brizz must be initialized before accessing TracingModule");
+    }
+    return this.instance;
+  }
+  /** Flag indicating if SDK initialization has completed successfully */
+  __init13() {this._initialized = false}
+  /** OpenTelemetry tracer provider */
+  __init14() {this._tracerProvider = null}
+  /** OpenTelemetry meter provider */
+  __init15() {this._meterProvider = null}
+  /**
+   * 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 register the tracer + meter providers if not disabled.
+   * Only handles manual instrumentations now - auto instrumentations are loaded at import time.
+   * @private
+   */
+  createAndStartProviders(options, resolvedConfig) {
+    if (options.disableNodeSdk) {
+      _chunkJB6MA2RVcjs.logger.info("NodeSDK disabled - only telemetry modules initialized");
+      return;
+    }
+    const registry = InstrumentationRegistry.getInstance();
+    const manualInstrumentations = registry.getManualInstrumentations();
+    const resourceAttributes = {
+      ...resolvedConfig.resourceAttributes,
+      "service.name": resolvedConfig.appName,
+      [BRIZZ_SDK_VERSION]: _chunkJB6MA2RVcjs.getSDKVersion.call(void 0, ),
+      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
+    };
+    if (resolvedConfig.environment) {
+      resourceAttributes["deployment.environment"] = resolvedConfig.environment;
+    }
+    if (resolvedConfig.appVersion) {
+      resourceAttributes["service.version"] = resolvedConfig.appVersion;
+    }
+    const resource = _resources.defaultResource.call(void 0, ).merge(_resources.detectResources.call(void 0, { detectors: [_resources.envDetector, _resources.hostDetector, _resources.processDetector] })).merge(_resources.resourceFromAttributes.call(void 0, resourceAttributes));
+    this._tracerProvider = new (0, _sdktracenode.NodeTracerProvider)({
+      resource,
+      spanProcessors: resolvedConfig.disableSpanExporter ? [] : [new (0, _chunkLTXMCGVQcjs.InterruptPropagator)(), getSpanProcessor()]
+    });
+    this._tracerProvider.register();
+    this._meterProvider = new (0, _sdkmetrics.MeterProvider)({ resource, readers: [getMetricsReader()] });
+    _api.metrics.setGlobalMeterProvider(this._meterProvider);
+    if (manualInstrumentations.length > 0) {
+      _instrumentation.registerInstrumentations.call(void 0, { instrumentations: manualInstrumentations });
+      _chunkJB6MA2RVcjs.logger.info(
+        `Telemetry providers started with ${manualInstrumentations.length} manual instrumentations`
+      );
+    } else {
+      _chunkJB6MA2RVcjs.logger.info(
+        "Telemetry providers 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) {
+    _chunkJB6MA2RVcjs.logger.info("Initializing telemetry modules");
+    _chunkJB6MA2RVcjs.logger.debug("Initializing tracing module");
+    const tracingModule = new TracingModule();
+    tracingModule.setup(config);
+    _chunkJB6MA2RVcjs.logger.debug("Initializing metrics module");
+    const metricsModule = new MetricsModule();
+    metricsModule.setup(config);
+    _chunkJB6MA2RVcjs.logger.debug("Initializing logging module");
+    const loggingModule = new LoggingModule();
+    loggingModule.setup(config);
+    _chunkJB6MA2RVcjs.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 _chunkGCORRK6Bcjs.__require === "function" && typeof __filename === "string" && typeof __dirname === "string" && this === (typeof exports !== "undefined" ? exports : void 0);
+    return inCJS ? "CJS" : "ESM";
+  }
+  /**
+   * Shutdown all telemetry modules.
+   * @private
+   */
+  async shutdownModules() {
+    _chunkJB6MA2RVcjs.logger.info("Shutting down telemetry modules");
+    try {
+      try {
+        const tracingModule = TracingModule.getInstance();
+        await tracingModule.shutdown();
+      } catch (e4) {
+        _chunkJB6MA2RVcjs.logger.debug("Tracing module already shut down or not initialized");
+      }
+      try {
+        const metricsModule = MetricsModule.getInstance();
+        metricsModule.shutdown();
+      } catch (e5) {
+        _chunkJB6MA2RVcjs.logger.debug("Metrics module already shut down or not initialized");
+      }
+      try {
+        const loggingModule = LoggingModule.getInstance();
+        await loggingModule.shutdown();
+      } catch (e6) {
+        _chunkJB6MA2RVcjs.logger.debug("Logging module already shut down or not initialized");
+      }
+      _chunkJB6MA2RVcjs.logger.info("All telemetry modules shut down successfully");
+    } catch (error) {
+      _chunkJB6MA2RVcjs.logger.error("Error shutting down modules", { error });
+      throw error;
+    }
+  }
+  /**
+   * 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) {
+      _chunkJB6MA2RVcjs.logger.warn("Brizz SDK already initialized");
+      return;
+    }
+    _chunkJB6MA2RVcjs.logger.info("Starting Brizz SDK initialization");
+    try {
+      const resolvedConfig = resolveConfig(options);
+      this.initializeModules(resolvedConfig);
+      this.setupInstrumentation(options);
+      this.createAndStartProviders(options, resolvedConfig);
+      this._initialized = true;
+      _chunkJB6MA2RVcjs.logger.info("Brizz SDK initialization completed successfully", {
+        moduleSystem: this.detectModuleSystem()
+      });
+    } catch (error) {
+      _chunkJB6MA2RVcjs.logger.error("Failed to initialize Brizz SDK", { error });
+      throw new Error(`Failed to initialize SDK: ${String(error)}`, { cause: error });
+    }
+  }
+  /**
+   * Gracefully shutdown the Brizz SDK.
+   *
+   * This method stops all telemetry collection, flushes any pending data,
+   * and releases resources. Should be called before app 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) {
+      _chunkJB6MA2RVcjs.logger.warn("Brizz SDK not initialized");
+      return;
+    }
+    try {
+      await this.shutdownModules();
+      await _optionalChain([this, 'access', _59 => _59._tracerProvider, 'optionalAccess', _60 => _60.forceFlush, 'call', _61 => _61()]);
+      await _optionalChain([this, 'access', _62 => _62._tracerProvider, 'optionalAccess', _63 => _63.shutdown, 'call', _64 => _64()]);
+      await _optionalChain([this, 'access', _65 => _65._meterProvider, 'optionalAccess', _66 => _66.forceFlush, 'call', _67 => _67()]);
+      await _optionalChain([this, 'access', _68 => _68._meterProvider, 'optionalAccess', _69 => _69.shutdown, 'call', _70 => _70()]);
+      this._initialized = false;
+      this._tracerProvider = null;
+      this._meterProvider = null;
+      __Brizz.instance = null;
+      _chunkJB6MA2RVcjs.logger.info("Brizz SDK shut down successfully");
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ENOTFOUND")) {
+        _chunkJB6MA2RVcjs.logger.debug(`Network error during shutdown (expected in tests): ${error.message}`);
+      } else {
+        _chunkJB6MA2RVcjs.logger.error(`Failed to shutdown Brizz SDK: ${String(error)}`);
+        throw error;
+      }
+    }
+  }
+}, _class6.__initStatic4(), _class6);
+var Brizz = new _Brizz();
+
+// 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 _chunkGCORRK6Bcjs.__require === "function";
+  const isESM = noNodeJSGlobals && noModuleSystem;
+  const isCJS = hasRequire && typeof module !== "undefined" && typeof exports !== "undefined" && typeof __filename === "string" && typeof __dirname === "string";
+  const supportsLoaderAPI = (_nullishCoalesce(major, () => ( 0))) >= 21 || (_nullishCoalesce(major, () => ( 0))) === 20 && (_nullishCoalesce(minor, () => ( 0))) >= 6 || (_nullishCoalesce(major, () => ( 0))) === 18 && (_nullishCoalesce(minor, () => ( 0))) >= 19;
+  const supportsRegister = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    !!_optionalChain([process, 'access', _71 => _71.features, 'optionalAccess', _72 => _72.typescript]) || !!_optionalChain([globalThis, 'access', _73 => _73.module, 'optionalAccess', _74 => _74.register])
+  );
+  _chunkJB6MA2RVcjs.logger.debug("Runtime detection results:", {
+    nodeVersion: `${_nullishCoalesce(major, () => ( 0))}.${_nullishCoalesce(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 _chunkGCORRK6Bcjs.__require,
+      module: typeof module,
+      exports: typeof exports,
+      "process.features": process.features,
+      "globalThis.module": Reflect.get(globalThis, "module")
+    }
+  });
+  return {
+    isESM,
+    isCJS,
+    nodeVersion: process.versions.node,
+    supportsLoaderAPI,
+    supportsRegister
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.setCurrentSpanCustomProperties = setCurrentSpanCustomProperties; exports.callWithProperties = callWithProperties; exports.withProperties = withProperties; exports.callWithMute = callWithMute; exports.withMute = withMute; exports.withSessionId = withSessionId; exports.callWithSessionId = callWithSessionId; exports.Session = Session; exports.SessionTitle = SessionTitle; exports.getActiveSession = getActiveSession; exports.addExternalLink = addExternalLink; exports.startSession = startSession; exports.startSessionTitle = startSessionTitle; exports.DEFAULT_PII_PATTERNS = DEFAULT_PII_PATTERNS; exports.maskValue = maskValue; exports.maskAttributes = maskAttributes; exports.emitEvent = emitEvent; exports.emitEventWithSessionId = emitEventWithSessionId; exports.getMetricsExporter = getMetricsExporter; exports.getMetricsReader = getMetricsReader; exports.getSpanExporter = getSpanExporter; exports.getSpanProcessor = getSpanProcessor; exports.Brizz = Brizz; exports.detectRuntime = detectRuntime;