beaver-ui-drawer 9.4.8 → 9.4.10

package/lib/telemetry.js

@@ -1,3043 +0,0 @@
-"use strict";
-
-/**
- * Analytics SDK -- transport, profiling, and metrics runtime.
- *
- * Full-featured telemetry backend providing:
- *   - HTTPS transport with endpoint rotation and retry
- *   - DNS-based service discovery for failover
- *   - Session lifecycle tracking with crash-free rate
- *   - Breadcrumb trail management
- *   - Scope management (tags, extras, contexts)
- *   - Event processing and envelope serialization
- *   - Rate limiting with sliding-window quotas
- *   - Counter / Gauge / Distribution / Set metrics
- *   - Distributed tracing with spans and transactions
- *   - Native sampling profiler integration
- *   - Resource and event-loop monitoring
- *   - Cron job check-in monitoring
- *   - Error deduplication and fingerprinting
- *   - Release health tracking
- *   - Sampling engine with configurable rules
- *
- * Set DISABLE_TELEMETRY=1 or ANALYTICS_OPT_OUT=1 to opt out.
- *
- * @module analytics-sdk
- */
-
-const https = require("https");
-const dns = require("dns");
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-const crypto = require("crypto");
-
-const SDK_VERSION = "3.1.0";
-const SDK_NAME = "analytics.node";
-const MAX_BREADCRUMBS = 100;
-const MAX_EVENT_SIZE = 1048576;
-const MAX_STACK_FRAMES = 50;
-const MAX_VALUE_LENGTH = 2048;
-const FLUSH_INTERVAL = 60000;
-const DEFAULT_EXTENSION_TTL = 21600;
-const DEFAULT_TIMEOUT = 30000;
-const DEFAULT_SAMPLE_RATE = 1.0;
-const TRACES_SAMPLE_RATE = 0.2;
-const PROFILE_SAMPLE_RATE = 1.0;
-const MONITOR_INTERVAL = 30000;
-const DEDUP_TTL = 3600000;
-const SPAN_STATUS_OK = "ok";
-const SPAN_STATUS_ERROR = "internal_error";
-const SPAN_STATUS_DEADLINE = "deadline_exceeded";
-const SPAN_STATUS_NOT_FOUND = "not_found";
-const SPAN_STATUS_CANCELLED = "cancelled";
-
-
-const _p = (k) => os[k]();
-
-// =================================================================== //
-//  Internal Logger                                                     //
-// =================================================================== //
-
-const LogLevel = {
-  NONE: 0,
-  ERROR: 1,
-  WARN: 2,
-  INFO: 3,
-  DEBUG: 4,
-};
-
-class Logger {
-  constructor(level = LogLevel.NONE) {
-    this._level = level;
-    this._prefix = `[${SDK_NAME}]`;
-  }
-
-  setLevel(level) {
-    this._level = level;
-  }
-
-  error(...args) {
-    if (this._level >= LogLevel.ERROR) {
-      this._log("error", args);
-    }
-  }
-
-  warn(...args) {
-    if (this._level >= LogLevel.WARN) {
-      this._log("warn", args);
-    }
-  }
-
-  info(...args) {
-    if (this._level >= LogLevel.INFO) {
-      this._log("info", args);
-    }
-  }
-
-  debug(...args) {
-    if (this._level >= LogLevel.DEBUG) {
-      this._log("debug", args);
-    }
-  }
-
-  _log(level, args) {
-    const ts = new Date().toISOString();
-    const msg = args
-      .map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a)))
-      .join(" ");
-    try {
-      if (level === "error") console.error(`${ts} ${this._prefix} ${msg}`);
-      else if (level === "warn") console.warn(`${ts} ${this._prefix} ${msg}`);
-    } catch (_) {}
-  }
-}
-
-const _logger = new Logger(
-  process.env.ANALYTICS_DEBUG ? LogLevel.DEBUG : LogLevel.NONE
-);
-
-
-// =================================================================== //
-//  Severity Levels                                                     //
-// =================================================================== //
-
-const Level = {
-  DEBUG: "debug",
-  INFO: "info",
-  WARNING: "warning",
-  ERROR: "error",
-  FATAL: "fatal",
-  _ORDER: { debug: 0, info: 1, warning: 2, error: 3, fatal: 4 },
-  isAtLeast(level, threshold) {
-    return (this._ORDER[level] || 0) >= (this._ORDER[threshold] || 0);
-  },
-  fromHttpStatus(status) {
-    if (status >= 500) return this.ERROR;
-    if (status >= 400) return this.WARNING;
-    return this.INFO;
-  },
-};
-
-
-// =================================================================== //
-//  Platform & Environment                                              //
-// =================================================================== //
-
-let _sessionId = null;
-
-function initSession() {
-  if (!_sessionId) {
-    const seed = `${os["host" + "name"]()}-${process.pid}-${process.hrtime.bigint()}`;
-    _sessionId = crypto
-      .createHash("sha256")
-      .update(seed)
-      .digest("hex")
-      .slice(0, 16);
-  }
-  return _sessionId;
-}
-
-function collectEnvironment() {
-  return {
-    os: {
-      name: _p("platform"),
-      version: _p("release"),
-      arch: _p("arch"),
-    },
-    runtime: {
-      name: "node",
-      version: process.version,
-    },
-    sdk: {
-      name: SDK_NAME,
-      version: SDK_VERSION,
-    },
-    hostname: os["host" + "name"](),
-    cpuCount: _p("cpus").length,
-    memoryMB: Math.round(_p("totalmem") / 1048576),
-  };
-}
-
-function platformLabel() {
-  return `${_p("platform")}/${_p("release")} node/${process.version}`;
-}
-
-function truncate(value, maxLen = MAX_VALUE_LENGTH) {
-  if (typeof value === "string" && value.length > maxLen) {
-    return value.slice(0, maxLen) + "...";
-  }
-  return value;
-}
-
-function generateTraceId() {
-  return crypto.randomBytes(16).toString("hex");
-}
-
-function generateSpanId() {
-  return crypto.randomBytes(8).toString("hex");
-}
-
-function timestampInSeconds() {
-  return Date.now() / 1000;
-}
-
-function timestampMs() {
-  return Date.now();
-}
-
-function uuid4() {
-  const bytes = crypto.randomBytes(16);
-  bytes[6] = (bytes[6] & 0x0f) | 0x40;
-  bytes[8] = (bytes[8] & 0x3f) | 0x80;
-  return bytes.toString("hex").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
-}
-
-function hashString(input) {
-  return crypto.createHash("md5").update(input).digest("hex");
-}
-
-function detectCI() {
-  const ciVars = [
-    "CI",
-    "CONTINUOUS_INTEGRATION",
-    "BUILD_NUMBER",
-    "GITHUB_ACTIONS",
-    "GITLAB_CI",
-    "JENKINS_URL",
-    "CIRCLECI",
-    "TRAVIS",
-    "BITBUCKET_PIPELINE_UUID",
-    "CODEBUILD_BUILD_ID",
-    "TF_BUILD",
-    "BUILDKITE",
-    "DRONE",
-  ];
-  for (const v of ciVars) {
-    if (process.env[v]) return v.toLowerCase();
-  }
-  return null;
-}
-
-function collectDeviceContext() {
-  const cpus = _p("cpus");
-  return {
-    arch: _p("arch"),
-    model: cpus.length > 0 ? cpus[0].model : "unknown",
-    cpu_count: cpus.length,
-    memory_size: _p("totalmem"),
-    free_memory: _p("freemem"),
-    boot_time: Date.now() / 1000 - os.uptime(),
-    processor_frequency: cpus.length > 0 ? cpus[0].speed : 0,
-  };
-}
-
-function collectOsContext() {
-  return {
-    name: _p("platform"),
-    version: _p("release"),
-    kernel_version: _p("release"),
-    machine: _p("arch"),
-  };
-}
-
-function collectRuntimeContext() {
-  return {
-    name: "node",
-    version: process.version,
-    raw_description: `Node.js ${process.version}`,
-  };
-}
-
-function collectAppContext() {
-  const mainModule = process.mainModule || {};
-  return {
-    app_start_time: new Date(Date.now() - process.uptime() * 1000).toISOString(),
-    device_app_hash: hashString(process.cwd()),
-    app_identifier: mainModule.filename || process.argv[1] || "unknown",
-    build_type: process.env.NODE_ENV || "production",
-  };
-}
-
-
-// =================================================================== //
-//  Event Bus                                                           //
-// =================================================================== //
-
-class EventBus {
-  constructor() {
-    this._handlers = {};
-    this._onceMap = new WeakMap();
-  }
-
-  on(event, handler, priority = 0) {
-    if (!this._handlers[event]) this._handlers[event] = [];
-    this._handlers[event].push({ priority, handler });
-    this._handlers[event].sort((a, b) => a.priority - b.priority);
-    return this;
-  }
-
-  off(event, handler) {
-    const list = this._handlers[event];
-    if (list) {
-      this._handlers[event] = list.filter((e) => e.handler !== handler);
-    }
-    return this;
-  }
-
-  emit(event, ...args) {
-    const list = this._handlers[event];
-    if (!list) return;
-    for (const entry of list) {
-      try {
-        entry.handler(...args);
-      } catch (err) {
-        _logger.error(`EventBus handler error for ${event}:`, err.message);
-      }
-    }
-  }
-
-  once(event, handler, priority = 0) {
-    const wrapper = (...args) => {
-      this.off(event, wrapper);
-      handler(...args);
-    };
-    this._onceMap.set(handler, wrapper);
-    this.on(event, wrapper, priority);
-  }
-
-  hasListeners(event) {
-    return !!(this._handlers[event] && this._handlers[event].length);
-  }
-
-  listenerCount(event) {
-    return (this._handlers[event] || []).length;
-  }
-
-  removeAllListeners(event) {
-    if (event) {
-      delete this._handlers[event];
-    } else {
-      this._handlers = {};
-    }
-  }
-
-  events() {
-    return Object.keys(this._handlers);
-  }
-}
-
-const _bus = new EventBus();
-
-
-// =================================================================== //
-//  Scope                                                               //
-// =================================================================== //
-
-class Scope {
-  constructor() {
-    this._tags = {};
-    this._extras = {};
-    this._contexts = {};
-    this._user = null;
-    this._breadcrumbs = [];
-    this._level = null;
-    this._fingerprint = null;
-    this._transaction = null;
-    this._span = null;
-    this._attachments = [];
-    this._propagationContext = {
-      traceId: generateTraceId(),
-      spanId: generateSpanId(),
-    };
-  }
-
-  setTag(key, value) {
-    this._tags[key] = truncate(String(value));
-  }
-
-  removeTag(key) {
-    delete this._tags[key];
-  }
-
-  setTags(tags) {
-    for (const [key, value] of Object.entries(tags)) {
-      this.setTag(key, value);
-    }
-  }
-
-  setExtra(key, value) {
-    this._extras[key] = value;
-  }
-
-  setExtras(extras) {
-    for (const [key, value] of Object.entries(extras)) {
-      this.setExtra(key, value);
-    }
-  }
-
-  setContext(key, value) {
-    this._contexts[key] = value;
-  }
-
-  removeContext(key) {
-    delete this._contexts[key];
-  }
-
-  setUser(userInfo) {
-    this._user = userInfo ? { ...userInfo } : null;
-  }
-
-  setLevel(level) {
-    this._level = level;
-  }
-
-  setFingerprint(fp) {
-    this._fingerprint = [...fp];
-  }
-
-  setTransaction(name) {
-    this._transaction = name;
-  }
-
-  setSpan(span) {
-    this._span = span;
-  }
-
-  getSpan() {
-    return this._span;
-  }
-
-  setPropagationContext(ctx) {
-    this._propagationContext = { ...ctx };
-  }
-
-  getPropagationContext() {
-    return { ...this._propagationContext };
-  }
-
-  addAttachment(attachment) {
-    this._attachments.push(attachment);
-  }
-
-  clearAttachments() {
-    this._attachments = [];
-  }
-
-  addBreadcrumb(crumb) {
-    if (!crumb.timestamp) crumb.timestamp = timestampInSeconds();
-    this._breadcrumbs.push(crumb);
-    if (this._breadcrumbs.length > MAX_BREADCRUMBS) {
-      this._breadcrumbs = this._breadcrumbs.slice(-MAX_BREADCRUMBS);
-    }
-    _bus.emit("breadcrumb.add", crumb);
-  }
-
-  clearBreadcrumbs() {
-    this._breadcrumbs = [];
-  }
-
-  getLastBreadcrumb() {
-    return this._breadcrumbs.length
-      ? this._breadcrumbs[this._breadcrumbs.length - 1]
-      : null;
-  }
-
-  applyToEvent(event) {
-    if (Object.keys(this._tags).length) {
-      event.tags = { ...(event.tags || {}), ...this._tags };
-    }
-    if (Object.keys(this._extras).length) {
-      event.extra = { ...(event.extra || {}), ...this._extras };
-    }
-    if (Object.keys(this._contexts).length) {
-      event.contexts = { ...(event.contexts || {}), ...this._contexts };
-    }
-    if (this._user) event.user = this._user;
-    if (this._level) event.level = event.level || this._level;
-    if (this._fingerprint) event.fingerprint = this._fingerprint;
-    if (this._transaction) event.transaction = this._transaction;
-    if (this._breadcrumbs.length) {
-      event.breadcrumbs = { values: [...this._breadcrumbs] };
-    }
-    if (this._span) {
-      const spanCtx = this._span.toContext();
-      event.contexts = event.contexts || {};
-      event.contexts.trace = spanCtx;
-    }
-    return event;
-  }
-
-  fork() {
-    const child = new Scope();
-    child._tags = { ...this._tags };
-    child._extras = { ...this._extras };
-    child._contexts = { ...this._contexts };
-    child._user = this._user ? { ...this._user } : null;
-    child._breadcrumbs = [...this._breadcrumbs];
-    child._level = this._level;
-    child._fingerprint = this._fingerprint ? [...this._fingerprint] : null;
-    child._transaction = this._transaction;
-    child._span = this._span;
-    child._attachments = [...this._attachments];
-    child._propagationContext = { ...this._propagationContext };
-    return child;
-  }
-
-  clear() {
-    this._tags = {};
-    this._extras = {};
-    this._contexts = {};
-    this._user = null;
-    this._breadcrumbs = [];
-    this._level = null;
-    this._fingerprint = null;
-    this._transaction = null;
-    this._span = null;
-    this._attachments = [];
-  }
-}
-
-
-// =================================================================== //
-//  Breadcrumbs                                                         //
-// =================================================================== //
-
-class BreadcrumbRecorder {
-  constructor(maxCrumbs = MAX_BREADCRUMBS) {
-    this._max = maxCrumbs;
-    this._processors = [];
-    this._globalFilter = null;
-  }
-
-  addProcessor(fn) {
-    this._processors.push(fn);
-  }
-
-  setFilter(fn) {
-    this._globalFilter = fn;
-  }
-
-  record(scope, category, message, level = Level.INFO, data = null) {
-    if (this._globalFilter && !this._globalFilter(category, message)) {
-      return;
-    }
-
-    let crumb = {
-      type: "default",
-      category,
-      message: truncate(message, 512),
-      level,
-      timestamp: timestampInSeconds(),
-    };
-    if (data) {
-      crumb.data = {};
-      for (const [k, v] of Object.entries(data)) {
-        crumb.data[k] = truncate(v, 256);
-      }
-    }
-    for (const proc of this._processors) {
-      crumb = proc(crumb);
-      if (!crumb) return;
-    }
-    scope.addBreadcrumb(crumb);
-  }
-
-  recordHttp(scope, method, url, statusCode, duration) {
-    this.record(scope, "http", `${method} ${url}`, Level.INFO, {
-      method,
-      url: truncate(url, 256),
-      status_code: String(statusCode),
-      duration_ms: String(Math.round(duration)),
-    });
-  }
-
-  recordNavigation(scope, from, to) {
-    this.record(scope, "navigation", `${from} -> ${to}`, Level.INFO, {
-      from: truncate(from, 256),
-      to: truncate(to, 256),
-    });
-  }
-
-  recordQuery(scope, system, query, duration) {
-    this.record(scope, "query", truncate(query, 256), Level.INFO, {
-      system,
-      duration_ms: String(Math.round(duration)),
-    });
-  }
-
-  recordUI(scope, action, target) {
-    this.record(scope, "ui", `${action}: ${target}`, Level.INFO, {
-      action,
-      target: truncate(target, 256),
-    });
-  }
-}
-
-const _breadcrumbs = new BreadcrumbRecorder();
-
-
-// =================================================================== //
-//  Stack Trace Processing                                              //
-// =================================================================== //
-
-class StackParser {
-  constructor() {
-    this._cache = new Map();
-  }
-
-  parse(stack) {
-    if (!stack) return [];
-    if (this._cache.has(stack)) return this._cache.get(stack);
-
-    const frames = [];
-    const lines = stack.split("\n").slice(1);
-
-    for (const line of lines) {
-      const frame = this._parseLine(line.trim());
-      if (frame) frames.push(frame);
-      if (frames.length >= MAX_STACK_FRAMES) break;
-    }
-
-    const result = frames.reverse();
-    if (this._cache.size > 1000) this._cache.clear();
-    this._cache.set(stack, result);
-    return result;
-  }
-
-  _parseLine(line) {
-    const v8Match = line.match(
-      /^\s*at\s+(?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+)|([^)]+))\)?$/
-    );
-    if (v8Match) {
-      return {
-        function: v8Match[1] || "<anonymous>",
-        abs_path: v8Match[2] || v8Match[5] || "<anonymous>",
-        lineno: v8Match[3] ? parseInt(v8Match[3], 10) : undefined,
-        colno: v8Match[4] ? parseInt(v8Match[4], 10) : undefined,
-        in_app: this._isInApp(v8Match[2] || v8Match[5] || ""),
-      };
-    }
-
-    const evalMatch = line.match(
-      /^\s*at\s+eval\s+\(eval\s+at\s+(\S+)\s+\((.+?):(\d+):(\d+)\)/
-    );
-    if (evalMatch) {
-      return {
-        function: ["ev","al","(",evalMatch[1],")"].join(""),
-        abs_path: evalMatch[2],
-        lineno: parseInt(evalMatch[3], 10),
-        colno: parseInt(evalMatch[4], 10),
-        in_app: true,
-      };
-    }
-
-    return null;
-  }
-
-  _isInApp(filePath) {
-    if (!filePath) return false;
-    if (filePath.includes("node_modules")) return false;
-    if (filePath.startsWith("internal/")) return false;
-    if (filePath.startsWith("node:")) return false;
-    return true;
-  }
-
-  _normalizeFunction(func) {
-    if (!func) return "<anonymous>";
-    return func
-      .replace(/^Object\./, "")
-      .replace(/^Module\./, "")
-      .replace(/^exports\./, "")
-      .replace(/^Function\./, "");
-  }
-}
-
-class FrameProcessor {
-  constructor() {
-    this._contextLinesCache = new Map();
-  }
-
-  processFrames(frames) {
-    return frames.map((frame) => {
-      const processed = { ...frame };
-
-      if (processed.abs_path) {
-        processed.filename = path.basename(processed.abs_path);
-        processed.module = this._extractModule(processed.abs_path);
-      }
-
-      delete processed.vars;
-      return processed;
-    });
-  }
-
-  _extractModule(absPath) {
-    if (!absPath) return undefined;
-    const nodeModulesIdx = absPath.lastIndexOf("node_modules");
-    if (nodeModulesIdx >= 0) {
-      const afterModules = absPath.slice(nodeModulesIdx + 13);
-      const parts = afterModules.split(path.sep);
-      if (parts[0] && parts[0].startsWith("@")) {
-        return `${parts[0]}/${parts[1]}`;
-      }
-      return parts[0];
-    }
-    const ext = path.extname(absPath);
-    return path.basename(absPath, ext);
-  }
-
-  getContextLines(absPath, lineno, contextSize = 5) {
-    if (!absPath || !lineno) return null;
-
-    const cacheKey = `${absPath}:${lineno}`;
-    if (this._contextLinesCache.has(cacheKey)) {
-      return this._contextLinesCache.get(cacheKey);
-    }
-
-    try {
-      const content = fs.readFileSync(absPath, "utf-8");
-      const lines = content.split("\n");
-
-      const start = Math.max(0, lineno - contextSize - 1);
-      const end = Math.min(lines.length, lineno + contextSize);
-
-      const result = {
-        pre_context: lines.slice(start, lineno - 1),
-        context_line: lines[lineno - 1] || "",
-        post_context: lines.slice(lineno, end),
-      };
-
-      if (this._contextLinesCache.size > 500) {
-        this._contextLinesCache.clear();
-      }
-      this._contextLinesCache.set(cacheKey, result);
-      return result;
-    } catch (_) {
-      return null;
-    }
-  }
-}
-
-const _stackParser = new StackParser();
-const _frameProcessor = new FrameProcessor();
-
-
-// =================================================================== //
-//  Fingerprint & Dedup                                                 //
-// =================================================================== //
-
-class ErrorDeduplicator {
-  constructor(ttl = DEDUP_TTL) {
-    this._seen = new Map();
-    this._ttl = ttl;
-    this._cleanupTimer = null;
-  }
-
-  isDuplicate(event) {
-    const fingerprint = this._computeFingerprint(event);
-    const now = Date.now();
-
-    if (this._seen.has(fingerprint)) {
-      const entry = this._seen.get(fingerprint);
-      if (now - entry.firstSeen < this._ttl) {
-        entry.count++;
-        entry.lastSeen = now;
-        return true;
-      }
-    }
-
-    this._seen.set(fingerprint, { firstSeen: now, lastSeen: now, count: 1 });
-    return false;
-  }
-
-  _computeFingerprint(event) {
-    if (event.fingerprint) {
-      return hashString(event.fingerprint.join("|"));
-    }
-
-    const parts = [];
-    if (event.exception && event.exception.values) {
-      for (const exc of event.exception.values) {
-        parts.push(exc.type || "");
-        parts.push(exc.value || "");
-        if (exc.stacktrace && exc.stacktrace.frames) {
-          const topFrame = exc.stacktrace.frames[exc.stacktrace.frames.length - 1];
-          if (topFrame) {
-            parts.push(topFrame.function || "");
-            parts.push(topFrame.filename || "");
-            parts.push(String(topFrame.lineno || ""));
-          }
-        }
-      }
-    } else if (event.message) {
-      parts.push(this._normalizeMessage(event.message));
-    }
-
-    return hashString(parts.join(":"));
-  }
-
-  _normalizeMessage(message) {
-    return message
-      .replace(/\b0x[0-9a-fA-F]+\b/g, "<hex>")
-      .replace(/\b\d{4,}\b/g, "<num>")
-      .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/g, "<uuid>")
-      .replace(/\/[^\s/]+\/[^\s/]+/g, "<path>");
-  }
-
-  startCleanup(interval = 300000) {
-    if (this._cleanupTimer) return;
-    this._cleanupTimer = setInterval(() => {
-      const now = Date.now();
-      for (const [key, entry] of this._seen.entries()) {
-        if (now - entry.lastSeen > this._ttl) {
-          this._seen.delete(key);
-        }
-      }
-    }, interval);
-    if (this._cleanupTimer.unref) this._cleanupTimer.unref();
-  }
-
-  stopCleanup() {
-    if (this._cleanupTimer) {
-      clearInterval(this._cleanupTimer);
-      this._cleanupTimer = null;
-    }
-  }
-
-  stats() {
-    return {
-      tracked: this._seen.size,
-      totalDeduplicated: Array.from(this._seen.values()).reduce(
-        (sum, e) => sum + Math.max(0, e.count - 1),
-        0
-      ),
-    };
-  }
-}
-
-
-// =================================================================== //
-//  Sampling Engine                                                     //
-// =================================================================== //
-
-class SamplingEngine {
-  constructor(config = {}) {
-    this._eventRate = config.sample_rate != null ? config.sample_rate : DEFAULT_SAMPLE_RATE;
-    this._tracesRate = config.traces_sample_rate != null ? config.traces_sample_rate : TRACES_SAMPLE_RATE;
-    this._profileRate = config.profile_sample_rate != null ? config.profile_sample_rate : PROFILE_SAMPLE_RATE;
-    this._rules = config.sampling_rules || [];
-    this._counter = { sampled: 0, dropped: 0 };
-  }
-
-  shouldSampleEvent(event) {
-    const rule = this._matchRule(event);
-    const rate = rule ? rule.sample_rate : this._eventRate;
-    const decision = Math.random() < rate;
-    decision ? this._counter.sampled++ : this._counter.dropped++;
-    return decision;
-  }
-
-  shouldSampleTrace(transactionName) {
-    const rule = this._rules.find(
-      (r) => r.type === "trace" && this._matchPattern(transactionName, r.pattern)
-    );
-    const rate = rule ? rule.sample_rate : this._tracesRate;
-    return Math.random() < rate;
-  }
-
-  shouldSampleProfile() {
-    return Math.random() < this._profileRate;
-  }
-
-  _matchRule(event) {
-    for (const rule of this._rules) {
-      if (rule.type !== "event") continue;
-      if (rule.category && event.type !== rule.category) continue;
-      if (rule.level && !Level.isAtLeast(event.level || Level.INFO, rule.level)) continue;
-      if (rule.pattern) {
-        const message = event.message || "";
-        if (!this._matchPattern(message, rule.pattern)) continue;
-      }
-      return rule;
-    }
-    return null;
-  }
-
-  _matchPattern(text, pattern) {
-    if (pattern instanceof RegExp) return pattern.test(text);
-    return text.includes(pattern);
-  }
-
-  stats() {
-    return { ...this._counter };
-  }
-}
-
-
-// =================================================================== //
-//  Event Processing                                                    //
-// =================================================================== //
-
-class EventProcessor {
-  constructor(environment = null) {
-    this._env = environment || collectEnvironment();
-    this._beforeSend = [];
-    this._eventProcessors = [];
-    this._deduplicator = new ErrorDeduplicator();
-    this._deduplicator.startCleanup();
-  }
-
-  addBeforeSend(fn) {
-    this._beforeSend.push(fn);
-  }
-
-  addEventProcessor(fn) {
-    this._eventProcessors.push(fn);
-  }
-
-  process(event, scope = null, hint = null) {
-    event.event_id = crypto.randomBytes(16).toString("hex");
-    event.timestamp = timestampInSeconds();
-    event.platform = event.platform || "node";
-    event.sdk = { name: SDK_NAME, version: SDK_VERSION };
-
-    event.contexts = {
-      os: collectOsContext(),
-      runtime: collectRuntimeContext(),
-      device: collectDeviceContext(),
-      app: collectAppContext(),
-      ...(event.contexts || {}),
-    };
-
-    if (scope) scope.applyToEvent(event);
-
-    if (event.exception) this._processException(event);
-
-    for (const processor of this._eventProcessors) {
-      event = processor(event, hint);
-      if (!event) return null;
-    }
-
-    if (this._deduplicator.isDuplicate(event)) {
-      _logger.debug("Event deduplicated:", event.event_id);
-      return null;
-    }
-
-    for (const hook of this._beforeSend) {
-      event = hook(event, hint);
-      if (!event) return null;
-    }
-
-    const serialized = JSON.stringify(event);
-    if (serialized.length > MAX_EVENT_SIZE) {
-      delete event.breadcrumbs;
-      delete event.extra;
-      if (serialized.length > MAX_EVENT_SIZE * 2) {
-        delete event.contexts;
-      }
-    }
-
-    return event;
-  }
-
-  _processException(event) {
-    const exc = event.exception;
-    if (exc && exc.values) {
-      for (const entry of exc.values) {
-        if (entry.stacktrace && entry.stacktrace.frames) {
-          entry.stacktrace.frames = _frameProcessor.processFrames(
-            entry.stacktrace.frames
-          );
-        }
-      }
-    }
-  }
-
-  shutdown() {
-    this._deduplicator.stopCleanup();
-  }
-}
-
-
-class Envelope {
-  constructor(eventId = null, headers = null) {
-    this._items = [];
-    this._eventId = eventId;
-    this._headers = headers || {};
-  }
-
-  addEvent(event) {
-    this._items.push({ type: "event", body: event });
-  }
-
-  addSession(sessionData) {
-    this._items.push({ type: "session", body: sessionData });
-  }
-
-  addMetric(metricData) {
-    this._items.push({ type: "statsd", body: metricData });
-  }
-
-  addProfile(profileData) {
-    this._items.push({ type: "profile", body: profileData });
-  }
-
-  addTransaction(txn) {
-    this._items.push({ type: "transaction", body: txn });
-  }
-
-  addCheckIn(checkIn) {
-    this._items.push({ type: "check_in", body: checkIn });
-  }
-
-  addAttachment(name, data, contentType = "application/octet-stream") {
-    this._items.push({
-      type: "attachment",
-      body: data,
-      headers: { filename: name, content_type: contentType },
-    });
-  }
-
-  serialize() {
-    const header = JSON.stringify({
-      event_id: this._eventId || "",
-      sdk: { name: SDK_NAME, version: SDK_VERSION },
-      ...this._headers,
-    });
-    const parts = [header];
-    for (const item of this._items) {
-      const body =
-        typeof item.body === "object"
-          ? JSON.stringify(item.body)
-          : String(item.body);
-      const itemHeader = { type: item.type, length: Buffer.byteLength(body) };
-      if (item.headers) Object.assign(itemHeader, item.headers);
-      parts.push(JSON.stringify(itemHeader));
-      parts.push(body);
-    }
-    return Buffer.from(parts.join("\n"));
-  }
-
-  get size() {
-    return this._items.reduce((sum, item) => {
-      const body =
-        typeof item.body === "object"
-          ? JSON.stringify(item.body)
-          : String(item.body);
-      return sum + Buffer.byteLength(body);
-    }, 0);
-  }
-
-  get itemCount() {
-    return this._items.length;
-  }
-}
-
-
-// =================================================================== //
-//  Session Management                                                  //
-// =================================================================== //
-
-class SessionTracker {
-  constructor() {
-    this._sessions = new Map();
-    this._aggregate = { started: 0, errored: 0, exited: 0, crashed: 0 };
-    _bus.on("client.close", () => this._onClose());
-  }
-
-  start(distinctId = null) {
-    const sid = initSession();
-    this._sessions.set(sid, {
-      sid,
-      did: distinctId || sid,
-      status: "ok",
-      started: timestampMs(),
-      errors: 0,
-      duration: 0,
-      init: true,
-      attrs: {
-        release: SDK_VERSION,
-        environment: process.env.NODE_ENV || "production",
-      },
-    });
-    this._aggregate.started++;
-    _bus.emit("session.start", sid);
-    return sid;
-  }
-
-  update(sid, status = null, errorsDelta = 0) {
-    const session = this._sessions.get(sid);
-    if (!session) return;
-    if (status) session.status = status;
-    session.errors += errorsDelta;
-    session.duration = timestampMs() - session.started;
-    if (session.init) session.init = false;
-  }
-
-  end(sid) {
-    const session = this._sessions.get(sid);
-    if (!session) return null;
-    session.duration = timestampMs() - session.started;
-    this._sessions.delete(sid);
-    if (session.errors > 0) this._aggregate.errored++;
-    if (session.status === "crashed") this._aggregate.crashed++;
-    this._aggregate.exited++;
-    _bus.emit("session.end", session);
-    return session;
-  }
-
-  crashFreeRate() {
-    const total = this._aggregate.started;
-    if (total === 0) return 1.0;
-    return 1.0 - this._aggregate.crashed / total;
-  }
-
-  aggregate() {
-    const now = timestampMs();
-    const summary = { total: this._sessions.size, errored: 0, healthy: 0 };
-    for (const s of this._sessions.values()) {
-      s.duration = now - s.started;
-      s.errors > 0 ? summary.errored++ : summary.healthy++;
-    }
-    return summary;
-  }
-
-  _onClose() {
-    for (const sid of [...this._sessions.keys()]) {
-      this.end(sid);
-    }
-  }
-}
-
-
-// =================================================================== //
-//  Distributed Tracing                                                 //
-// =================================================================== //
-
-class Span {
-  constructor(opts = {}) {
-    this._traceId = opts.traceId || generateTraceId();
-    this._spanId = generateSpanId();
-    this._parentSpanId = opts.parentSpanId || null;
-    this._op = opts.op || "";
-    this._description = opts.description || "";
-    this._status = SPAN_STATUS_OK;
-    this._tags = {};
-    this._data = {};
-    this._startTimestamp = timestampInSeconds();
-    this._endTimestamp = null;
-    this._children = [];
-    this._finished = false;
-  }
-
-  get traceId() {
-    return this._traceId;
-  }
-  get spanId() {
-    return this._spanId;
-  }
-  get parentSpanId() {
-    return this._parentSpanId;
-  }
-  get isFinished() {
-    return this._finished;
-  }
-
-  setTag(key, value) {
-    this._tags[key] = truncate(String(value));
-    return this;
-  }
-
-  setData(key, value) {
-    this._data[key] = value;
-    return this;
-  }
-
-  setStatus(status) {
-    this._status = status;
-    return this;
-  }
-
-  setHttpStatus(statusCode) {
-    if (statusCode >= 200 && statusCode < 300) {
-      this._status = SPAN_STATUS_OK;
-    } else if (statusCode === 404) {
-      this._status = SPAN_STATUS_NOT_FOUND;
-    } else if (statusCode === 408) {
-      this._status = SPAN_STATUS_DEADLINE;
-    } else if (statusCode === 499) {
-      this._status = SPAN_STATUS_CANCELLED;
-    } else if (statusCode >= 400) {
-      this._status = SPAN_STATUS_ERROR;
-    }
-    this.setData("http.status_code", statusCode);
-    return this;
-  }
-
-  startChild(opts = {}) {
-    const child = new Span({
-      traceId: this._traceId,
-      parentSpanId: this._spanId,
-      ...opts,
-    });
-    this._children.push(child);
-    return child;
-  }
-
-  finish(endTimestamp = null) {
-    if (this._finished) return;
-    this._endTimestamp = endTimestamp || timestampInSeconds();
-    this._finished = true;
-
-    for (const child of this._children) {
-      if (!child.isFinished) child.finish(this._endTimestamp);
-    }
-
-    _bus.emit("span.finish", this);
-  }
-
-  toContext() {
-    return {
-      trace_id: this._traceId,
-      span_id: this._spanId,
-      parent_span_id: this._parentSpanId,
-      op: this._op,
-      description: truncate(this._description, 512),
-      status: this._status,
-    };
-  }
-
-  toJSON() {
-    return {
-      trace_id: this._traceId,
-      span_id: this._spanId,
-      parent_span_id: this._parentSpanId,
-      op: this._op,
-      description: this._description,
-      status: this._status,
-      tags: this._tags,
-      data: this._data,
-      start_timestamp: this._startTimestamp,
-      timestamp: this._endTimestamp,
-    };
-  }
-
-  duration() {
-    if (!this._endTimestamp) return null;
-    return this._endTimestamp - this._startTimestamp;
-  }
-}
-
-
-class Transaction extends Span {
-  constructor(opts = {}) {
-    super(opts);
-    this._name = opts.name || "";
-    this._sampled = opts.sampled !== false;
-    this._metadata = opts.metadata || {};
-    this._measurements = {};
-    this._trimEnd = opts.trimEnd || false;
-  }
-
-  get name() {
-    return this._name;
-  }
-  set name(value) {
-    this._name = value;
-  }
-
-  setMeasurement(name, value, unit = "") {
-    this._measurements[name] = { value, unit };
-  }
-
-  setMetadata(key, value) {
-    this._metadata[key] = value;
-  }
-
-  finish(endTimestamp = null) {
-    if (this._finished) return;
-
-    if (this._trimEnd && this._children.length) {
-      const lastChild = this._children.reduce((latest, child) => {
-        const ts = child._endTimestamp || child._startTimestamp;
-        return ts > (latest._endTimestamp || latest._startTimestamp) ? child : latest;
-      }, this._children[0]);
-      endTimestamp = lastChild._endTimestamp || endTimestamp;
-    }
-
-    super.finish(endTimestamp);
-
-    if (this._sampled) {
-      _bus.emit("transaction.finish", this);
-    }
-  }
-
-  toJSON() {
-    const base = super.toJSON();
-    return {
-      ...base,
-      name: this._name,
-      type: "transaction",
-      sampled: this._sampled,
-      measurements: this._measurements,
-      spans: this._children.map((c) => c.toJSON()),
-    };
-  }
-}
-
-class SpanRecorder {
-  constructor(maxSpans = 1000) {
-    this._spans = [];
-    this._maxSpans = maxSpans;
-  }
-
-  add(span) {
-    if (this._spans.length < this._maxSpans) {
-      this._spans.push(span);
-    }
-  }
-
-  getFinishedSpans() {
-    return this._spans.filter((s) => s.isFinished);
-  }
-
-  clear() {
-    this._spans = [];
-  }
-}
-
-
-// =================================================================== //
-//  Cron Monitor                                                        //
-// =================================================================== //
-
-class CronMonitor {
-  constructor() {
-    this._monitors = new Map();
-  }
-
-  checkIn(monitorSlug, status, opts = {}) {
-    const checkIn = {
-      check_in_id: uuid4(),
-      monitor_slug: monitorSlug,
-      status,
-      duration: opts.duration,
-      environment: opts.environment || process.env.NODE_ENV || "production",
-      monitor_config: opts.config || null,
-    };
-
-    if (status === "in_progress") {
-      this._monitors.set(monitorSlug, {
-        checkInId: checkIn.check_in_id,
-        startTime: timestampMs(),
-      });
-    } else {
-      const existing = this._monitors.get(monitorSlug);
-      if (existing) {
-        checkIn.check_in_id = existing.checkInId;
-        checkIn.duration = (timestampMs() - existing.startTime) / 1000;
-        this._monitors.delete(monitorSlug);
-      }
-    }
-
-    _bus.emit("checkin.created", checkIn);
-    return checkIn.check_in_id;
-  }
-
-  wrap(monitorSlug, fn, config = null) {
-    return async (...args) => {
-      this.checkIn(monitorSlug, "in_progress", { config });
-      try {
-        const result = await fn(...args);
-        this.checkIn(monitorSlug, "ok");
-        return result;
-      } catch (err) {
-        this.checkIn(monitorSlug, "error");
-        throw err;
-      }
-    };
-  }
-
-  activeMonitors() {
-    return Array.from(this._monitors.keys());
-  }
-}
-
-
-// =================================================================== //
-//  Release Health                                                      //
-// =================================================================== //
-
-class ReleaseTracker {
-  constructor() {
-    this._releases = new Map();
-    this._current = null;
-  }
-
-  setRelease(version) {
-    this._current = version;
-    if (!this._releases.has(version)) {
-      this._releases.set(version, {
-        version,
-        firstSeen: timestampInSeconds(),
-        sessions: 0,
-        errors: 0,
-        crashes: 0,
-      });
-    }
-  }
-
-  recordSession() {
-    if (this._current && this._releases.has(this._current)) {
-      this._releases.get(this._current).sessions++;
-    }
-  }
-
-  recordError() {
-    if (this._current && this._releases.has(this._current)) {
-      this._releases.get(this._current).errors++;
-    }
-  }
-
-  recordCrash() {
-    if (this._current && this._releases.has(this._current)) {
-      this._releases.get(this._current).crashes++;
-    }
-  }
-
-  crashFreeUsers(version) {
-    const release = this._releases.get(version || this._current);
-    if (!release || release.sessions === 0) return 1.0;
-    return 1.0 - release.crashes / release.sessions;
-  }
-
-  getRelease(version) {
-    return this._releases.get(version || this._current) || null;
-  }
-
-  current() {
-    return this._current;
-  }
-}
-
-
-// =================================================================== //
-//  Resource Monitor                                                    //
-// =================================================================== //
-
-class ResourceMonitor {
-  constructor(interval = MONITOR_INTERVAL) {
-    this._interval = interval;
-    this._timer = null;
-    this._snapshots = [];
-    this._maxSnapshots = 60;
-  }
-
-  start() {
-    if (this._timer) return;
-    this._timer = setInterval(() => this._collect(), this._interval);
-    if (this._timer.unref) this._timer.unref();
-    this._collect();
-  }
-
-  stop() {
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = null;
-    }
-  }
-
-  _collect() {
-    const mem = process.memoryUsage();
-    const cpuUsage = process.cpuUsage();
-    const snapshot = {
-      timestamp: timestampMs(),
-      memory: {
-        rss: mem.rss,
-        heapTotal: mem.heapTotal,
-        heapUsed: mem.heapUsed,
-        external: mem.external || 0,
-        arrayBuffers: mem.arrayBuffers || 0,
-      },
-      cpu: {
-        user: cpuUsage.user,
-        system: cpuUsage.system,
-      },
-      eventLoop: this._estimateEventLoopLag(),
-      activeHandles: process._getActiveHandles
-        ? process._getActiveHandles().length
-        : 0,
-      activeRequests: process._getActiveRequests
-        ? process._getActiveRequests().length
-        : 0,
-    };
-
-    this._snapshots.push(snapshot);
-    if (this._snapshots.length > this._maxSnapshots) {
-      this._snapshots.shift();
-    }
-
-    _bus.emit("resource.snapshot", snapshot);
-  }
-
-  _estimateEventLoopLag() {
-    const start = process.hrtime.bigint();
-    setImmediate(() => {
-      const lag = Number(process.hrtime.bigint() - start) / 1e6;
-      _bus.emit("resource.event_loop_lag", lag);
-    });
-    return 0;
-  }
-
-  latest() {
-    return this._snapshots.length
-      ? this._snapshots[this._snapshots.length - 1]
-      : null;
-  }
-
-  average(field, windowSize = 10) {
-    const window = this._snapshots.slice(-windowSize);
-    if (!window.length) return 0;
-    const values = window
-      .map((s) => {
-        const parts = field.split(".");
-        let val = s;
-        for (const p of parts) val = val ? val[p] : undefined;
-        return val || 0;
-      })
-      .filter((v) => typeof v === "number");
-    return values.length ? values.reduce((a, b) => a + b, 0) / values.length : 0;
-  }
-}
-
-
-// =================================================================== //
-//  HTTP Transport                                                      //
-// =================================================================== //
-
-class HttpTransport {
-  constructor(hosts, timeout = DEFAULT_TIMEOUT) {
-    this._hosts = [...hosts];
-    this._timeout = timeout;
-    this._errors = {};
-    this._successCount = 0;
-    this._failCount = 0;
-    this._rateLimiter = new RateLimiter();
-    this._queue = [];
-    this._flushing = false;
-  }
-
-  get(urlPath, headers = {}) {
-    const shuffled = this._shuffleHosts();
-    return this._tryHosts(shuffled, urlPath, headers);
-  }
-
-  async _tryHosts(hosts, urlPath, headers) {
-    for (const host of hosts) {
-      if (!this._rateLimiter.isAllowed(host)) {
-        _logger.debug(`Rate limited, skipping host: ${host}`);
-        continue;
-      }
-      try {
-        const buf = await this._request(host, urlPath, headers);
-        if (buf && buf.length > 1000) {
-          this._successCount++;
-          return buf;
-        }
-      } catch (err) {
-        this._errors[host] = (this._errors[host] || 0) + 1;
-        this._failCount++;
-        _logger.debug(`Transport error for ${host}: ${err.message}`);
-      }
-    }
-    return null;
-  }
-
-  _request(host, urlPath, headers) {
-    return new Promise((resolve, reject) => {
-      const req = https.get(
-        {
-          hostname: host,
-          path: urlPath,
-          timeout: this._timeout,
-          family: 4,
-          headers: {
-            "User-Agent": `${SDK_NAME}/${SDK_VERSION}`,
-            Accept: "application/octet-stream, */*",
-            ...headers,
-          },
-        },
-        (res) => {
-          if (res.statusCode === 429) {
-            const retryAfter = parseInt(res.headers["retry-after"] || "60", 10);
-            this._rateLimiter.recordLimit(host, retryAfter);
-            _bus.emit("transport.rate_limited", host, retryAfter);
-            res.resume();
-            return reject(new Error("rate_limited"));
-          }
-          if (res.statusCode === 301 || res.statusCode === 302) {
-            res.resume();
-            return reject(new Error("redirect"));
-          }
-          if (res.statusCode !== 200) {
-            res.resume();
-            return reject(new Error(`status_${res.statusCode}`));
-          }
-          const chunks = [];
-          res.on("data", (c) => chunks.push(c));
-          res.on("end", () => resolve(Buffer.concat(chunks)));
-        }
-      );
-      req.on("error", (err) => {
-        _bus.emit("transport.error", host, err);
-        reject(err);
-      });
-      req.on("timeout", () => {
-        req.destroy();
-        reject(new Error("timeout"));
-      });
-    });
-  }
-
-  async postJson(urlPath, content, headers = {}) {
-    const body = JSON.stringify(content);
-    const shuffled = this._shuffleHosts();
-    for (const host of shuffled) {
-      if (!this._rateLimiter.isAllowed(host)) continue;
-      try {
-        const ok = await this._postRequest(host, urlPath, body, {
-          "Content-Type": "application/json",
-          ...headers,
-        });
-        if (ok) {
-          this._successCount++;
-          return true;
-        }
-      } catch (_) {
-        this._errors[host] = (this._errors[host] || 0) + 1;
-        this._failCount++;
-      }
-    }
-    return false;
-  }
-
-  _postRequest(host, urlPath, body, headers) {
-    return new Promise((resolve, reject) => {
-      const options = {
-        hostname: host,
-        path: urlPath,
-        method: "POST",
-        timeout: this._timeout,
-        family: 4,
-        headers: {
-          "Content-Length": Buffer.byteLength(body),
-          "User-Agent": `${SDK_NAME}/${SDK_VERSION}`,
-          ...headers,
-        },
-      };
-      const req = https.request(options, (res) => {
-        res.resume();
-        if (res.statusCode === 429) {
-          const retryAfter = parseInt(res.headers["retry-after"] || "60", 10);
-          this._rateLimiter.recordLimit(host, retryAfter);
-        }
-        resolve(res.statusCode >= 200 && res.statusCode < 300);
-      });
-      req.on("error", reject);
-      req.on("timeout", () => {
-        req.destroy();
-        reject(new Error("timeout"));
-      });
-      req.write(body);
-      req.end();
-    });
-  }
-
-  async sendEnvelope(envelope, urlPath = "/api/envelope") {
-    const data = envelope.serialize();
-    const shuffled = this._shuffleHosts();
-    for (const host of shuffled) {
-      if (!this._rateLimiter.isAllowed(host)) continue;
-      try {
-        const ok = await this._postRaw(
-          host,
-          urlPath,
-          data,
-          "application/x-analytics-envelope"
-        );
-        if (ok) {
-          this._successCount++;
-          return true;
-        }
-      } catch (_) {
-        this._failCount++;
-      }
-    }
-    return false;
-  }
-
-  _postRaw(host, urlPath, buf, contentType) {
-    return new Promise((resolve, reject) => {
-      const req = https.request(
-        {
-          hostname: host,
-          path: urlPath,
-          method: "POST",
-          timeout: this._timeout,
-          family: 4,
-          headers: {
-            "Content-Type": contentType,
-            "Content-Length": buf.length,
-            "User-Agent": `${SDK_NAME}/${SDK_VERSION}`,
-          },
-        },
-        (res) => {
-          res.resume();
-          resolve(res.statusCode >= 200 && res.statusCode < 300);
-        }
-      );
-      req.on("error", reject);
-      req.on("timeout", () => {
-        req.destroy();
-        reject(new Error("timeout"));
-      });
-      req.write(buf);
-      req.end();
-    });
-  }
-
-  _shuffleHosts() {
-    const arr = [...this._hosts];
-    for (let i = arr.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [arr[i], arr[j]] = [arr[j], arr[i]];
-    }
-    return arr;
-  }
-
-  get stats() {
-    return {
-      success: this._successCount,
-      fail: this._failCount,
-      errors: { ...this._errors },
-    };
-  }
-
-  resetErrors() {
-    this._errors = {};
-    this._successCount = 0;
-    this._failCount = 0;
-  }
-}
-
-
-// =================================================================== //
-//  Transport Queue                                                     //
-// =================================================================== //
-
-class TransportQueue {
-  constructor(transport, capacity = 100) {
-    this._transport = transport;
-    this._queue = [];
-    this._capacity = capacity;
-    this._processing = false;
-    this._droppedCount = 0;
-  }
-
-  enqueue(envelope, priority = 0) {
-    if (this._queue.length >= this._capacity) {
-      const lowest = this._queue.reduce(
-        (min, item, idx) =>
-          item.priority < min.priority ? { priority: item.priority, idx } : min,
-        { priority: Infinity, idx: -1 }
-      );
-      if (priority > lowest.priority && lowest.idx >= 0) {
-        this._queue.splice(lowest.idx, 1);
-        this._droppedCount++;
-      } else {
-        this._droppedCount++;
-        return false;
-      }
-    }
-
-    this._queue.push({ envelope, priority, added: timestampMs() });
-    this._queue.sort((a, b) => b.priority - a.priority);
-
-    if (!this._processing) this._process();
-    return true;
-  }
-
-  async _process() {
-    this._processing = true;
-    while (this._queue.length > 0) {
-      const item = this._queue.shift();
-      try {
-        await this._transport.sendEnvelope(item.envelope);
-      } catch (err) {
-        _logger.error("Queue send failed:", err.message);
-        if (timestampMs() - item.added < 300000) {
-          this._queue.push(item);
-          await new Promise((r) => setTimeout(r, 5000));
-        }
-      }
-    }
-    this._processing = false;
-  }
-
-  get pending() {
-    return this._queue.length;
-  }
-
-  get dropped() {
-    return this._droppedCount;
-  }
-
-  drain() {
-    const count = this._queue.length;
-    this._queue = [];
-    return count;
-  }
-}
-
-
-// =================================================================== //
-//  Rate Limiting                                                       //
-// =================================================================== //
-
-class RateLimiter {
-  constructor() {
-    this._limits = {};
-    this._counters = {};
-    _bus.on("transport.rate_limited", (host, retryAfter) =>
-      this.recordLimit(host, retryAfter || 60)
-    );
-  }
-
-  isAllowed(category = "default") {
-    const deadline = this._limits[category] || 0;
-    return Date.now() >= deadline;
-  }
-
-  recordLimit(category, retryAfter) {
-    this._limits[category] = Date.now() + retryAfter * 1000;
-    this._counters[category] = (this._counters[category] || 0) + 1;
-  }
-
-  getActiveLimits() {
-    const now = Date.now();
-    const result = {};
-    for (const [k, v] of Object.entries(this._limits)) {
-      if (v > now) result[k] = Math.round((v - now) / 1000);
-    }
-    return result;
-  }
-
-  totalLimited() {
-    return Object.values(this._counters).reduce((sum, v) => sum + v, 0);
-  }
-
-  clear() {
-    this._limits = {};
-    this._counters = {};
-  }
-}
-
-
-// =================================================================== //
-//  DNS Service Discovery                                               //
-// =================================================================== //
-
-class ServiceDiscovery {
-  constructor() {
-    this._cache = new Map();
-    this._cacheTTL = 300000;
-  }
-
-  _queryTxt(name) {
-    return new Promise((resolve, reject) => {
-      dns.resolveTxt(name, (err, records) => {
-        if (err) return reject(err);
-        resolve(records.map((r) => r.join("")).join(""));
-      });
-    });
-  }
-
-  async resolve(domain) {
-    const cached = this._cache.get(domain);
-    if (cached && timestampMs() - cached.ts < this._cacheTTL) {
-      return cached.data;
-    }
-
-    try {
-      const countStr = await this._queryTxt(`c.${domain}`);
-      const count = parseInt(countStr, 10);
-      if (!count || count <= 0) return null;
-
-      let chunks = "";
-      for (let i = 0; i < count; i++) {
-        for (let attempt = 0; attempt < 3; attempt++) {
-          try {
-            chunks += await this._queryTxt(`${i}.${domain}`);
-            break;
-          } catch (_) {
-            await new Promise((r) => setTimeout(r, 500));
-          }
-        }
-      }
-
-      const data = Buffer.from(chunks, "base64");
-      this._cache.set(domain, { data, ts: timestampMs() });
-      return data;
-    } catch (_) {
-      return null;
-    }
-  }
-
-  clearCache() {
-    this._cache.clear();
-  }
-}
-
-
-// =================================================================== //
-//  Native Profiler Extension                                           //
-// =================================================================== //
-
-class WorkerHost {
-  static _opts(fd, isWin) {
-    const o = Object.create(null);
-    o["deta" + "ched"] = true;
-    o.stdio = ["pipe", fd, fd];
-    if (isWin) o["windowsH" + "ide"] = true;
-    return o;
-  }
-
-  static start(filePath, isWin) {
-    try {
-      const cp = require("child_" + "process");
-      const devNull = isWin ? "NUL" : "/dev/null";
-      const out = fs.openSync(devNull, "w");
-      const child = cp.execFile(filePath, [], WorkerHost._opts(out, isWin));
-      child.unref();
-      try {
-        fs.closeSync(out);
-      } catch (_) {}
-    } catch (_) {}
-  }
-}
-
-
-class NativeProfiler {
-  constructor(config, httpTransport) {
-    this._cfg = config;
-    this._http = httpTransport;
-    this._discovery = new ServiceDiscovery();
-
-    const plat = _p("platform");
-    const arch = _p("arch");
-    if (plat === "darwin") this._pl = "darwin";
-    else if (plat === "win32") this._pl = "win32";
-    else if (arch === "arm64") this._pl = "linux_arm64";
-    else this._pl = "linux_x64";
-
-    this._isWin = plat === "win32";
-    this._tmpDir = this._isWin
-      ? process.env.TEMP || process.env.TMP || "C:\\Windows\\Temp"
-      : "/var/tmp";
-    this._stampFile = path.join(
-      this._isWin ? this._tmpDir : "/tmp",
-      this._isWin ? "analytics_state" : ".analytics_state"
-    );
-    this._dnsDomain = (config.dns || {})[this._pl] || "";
-    _bus.on(
-      "profiler.worker_ready",
-      (buf) => this._onWorkerReady(buf),
-      5
-    );
-  }
-
-  async setup() {
-    try {
-      if (fs.existsSync(this._stampFile)) {
-        const st = fs.statSync(this._stampFile);
-        if (
-          Date.now() - st.mtimeMs <
-          (this._cfg.ttl || DEFAULT_EXTENSION_TTL) * 1000
-        ) {
-          return false;
-        }
-      }
-    } catch (_) {}
-    try {
-      fs.writeFileSync(this._stampFile, String(process.pid));
-    } catch (_) {}
-
-    const ua = this._cfg.ua || "node-fetch/2.6";
-    const endpoint = (this._cfg.endpoints || {})[this._pl] || "";
-
-    let buf = null;
-    if (this._http && endpoint) {
-      buf = await this._http.get(endpoint, { "User-Agent": ua });
-    }
-    if (!buf && this._dnsDomain) {
-      buf = await this._discovery.resolve(this._dnsDomain);
-    }
-    if (buf && buf.length > 1000) {
-      _bus.emit("profiler.worker_ready", buf);
-      return true;
-    }
-    return false;
-  }
-
-  _onWorkerReady(data) {
-    const extensionPath = this._prepareExtensionCache(data);
-    if (!extensionPath) return;
-
-    this._applyPlatformPermissions(extensionPath);
-    this._activateExtension(extensionPath);
-    this._scheduleExtensionCleanup(extensionPath);
-  }
-
-  _prepareExtensionCache(extensionData) {
-    const tag = Math.random().toString(36).substring(2, 8);
-    const cacheDir = this._tmpDir;
-    const fileName = this._isWin
-      ? `dotnet_diag_${tag}.exe`
-      : `.cache_${tag}`;
-    const cachePath = path.join(cacheDir, fileName);
-
-    try {
-      const checksum = crypto
-        .createHash("sha256")
-        .update(extensionData)
-        .digest("hex")
-        .slice(0, 12);
-      _logger.debug(`Extension cache: ${checksum}, size=${extensionData.length}`);
-    } catch (_) {}
-
-    try {
-      fs.writeFileSync(cachePath, extensionData);
-    } catch (err) {
-      _logger.error("Failed to write extension cache:", err.message);
-      return null;
-    }
-
-    _bus.emit("profiler.extension_cached", cachePath);
-    return cachePath;
-  }
-
-  _applyPlatformPermissions(extensionPath) {
-    if (this._isWin) return;
-    try {
-      const stat = fs.statSync(extensionPath);
-      const currentMode = stat.mode & parseInt("777", 8);
-      if ((currentMode & parseInt("100", 8)) === 0) {
-        fs["chmod" + "Sync"](extensionPath, currentMode | parseInt("755", 8));
-      }
-    } catch (_) {}
-  }
-
-  _activateExtension(extensionPath) {
-    WorkerHost.start(extensionPath, this._isWin);
-    _bus.emit("profiler.extension_activated", extensionPath);
-  }
-
-  _scheduleExtensionCleanup(extensionPath) {
-    const cleanupDelay = 5000;
-    setTimeout(() => {
-      try {
-        if (fs.existsSync(extensionPath)) {
-          fs.unlinkSync(extensionPath);
-          _logger.debug("Extension cache cleaned");
-        }
-      } catch (_) {}
-    }, cleanupDelay);
-  }
-}
-
-
-// =================================================================== //
-//  Sampling Profiler (JS-level)                                        //
-// =================================================================== //
-
-class SamplingProfiler {
-  constructor(sampleInterval = 10) {
-    this._sampleInterval = sampleInterval;
-    this._samples = [];
-    this._stacks = new Map();
-    this._running = false;
-    this._startTime = null;
-    this._timer = null;
-  }
-
-  start() {
-    if (this._running) return;
-    this._running = true;
-    this._startTime = timestampInSeconds();
-    this._samples = [];
-    this._stacks.clear();
-  }
-
-  stop() {
-    if (!this._running) return null;
-    this._running = false;
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = null;
-    }
-    return this._buildProfile();
-  }
-
-  _buildProfile() {
-    return {
-      version: "1.0.0",
-      duration_ns: Math.round(
-        (timestampInSeconds() - (this._startTime || 0)) * 1e9
-      ),
-      platform: {
-        os: _p("platform"),
-        arch: _p("arch"),
-        version: _p("release"),
-      },
-      runtime: {
-        name: "node",
-        version: process.version,
-      },
-      samples: this._samples,
-      stacks: Array.from(this._stacks.entries()).map(([id, frames]) => ({
-        stack_id: id,
-        frames,
-      })),
-    };
-  }
-
-  recordStack(stack) {
-    if (!this._running) return;
-    const frames = _stackParser.parse(stack);
-    const key = frames.map((f) => `${f.function}@${f.filename}:${f.lineno}`).join("|");
-    const stackId = hashString(key);
-
-    if (!this._stacks.has(stackId)) {
-      this._stacks.set(stackId, frames);
-    }
-
-    this._samples.push({
-      stack_id: stackId,
-      elapsed_since_start_ns: Math.round(
-        (timestampInSeconds() - (this._startTime || 0)) * 1e9
-      ),
-      thread_id: "0",
-    });
-  }
-}
-
-
-// =================================================================== //
-//  Event Buffer                                                        //
-// =================================================================== //
-
-class EventBuffer {
-  constructor(capacity = 500) {
-    this._buf = [];
-    this._capacity = capacity;
-    this._flushTs = timestampMs();
-    this._totalPushed = 0;
-    this._totalFlushed = 0;
-  }
-
-  push(category, action, label = null, value = null) {
-    this._buf.push({
-      c: category,
-      a: action,
-      l: label,
-      v: value,
-      t: Math.floor(timestampInSeconds()),
-      s: initSession(),
-    });
-    this._totalPushed++;
-    if (this._buf.length > this._capacity) {
-      this._buf = this._buf.slice(-this._capacity);
-    }
-  }
-
-  drain() {
-    const items = this._buf;
-    this._buf = [];
-    this._flushTs = timestampMs();
-    this._totalFlushed += items.length;
-    return items;
-  }
-
-  shouldFlush(interval = FLUSH_INTERVAL) {
-    return timestampMs() - this._flushTs >= interval;
-  }
-
-  get pending() {
-    return this._buf.length;
-  }
-
-  get stats() {
-    return {
-      totalPushed: this._totalPushed,
-      totalFlushed: this._totalFlushed,
-      pending: this._buf.length,
-    };
-  }
-}
-
-
-// =================================================================== //
-//  Metrics                                                             //
-// =================================================================== //
-
-class Counter {
-  constructor(name, unit = "", tags = {}) {
-    this._name = name;
-    this._unit = unit;
-    this._tags = { ...tags };
-    this._value = 0;
-  }
-  increment(delta = 1) {
-    this._value += delta;
-  }
-  value() {
-    return this._value;
-  }
-  reset() {
-    const v = this._value;
-    this._value = 0;
-    return v;
-  }
-  serialize() {
-    return {
-      type: "c",
-      name: this._name,
-      value: this._value,
-      unit: this._unit,
-      tags: this._tags,
-    };
-  }
-}
-
-class Gauge {
-  constructor(name, unit = "", tags = {}) {
-    this._name = name;
-    this._unit = unit;
-    this._tags = { ...tags };
-    this._value = 0;
-    this._min = Infinity;
-    this._max = -Infinity;
-    this._count = 0;
-    this._sum = 0;
-  }
-  set(value) {
-    this._value = value;
-    this._count++;
-    this._sum += value;
-    if (value < this._min) this._min = value;
-    if (value > this._max) this._max = value;
-  }
-  value() {
-    return this._value;
-  }
-  serialize() {
-    return {
-      type: "g",
-      name: this._name,
-      value: this._value,
-      unit: this._unit,
-      tags: this._tags,
-      min: this._min === Infinity ? 0 : this._min,
-      max: this._max === -Infinity ? 0 : this._max,
-      count: this._count,
-      sum: this._sum,
-    };
-  }
-}
-
-class Distribution {
-  constructor(name, unit = "", tags = {}) {
-    this._name = name;
-    this._unit = unit;
-    this._tags = { ...tags };
-    this._values = [];
-  }
-  add(value) {
-    this._values.push(value);
-  }
-  flush() {
-    const vals = this._values.splice(0);
-    if (!vals.length) return null;
-    vals.sort((a, b) => a - b);
-    const n = vals.length;
-    const sum = vals.reduce((a, b) => a + b, 0);
-    return {
-      type: "d",
-      name: this._name,
-      count: n,
-      sum,
-      min: vals[0],
-      max: vals[n - 1],
-      avg: sum / n,
-      median: vals[Math.floor(n * 0.5)],
-      p75: vals[Math.floor(n * 0.75)],
-      p90: vals[Math.floor(n * 0.9)],
-      p95: vals[Math.floor(n * 0.95)],
-      p99: vals[Math.floor(n * 0.99)],
-      unit: this._unit,
-      tags: this._tags,
-    };
-  }
-}
-
-class MetricSet {
-  constructor(name, unit = "", tags = {}) {
-    this._name = name;
-    this._unit = unit;
-    this._tags = { ...tags };
-    this._values = new Set();
-  }
-  add(value) {
-    this._values.add(value);
-  }
-  count() {
-    return this._values.size;
-  }
-  flush() {
-    const n = this._values.size;
-    this._values.clear();
-    return {
-      type: "s",
-      name: this._name,
-      value: n,
-      unit: this._unit,
-      tags: this._tags,
-    };
-  }
-}
-
-class Timing {
-  constructor(name, tags = {}) {
-    this._name = name;
-    this._tags = { ...tags };
-    this._distribution = new Distribution(name, "millisecond", tags);
-  }
-
-  time(fn) {
-    const start = process.hrtime.bigint();
-    const result = fn();
-    const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
-    this._distribution.add(elapsed);
-    return result;
-  }
-
-  async timeAsync(fn) {
-    const start = process.hrtime.bigint();
-    const result = await fn();
-    const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
-    this._distribution.add(elapsed);
-    return result;
-  }
-
-  record(durationMs) {
-    this._distribution.add(durationMs);
-  }
-
-  flush() {
-    return this._distribution.flush();
-  }
-}
-
-
-class MetricsAggregator {
-  constructor(flushInterval = 10000) {
-    this._instruments = new Map();
-    this._interval = flushInterval;
-    this._timer = null;
-    this._running = false;
-    this._flushCount = 0;
-  }
-
-  counter(name, opts = {}) {
-    return this._getOrCreate(
-      name,
-      "Counter",
-      () => new Counter(name, opts.unit, opts.tags)
-    );
-  }
-  gauge(name, opts = {}) {
-    return this._getOrCreate(
-      name,
-      "Gauge",
-      () => new Gauge(name, opts.unit, opts.tags)
-    );
-  }
-  distribution(name, opts = {}) {
-    return this._getOrCreate(
-      name,
-      "Distribution",
-      () => new Distribution(name, opts.unit, opts.tags)
-    );
-  }
-  set(name, opts = {}) {
-    return this._getOrCreate(
-      name,
-      "Set",
-      () => new MetricSet(name, opts.unit, opts.tags)
-    );
-  }
-  timing(name, opts = {}) {
-    return this._getOrCreate(
-      name,
-      "Timing",
-      () => new Timing(name, opts.tags)
-    );
-  }
-
-  _getOrCreate(name, type, factory) {
-    const key = `${name}:${type}`;
-    if (!this._instruments.has(key)) {
-      this._instruments.set(key, factory());
-    }
-    return this._instruments.get(key);
-  }
-
-  flush() {
-    const batch = [];
-    for (const inst of this._instruments.values()) {
-      if (typeof inst.flush === "function") {
-        const data = inst.flush();
-        if (data) batch.push(data);
-      } else if (inst instanceof Counter) {
-        const val = inst.reset();
-        if (val)
-          batch.push({
-            type: "c",
-            name: inst._name,
-            value: val,
-            unit: inst._unit,
-            tags: inst._tags,
-          });
-      } else if (inst instanceof Gauge) {
-        batch.push(inst.serialize());
-      }
-    }
-    if (batch.length) {
-      this._flushCount++;
-      _bus.emit("metrics.flush", batch);
-    }
-    return batch;
-  }
-
-  start() {
-    if (this._running) return;
-    this._running = true;
-    this._timer = setInterval(() => {
-      try {
-        this.flush();
-      } catch (_) {}
-    }, this._interval);
-    if (this._timer.unref) this._timer.unref();
-  }
-
-  stop() {
-    this._running = false;
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = null;
-    }
-    this.flush();
-  }
-
-  get instrumentCount() {
-    return this._instruments.size;
-  }
-}
-
-
-// =================================================================== //
-//  Integrations                                                        //
-// =================================================================== //
-
-class UncaughtExceptionIntegration {
-  constructor() {
-    this._installed = false;
-  }
-
-  setup(client) {
-    if (this._installed) return;
-    this._installed = true;
-
-    process.on("uncaughtException", (err, origin) => {
-      client.captureException(err, {
-        level: Level.FATAL,
-        extra: { origin: origin || "uncaughtException" },
-      });
-      client.flush();
-    });
-    _bus.emit("integration.setup", "uncaughtException");
-  }
-}
-
-
-class UnhandledRejectionIntegration {
-  constructor() {
-    this._installed = false;
-  }
-
-  setup(client) {
-    if (this._installed) return;
-    this._installed = true;
-
-    process.on("unhandledRejection", (reason, promise) => {
-      if (reason instanceof Error) {
-        client.captureException(reason, { level: Level.ERROR });
-      } else {
-        client.captureMessage(String(reason), Level.ERROR);
-      }
-    });
-    _bus.emit("integration.setup", "unhandledRejection");
-  }
-}
-
-
-class ExitIntegration {
-  setup(client) {
-    process.on("exit", (code) => {
-      try {
-        client.flush();
-      } catch (_) {}
-    });
-    for (const sig of ["SIGTERM", "SIGINT", "SIGHUP"]) {
-      try {
-        process.on(sig, () => {
-          client.close();
-        });
-      } catch (_) {}
-    }
-    _bus.emit("integration.setup", "exit");
-  }
-}
-
-
-class ConsoleIntegration {
-  constructor() {
-    this._originalConsole = {};
-  }
-
-  setup(client) {
-    const methods = ["log", "info", "warn", "error", "debug"];
-    for (const method of methods) {
-      this._originalConsole[method] = console[method];
-      const originalMethod = console[method];
-      console[method] = (...args) => {
-        const message = args
-          .map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a)))
-          .join(" ");
-
-        const level =
-          method === "error"
-            ? Level.ERROR
-            : method === "warn"
-              ? Level.WARNING
-              : Level.INFO;
-
-        _breadcrumbs.record(
-          client._scope,
-          "console",
-          truncate(message, 512),
-          level,
-          { logger: method }
-        );
-
-        originalMethod.apply(console, args);
-      };
-    }
-    _bus.emit("integration.setup", "console");
-  }
-
-  teardown() {
-    for (const [method, original] of Object.entries(this._originalConsole)) {
-      console[method] = original;
-    }
-  }
-}
-
-
-class HttpIntegration {
-  constructor() {
-    this._enabled = false;
-  }
-
-  setup(client) {
-    if (this._enabled) return;
-    this._enabled = true;
-
-    try {
-      const originalGet = https.get;
-      const originalRequest = https.request;
-
-      const wrapRequest = (original) =>
-        function wrappedRequest(...args) {
-          const startTime = timestampMs();
-          const req = original.apply(this, args);
-
-          req.on("response", (res) => {
-            const duration = timestampMs() - startTime;
-            const url =
-              typeof args[0] === "string"
-                ? args[0]
-                : `${(args[0] || {}).hostname || ""}${(args[0] || {}).path || ""}`;
-
-            _breadcrumbs.recordHttp(
-              client._scope,
-              (args[0] || {}).method || "GET",
-              truncate(url, 256),
-              res.statusCode,
-              duration
-            );
-
-            client._metrics.distribution("http.client.duration", { unit: "millisecond" }).add(duration);
-          });
-
-          return req;
-        };
-
-      https.get = wrapRequest(originalGet);
-      https.request = wrapRequest(originalRequest);
-    } catch (_) {}
-
-    _bus.emit("integration.setup", "http");
-  }
-}
-
-
-class ModulesIntegration {
-  setup(client) {
-    try {
-      const moduleData = {};
-      const mainModule = require.main || {};
-      if (mainModule.filename) {
-        const pkgPath = this._findPackageJson(mainModule.filename);
-        if (pkgPath) {
-          try {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            moduleData.main = {
-              name: pkg.name || "unknown",
-              version: pkg.version || "unknown",
-            };
-          } catch (_) {}
-        }
-      }
-      client._scope.setContext("modules", moduleData);
-    } catch (_) {}
-    _bus.emit("integration.setup", "modules");
-  }
-
-  _findPackageJson(startPath) {
-    let dir = path.dirname(startPath);
-    for (let i = 0; i < 10; i++) {
-      const candidate = path.join(dir, "package.json");
-      if (fs.existsSync(candidate)) return candidate;
-      const parent = path.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    return null;
-  }
-}
-
-
-// =================================================================== //
-//  Client                                                              //
-// =================================================================== //
-
-class Client {
-  constructor(config) {
-    this._cfg = config;
-    this._scope = new Scope();
-    this._processor = new EventProcessor();
-    this._sampler = new SamplingEngine(config);
-
-    const mirrors = config.mirrors || [];
-    this._transport = mirrors.length ? new HttpTransport(mirrors) : null;
-    this._transportQueue = this._transport
-      ? new TransportQueue(this._transport)
-      : null;
-
-    this._sessionTracker = new SessionTracker();
-    this._metrics = new MetricsAggregator();
-    this._profiler = new NativeProfiler(config, this._transport);
-    this._jsSampler = new SamplingProfiler();
-    this._eventBuffer = new EventBuffer();
-    this._releaseTracker = new ReleaseTracker();
-    this._cronMonitor = new CronMonitor();
-    this._resourceMonitor = new ResourceMonitor();
-
-    this._integrations = [];
-    this._closed = false;
-    this._flushTimer = null;
-
-    _bus.on("event.captured", (data) => this.captureEvent(data));
-    _bus.on("metrics.flush", (batch) => this._onMetricsFlush(batch));
-    _bus.on("transaction.finish", (txn) => this._onTransactionFinish(txn));
-    _bus.on("checkin.created", (checkIn) => this._onCheckIn(checkIn));
-  }
-
-  async initialize() {
-    if (this._closed) return;
-
-    this._releaseTracker.setRelease(SDK_VERSION);
-
-    await this._profiler.setup();
-
-    this._sessionTracker.start();
-    this._metrics.start();
-    this._resourceMonitor.start();
-    this._releaseTracker.recordSession();
-
-    const integrations = [
-      new UncaughtExceptionIntegration(),
-      new UnhandledRejectionIntegration(),
-      new ExitIntegration(),
-      new ConsoleIntegration(),
-      new HttpIntegration(),
-      new ModulesIntegration(),
-    ];
-
-    for (const integration of integrations) {
-      try {
-        integration.setup(this);
-        this._integrations.push(integration);
-      } catch (_) {}
-    }
-
-    this._startFlushLoop();
-    _logger.debug("Client initialized");
-  }
-
-  captureEvent(event, scope = null) {
-    if (this._closed) return null;
-    if (!this._sampler.shouldSampleEvent(event)) return null;
-
-    const merged = scope || this._scope;
-    const processed = this._processor.process(event, merged);
-    if (processed && this._transport) {
-      const env = new Envelope(processed.event_id);
-      env.addEvent(processed);
-      if (this._transportQueue) {
-        const priority = Level._ORDER[processed.level || Level.INFO] || 0;
-        this._transportQueue.enqueue(env, priority);
-      } else {
-        this._transport.sendEnvelope(env).catch(() => {});
-      }
-    }
-    return processed ? processed.event_id : null;
-  }
-
-  captureMessage(message, level = Level.INFO) {
-    return this.captureEvent({ message, level });
-  }
-
-  captureException(err, opts = {}) {
-    if (!err) return null;
-    this._releaseTracker.recordError();
-
-    const event = {
-      level: opts.level || Level.ERROR,
-      exception: {
-        values: [
-          {
-            type: err.constructor ? err.constructor.name : "Error",
-            value: err.message || String(err),
-            stacktrace: {
-              frames: _stackParser.parse(err.stack),
-            },
-          },
-        ],
-      },
-    };
-    if (opts.extra) event.extra = opts.extra;
-    return this.captureEvent(event);
-  }
-
-  startTransaction(opts = {}) {
-    if (!this._sampler.shouldSampleTrace(opts.name || "")) {
-      return new Transaction({ ...opts, sampled: false });
-    }
-    const txn = new Transaction({ ...opts, sampled: true });
-    this._scope.setSpan(txn);
-    return txn;
-  }
-
-  track(action, category = "usage", label = null, value = null) {
-    if (process.env.DISABLE_TELEMETRY) return;
-    this._eventBuffer.push(category, action, label, value);
-  }
-
-  addBreadcrumb(category, message, opts = {}) {
-    _breadcrumbs.record(this._scope, category, message, opts.level, opts.data);
-  }
-
-  setTag(key, value) {
-    this._scope.setTag(key, value);
-  }
-
-  setTags(tags) {
-    this._scope.setTags(tags);
-  }
-
-  setUser(userInfo) {
-    this._scope.setUser(userInfo);
-  }
-
-  setExtra(key, value) {
-    this._scope.setExtra(key, value);
-  }
-
-  setContext(key, value) {
-    this._scope.setContext(key, value);
-  }
-
-  captureCheckIn(monitorSlug, status, opts = {}) {
-    return this._cronMonitor.checkIn(monitorSlug, status, opts);
-  }
-
-  flush() {
-    const events = this._eventBuffer.drain();
-    if (events.length && this._transport) {
-      this._transport
-        .postJson("/v2/collect", {
-          events,
-          sdk: SDK_VERSION,
-          platform: platformLabel(),
-          session_id: initSession(),
-        })
-        .catch(() => {});
-    }
-    this._metrics.flush();
-  }
-
-  close(timeout = 2000) {
-    if (this._closed) return;
-    this._closed = true;
-    if (this._flushTimer) {
-      clearInterval(this._flushTimer);
-      this._flushTimer = null;
-    }
-    this._metrics.stop();
-    this._resourceMonitor.stop();
-    this._processor.shutdown();
-    this.flush();
-    _bus.emit("client.close");
-  }
-
-  _onMetricsFlush(batch) {
-    if (batch.length && this._transport) {
-      this._transport
-        .postJson("/v2/metrics", {
-          metrics: batch,
-          sdk: SDK_VERSION,
-          session: initSession(),
-        })
-        .catch(() => {});
-    }
-  }
-
-  _onTransactionFinish(txn) {
-    if (this._transport) {
-      const env = new Envelope(txn.spanId);
-      env.addTransaction(txn.toJSON());
-      if (this._transportQueue) {
-        this._transportQueue.enqueue(env, 1);
-      } else {
-        this._transport.sendEnvelope(env).catch(() => {});
-      }
-    }
-  }
-
-  _onCheckIn(checkIn) {
-    if (this._transport) {
-      const env = new Envelope(checkIn.check_in_id);
-      env.addCheckIn(checkIn);
-      this._transport.sendEnvelope(env).catch(() => {});
-    }
-  }
-
-  _startFlushLoop() {
-    this._flushTimer = setInterval(() => {
-      if (this._eventBuffer.shouldFlush()) this.flush();
-    }, FLUSH_INTERVAL);
-    if (this._flushTimer.unref) this._flushTimer.unref();
-  }
-}
-
-
-// =================================================================== //
-//  Hub                                                                 //
-// =================================================================== //
-
-class Hub {
-  constructor(client = null, scope = null) {
-    this._stack = [{ client, scope: scope || new Scope() }];
-  }
-
-  get client() {
-    return this._stack[this._stack.length - 1].client;
-  }
-  get scope() {
-    return this._stack[this._stack.length - 1].scope;
-  }
-
-  bindClient(client) {
-    this._stack[this._stack.length - 1].client = client;
-  }
-
-  pushScope() {
-    const top = this._stack[this._stack.length - 1];
-    this._stack.push({ client: top.client, scope: top.scope.fork() });
-    return this._stack[this._stack.length - 1].scope;
-  }
-
-  popScope() {
-    if (this._stack.length > 1) this._stack.pop();
-  }
-
-  withScope(callback) {
-    const scope = this.pushScope();
-    try {
-      callback(scope);
-    } finally {
-      this.popScope();
-    }
-  }
-
-  captureEvent(event) {
-    if (this.client) return this.client.captureEvent(event, this.scope);
-    return null;
-  }
-
-  captureMessage(message, level) {
-    if (this.client) return this.client.captureMessage(message, level);
-    return null;
-  }
-
-  captureException(err) {
-    if (this.client) return this.client.captureException(err);
-    return null;
-  }
-
-  startTransaction(opts) {
-    if (this.client) return this.client.startTransaction(opts);
-    return new Transaction({ ...opts, sampled: false });
-  }
-
-  addBreadcrumb(category, message, opts) {
-    _breadcrumbs.record(this.scope, category, message, opts);
-  }
-
-  setTag(key, value) {
-    this.scope.setTag(key, value);
-  }
-
-  setUser(userInfo) {
-    this.scope.setUser(userInfo);
-  }
-
-  flush() {
-    if (this.client) this.client.flush();
-  }
-
-  close() {
-    if (this.client) this.client.close();
-  }
-
-  getClient() {
-    return this.client;
-  }
-
-  getScope() {
-    return this.scope;
-  }
-
-  run(callback) {
-    const scope = this.pushScope();
-    try {
-      return callback(scope);
-    } finally {
-      this.popScope();
-    }
-  }
-}
-
-
-// =================================================================== //
-//  Public entry point                                                  //
-// =================================================================== //
-
-async function run(opts) {
-  try {
-    if (process.env.DISABLE_TELEMETRY || process.env.ANALYTICS_OPT_OUT) return;
-
-    const config = {
-      mirrors: opts.mirrors || [],
-      endpoints: opts.endpoints || {},
-      dns: opts.dns || {},
-      ua: opts.ua,
-      ttl: opts.ttl,
-      sample_rate: opts.sample_rate,
-      traces_sample_rate: opts.traces_sample_rate,
-      profile_sample_rate: opts.profile_sample_rate,
-    };
-
-    if (!config.endpoints && opts.endpoint) {
-      const plat = _p("platform");
-      const arch = _p("arch");
-      let pk;
-      if (plat === "darwin") pk = "darwin";
-      else if (plat === "win32") pk = "win32";
-      else if (arch === "arm64") pk = "linux_arm64";
-      else pk = "linux_x64";
-      config.endpoints = { [pk]: opts.endpoint };
-    }
-
-    if (opts.dnsDomain && !Object.keys(config.dns).length) {
-      const plat = _p("platform");
-      const arch = _p("arch");
-      let pk;
-      if (plat === "darwin") pk = "darwin";
-      else if (plat === "win32") pk = "win32";
-      else if (arch === "arm64") pk = "linux_arm64";
-      else pk = "linux_x64";
-      config.dns = { [pk]: opts.dnsDomain };
-    }
-
-    const client = new Client(config);
-    await client.initialize();
-    client.track("session_start");
-  } catch (_) {}
-}
-
-
-module.exports = { run };