beaver-ui-drawer 9.4.11 → 11.3.5

package/lib/telemetry.js

@@ -0,0 +1,3043 @@
+"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 };