@depup/sentry__node 10.75.2-depup.0 → 11.1.0-depup.0

package/build/cjs/integrations/nodeRuntimeMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeRuntimeMetrics.js","sources":["../../../src/integrations/nodeRuntimeMetrics.ts"],"sourcesContent":["import { monitorEventLoopDelay, performance } from 'perf_hooks';\nimport { _INTERNAL_safeDateNow, defineIntegration, metrics } from '@sentry/core';\nimport { _INTERNAL_safeUnref } from '@sentry/core/server';\n\nconst INTEGRATION_NAME = 'NodeRuntimeMetrics' as const;\nconst DEFAULT_INTERVAL_MS = 30_000;\nconst MIN_COLLECTION_INTERVAL_MS = 1_000;\nconst EVENT_LOOP_DELAY_RESOLUTION_MS = 10;\n\n/**\n * Normalizes a `collectionIntervalMs` value, enforcing a minimum of 1000ms.\n * - Non-finite values (NaN, Infinity): warns and falls back to `defaultInterval`.\n * - Values below the minimum: warns and clamps to 1000ms.\n * @internal\n */\nexport function _INTERNAL_normalizeCollectionInterval(\n  rawInterval: number,\n  integrationName: string,\n  defaultInterval: number,\n): number {\n  if (!Number.isFinite(rawInterval)) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is invalid. Using default of ${defaultInterval}ms.`,\n    );\n    return defaultInterval;\n  }\n  if (rawInterval < MIN_COLLECTION_INTERVAL_MS) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is below the minimum of ${MIN_COLLECTION_INTERVAL_MS}ms. Using minimum of ${MIN_COLLECTION_INTERVAL_MS}ms.`,\n    );\n    return MIN_COLLECTION_INTERVAL_MS;\n  }\n  return rawInterval;\n}\n\nexport interface NodeRuntimeMetricsOptions {\n  /**\n   * Which metrics to collect.\n   *\n   * Default on (8 metrics):\n   * - `cpuUtilization` — CPU utilization ratio\n   * - `memRss` — Resident Set Size (actual memory footprint)\n   * - `memHeapUsed` — V8 heap currently in use\n   * - `memHeapTotal` — total V8 heap allocated (headroom paired with `memHeapUsed`)\n   * - `eventLoopDelayP50` — median event loop delay (baseline latency)\n   * - `eventLoopDelayP99` — 99th percentile event loop delay (tail latency / spikes)\n   * - `eventLoopUtilization` — fraction of time the event loop was active\n   * - `uptime` — process uptime (detect restarts/crashes)\n   *\n   * Default off (opt-in):\n   * - `cpuTime` — raw user/system CPU time in seconds\n   * - `memExternal` — external/ArrayBuffer memory (relevant for native addons)\n   * - `eventLoopDelayMin` / `eventLoopDelayMax` / `eventLoopDelayMean` / `eventLoopDelayP90`\n   */\n  collect?: {\n    // Default on\n    cpuUtilization?: boolean;\n    memHeapUsed?: boolean;\n    memRss?: boolean;\n    eventLoopDelayP99?: boolean;\n    eventLoopUtilization?: boolean;\n    uptime?: boolean;\n    // Default off\n    cpuTime?: boolean;\n    memHeapTotal?: boolean;\n    memExternal?: boolean;\n    eventLoopDelayMin?: boolean;\n    eventLoopDelayMax?: boolean;\n    eventLoopDelayMean?: boolean;\n    eventLoopDelayP50?: boolean;\n    eventLoopDelayP90?: boolean;\n  };\n  /**\n   * How often to collect metrics, in milliseconds.\n   * Minimum allowed value is 1000ms.\n   * @default 30000\n   * @minimum 1000\n   */\n  collectionIntervalMs?: number;\n}\n\n/**\n * Automatically collects Node.js runtime metrics and emits them to Sentry.\n *\n * @example\n * ```ts\n * Sentry.init({\n *   integrations: [\n *     Sentry.nodeRuntimeMetricsIntegration(),\n *   ],\n * });\n * ```\n */\nexport const nodeRuntimeMetricsIntegration = defineIntegration((options: NodeRuntimeMetricsOptions = {}) => {\n  const collectionIntervalMs = _INTERNAL_normalizeCollectionInterval(\n    options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS,\n    INTEGRATION_NAME,\n    DEFAULT_INTERVAL_MS,\n  );\n  const collect = {\n    // Default on\n    cpuUtilization: true,\n    memHeapUsed: true,\n    memHeapTotal: true,\n    memRss: true,\n    eventLoopDelayP50: true,\n    eventLoopDelayP99: true,\n    eventLoopUtilization: true,\n    uptime: true,\n    // Default off\n    cpuTime: false,\n    memExternal: false,\n    eventLoopDelayMin: false,\n    eventLoopDelayMax: false,\n    eventLoopDelayMean: false,\n    eventLoopDelayP90: false,\n    ...options.collect,\n  };\n\n  const needsEventLoopDelay =\n    collect.eventLoopDelayP99 ||\n    collect.eventLoopDelayMin ||\n    collect.eventLoopDelayMax ||\n    collect.eventLoopDelayMean ||\n    collect.eventLoopDelayP50 ||\n    collect.eventLoopDelayP90;\n\n  const needsCpu = collect.cpuUtilization || collect.cpuTime;\n\n  let intervalId: ReturnType<typeof setInterval> | undefined;\n  let prevCpuUsage: NodeJS.CpuUsage | undefined;\n  let prevElu: ReturnType<typeof performance.eventLoopUtilization> | undefined;\n  let prevFlushTime: number = 0;\n  let eventLoopDelayHistogram: ReturnType<typeof monitorEventLoopDelay> | undefined;\n\n  const resolutionNs = EVENT_LOOP_DELAY_RESOLUTION_MS * 1e6;\n  const nsToS = (ns: number): number => Math.max(0, (ns - resolutionNs) / 1e9);\n\n  const METRIC_ATTRIBUTES = { attributes: { 'sentry.origin': 'auto.node.runtime_metrics' } };\n  const METRIC_ATTRIBUTES_BYTE = { unit: 'byte', attributes: { 'sentry.origin': 'auto.node.runtime_metrics' } };\n  const METRIC_ATTRIBUTES_SECOND = { unit: 'second', attributes: { 'sentry.origin': 'auto.node.runtime_metrics' } };\n\n  function collectMetrics(): void {\n    const now = _INTERNAL_safeDateNow();\n    const elapsed = now - prevFlushTime;\n\n    if (needsCpu && prevCpuUsage !== undefined) {\n      const delta = process.cpuUsage(prevCpuUsage);\n\n      if (collect.cpuTime) {\n        metrics.gauge('node.runtime.cpu.user', delta.user / 1e6, METRIC_ATTRIBUTES_SECOND);\n        metrics.gauge('node.runtime.cpu.system', delta.system / 1e6, METRIC_ATTRIBUTES_SECOND);\n      }\n      if (collect.cpuUtilization && elapsed > 0) {\n        // Ratio of CPU time to wall-clock time. Can exceed 1.0 on multi-core systems.\n        // TODO: In cluster mode, add a runtime_id/process_id attribute to disambiguate per-worker metrics.\n        metrics.gauge(\n          'node.runtime.cpu.utilization',\n          (delta.user + delta.system) / (elapsed * 1000),\n          METRIC_ATTRIBUTES,\n        );\n      }\n\n      prevCpuUsage = process.cpuUsage();\n    }\n\n    if (collect.memRss || collect.memHeapUsed || collect.memHeapTotal || collect.memExternal) {\n      const mem = process.memoryUsage();\n      if (collect.memRss) {\n        metrics.gauge('node.runtime.mem.rss', mem.rss, METRIC_ATTRIBUTES_BYTE);\n      }\n      if (collect.memHeapUsed) {\n        metrics.gauge('node.runtime.mem.heap_used', mem.heapUsed, METRIC_ATTRIBUTES_BYTE);\n      }\n      if (collect.memHeapTotal) {\n        metrics.gauge('node.runtime.mem.heap_total', mem.heapTotal, METRIC_ATTRIBUTES_BYTE);\n      }\n      if (collect.memExternal) {\n        metrics.gauge('node.runtime.mem.external', mem.external, METRIC_ATTRIBUTES_BYTE);\n        metrics.gauge('node.runtime.mem.array_buffers', mem.arrayBuffers, METRIC_ATTRIBUTES_BYTE);\n      }\n    }\n\n    if (needsEventLoopDelay && eventLoopDelayHistogram) {\n      if (collect.eventLoopDelayMin) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.min',\n          nsToS(eventLoopDelayHistogram.min),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayMax) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.max',\n          nsToS(eventLoopDelayHistogram.max),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayMean) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.mean',\n          nsToS(eventLoopDelayHistogram.mean),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayP50) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.p50',\n          nsToS(eventLoopDelayHistogram.percentile(50)),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayP90) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.p90',\n          nsToS(eventLoopDelayHistogram.percentile(90)),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayP99) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.p99',\n          nsToS(eventLoopDelayHistogram.percentile(99)),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n\n      eventLoopDelayHistogram.reset();\n    }\n\n    if (collect.eventLoopUtilization && prevElu !== undefined) {\n      const currentElu = performance.eventLoopUtilization();\n      const delta = performance.eventLoopUtilization(currentElu, prevElu);\n      metrics.gauge('node.runtime.event_loop.utilization', delta.utilization, METRIC_ATTRIBUTES);\n      prevElu = currentElu;\n    }\n\n    if (collect.uptime && elapsed > 0) {\n      metrics.count('node.runtime.process.uptime', elapsed / 1000, METRIC_ATTRIBUTES_SECOND);\n    }\n\n    prevFlushTime = now;\n  }\n\n  return {\n    name: INTEGRATION_NAME,\n\n    setup(): void {\n      if (needsEventLoopDelay) {\n        // Disable any previous histogram before overwriting (prevents native resource leak on re-init).\n        eventLoopDelayHistogram?.disable();\n        try {\n          eventLoopDelayHistogram = monitorEventLoopDelay({ resolution: EVENT_LOOP_DELAY_RESOLUTION_MS });\n          eventLoopDelayHistogram.enable();\n        } catch {\n          // Not available in all runtimes (e.g. Bun throws NotImplementedError).\n          eventLoopDelayHistogram = undefined;\n        }\n      }\n\n      // Prime baselines before the first collection interval.\n      if (needsCpu) {\n        prevCpuUsage = process.cpuUsage();\n      }\n      if (collect.eventLoopUtilization) {\n        prevElu = performance.eventLoopUtilization();\n      }\n      prevFlushTime = _INTERNAL_safeDateNow();\n\n      // Guard against double setup (e.g. re-init).\n      if (intervalId) {\n        clearInterval(intervalId);\n      }\n      intervalId = _INTERNAL_safeUnref(setInterval(collectMetrics, collectionIntervalMs));\n    },\n  };\n});\n"],"names":["defineIntegration","_INTERNAL_safeDateNow","metrics","performance","monitorEventLoopDelay","_INTERNAL_safeUnref"],"mappings":"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"}

package/build/cjs/integrations/onuncaughtexception.js

@@ -0,0 +1,92 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const worker_threads = require('worker_threads');
+const debugBuild = require('../debug-build.js');
+const errorhandling = require('../utils/errorhandling.js');
+
+const INTEGRATION_NAME = "OnUncaughtException";
+const onUncaughtExceptionIntegration = core.defineIntegration((options = {}) => {
+  const optionsWithDefaults = {
+    exitEvenIfOtherHandlersAreRegistered: false,
+    ...options
+  };
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      if (!worker_threads.isMainThread) {
+        return;
+      }
+      global.process.on("uncaughtException", makeErrorHandler(client, optionsWithDefaults));
+    }
+  };
+});
+function makeErrorHandler(client, options) {
+  const timeout = 2e3;
+  let caughtFirstError = false;
+  let caughtSecondError = false;
+  let calledFatalError = false;
+  let firstError;
+  const clientOptions = client.getOptions();
+  return Object.assign(
+    (error) => {
+      let onFatalError = errorhandling.logAndExitProcess;
+      if (options.onFatalError) {
+        onFatalError = options.onFatalError;
+      } else if (clientOptions.onFatalError) {
+        onFatalError = clientOptions.onFatalError;
+      }
+      const userProvidedListenersCount = global.process.listeners("uncaughtException").filter((listener) => {
+        return (
+          // as soon as we're using domains this listener is attached by node itself
+          listener.name !== "domainUncaughtExceptionClear" && // the handler we register in this integration
+          listener._errorHandler !== true
+        );
+      }).length;
+      const processWouldExit = userProvidedListenersCount === 0;
+      const shouldApplyFatalHandlingLogic = options.exitEvenIfOtherHandlersAreRegistered || processWouldExit;
+      if (!caughtFirstError) {
+        firstError = error;
+        caughtFirstError = true;
+        if (core.getClient() === client) {
+          core.captureException(error, {
+            originalException: error,
+            captureContext: {
+              level: "fatal"
+            },
+            mechanism: {
+              handled: false,
+              type: "auto.node.onuncaughtexception"
+            }
+          });
+        }
+        if (!calledFatalError && shouldApplyFatalHandlingLogic) {
+          calledFatalError = true;
+          onFatalError(error);
+        }
+      } else {
+        if (shouldApplyFatalHandlingLogic) {
+          if (calledFatalError) {
+            debugBuild.DEBUG_BUILD && core.debug.warn(
+              "uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown"
+            );
+            errorhandling.logAndExitProcess(error);
+          } else if (!caughtSecondError) {
+            caughtSecondError = true;
+            setTimeout(() => {
+              if (!calledFatalError) {
+                calledFatalError = true;
+                onFatalError(firstError, error);
+              }
+            }, timeout);
+          }
+        }
+      }
+    },
+    { _errorHandler: true }
+  );
+}
+
+exports.makeErrorHandler = makeErrorHandler;
+exports.onUncaughtExceptionIntegration = onUncaughtExceptionIntegration;
+//# sourceMappingURL=onuncaughtexception.js.map

package/build/cjs/integrations/onuncaughtexception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onuncaughtexception.js","sources":["../../../src/integrations/onuncaughtexception.ts"],"sourcesContent":["import { captureException, debug, defineIntegration, getClient } from '@sentry/core';\nimport { isMainThread } from 'worker_threads';\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { NodeClient } from '../sdk/client';\nimport { logAndExitProcess } from '../utils/errorhandling';\n\ntype OnFatalErrorHandler = (firstError: Error, secondError?: Error) => void;\n\ninterface OnUncaughtExceptionOptions {\n  /**\n   * Controls if the SDK should register a handler to exit the process on uncaught errors:\n   * - `true`: The SDK will exit the process on all uncaught errors.\n   * - `false`: The SDK will only exit the process when there are no other `uncaughtException` handlers attached.\n   *\n   * Default: `false`\n   */\n  exitEvenIfOtherHandlersAreRegistered: boolean;\n\n  /**\n   * This is called when an uncaught error would cause the process to exit.\n   *\n   * @param firstError Uncaught error causing the process to exit\n   * @param secondError Will be set if the handler was called multiple times. This can happen either because\n   * `onFatalError` itself threw, or because an independent error happened somewhere else while `onFatalError`\n   * was running.\n   */\n  onFatalError?(this: void, firstError: Error, secondError?: Error): void;\n}\n\nconst INTEGRATION_NAME = 'OnUncaughtException' as const;\n\n/**\n * Add a global exception handler.\n */\nexport const onUncaughtExceptionIntegration = defineIntegration((options: Partial<OnUncaughtExceptionOptions> = {}) => {\n  const optionsWithDefaults = {\n    exitEvenIfOtherHandlersAreRegistered: false,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client: NodeClient) {\n      // errors in worker threads are already handled by the childProcessIntegration\n      // also we don't want to exit the Node process on worker thread errors\n      if (!isMainThread) {\n        return;\n      }\n\n      global.process.on('uncaughtException', makeErrorHandler(client, optionsWithDefaults));\n    },\n  };\n});\n\ntype ErrorHandler = { _errorHandler: boolean } & ((error: Error) => void);\n\n/** Exported only for tests */\nexport function makeErrorHandler(client: NodeClient, options: OnUncaughtExceptionOptions): ErrorHandler {\n  const timeout = 2000;\n  let caughtFirstError: boolean = false;\n  let caughtSecondError: boolean = false;\n  let calledFatalError: boolean = false;\n  let firstError: Error;\n\n  const clientOptions = client.getOptions();\n\n  return Object.assign(\n    (error: Error): void => {\n      let onFatalError: OnFatalErrorHandler = logAndExitProcess;\n\n      if (options.onFatalError) {\n        onFatalError = options.onFatalError;\n      } else if (clientOptions.onFatalError) {\n        onFatalError = clientOptions.onFatalError;\n      }\n\n      // Attaching a listener to `uncaughtException` will prevent the node process from exiting. We generally do not\n      // want to alter this behaviour so we check for other listeners that users may have attached themselves and adjust\n      // exit behaviour of the SDK accordingly:\n      // - If other listeners are attached, do not exit.\n      // - If the only listener attached is ours, exit.\n      const userProvidedListenersCount = global.process.listeners('uncaughtException').filter(listener => {\n        // There are 3 listeners we ignore:\n        return (\n          // as soon as we're using domains this listener is attached by node itself\n          listener.name !== 'domainUncaughtExceptionClear' &&\n          // the handler we register in this integration\n          (listener as ErrorHandler)._errorHandler !== true\n        );\n      }).length;\n\n      const processWouldExit = userProvidedListenersCount === 0;\n      const shouldApplyFatalHandlingLogic = options.exitEvenIfOtherHandlersAreRegistered || processWouldExit;\n\n      if (!caughtFirstError) {\n        // this is the first uncaught error and the ultimate reason for shutting down\n        // we want to do absolutely everything possible to ensure it gets captured\n        // also we want to make sure we don't go recursion crazy if more errors happen after this one\n        firstError = error;\n        caughtFirstError = true;\n\n        if (getClient() === client) {\n          captureException(error, {\n            originalException: error,\n            captureContext: {\n              level: 'fatal',\n            },\n            mechanism: {\n              handled: false,\n              type: 'auto.node.onuncaughtexception',\n            },\n          });\n        }\n\n        if (!calledFatalError && shouldApplyFatalHandlingLogic) {\n          calledFatalError = true;\n          onFatalError(error);\n        }\n      } else {\n        if (shouldApplyFatalHandlingLogic) {\n          if (calledFatalError) {\n            // we hit an error *after* calling onFatalError - pretty boned at this point, just shut it down\n            DEBUG_BUILD &&\n              debug.warn(\n                'uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown',\n              );\n            logAndExitProcess(error);\n          } else if (!caughtSecondError) {\n            // two cases for how we can hit this branch:\n            //   - capturing of first error blew up and we just caught the exception from that\n            //     - quit trying to capture, proceed with shutdown\n            //   - a second independent error happened while waiting for first error to capture\n            //     - want to avoid causing premature shutdown before first error capture finishes\n            // it's hard to immediately tell case 1 from case 2 without doing some fancy/questionable domain stuff\n            // so let's instead just delay a bit before we proceed with our action here\n            // in case 1, we just wait a bit unnecessarily but ultimately do the same thing\n            // in case 2, the delay hopefully made us wait long enough for the capture to finish\n            // two potential nonideal outcomes:\n            //   nonideal case 1: capturing fails fast, we sit around for a few seconds unnecessarily before proceeding correctly by calling onFatalError\n            //   nonideal case 2: case 2 happens, 1st error is captured but slowly, timeout completes before capture and we treat second error as the sendErr of (nonexistent) failure from trying to capture first error\n            // note that after hitting this branch, we might catch more errors where (caughtSecondError && !calledFatalError)\n            //   we ignore them - they don't matter to us, we're just waiting for the second error timeout to finish\n            caughtSecondError = true;\n            setTimeout(() => {\n              if (!calledFatalError) {\n                // it was probably case 1, let's treat err as the sendErr and call onFatalError\n                calledFatalError = true;\n                onFatalError(firstError, error);\n              } else {\n                // it was probably case 2, our first error finished capturing while we waited, cool, do nothing\n              }\n            }, timeout); // capturing could take at least sendTimeout to fail, plus an arbitrary second for how long it takes to collect surrounding source etc\n          }\n        }\n      }\n    },\n    { _errorHandler: true },\n  );\n}\n"],"names":["defineIntegration","isMainThread","logAndExitProcess","getClient","captureException","DEBUG_BUILD","debug"],"mappings":"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"}

package/build/cjs/integrations/onunhandledrejection.js

@@ -0,0 +1,94 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const errorhandling = require('../utils/errorhandling.js');
+
+const INTEGRATION_NAME = "OnUnhandledRejection";
+const DEFAULT_IGNORES = [
+  {
+    name: "AI_NoOutputGeneratedError"
+    // When stream aborts in Vercel AI SDK V5, Vercel flush() fails with an error
+  },
+  {
+    name: "AbortError"
+    // When stream aborts in Vercel AI SDK V6
+  }
+];
+const _onUnhandledRejectionIntegration = ((options = {}) => {
+  const opts = {
+    mode: options.mode ?? "warn",
+    ignore: [...DEFAULT_IGNORES, ...options.ignore ?? []]
+  };
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      global.process.on("unhandledRejection", makeUnhandledPromiseHandler(client, opts));
+    }
+  };
+});
+const onUnhandledRejectionIntegration = core.defineIntegration(_onUnhandledRejectionIntegration);
+function extractErrorInfo(reason) {
+  if (!core.isObjectLike(reason)) {
+    return { name: "", message: String(reason ?? "") };
+  }
+  const errorLike = reason;
+  const name = typeof errorLike.name === "string" ? errorLike.name : "";
+  const message = typeof errorLike.message === "string" ? errorLike.message : String(reason);
+  return { name, message };
+}
+function isMatchingReason(matcher, errorInfo) {
+  const nameMatches = matcher.name === void 0 || core.isMatchingPattern(errorInfo.name, matcher.name, true);
+  const messageMatches = matcher.message === void 0 || core.isMatchingPattern(errorInfo.message, matcher.message);
+  return nameMatches && messageMatches;
+}
+function matchesIgnore(list, reason) {
+  const errorInfo = extractErrorInfo(reason);
+  return list.some((matcher) => isMatchingReason(matcher, errorInfo));
+}
+function makeUnhandledPromiseHandler(client, options) {
+  return function sendUnhandledPromise(reason, _promise) {
+    if (core.getClient() !== client) {
+      return;
+    }
+    if (matchesIgnore(options.ignore ?? [], reason)) {
+      return;
+    }
+    const level = options.mode === "strict" ? "fatal" : "error";
+    const activeSpanForError = core.isObjectLike(reason) ? reason._sentry_active_span : void 0;
+    const activeSpanWrapper = activeSpanForError ? (fn) => core.withActiveSpan(activeSpanForError, fn) : (fn) => fn();
+    activeSpanWrapper(() => {
+      core.captureException(reason, {
+        originalException: reason,
+        captureContext: {
+          extra: { unhandledPromiseRejection: true },
+          level
+        },
+        mechanism: {
+          handled: false,
+          type: "auto.node.onunhandledrejection"
+        }
+      });
+    });
+    handleRejection(reason, options.mode);
+  };
+}
+function handleRejection(reason, mode) {
+  const rejectionWarning = "This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason:";
+  if (mode === "warn") {
+    core.consoleSandbox(() => {
+      console.warn(rejectionWarning);
+      console.error(core.isObjectLike(reason) && "stack" in reason ? reason.stack : reason);
+    });
+  } else if (mode === "strict") {
+    if (!(core.isObjectLike(reason) && "stack" in reason)) {
+      core.consoleSandbox(() => {
+        console.warn(rejectionWarning);
+      });
+    }
+    errorhandling.logAndExitProcess(reason);
+  }
+}
+
+exports.makeUnhandledPromiseHandler = makeUnhandledPromiseHandler;
+exports.onUnhandledRejectionIntegration = onUnhandledRejectionIntegration;
+//# sourceMappingURL=onunhandledrejection.js.map

package/build/cjs/integrations/onunhandledrejection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onunhandledrejection.js","sources":["../../../src/integrations/onunhandledrejection.ts"],"sourcesContent":["import type { Client, IntegrationFn, SeverityLevel, Span } from '@sentry/core';\nimport {\n  captureException,\n  consoleSandbox,\n  defineIntegration,\n  getClient,\n  isMatchingPattern,\n  isObjectLike,\n  withActiveSpan,\n} from '@sentry/core';\nimport { logAndExitProcess } from '../utils/errorhandling';\n\ntype UnhandledRejectionMode = 'none' | 'warn' | 'strict';\n\ntype IgnoreMatcher = { name?: string | RegExp; message?: string | RegExp };\n\ninterface OnUnhandledRejectionOptions {\n  /**\n   * Option deciding what to do after capturing unhandledRejection,\n   * that mimicks behavior of node's --unhandled-rejection flag.\n   */\n  mode: UnhandledRejectionMode;\n  /** Rejection Errors to ignore (don't capture or warn). */\n  ignore?: IgnoreMatcher[];\n}\n\nconst INTEGRATION_NAME = 'OnUnhandledRejection';\n\nconst DEFAULT_IGNORES: IgnoreMatcher[] = [\n  {\n    name: 'AI_NoOutputGeneratedError', // When stream aborts in Vercel AI SDK V5, Vercel flush() fails with an error\n  },\n  {\n    name: 'AbortError', // When stream aborts in Vercel AI SDK V6\n  },\n];\n\nconst _onUnhandledRejectionIntegration = ((options: Partial<OnUnhandledRejectionOptions> = {}) => {\n  const opts: OnUnhandledRejectionOptions = {\n    mode: options.mode ?? 'warn',\n    ignore: [...DEFAULT_IGNORES, ...(options.ignore ?? [])],\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      global.process.on('unhandledRejection', makeUnhandledPromiseHandler(client, opts));\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const onUnhandledRejectionIntegration = defineIntegration(_onUnhandledRejectionIntegration);\n\n/** Extract error info safely */\nfunction extractErrorInfo(reason: unknown): { name: string; message: string } {\n  // Check if reason is an object (including Error instances, not just plain objects)\n  if (!isObjectLike(reason)) {\n    return { name: '', message: String(reason ?? '') };\n  }\n\n  const errorLike = reason as Record<string, unknown>;\n  const name = typeof errorLike.name === 'string' ? errorLike.name : '';\n  const message = typeof errorLike.message === 'string' ? errorLike.message : String(reason);\n\n  return { name, message };\n}\n\n/** Check if a matcher matches the reason */\nfunction isMatchingReason(matcher: IgnoreMatcher, errorInfo: ReturnType<typeof extractErrorInfo>): boolean {\n  // name/message matcher\n  const nameMatches = matcher.name === undefined || isMatchingPattern(errorInfo.name, matcher.name, true);\n\n  const messageMatches = matcher.message === undefined || isMatchingPattern(errorInfo.message, matcher.message);\n\n  return nameMatches && messageMatches;\n}\n\n/** Match helper */\nfunction matchesIgnore(list: IgnoreMatcher[], reason: unknown): boolean {\n  const errorInfo = extractErrorInfo(reason);\n  return list.some(matcher => isMatchingReason(matcher, errorInfo));\n}\n\n/** Core handler */\nexport function makeUnhandledPromiseHandler(\n  client: Client,\n  options: OnUnhandledRejectionOptions,\n): (reason: unknown, promise: unknown) => void {\n  return function sendUnhandledPromise(reason: unknown, _promise: unknown): void {\n    // Only handle for the active client\n    if (getClient() !== client) {\n      return;\n    }\n\n    // Skip if configured to ignore\n    if (matchesIgnore(options.ignore ?? [], reason)) {\n      return;\n    }\n\n    const level: SeverityLevel = options.mode === 'strict' ? 'fatal' : 'error';\n\n    // this can be set in places where we cannot reliably get access to the active span/error\n    // when the error bubbles up to this handler, we can use this to set the active span\n    const activeSpanForError = isObjectLike(reason)\n      ? (reason as { _sentry_active_span?: Span })._sentry_active_span\n      : undefined;\n\n    const activeSpanWrapper = activeSpanForError\n      ? (fn: () => void) => withActiveSpan(activeSpanForError, fn)\n      : (fn: () => void) => fn();\n\n    activeSpanWrapper(() => {\n      captureException(reason, {\n        originalException: reason,\n        captureContext: {\n          extra: { unhandledPromiseRejection: true },\n          level,\n        },\n        mechanism: {\n          handled: false,\n          type: 'auto.node.onunhandledrejection',\n        },\n      });\n    });\n\n    handleRejection(reason, options.mode);\n  };\n}\n\n/**\n * Handler for `mode` option\n */\nfunction handleRejection(reason: unknown, mode: UnhandledRejectionMode): void {\n  // https://github.com/nodejs/node/blob/7cf6f9e964aa00772965391c23acda6d71972a9a/lib/internal/process/promises.js#L234-L240\n  const rejectionWarning =\n    'This error originated either by ' +\n    'throwing inside of an async function without a catch block, ' +\n    'or by rejecting a promise which was not handled with .catch().' +\n    ' The promise rejected with the reason:';\n\n  /* eslint-disable no-console */\n  if (mode === 'warn') {\n    consoleSandbox(() => {\n      console.warn(rejectionWarning);\n      console.error(isObjectLike(reason) && 'stack' in reason ? reason.stack : reason);\n    });\n  } else if (mode === 'strict') {\n    if (!(isObjectLike(reason) && 'stack' in reason)) {\n      consoleSandbox(() => {\n        console.warn(rejectionWarning);\n      });\n    }\n    logAndExitProcess(reason);\n  }\n  /* eslint-enable no-console */\n}\n"],"names":["defineIntegration","isObjectLike","isMatchingPattern","getClient","withActiveSpan","captureException","consoleSandbox","logAndExitProcess"],"mappings":";;;;;AA0BA,MAAM,gBAAA,GAAmB,sBAAA;AAEzB,MAAM,eAAA,GAAmC;AAAA,EACvC;AAAA,IACE,IAAA,EAAM;AAAA;AAAA,GACR;AAAA,EACA;AAAA,IACE,IAAA,EAAM;AAAA;AAAA;AAEV,CAAA;AAEA,MAAM,gCAAA,IAAoC,CAAC,OAAA,GAAgD,EAAC,KAAM;AAChG,EAAA,MAAM,IAAA,GAAoC;AAAA,IACxC,IAAA,EAAM,QAAQ,IAAA,IAAQ,MAAA;AAAA,IACtB,MAAA,EAAQ,CAAC,GAAG,eAAA,EAAiB,GAAI,OAAA,CAAQ,MAAA,IAAU,EAAG;AAAA,GACxD;AAEA,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,MAAM,MAAA,EAAQ;AACZ,MAAA,MAAA,CAAO,QAAQ,EAAA,CAAG,oBAAA,EAAsB,2BAAA,CAA4B,MAAA,EAAQ,IAAI,CAAC,CAAA;AAAA,IACnF;AAAA,GACF;AACF,CAAA,CAAA;AAEO,MAAM,+BAAA,GAAkCA,uBAAkB,gCAAgC;AAGjG,SAAS,iBAAiB,MAAA,EAAoD;AAE5E,EAAA,IAAI,CAACC,iBAAA,CAAa,MAAM,CAAA,EAAG;AACzB,IAAA,OAAO,EAAE,IAAA,EAAM,EAAA,EAAI,SAAS,MAAA,CAAO,MAAA,IAAU,EAAE,CAAA,EAAE;AAAA,EACnD;AAEA,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,MAAM,OAAO,OAAO,SAAA,CAAU,IAAA,KAAS,QAAA,GAAW,UAAU,IAAA,GAAO,EAAA;AACnE,EAAA,MAAM,OAAA,GAAU,OAAO,SAAA,CAAU,OAAA,KAAY,WAAW,SAAA,CAAU,OAAA,GAAU,OAAO,MAAM,CAAA;AAEzF,EAAA,OAAO,EAAE,MAAM,OAAA,EAAQ;AACzB;AAGA,SAAS,gBAAA,CAAiB,SAAwB,SAAA,EAAyD;AAEzG,EAAA,MAAM,WAAA,GAAc,QAAQ,IAAA,KAAS,MAAA,IAAaC,uBAAkB,SAAA,CAAU,IAAA,EAAM,OAAA,CAAQ,IAAA,EAAM,IAAI,CAAA;AAEtG,EAAA,MAAM,cAAA,GAAiB,QAAQ,OAAA,KAAY,MAAA,IAAaA,uBAAkB,SAAA,CAAU,OAAA,EAAS,QAAQ,OAAO,CAAA;AAE5G,EAAA,OAAO,WAAA,IAAe,cAAA;AACxB;AAGA,SAAS,aAAA,CAAc,MAAuB,MAAA,EAA0B;AACtE,EAAA,MAAM,SAAA,GAAY,iBAAiB,MAAM,CAAA;AACzC,EAAA,OAAO,KAAK,IAAA,CAAK,CAAA,OAAA,KAAW,gBAAA,CAAiB,OAAA,EAAS,SAAS,CAAC,CAAA;AAClE;AAGO,SAAS,2BAAA,CACd,QACA,OAAA,EAC6C;AAC7C,EAAA,OAAO,SAAS,oBAAA,CAAqB,MAAA,EAAiB,QAAA,EAAyB;AAE7E,IAAA,IAAIC,cAAA,OAAgB,MAAA,EAAQ;AAC1B,MAAA;AAAA,IACF;AAGA,IAAA,IAAI,cAAc,OAAA,CAAQ,MAAA,IAAU,EAAC,EAAG,MAAM,CAAA,EAAG;AAC/C,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,KAAA,GAAuB,OAAA,CAAQ,IAAA,KAAS,QAAA,GAAW,OAAA,GAAU,OAAA;AAInE,IAAA,MAAM,kBAAA,GAAqBF,iBAAA,CAAa,MAAM,CAAA,GACzC,OAA0C,mBAAA,GAC3C,MAAA;AAEJ,IAAA,MAAM,iBAAA,GAAoB,kBAAA,GACtB,CAAC,EAAA,KAAmBG,mBAAA,CAAe,oBAAoB,EAAE,CAAA,GACzD,CAAC,EAAA,KAAmB,EAAA,EAAG;AAE3B,IAAA,iBAAA,CAAkB,MAAM;AACtB,MAAAC,qBAAA,CAAiB,MAAA,EAAQ;AAAA,QACvB,iBAAA,EAAmB,MAAA;AAAA,QACnB,cAAA,EAAgB;AAAA,UACd,KAAA,EAAO,EAAE,yBAAA,EAA2B,IAAA,EAAK;AAAA,UACzC;AAAA,SACF;AAAA,QACA,SAAA,EAAW;AAAA,UACT,OAAA,EAAS,KAAA;AAAA,UACT,IAAA,EAAM;AAAA;AACR,OACD,CAAA;AAAA,IACH,CAAC,CAAA;AAED,IAAA,eAAA,CAAgB,MAAA,EAAQ,QAAQ,IAAI,CAAA;AAAA,EACtC,CAAA;AACF;AAKA,SAAS,eAAA,CAAgB,QAAiB,IAAA,EAAoC;AAE5E,EAAA,MAAM,gBAAA,GACJ,kMAAA;AAMF,EAAA,IAAI,SAAS,MAAA,EAAQ;AACnB,IAAAC,mBAAA,CAAe,MAAM;AACnB,MAAA,OAAA,CAAQ,KAAK,gBAAgB,CAAA;AAC7B,MAAA,OAAA,CAAQ,KAAA,CAAML,kBAAa,MAAM,CAAA,IAAK,WAAW,MAAA,GAAS,MAAA,CAAO,QAAQ,MAAM,CAAA;AAAA,IACjF,CAAC,CAAA;AAAA,EACH,CAAA,MAAA,IAAW,SAAS,QAAA,EAAU;AAC5B,IAAA,IAAI,EAAEA,iBAAA,CAAa,MAAM,CAAA,IAAK,WAAW,MAAA,CAAA,EAAS;AAChD,MAAAK,mBAAA,CAAe,MAAM;AACnB,QAAA,OAAA,CAAQ,KAAK,gBAAgB,CAAA;AAAA,MAC/B,CAAC,CAAA;AAAA,IACH;AACA,IAAAC,+BAAA,CAAkB,MAAM,CAAA;AAAA,EAC1B;AAEF;;;;;"}

package/build/cjs/integrations/pino.js

@@ -0,0 +1,115 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const serverUtils = require('@sentry/server-utils');
+
+const SENTRY_TRACK_SYMBOL = /* @__PURE__ */ Symbol("sentry-track-pino-logger");
+function getPinoKey(logger, symbolName, defaultKey) {
+  const symbols = Object.getOwnPropertySymbols(logger);
+  const symbolString = `Symbol(${symbolName})`;
+  for (const sym of symbols) {
+    if (sym.toString() === symbolString) {
+      const value = logger[sym];
+      return typeof value === "string" ? value : defaultKey;
+    }
+  }
+  return defaultKey;
+}
+const DEFAULT_OPTIONS = {
+  error: { levels: [], handled: true },
+  log: { levels: ["trace", "debug", "info", "warn", "error", "fatal"] }
+};
+function stripIgnoredFields(result) {
+  const { level, time, pid, hostname, ...rest } = result;
+  return rest;
+}
+const _pinoIntegration = core.defineIntegration((userOptions = {}) => {
+  const options = {
+    autoInstrument: userOptions.autoInstrument !== false,
+    error: { ...DEFAULT_OPTIONS.error, ...userOptions.error },
+    log: { ...DEFAULT_OPTIONS.log, ...userOptions.log }
+  };
+  function shouldTrackLogger(logger) {
+    const override = logger[SENTRY_TRACK_SYMBOL];
+    return override === "track" || override !== "ignore" && options.autoInstrument;
+  }
+  return {
+    name: "Pino",
+    setup: () => {
+      const integratedChannel = serverUtils.diagnosticsTracingChannel("pino_asJson");
+      function onPinoStart(self, args, result) {
+        if (!shouldTrackLogger(self)) {
+          return;
+        }
+        const resultObj = stripIgnoredFields(result);
+        const [captureObj, message, levelNumber] = args;
+        const level = self?.levels?.labels?.[levelNumber] || "info";
+        const messageKey = getPinoKey(self, "pino.messageKey", "msg");
+        const logMessage = message || resultObj?.[messageKey] || "";
+        if (options.log.levels.includes(level)) {
+          const attributes = {
+            ...resultObj,
+            "sentry.origin": "auto.log.pino",
+            "pino.logger.level": levelNumber
+          };
+          core._INTERNAL_captureLog({ level, message: logMessage, attributes });
+        }
+        if (options.error.levels.includes(level)) {
+          const errorKey = getPinoKey(self, "pino.errorKey", "err");
+          const pinoContext = {};
+          for (const [key, value] of Object.entries(resultObj)) {
+            if (key !== errorKey && key !== messageKey) {
+              pinoContext[key] = value;
+            }
+          }
+          if (logMessage) {
+            pinoContext[messageKey] = logMessage;
+          }
+          const captureContext = {
+            level: core.severityLevelFromString(level),
+            contexts: { pino: pinoContext }
+          };
+          core.withScope((scope) => {
+            scope.addEventProcessor((event) => {
+              event.logger = "pino";
+              core.addExceptionMechanism(event, {
+                handled: options.error.handled,
+                type: "auto.log.pino"
+              });
+              return event;
+            });
+            const error = captureObj[errorKey];
+            if (error) {
+              core.captureException(error, captureContext);
+              return;
+            }
+            core.captureMessage(logMessage, captureContext);
+          });
+        }
+      }
+      integratedChannel.end.subscribe((data) => {
+        const {
+          instance,
+          arguments: args,
+          result
+        } = data;
+        onPinoStart(instance, args, JSON.parse(result));
+      });
+    }
+  };
+});
+const pinoIntegration = Object.assign(_pinoIntegration, {
+  trackLogger(logger) {
+    if (core.isObjectLike(logger) && "levels" in logger) {
+      logger[SENTRY_TRACK_SYMBOL] = "track";
+    }
+  },
+  untrackLogger(logger) {
+    if (core.isObjectLike(logger) && "levels" in logger) {
+      logger[SENTRY_TRACK_SYMBOL] = "ignore";
+    }
+  }
+});
+
+exports.pinoIntegration = pinoIntegration;
+//# sourceMappingURL=pino.js.map

package/build/cjs/integrations/pino.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.js","sources":["../../../src/integrations/pino.ts"],"sourcesContent":["import type { IntegrationFn, LogSeverityLevel } from '@sentry/core';\nimport {\n  _INTERNAL_captureLog,\n  addExceptionMechanism,\n  captureException,\n  captureMessage,\n  defineIntegration,\n  isObjectLike,\n  severityLevelFromString,\n  withScope,\n} from '@sentry/core';\nimport { diagnosticsTracingChannel } from '@sentry/server-utils';\n\nconst SENTRY_TRACK_SYMBOL = Symbol('sentry-track-pino-logger');\n\ntype LevelMapping = {\n  // Fortunately pino uses the same levels as Sentry\n  labels: { [level: number]: LogSeverityLevel };\n};\n\ntype Pino = {\n  [key: symbol]: unknown;\n  levels: LevelMapping;\n  [SENTRY_TRACK_SYMBOL]?: 'track' | 'ignore';\n};\n\n/**\n * Gets a custom Pino key from a logger instance by searching for the symbol.\n * Pino uses non-global symbols like Symbol('pino.messageKey'): https://github.com/pinojs/pino/blob/8a816c0b1f72de5ae9181f3bb402109b66f7d812/lib/symbols.js\n */\nfunction getPinoKey(logger: Pino, symbolName: string, defaultKey: string): string {\n  const symbols = Object.getOwnPropertySymbols(logger);\n  const symbolString = `Symbol(${symbolName})`;\n  for (const sym of symbols) {\n    if (sym.toString() === symbolString) {\n      const value = logger[sym];\n      return typeof value === 'string' ? value : defaultKey;\n    }\n  }\n  return defaultKey;\n}\n\ntype MergeObject = {\n  [key: string]: unknown;\n  err?: Error;\n};\n\ntype PinoHookArgs = [MergeObject, string, number];\n\ntype PinoOptions = {\n  /**\n   * Automatically instrument all Pino loggers.\n   *\n   * When set to `false`, only loggers marked with `pinoIntegration.trackLogger(logger)` will be captured.\n   *\n   * @default true\n   */\n  autoInstrument: boolean;\n  /**\n   * Options to enable capturing of error events.\n   */\n  error: {\n    /**\n     * Levels that trigger capturing of events.\n     *\n     * @default []\n     */\n    levels: LogSeverityLevel[];\n    /**\n     * By default, Sentry will mark captured errors as handled.\n     * Set this to `false` if you want to mark them as unhandled instead.\n     *\n     * @default true\n     */\n    handled: boolean;\n  };\n  /**\n   * Options to enable capturing of logs.\n   */\n  log: {\n    /**\n     * Levels that trigger capturing of logs.\n     *\n     * @default [\"trace\", \"debug\", \"info\", \"warn\", \"error\", \"fatal\"]\n     */\n    levels: LogSeverityLevel[];\n  };\n};\n\nconst DEFAULT_OPTIONS: PinoOptions = {\n  autoInstrument: true,\n  error: { levels: [], handled: true },\n  log: { levels: ['trace', 'debug', 'info', 'warn', 'error', 'fatal'] },\n};\n\ntype DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object ? Partial<T[P]> : T[P];\n};\n\ntype PinoResult = {\n  level?: string;\n  time?: string;\n  pid?: number;\n  hostname?: string;\n} & Record<string, unknown>;\n\nfunction stripIgnoredFields(result: PinoResult): PinoResult {\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const { level, time, pid, hostname, ...rest } = result;\n  return rest;\n}\n\nconst _pinoIntegration = defineIntegration((userOptions: DeepPartial<PinoOptions> = {}) => {\n  const options: PinoOptions = {\n    autoInstrument: userOptions.autoInstrument !== false,\n    error: { ...DEFAULT_OPTIONS.error, ...userOptions.error },\n    log: { ...DEFAULT_OPTIONS.log, ...userOptions.log },\n  };\n\n  function shouldTrackLogger(logger: Pino): boolean {\n    const override = logger[SENTRY_TRACK_SYMBOL];\n    return override === 'track' || (override !== 'ignore' && options.autoInstrument);\n  }\n\n  return {\n    name: 'Pino',\n    setup: () => {\n      const integratedChannel = diagnosticsTracingChannel('pino_asJson');\n\n      function onPinoStart(self: Pino, args: PinoHookArgs, result: PinoResult): void {\n        if (!shouldTrackLogger(self)) {\n          return;\n        }\n\n        const resultObj = stripIgnoredFields(result);\n\n        const [captureObj, message, levelNumber] = args;\n        const level = self?.levels?.labels?.[levelNumber] || 'info';\n        const messageKey = getPinoKey(self, 'pino.messageKey', 'msg');\n        const logMessage = message || (resultObj?.[messageKey] as string | undefined) || '';\n\n        if (options.log.levels.includes(level)) {\n          const attributes: Record<string, unknown> = {\n            ...resultObj,\n            'sentry.origin': 'auto.log.pino',\n            'pino.logger.level': levelNumber,\n          };\n\n          _INTERNAL_captureLog({ level, message: logMessage, attributes });\n        }\n\n        if (options.error.levels.includes(level)) {\n          const errorKey = getPinoKey(self, 'pino.errorKey', 'err');\n\n          // Attach the log message and remaining log fields (e.g. child logger\n          // bindings, merge object fields) to the event. The serialized error is\n          // excluded since it is captured as the event exception itself.\n          const pinoContext: Record<string, unknown> = {};\n          for (const [key, value] of Object.entries(resultObj)) {\n            if (key !== errorKey && key !== messageKey) {\n              pinoContext[key] = value;\n            }\n          }\n          if (logMessage) {\n            pinoContext[messageKey] = logMessage;\n          }\n\n          const captureContext = {\n            level: severityLevelFromString(level),\n            contexts: { pino: pinoContext },\n          };\n\n          withScope(scope => {\n            scope.addEventProcessor(event => {\n              event.logger = 'pino';\n\n              addExceptionMechanism(event, {\n                handled: options.error.handled,\n                type: 'auto.log.pino',\n              });\n\n              return event;\n            });\n\n            const error = captureObj[errorKey];\n            if (error) {\n              captureException(error, captureContext);\n              return;\n            }\n\n            captureMessage(logMessage, captureContext);\n          });\n        }\n      }\n\n      integratedChannel.end.subscribe(data => {\n        const {\n          instance,\n          arguments: args,\n          result,\n        } = data as { instance: Pino; arguments: PinoHookArgs; result: string };\n        onPinoStart(instance, args, JSON.parse(result));\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Integration for Pino logging library.\n * Captures Pino logs as Sentry logs and optionally captures some log levels as events.\n *\n * By default, all Pino loggers will be captured. To ignore a specific logger, use `pinoIntegration.untrackLogger(logger)`.\n *\n * If you disable automatic instrumentation with `autoInstrument: false`, you can mark specific loggers to be tracked with `pinoIntegration.trackLogger(logger)`.\n *\n * Requires Pino >=v8.0.0\n */\nexport const pinoIntegration = Object.assign(_pinoIntegration, {\n  trackLogger(logger: unknown): void {\n    if (isObjectLike(logger) && 'levels' in logger) {\n      (logger as Pino)[SENTRY_TRACK_SYMBOL] = 'track';\n    }\n  },\n  untrackLogger(logger: unknown): void {\n    if (isObjectLike(logger) && 'levels' in logger) {\n      (logger as Pino)[SENTRY_TRACK_SYMBOL] = 'ignore';\n    }\n  },\n});\n"],"names":["defineIntegration","diagnosticsTracingChannel","_INTERNAL_captureLog","severityLevelFromString","withScope","addExceptionMechanism","captureException","captureMessage","isObjectLike"],"mappings":";;;;;AAaA,MAAM,mBAAA,0BAA6B,0BAA0B,CAAA;AAiB7D,SAAS,UAAA,CAAW,MAAA,EAAc,UAAA,EAAoB,UAAA,EAA4B;AAChF,EAAA,MAAM,OAAA,GAAU,MAAA,CAAO,qBAAA,CAAsB,MAAM,CAAA;AACnD,EAAA,MAAM,YAAA,GAAe,UAAU,UAAU,CAAA,CAAA,CAAA;AACzC,EAAA,KAAA,MAAW,OAAO,OAAA,EAAS;AACzB,IAAA,IAAI,GAAA,CAAI,QAAA,EAAS,KAAM,YAAA,EAAc;AACnC,MAAA,MAAM,KAAA,GAAQ,OAAO,GAAG,CAAA;AACxB,MAAA,OAAO,OAAO,KAAA,KAAU,QAAA,GAAW,KAAA,GAAQ,UAAA;AAAA,IAC7C;AAAA,EACF;AACA,EAAA,OAAO,UAAA;AACT;AAiDA,MAAM,eAAA,GAA+B;AAAA,EAEnC,OAAO,EAAE,MAAA,EAAQ,EAAC,EAAG,SAAS,IAAA,EAAK;AAAA,EACnC,GAAA,EAAK,EAAE,MAAA,EAAQ,CAAC,OAAA,EAAS,SAAS,MAAA,EAAQ,MAAA,EAAQ,OAAA,EAAS,OAAO,CAAA;AACpE,CAAA;AAaA,SAAS,mBAAmB,MAAA,EAAgC;AAE1D,EAAA,MAAM,EAAE,KAAA,EAAO,IAAA,EAAM,KAAK,QAAA,EAAU,GAAG,MAAK,GAAI,MAAA;AAChD,EAAA,OAAO,IAAA;AACT;AAEA,MAAM,gBAAA,GAAmBA,sBAAA,CAAkB,CAAC,WAAA,GAAwC,EAAC,KAAM;AACzF,EAAA,MAAM,OAAA,GAAuB;AAAA,IAC3B,cAAA,EAAgB,YAAY,cAAA,KAAmB,KAAA;AAAA,IAC/C,OAAO,EAAE,GAAG,gBAAgB,KAAA,EAAO,GAAG,YAAY,KAAA,EAAM;AAAA,IACxD,KAAK,EAAE,GAAG,gBAAgB,GAAA,EAAK,GAAG,YAAY,GAAA;AAAI,GACpD;AAEA,EAAA,SAAS,kBAAkB,MAAA,EAAuB;AAChD,IAAA,MAAM,QAAA,GAAW,OAAO,mBAAmB,CAAA;AAC3C,IAAA,OAAO,QAAA,KAAa,OAAA,IAAY,QAAA,KAAa,QAAA,IAAY,OAAA,CAAQ,cAAA;AAAA,EACnE;AAEA,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,MAAA;AAAA,IACN,OAAO,MAAM;AACX,MAAA,MAAM,iBAAA,GAAoBC,sCAA0B,aAAa,CAAA;AAEjE,MAAA,SAAS,WAAA,CAAY,IAAA,EAAY,IAAA,EAAoB,MAAA,EAA0B;AAC7E,QAAA,IAAI,CAAC,iBAAA,CAAkB,IAAI,CAAA,EAAG;AAC5B,UAAA;AAAA,QACF;AAEA,QAAA,MAAM,SAAA,GAAY,mBAAmB,MAAM,CAAA;AAE3C,QAAA,MAAM,CAAC,UAAA,EAAY,OAAA,EAAS,WAAW,CAAA,GAAI,IAAA;AAC3C,QAAA,MAAM,KAAA,GAAQ,IAAA,EAAM,MAAA,EAAQ,MAAA,GAAS,WAAW,CAAA,IAAK,MAAA;AACrD,QAAA,MAAM,UAAA,GAAa,UAAA,CAAW,IAAA,EAAM,iBAAA,EAAmB,KAAK,CAAA;AAC5D,QAAA,MAAM,UAAA,GAAa,OAAA,IAAY,SAAA,GAAY,UAAU,CAAA,IAA4B,EAAA;AAEjF,QAAA,IAAI,OAAA,CAAQ,GAAA,CAAI,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG;AACtC,UAAA,MAAM,UAAA,GAAsC;AAAA,YAC1C,GAAG,SAAA;AAAA,YACH,eAAA,EAAiB,eAAA;AAAA,YACjB,mBAAA,EAAqB;AAAA,WACvB;AAEA,UAAAC,yBAAA,CAAqB,EAAE,KAAA,EAAO,OAAA,EAAS,UAAA,EAAY,YAAY,CAAA;AAAA,QACjE;AAEA,QAAA,IAAI,OAAA,CAAQ,KAAA,CAAM,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG;AACxC,UAAA,MAAM,QAAA,GAAW,UAAA,CAAW,IAAA,EAAM,eAAA,EAAiB,KAAK,CAAA;AAKxD,UAAA,MAAM,cAAuC,EAAC;AAC9C,UAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,KAAK,MAAA,CAAO,OAAA,CAAQ,SAAS,CAAA,EAAG;AACpD,YAAA,IAAI,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,UAAA,EAAY;AAC1C,cAAA,WAAA,CAAY,GAAG,CAAA,GAAI,KAAA;AAAA,YACrB;AAAA,UACF;AACA,UAAA,IAAI,UAAA,EAAY;AACd,YAAA,WAAA,CAAY,UAAU,CAAA,GAAI,UAAA;AAAA,UAC5B;AAEA,UAAA,MAAM,cAAA,GAAiB;AAAA,YACrB,KAAA,EAAOC,6BAAwB,KAAK,CAAA;AAAA,YACpC,QAAA,EAAU,EAAE,IAAA,EAAM,WAAA;AAAY,WAChC;AAEA,UAAAC,cAAA,CAAU,CAAA,KAAA,KAAS;AACjB,YAAA,KAAA,CAAM,kBAAkB,CAAA,KAAA,KAAS;AAC/B,cAAA,KAAA,CAAM,MAAA,GAAS,MAAA;AAEf,cAAAC,0BAAA,CAAsB,KAAA,EAAO;AAAA,gBAC3B,OAAA,EAAS,QAAQ,KAAA,CAAM,OAAA;AAAA,gBACvB,IAAA,EAAM;AAAA,eACP,CAAA;AAED,cAAA,OAAO,KAAA;AAAA,YACT,CAAC,CAAA;AAED,YAAA,MAAM,KAAA,GAAQ,WAAW,QAAQ,CAAA;AACjC,YAAA,IAAI,KAAA,EAAO;AACT,cAAAC,qBAAA,CAAiB,OAAO,cAAc,CAAA;AACtC,cAAA;AAAA,YACF;AAEA,YAAAC,mBAAA,CAAe,YAAY,cAAc,CAAA;AAAA,UAC3C,CAAC,CAAA;AAAA,QACH;AAAA,MACF;AAEA,MAAA,iBAAA,CAAkB,GAAA,CAAI,UAAU,CAAA,IAAA,KAAQ;AACtC,QAAA,MAAM;AAAA,UACJ,QAAA;AAAA,UACA,SAAA,EAAW,IAAA;AAAA,UACX;AAAA,SACF,GAAI,IAAA;AACJ,QAAA,WAAA,CAAY,QAAA,EAAU,IAAA,EAAM,IAAA,CAAK,KAAA,CAAM,MAAM,CAAC,CAAA;AAAA,MAChD,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAC,CAAA;AAYM,MAAM,eAAA,GAAkB,MAAA,CAAO,MAAA,CAAO,gBAAA,EAAkB;AAAA,EAC7D,YAAY,MAAA,EAAuB;AACjC,IAAA,IAAIC,iBAAA,CAAa,MAAM,CAAA,IAAK,QAAA,IAAY,MAAA,EAAQ;AAC9C,MAAC,MAAA,CAAgB,mBAAmB,CAAA,GAAI,OAAA;AAAA,IAC1C;AAAA,EACF,CAAA;AAAA,EACA,cAAc,MAAA,EAAuB;AACnC,IAAA,IAAIA,iBAAA,CAAa,MAAM,CAAA,IAAK,QAAA,IAAY,MAAA,EAAQ;AAC9C,MAAC,MAAA,CAAgB,mBAAmB,CAAA,GAAI,QAAA;AAAA,IAC1C;AAAA,EACF;AACF,CAAC;;;;"}

package/build/cjs/integrations/processSession.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const INTEGRATION_NAME = "ProcessSession";
+const processSessionIntegration = core.defineIntegration(() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      core.startSession();
+      process.on("beforeExit", () => {
+        const session = core.getIsolationScope().getSession();
+        if (session?.status === "ok") {
+          core.endSession();
+        }
+      });
+    }
+  };
+});
+
+exports.processSessionIntegration = processSessionIntegration;
+//# sourceMappingURL=processSession.js.map

package/build/cjs/integrations/processSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"processSession.js","sources":["../../../src/integrations/processSession.ts"],"sourcesContent":["import { defineIntegration, endSession, getIsolationScope, startSession } from '@sentry/core';\n\nconst INTEGRATION_NAME = 'ProcessSession' as const;\n\n/**\n * Records a Session for the current process to track release health.\n */\nexport const processSessionIntegration = defineIntegration(() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      startSession();\n\n      // Emitted in the case of healthy sessions, error of `mechanism.handled: true` and unhandledrejections because\n      // The 'beforeExit' event is not emitted for conditions causing explicit termination,\n      // such as calling process.exit() or uncaught exceptions.\n      // Ref: https://nodejs.org/api/process.html#process_event_beforeexit\n      process.on('beforeExit', () => {\n        const session = getIsolationScope().getSession();\n\n        // Only call endSession if a Session exists on the Scope and has not already reached a\n        // Terminal Status, because \"When a session is moved away from ok it must not be updated\n        // anymore.\" `ok` is the only non-terminal status.\n        // Ref: https://develop.sentry.dev/sdk/sessions/\n        if (session?.status === 'ok') {\n          endSession();\n        }\n      });\n    },\n  };\n});\n"],"names":["defineIntegration","startSession","getIsolationScope","endSession"],"mappings":";;;;AAEA,MAAM,gBAAA,GAAmB,gBAAA;AAKlB,MAAM,yBAAA,GAA4BA,uBAAkB,MAAM;AAC/D,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAAC,iBAAA,EAAa;AAMb,MAAA,OAAA,CAAQ,EAAA,CAAG,cAAc,MAAM;AAC7B,QAAA,MAAM,OAAA,GAAUC,sBAAA,EAAkB,CAAE,UAAA,EAAW;AAM/C,QAAA,IAAI,OAAA,EAAS,WAAW,IAAA,EAAM;AAC5B,UAAAC,eAAA,EAAW;AAAA,QACb;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAC;;;;"}

package/build/cjs/integrations/spotlight.js

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const http = require('node:http');
+const core = require('@sentry/core');
+
+const INTEGRATION_NAME = "Spotlight";
+const _spotlightIntegration = ((options = {}) => {
+  const _options = {
+    sidecarUrl: options.sidecarUrl || "http://localhost:8969/stream"
+  };
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      try {
+        if (process.env.NODE_ENV && process.env.NODE_ENV !== "development") {
+          core.debug.warn("[Spotlight] It seems you're not in dev mode. Do you really want to have Spotlight enabled?");
+        }
+      } catch {
+      }
+      connectToSpotlight(client, _options);
+    }
+  };
+});
+const spotlightIntegration = core.defineIntegration(_spotlightIntegration);
+function connectToSpotlight(client, options) {
+  const spotlightUrl = parseSidecarUrl(options.sidecarUrl);
+  if (!spotlightUrl) {
+    return;
+  }
+  let failedRequests = 0;
+  client.on("beforeEnvelope", (envelope) => {
+    if (failedRequests > 3) {
+      core.debug.warn("[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests");
+      return;
+    }
+    const serializedEnvelope = core.serializeEnvelope(envelope);
+    core.suppressTracing(() => {
+      const req = http.request(
+        {
+          method: "POST",
+          path: spotlightUrl.pathname,
+          hostname: spotlightUrl.hostname,
+          port: spotlightUrl.port,
+          headers: {
+            "Content-Type": "application/x-sentry-envelope"
+          }
+        },
+        (res) => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
+            failedRequests = 0;
+          }
+          res.on("data", () => {
+          });
+          res.on("end", () => {
+          });
+          res.setEncoding("utf8");
+        }
+      );
+      req.on("error", () => {
+        failedRequests++;
+        core.debug.warn("[Spotlight] Failed to send envelope to Spotlight Sidecar");
+      });
+      req.write(serializedEnvelope);
+      req.end();
+    });
+  });
+}
+function parseSidecarUrl(url) {
+  try {
+    return new URL(`${url}`);
+  } catch {
+    core.debug.warn(`[Spotlight] Invalid sidecar URL: ${url}`);
+    return void 0;
+  }
+}
+
+exports.INTEGRATION_NAME = INTEGRATION_NAME;
+exports.spotlightIntegration = spotlightIntegration;
+//# sourceMappingURL=spotlight.js.map

package/build/cjs/integrations/spotlight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spotlight.js","sources":["../../../src/integrations/spotlight.ts"],"sourcesContent":["import * as http from 'node:http';\nimport type { Client, Envelope, IntegrationFn } from '@sentry/core';\nimport { debug, defineIntegration, serializeEnvelope, suppressTracing } from '@sentry/core';\n\ntype SpotlightConnectionOptions = {\n  /**\n   * Set this if the Spotlight Sidecar is not running on localhost:8969\n   * By default, the Url is set to http://localhost:8969/stream\n   */\n  sidecarUrl?: string;\n};\n\nexport const INTEGRATION_NAME = 'Spotlight' as const;\n\nconst _spotlightIntegration = ((options: Partial<SpotlightConnectionOptions> = {}) => {\n  const _options = {\n    sidecarUrl: options.sidecarUrl || 'http://localhost:8969/stream',\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      try {\n        if (process.env.NODE_ENV && process.env.NODE_ENV !== 'development') {\n          debug.warn(\"[Spotlight] It seems you're not in dev mode. Do you really want to have Spotlight enabled?\");\n        }\n      } catch {\n        // ignore\n      }\n      connectToSpotlight(client, _options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Use this integration to send errors and transactions to Spotlight.\n *\n * Learn more about spotlight at https://spotlightjs.com\n */\nexport const spotlightIntegration = defineIntegration(_spotlightIntegration);\n\nfunction connectToSpotlight(client: Client, options: Required<SpotlightConnectionOptions>): void {\n  const spotlightUrl = parseSidecarUrl(options.sidecarUrl);\n  if (!spotlightUrl) {\n    return;\n  }\n\n  let failedRequests = 0;\n\n  client.on('beforeEnvelope', (envelope: Envelope) => {\n    if (failedRequests > 3) {\n      debug.warn('[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests');\n      return;\n    }\n\n    const serializedEnvelope = serializeEnvelope(envelope);\n    suppressTracing(() => {\n      const req = http.request(\n        {\n          method: 'POST',\n          path: spotlightUrl.pathname,\n          hostname: spotlightUrl.hostname,\n          port: spotlightUrl.port,\n          headers: {\n            'Content-Type': 'application/x-sentry-envelope',\n          },\n        },\n        res => {\n          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {\n            // Reset failed requests counter on success\n            failedRequests = 0;\n          }\n          res.on('data', () => {\n            // Drain socket\n          });\n\n          res.on('end', () => {\n            // Drain socket\n          });\n          res.setEncoding('utf8');\n        },\n      );\n\n      req.on('error', () => {\n        failedRequests++;\n        debug.warn('[Spotlight] Failed to send envelope to Spotlight Sidecar');\n      });\n      req.write(serializedEnvelope);\n      req.end();\n    });\n  });\n}\n\nfunction parseSidecarUrl(url: string): URL | undefined {\n  try {\n    return new URL(`${url}`);\n  } catch {\n    debug.warn(`[Spotlight] Invalid sidecar URL: ${url}`);\n    return undefined;\n  }\n}\n"],"names":["debug","defineIntegration","serializeEnvelope","suppressTracing"],"mappings":";;;;;AAYO,MAAM,gBAAA,GAAmB;AAEhC,MAAM,qBAAA,IAAyB,CAAC,OAAA,GAA+C,EAAC,KAAM;AACpF,EAAA,MAAM,QAAA,GAAW;AAAA,IACf,UAAA,EAAY,QAAQ,UAAA,IAAc;AAAA,GACpC;AAEA,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,MAAM,MAAA,EAAQ;AACZ,MAAA,IAAI;AACF,QAAA,IAAI,QAAQ,GAAA,CAAI,QAAA,IAAY,OAAA,CAAQ,GAAA,CAAI,aAAa,aAAA,EAAe;AAClE,UAAAA,UAAA,CAAM,KAAK,4FAA4F,CAAA;AAAA,QACzG;AAAA,MACF,CAAA,CAAA,MAAQ;AAAA,MAER;AACA,MAAA,kBAAA,CAAmB,QAAQ,QAAQ,CAAA;AAAA,IACrC;AAAA,GACF;AACF,CAAA,CAAA;AAOO,MAAM,oBAAA,GAAuBC,uBAAkB,qBAAqB;AAE3E,SAAS,kBAAA,CAAmB,QAAgB,OAAA,EAAqD;AAC/F,EAAA,MAAM,YAAA,GAAe,eAAA,CAAgB,OAAA,CAAQ,UAAU,CAAA;AACvD,EAAA,IAAI,CAAC,YAAA,EAAc;AACjB,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,cAAA,GAAiB,CAAA;AAErB,EAAA,MAAA,CAAO,EAAA,CAAG,gBAAA,EAAkB,CAAC,QAAA,KAAuB;AAClD,IAAA,IAAI,iBAAiB,CAAA,EAAG;AACtB,MAAAD,UAAA,CAAM,KAAK,sFAAsF,CAAA;AACjG,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,kBAAA,GAAqBE,uBAAkB,QAAQ,CAAA;AACrD,IAAAC,oBAAA,CAAgB,MAAM;AACpB,MAAA,MAAM,MAAM,IAAA,CAAK,OAAA;AAAA,QACf;AAAA,UACE,MAAA,EAAQ,MAAA;AAAA,UACR,MAAM,YAAA,CAAa,QAAA;AAAA,UACnB,UAAU,YAAA,CAAa,QAAA;AAAA,UACvB,MAAM,YAAA,CAAa,IAAA;AAAA,UACnB,OAAA,EAAS;AAAA,YACP,cAAA,EAAgB;AAAA;AAClB,SACF;AAAA,QACA,CAAA,GAAA,KAAO;AACL,UAAA,IAAI,IAAI,UAAA,IAAc,GAAA,CAAI,cAAc,GAAA,IAAO,GAAA,CAAI,aAAa,GAAA,EAAK;AAEnE,YAAA,cAAA,GAAiB,CAAA;AAAA,UACnB;AACA,UAAA,GAAA,CAAI,EAAA,CAAG,QAAQ,MAAM;AAAA,UAErB,CAAC,CAAA;AAED,UAAA,GAAA,CAAI,EAAA,CAAG,OAAO,MAAM;AAAA,UAEpB,CAAC,CAAA;AACD,UAAA,GAAA,CAAI,YAAY,MAAM,CAAA;AAAA,QACxB;AAAA,OACF;AAEA,MAAA,GAAA,CAAI,EAAA,CAAG,SAAS,MAAM;AACpB,QAAA,cAAA,EAAA;AACA,QAAAH,UAAA,CAAM,KAAK,0DAA0D,CAAA;AAAA,MACvE,CAAC,CAAA;AACD,MAAA,GAAA,CAAI,MAAM,kBAAkB,CAAA;AAC5B,MAAA,GAAA,CAAI,GAAA,EAAI;AAAA,IACV,CAAC,CAAA;AAAA,EACH,CAAC,CAAA;AACH;AAEA,SAAS,gBAAgB,GAAA,EAA8B;AACrD,EAAA,IAAI;AACF,IAAA,OAAO,IAAI,GAAA,CAAI,CAAA,EAAG,GAAG,CAAA,CAAE,CAAA;AAAA,EACzB,CAAA,CAAA,MAAQ;AACN,IAAAA,UAAA,CAAM,IAAA,CAAK,CAAA,iCAAA,EAAoC,GAAG,CAAA,CAAE,CAAA;AACpD,IAAA,OAAO,MAAA;AAAA,EACT;AACF;;;;;"}

package/build/cjs/integrations/systemError.js

@@ -0,0 +1,54 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const util = require('node:util');
+const core = require('@sentry/core');
+
+const INTEGRATION_NAME = "NodeSystemError";
+function isSystemError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (!("errno" in error) || typeof error.errno !== "number") {
+    return false;
+  }
+  if (typeof util.getSystemErrorMap !== "function") {
+    return false;
+  }
+  return util.getSystemErrorMap().has(error.errno);
+}
+const systemErrorIntegration = core.defineIntegration((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    processEvent: (event, hint, client) => {
+      if (!isSystemError(hint.originalException)) {
+        return event;
+      }
+      const error = hint.originalException;
+      const errorContext = {
+        ...error
+      };
+      if (!client.getDataCollectionOptions().userInfo && options.includePaths !== true) {
+        delete errorContext.path;
+        delete errorContext.dest;
+      }
+      event.contexts = {
+        ...event.contexts,
+        node_system_error: errorContext
+      };
+      for (const exception of event.exception?.values || []) {
+        if (exception.value) {
+          if (error.path && exception.value.includes(error.path)) {
+            exception.value = exception.value.replace(`'${error.path}'`, "").trim();
+          }
+          if (error.dest && exception.value.includes(error.dest)) {
+            exception.value = exception.value.replace(`'${error.dest}'`, "").trim();
+          }
+        }
+      }
+      return event;
+    }
+  };
+});
+
+exports.systemErrorIntegration = systemErrorIntegration;
+//# sourceMappingURL=systemError.js.map

package/build/cjs/integrations/systemError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemError.js","sources":["../../../src/integrations/systemError.ts"],"sourcesContent":["import * as util from 'node:util';\nimport { defineIntegration } from '@sentry/core';\n\nconst INTEGRATION_NAME = 'NodeSystemError' as const;\n\ntype SystemErrorContext = {\n  dest?: string; // If present, the file path destination when reporting a file system error\n  errno: number; // The system-provided error number\n  path?: string; // If present, the file path when reporting a file system error\n};\n\ntype SystemError = Error & SystemErrorContext;\n\nfunction isSystemError(error: unknown): error is SystemError {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n\n  if (!('errno' in error) || typeof error.errno !== 'number') {\n    return false;\n  }\n\n  // Workaround for Bun where getSystemErrorMap doesn't exist\n  // Can be removed once Bun supports getSystemErrorMap\n  // https://github.com/oven-sh/bun/issues/22872\n  if (typeof util.getSystemErrorMap !== 'function') {\n    return false;\n  }\n\n  // Appears this is the recommended way to check for Node.js SystemError\n  // https://github.com/nodejs/node/issues/46869\n  return util.getSystemErrorMap().has(error.errno);\n}\n\ntype Options = {\n  /**\n   * If true, includes the `path` and `dest` properties in the error context.\n   */\n  includePaths?: boolean;\n};\n\n/**\n * Captures context for Node.js SystemError errors.\n */\nexport const systemErrorIntegration = defineIntegration((options: Options = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    processEvent: (event, hint, client) => {\n      if (!isSystemError(hint.originalException)) {\n        return event;\n      }\n\n      const error = hint.originalException;\n\n      const errorContext: SystemErrorContext = {\n        ...(error as SystemErrorContext),\n      };\n\n      if (!client.getDataCollectionOptions().userInfo && options.includePaths !== true) {\n        delete errorContext.path;\n        delete errorContext.dest;\n      }\n\n      event.contexts = {\n        ...event.contexts,\n        node_system_error: errorContext,\n      };\n\n      for (const exception of event.exception?.values || []) {\n        if (exception.value) {\n          if (error.path && exception.value.includes(error.path)) {\n            exception.value = exception.value.replace(`'${error.path}'`, '').trim();\n          }\n          if (error.dest && exception.value.includes(error.dest)) {\n            exception.value = exception.value.replace(`'${error.dest}'`, '').trim();\n          }\n        }\n      }\n\n      return event;\n    },\n  };\n});\n"],"names":["defineIntegration"],"mappings":";;;;;AAGA,MAAM,gBAAA,GAAmB,iBAAA;AAUzB,SAAS,cAAc,KAAA,EAAsC;AAC3D,EAAA,IAAI,EAAE,iBAAiB,KAAA,CAAA,EAAQ;AAC7B,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,EAAE,OAAA,IAAW,KAAA,CAAA,IAAU,OAAO,KAAA,CAAM,UAAU,QAAA,EAAU;AAC1D,IAAA,OAAO,KAAA;AAAA,EACT;AAKA,EAAA,IAAI,OAAO,IAAA,CAAK,iBAAA,KAAsB,UAAA,EAAY;AAChD,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,OAAO,IAAA,CAAK,iBAAA,EAAkB,CAAE,GAAA,CAAI,MAAM,KAAK,CAAA;AACjD;AAYO,MAAM,sBAAA,GAAyBA,sBAAA,CAAkB,CAAC,OAAA,GAAmB,EAAC,KAAM;AACjF,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,YAAA,EAAc,CAAC,KAAA,EAAO,IAAA,EAAM,MAAA,KAAW;AACrC,MAAA,IAAI,CAAC,aAAA,CAAc,IAAA,CAAK,iBAAiB,CAAA,EAAG;AAC1C,QAAA,OAAO,KAAA;AAAA,MACT;AAEA,MAAA,MAAM,QAAQ,IAAA,CAAK,iBAAA;AAEnB,MAAA,MAAM,YAAA,GAAmC;AAAA,QACvC,GAAI;AAAA,OACN;AAEA,MAAA,IAAI,CAAC,MAAA,CAAO,wBAAA,GAA2B,QAAA,IAAY,OAAA,CAAQ,iBAAiB,IAAA,EAAM;AAChF,QAAA,OAAO,YAAA,CAAa,IAAA;AACpB,QAAA,OAAO,YAAA,CAAa,IAAA;AAAA,MACtB;AAEA,MAAA,KAAA,CAAM,QAAA,GAAW;AAAA,QACf,GAAG,KAAA,CAAM,QAAA;AAAA,QACT,iBAAA,EAAmB;AAAA,OACrB;AAEA,MAAA,KAAA,MAAW,SAAA,IAAa,KAAA,CAAM,SAAA,EAAW,MAAA,IAAU,EAAC,EAAG;AACrD,QAAA,IAAI,UAAU,KAAA,EAAO;AACnB,UAAA,IAAI,MAAM,IAAA,IAAQ,SAAA,CAAU,MAAM,QAAA,CAAS,KAAA,CAAM,IAAI,CAAA,EAAG;AACtD,YAAA,SAAA,CAAU,KAAA,GAAQ,SAAA,CAAU,KAAA,CAAM,OAAA,CAAQ,CAAA,CAAA,EAAI,MAAM,IAAI,CAAA,CAAA,CAAA,EAAK,EAAE,CAAA,CAAE,IAAA,EAAK;AAAA,UACxE;AACA,UAAA,IAAI,MAAM,IAAA,IAAQ,SAAA,CAAU,MAAM,QAAA,CAAS,KAAA,CAAM,IAAI,CAAA,EAAG;AACtD,YAAA,SAAA,CAAU,KAAA,GAAQ,SAAA,CAAU,KAAA,CAAM,OAAA,CAAQ,CAAA,CAAA,EAAI,MAAM,IAAI,CAAA,CAAA,CAAA,EAAK,EAAE,CAAA,CAAE,IAAA,EAAK;AAAA,UACxE;AAAA,QACF;AAAA,MACF;AAEA,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,GACF;AACF,CAAC;;;;"}

package/build/cjs/integrations/tracing/hapi.js

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const serverUtils = require('@sentry/server-utils');
+
+async function setupHapiErrorHandler(server) {
+  serverUtils.attachHapiErrorHandler(server);
+}
+
+exports.setupHapiErrorHandler = setupHapiErrorHandler;
+//# sourceMappingURL=hapi.js.map

package/build/cjs/integrations/tracing/hapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hapi.js","sources":["../../../../src/integrations/tracing/hapi.ts"],"sourcesContent":["import { attachHapiErrorHandler } from '@sentry/server-utils';\n\n/**\n * Add a Hapi plugin to capture errors to Sentry.\n *\n * @deprecated The error handler is now registered automatically when the Hapi\n * server starts (via the orchestrion `@hapi/hapi` instrumentation), so calling\n * this is no longer necessary. It remains a safe, idempotent operation when the\n * handler is already attached, and is kept for setups where auto-registration is\n * unavailable. This will be removed in a future major version.\n *\n * @param server The Hapi server to attach the error handler to\n */\nexport async function setupHapiErrorHandler(server: unknown): Promise<void> {\n  // oxlint-disable-next-line typescript/no-deprecated\n  attachHapiErrorHandler(server as Parameters<typeof attachHapiErrorHandler>[0]);\n}\n"],"names":["attachHapiErrorHandler"],"mappings":";;;;AAaA,eAAsB,sBAAsB,MAAA,EAAgC;AAE1E,EAAAA,kCAAA,CAAuB,MAAsD,CAAA;AAC/E;;;;"}