@sentry/node 8.0.0 → 8.1.0

package/esm/integrations/node-fetch.js

@@ -0,0 +1,79 @@
+import { SpanKind } from '@opentelemetry/api';
+import { defineIntegration, addBreadcrumb } from '@sentry/core';
+import { addOpenTelemetryInstrumentation, getSpanKind, getRequestSpanData } from '@sentry/opentelemetry';
+import { logger } from '@sentry/utils';
+import { DEBUG_BUILD } from '../debug-build.js';
+import { NODE_MAJOR } from '../nodeVersion.js';
+import { addOriginToSpan } from '../utils/addOriginToSpan.js';
+
+const _nativeNodeFetchIntegration = ((options = {}) => {
+  const _breadcrumbs = typeof options.breadcrumbs === 'undefined' ? true : options.breadcrumbs;
+  const _ignoreOutgoingRequests = options.ignoreOutgoingRequests;
+
+  async function getInstrumentation() {
+    // Only add NodeFetch if Node >= 18, as previous versions do not support it
+    if (NODE_MAJOR < 18) {
+      DEBUG_BUILD && logger.log('NodeFetch is not supported on Node < 18, skipping instrumentation...');
+      return;
+    }
+
+    try {
+      const pkg = await import('opentelemetry-instrumentation-fetch-node');
+      return new pkg.FetchInstrumentation({
+        ignoreRequestHook: (request) => {
+          const url = request.origin;
+          return _ignoreOutgoingRequests && url && _ignoreOutgoingRequests(url);
+        },
+        onRequest: ({ span }) => {
+          _updateSpan(span);
+
+          if (_breadcrumbs) {
+            _addRequestBreadcrumb(span);
+          }
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } );
+    } catch (error) {
+      // Could not load instrumentation
+      DEBUG_BUILD && logger.log('Could not load NodeFetch instrumentation.');
+    }
+  }
+
+  return {
+    name: 'NodeFetch',
+    setupOnce() {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      getInstrumentation().then(instrumentation => {
+        if (instrumentation) {
+          addOpenTelemetryInstrumentation(instrumentation);
+        }
+      });
+    },
+  };
+}) ;
+
+const nativeNodeFetchIntegration = defineIntegration(_nativeNodeFetchIntegration);
+
+/** Update the span with data we need. */
+function _updateSpan(span) {
+  addOriginToSpan(span, 'auto.http.otel.node_fetch');
+}
+
+/** Add a breadcrumb for outgoing requests. */
+function _addRequestBreadcrumb(span) {
+  if (getSpanKind(span) !== SpanKind.CLIENT) {
+    return;
+  }
+
+  const data = getRequestSpanData(span);
+  addBreadcrumb({
+    category: 'http',
+    data: {
+      ...data,
+    },
+    type: 'http',
+  });
+}
+
+export { nativeNodeFetchIntegration };
+//# sourceMappingURL=node-fetch.js.map

package/esm/integrations/node-fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-fetch.js","sources":["../../../src/integrations/node-fetch.ts"],"sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport { SpanKind } from '@opentelemetry/api';\nimport { addBreadcrumb, defineIntegration } from '@sentry/core';\nimport { addOpenTelemetryInstrumentation } from '@sentry/opentelemetry';\nimport { getRequestSpanData, getSpanKind } from '@sentry/opentelemetry';\nimport type { IntegrationFn } from '@sentry/types';\nimport { logger } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { NODE_MAJOR } from '../nodeVersion';\n\nimport type { FetchInstrumentation } from 'opentelemetry-instrumentation-fetch-node';\n\nimport { addOriginToSpan } from '../utils/addOriginToSpan';\n\ninterface NodeFetchOptions {\n  /**\n   * Whether breadcrumbs should be recorded for requests.\n   * Defaults to true\n   */\n  breadcrumbs?: boolean;\n\n  /**\n   * Do not capture spans or breadcrumbs for outgoing fetch requests to URLs where the given callback returns `true`.\n   * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.\n   */\n  ignoreOutgoingRequests?: (url: string) => boolean;\n}\n\nconst _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {\n  const _breadcrumbs = typeof options.breadcrumbs === 'undefined' ? true : options.breadcrumbs;\n  const _ignoreOutgoingRequests = options.ignoreOutgoingRequests;\n\n  async function getInstrumentation(): Promise<FetchInstrumentation | void> {\n    // Only add NodeFetch if Node >= 18, as previous versions do not support it\n    if (NODE_MAJOR < 18) {\n      DEBUG_BUILD && logger.log('NodeFetch is not supported on Node < 18, skipping instrumentation...');\n      return;\n    }\n\n    try {\n      const pkg = await import('opentelemetry-instrumentation-fetch-node');\n      return new pkg.FetchInstrumentation({\n        ignoreRequestHook: (request: { origin?: string }) => {\n          const url = request.origin;\n          return _ignoreOutgoingRequests && url && _ignoreOutgoingRequests(url);\n        },\n        onRequest: ({ span }: { span: Span }) => {\n          _updateSpan(span);\n\n          if (_breadcrumbs) {\n            _addRequestBreadcrumb(span);\n          }\n        },\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } as any);\n    } catch (error) {\n      // Could not load instrumentation\n      DEBUG_BUILD && logger.log('Could not load NodeFetch instrumentation.');\n    }\n  }\n\n  return {\n    name: 'NodeFetch',\n    setupOnce() {\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      getInstrumentation().then(instrumentation => {\n        if (instrumentation) {\n          addOpenTelemetryInstrumentation(instrumentation);\n        }\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const nativeNodeFetchIntegration = defineIntegration(_nativeNodeFetchIntegration);\n\n/** Update the span with data we need. */\nfunction _updateSpan(span: Span): void {\n  addOriginToSpan(span, 'auto.http.otel.node_fetch');\n}\n\n/** Add a breadcrumb for outgoing requests. */\nfunction _addRequestBreadcrumb(span: Span): void {\n  if (getSpanKind(span) !== SpanKind.CLIENT) {\n    return;\n  }\n\n  const data = getRequestSpanData(span);\n  addBreadcrumb({\n    category: 'http',\n    data: {\n      ...data,\n    },\n    type: 'http',\n  });\n}\n"],"names":[],"mappings":";;;;;;;;AA4BA,MAAM,2BAAA,IAA+B,CAAC,OAAO,GAAqB,EAAE,KAAK;AACzE,EAAE,MAAM,YAAA,GAAe,OAAO,OAAO,CAAC,WAAA,KAAgB,WAAA,GAAc,IAAA,GAAO,OAAO,CAAC,WAAW,CAAA;AAC9F,EAAE,MAAM,uBAAA,GAA0B,OAAO,CAAC,sBAAsB,CAAA;AAChE;AACA,EAAE,eAAe,kBAAkB,GAAyC;AAC5E;AACA,IAAI,IAAI,UAAW,GAAE,EAAE,EAAE;AACzB,MAAM,eAAe,MAAM,CAAC,GAAG,CAAC,sEAAsE,CAAC,CAAA;AACvG,MAAM,OAAM;AACZ,KAAI;AACJ;AACA,IAAI,IAAI;AACR,MAAM,MAAM,GAAI,GAAE,MAAM,OAAO,0CAA0C,CAAC,CAAA;AAC1E,MAAM,OAAO,IAAI,GAAG,CAAC,oBAAoB,CAAC;AAC1C,QAAQ,iBAAiB,EAAE,CAAC,OAAO,KAA0B;AAC7D,UAAU,MAAM,GAAA,GAAM,OAAO,CAAC,MAAM,CAAA;AACpC,UAAU,OAAO,2BAA2B,GAAA,IAAO,uBAAuB,CAAC,GAAG,CAAC,CAAA;AAC/E,SAAS;AACT,QAAQ,SAAS,EAAE,CAAC,EAAE,IAAK,EAAC,KAAqB;AACjD,UAAU,WAAW,CAAC,IAAI,CAAC,CAAA;AAC3B;AACA,UAAU,IAAI,YAAY,EAAE;AAC5B,YAAY,qBAAqB,CAAC,IAAI,CAAC,CAAA;AACvC,WAAU;AACV,SAAS;AACT;AACA,SAAe,CAAA;AACf,KAAM,CAAA,OAAO,KAAK,EAAE;AACpB;AACA,MAAM,eAAe,MAAM,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAA;AAC5E,KAAI;AACJ,GAAE;AACF;AACA,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,WAAW;AACrB,IAAI,SAAS,GAAG;AAChB;AACA,MAAM,kBAAkB,EAAE,CAAC,IAAI,CAAC,mBAAmB;AACnD,QAAQ,IAAI,eAAe,EAAE;AAC7B,UAAU,+BAA+B,CAAC,eAAe,CAAC,CAAA;AAC1D,SAAQ;AACR,OAAO,CAAC,CAAA;AACR,KAAK;AACL,GAAG,CAAA;AACH,CAAC,CAAE,EAAA;AACH;MACa,0BAA2B,GAAE,iBAAiB,CAAC,2BAA2B,EAAC;AACxF;AACA;AACA,SAAS,WAAW,CAAC,IAAI,EAAc;AACvC,EAAE,eAAe,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAA;AACpD,CAAA;AACA;AACA;AACA,SAAS,qBAAqB,CAAC,IAAI,EAAc;AACjD,EAAE,IAAI,WAAW,CAAC,IAAI,MAAM,QAAQ,CAAC,MAAM,EAAE;AAC7C,IAAI,OAAM;AACV,GAAE;AACF;AACA,EAAE,MAAM,IAAK,GAAE,kBAAkB,CAAC,IAAI,CAAC,CAAA;AACvC,EAAE,aAAa,CAAC;AAChB,IAAI,QAAQ,EAAE,MAAM;AACpB,IAAI,IAAI,EAAE;AACV,MAAM,GAAG,IAAI;AACb,KAAK;AACL,IAAI,IAAI,EAAE,MAAM;AAChB,GAAG,CAAC,CAAA;AACJ;;;;"}

package/esm/integrations/onuncaughtexception.js

@@ -0,0 +1,132 @@
+import { defineIntegration, getClient, captureException } from '@sentry/core';
+import { logger } from '@sentry/utils';
+import { DEBUG_BUILD } from '../debug-build.js';
+import { logAndExitProcess } from '../utils/errorhandling.js';
+
+const INTEGRATION_NAME = 'OnUncaughtException';
+
+/**
+ * Add a global exception handler.
+ */
+const onUncaughtExceptionIntegration = defineIntegration((options = {}) => {
+  const optionsWithDefaults = {
+    exitEvenIfOtherHandlersAreRegistered: false,
+    ...options,
+  };
+
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      global.process.on('uncaughtException', makeErrorHandler(client, optionsWithDefaults));
+    },
+  };
+});
+
+/** Exported only for tests */
+function makeErrorHandler(client, options) {
+  const timeout = 2000;
+  let caughtFirstError = false;
+  let caughtSecondError = false;
+  let calledFatalError = false;
+  let firstError;
+
+  const clientOptions = client.getOptions();
+
+  return Object.assign(
+    (error) => {
+      let onFatalError = logAndExitProcess;
+
+      if (options.onFatalError) {
+        onFatalError = options.onFatalError;
+      } else if (clientOptions.onFatalError) {
+        onFatalError = clientOptions.onFatalError ;
+      }
+
+      // Attaching a listener to `uncaughtException` will prevent the node process from exiting. We generally do not
+      // want to alter this behaviour so we check for other listeners that users may have attached themselves and adjust
+      // exit behaviour of the SDK accordingly:
+      // - If other listeners are attached, do not exit.
+      // - If the only listener attached is ours, exit.
+      const userProvidedListenersCount = (global.process.listeners('uncaughtException') ).filter(
+        listener => {
+          // There are 3 listeners we ignore:
+          return (
+            // as soon as we're using domains this listener is attached by node itself
+            listener.name !== 'domainUncaughtExceptionClear' &&
+            // the handler we register for tracing
+            listener.tag !== 'sentry_tracingErrorCallback' &&
+            // the handler we register in this integration
+            (listener )._errorHandler !== true
+          );
+        },
+      ).length;
+
+      const processWouldExit = userProvidedListenersCount === 0;
+      const shouldApplyFatalHandlingLogic = options.exitEvenIfOtherHandlersAreRegistered || processWouldExit;
+
+      if (!caughtFirstError) {
+        // this is the first uncaught error and the ultimate reason for shutting down
+        // we want to do absolutely everything possible to ensure it gets captured
+        // also we want to make sure we don't go recursion crazy if more errors happen after this one
+        firstError = error;
+        caughtFirstError = true;
+
+        if (getClient() === client) {
+          captureException(error, {
+            originalException: error,
+            captureContext: {
+              level: 'fatal',
+            },
+            mechanism: {
+              handled: false,
+              type: 'onuncaughtexception',
+            },
+          });
+        }
+
+        if (!calledFatalError && shouldApplyFatalHandlingLogic) {
+          calledFatalError = true;
+          onFatalError(error);
+        }
+      } else {
+        if (shouldApplyFatalHandlingLogic) {
+          if (calledFatalError) {
+            // we hit an error *after* calling onFatalError - pretty boned at this point, just shut it down
+            DEBUG_BUILD &&
+              logger.warn(
+                'uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown',
+              );
+            logAndExitProcess(error);
+          } else if (!caughtSecondError) {
+            // two cases for how we can hit this branch:
+            //   - capturing of first error blew up and we just caught the exception from that
+            //     - quit trying to capture, proceed with shutdown
+            //   - a second independent error happened while waiting for first error to capture
+            //     - want to avoid causing premature shutdown before first error capture finishes
+            // it's hard to immediately tell case 1 from case 2 without doing some fancy/questionable domain stuff
+            // so let's instead just delay a bit before we proceed with our action here
+            // in case 1, we just wait a bit unnecessarily but ultimately do the same thing
+            // in case 2, the delay hopefully made us wait long enough for the capture to finish
+            // two potential nonideal outcomes:
+            //   nonideal case 1: capturing fails fast, we sit around for a few seconds unnecessarily before proceeding correctly by calling onFatalError
+            //   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
+            // note that after hitting this branch, we might catch more errors where (caughtSecondError && !calledFatalError)
+            //   we ignore them - they don't matter to us, we're just waiting for the second error timeout to finish
+            caughtSecondError = true;
+            setTimeout(() => {
+              if (!calledFatalError) {
+                // it was probably case 1, let's treat err as the sendErr and call onFatalError
+                calledFatalError = true;
+                onFatalError(firstError, error);
+              }
+            }, timeout); // capturing could take at least sendTimeout to fail, plus an arbitrary second for how long it takes to collect surrounding source etc
+          }
+        }
+      }
+    },
+    { _errorHandler: true },
+  );
+}
+
+export { makeErrorHandler, onUncaughtExceptionIntegration };
+//# sourceMappingURL=onuncaughtexception.js.map

package/esm/integrations/onuncaughtexception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onuncaughtexception.js","sources":["../../../src/integrations/onuncaughtexception.ts"],"sourcesContent":["import { captureException, defineIntegration } from '@sentry/core';\nimport { getClient } from '@sentry/core';\nimport { logger } from '@sentry/utils';\n\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\ntype TaggedListener = NodeJS.UncaughtExceptionListener & {\n  tag?: string;\n};\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';\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      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 as OnFatalErrorHandler;\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') as TaggedListener[]).filter(\n        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 for tracing\n            listener.tag !== 'sentry_tracingErrorCallback' &&\n            // the handler we register in this integration\n            (listener as ErrorHandler)._errorHandler !== true\n          );\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: '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              logger.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":[],"mappings":"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"}

package/esm/integrations/onunhandledrejection.js

@@ -0,0 +1,87 @@
+import { defineIntegration, getClient, captureException } from '@sentry/core';
+import { consoleSandbox } from '@sentry/utils';
+import { logAndExitProcess } from '../utils/errorhandling.js';
+
+const INTEGRATION_NAME = 'OnUnhandledRejection';
+
+const _onUnhandledRejectionIntegration = ((options = {}) => {
+  const mode = options.mode || 'warn';
+
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      global.process.on('unhandledRejection', makeUnhandledPromiseHandler(client, { mode }));
+    },
+  };
+}) ;
+
+/**
+ * Add a global promise rejection handler.
+ */
+const onUnhandledRejectionIntegration = defineIntegration(_onUnhandledRejectionIntegration);
+
+/**
+ * Send an exception with reason
+ * @param reason string
+ * @param promise promise
+ *
+ * Exported only for tests.
+ */
+function makeUnhandledPromiseHandler(
+  client,
+  options,
+) {
+  return function sendUnhandledPromise(reason, promise) {
+    if (getClient() !== client) {
+      return;
+    }
+
+    captureException(reason, {
+      originalException: promise,
+      captureContext: {
+        extra: { unhandledPromiseRejection: true },
+      },
+      mechanism: {
+        handled: false,
+        type: 'onunhandledrejection',
+      },
+    });
+
+    handleRejection(reason, options);
+  };
+}
+
+/**
+ * Handler for `mode` option
+
+ */
+function handleRejection(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  reason,
+  options,
+) {
+  // https://github.com/nodejs/node/blob/7cf6f9e964aa00772965391c23acda6d71972a9a/lib/internal/process/promises.js#L234-L240
+  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:';
+
+  /* eslint-disable no-console */
+  if (options.mode === 'warn') {
+    consoleSandbox(() => {
+      console.warn(rejectionWarning);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      console.error(reason && reason.stack ? reason.stack : reason);
+    });
+  } else if (options.mode === 'strict') {
+    consoleSandbox(() => {
+      console.warn(rejectionWarning);
+    });
+    logAndExitProcess(reason);
+  }
+  /* eslint-enable no-console */
+}
+
+export { makeUnhandledPromiseHandler, onUnhandledRejectionIntegration };
+//# sourceMappingURL=onunhandledrejection.js.map

package/esm/integrations/onunhandledrejection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onunhandledrejection.js","sources":["../../../src/integrations/onunhandledrejection.ts"],"sourcesContent":["import { captureException, defineIntegration, getClient } from '@sentry/core';\nimport type { Client, IntegrationFn } from '@sentry/types';\nimport { consoleSandbox } from '@sentry/utils';\nimport { logAndExitProcess } from '../utils/errorhandling';\n\ntype UnhandledRejectionMode = 'none' | 'warn' | 'strict';\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}\n\nconst INTEGRATION_NAME = 'OnUnhandledRejection';\n\nconst _onUnhandledRejectionIntegration = ((options: Partial<OnUnhandledRejectionOptions> = {}) => {\n  const mode = options.mode || 'warn';\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      global.process.on('unhandledRejection', makeUnhandledPromiseHandler(client, { mode }));\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Add a global promise rejection handler.\n */\nexport const onUnhandledRejectionIntegration = defineIntegration(_onUnhandledRejectionIntegration);\n\n/**\n * Send an exception with reason\n * @param reason string\n * @param promise promise\n *\n * Exported only for tests.\n */\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    if (getClient() !== client) {\n      return;\n    }\n\n    captureException(reason, {\n      originalException: promise,\n      captureContext: {\n        extra: { unhandledPromiseRejection: true },\n      },\n      mechanism: {\n        handled: false,\n        type: 'onunhandledrejection',\n      },\n    });\n\n    handleRejection(reason, options);\n  };\n}\n\n/**\n * Handler for `mode` option\n\n */\nfunction handleRejection(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  reason: any,\n  options: OnUnhandledRejectionOptions,\n): 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 (options.mode === 'warn') {\n    consoleSandbox(() => {\n      console.warn(rejectionWarning);\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      console.error(reason && reason.stack ? reason.stack : reason);\n    });\n  } else if (options.mode === 'strict') {\n    consoleSandbox(() => {\n      console.warn(rejectionWarning);\n    });\n    logAndExitProcess(reason);\n  }\n  /* eslint-enable no-console */\n}\n"],"names":[],"mappings":";;;;AAeA,MAAM,gBAAA,GAAmB,sBAAsB,CAAA;AAC/C;AACA,MAAM,gCAAA,IAAoC,CAAC,OAAO,GAAyC,EAAE,KAAK;AAClG,EAAE,MAAM,IAAK,GAAE,OAAO,CAAC,IAAA,IAAQ,MAAM,CAAA;AACrC;AACA,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,KAAK,CAAC,MAAM,EAAE;AAClB,MAAM,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,oBAAoB,EAAE,2BAA2B,CAAC,MAAM,EAAE,EAAE,IAAK,EAAC,CAAC,CAAC,CAAA;AAC5F,KAAK;AACL,GAAG,CAAA;AACH,CAAC,CAAE,EAAA;AACH;AACA;AACA;AACA;MACa,+BAAgC,GAAE,iBAAiB,CAAC,gCAAgC,EAAC;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,2BAA2B;AAC3C,EAAE,MAAM;AACR,EAAE,OAAO;AACT,EAA+C;AAC/C,EAAE,OAAO,SAAS,oBAAoB,CAAC,MAAM,EAAW,OAAO,EAAiB;AAChF,IAAI,IAAI,SAAS,EAAG,KAAI,MAAM,EAAE;AAChC,MAAM,OAAM;AACZ,KAAI;AACJ;AACA,IAAI,gBAAgB,CAAC,MAAM,EAAE;AAC7B,MAAM,iBAAiB,EAAE,OAAO;AAChC,MAAM,cAAc,EAAE;AACtB,QAAQ,KAAK,EAAE,EAAE,yBAAyB,EAAE,MAAM;AAClD,OAAO;AACP,MAAM,SAAS,EAAE;AACjB,QAAQ,OAAO,EAAE,KAAK;AACtB,QAAQ,IAAI,EAAE,sBAAsB;AACpC,OAAO;AACP,KAAK,CAAC,CAAA;AACN;AACA,IAAI,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AACpC,GAAG,CAAA;AACH,CAAA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe;AACxB;AACA,EAAE,MAAM;AACR,EAAE,OAAO;AACT,EAAQ;AACR;AACA,EAAE,MAAM,gBAAiB;AACzB,IAAI,kCAAmC;AACvC,IAAI,8DAA+D;AACnE,IAAI,gEAAiE;AACrE,IAAI,wCAAwC,CAAA;AAC5C;AACA;AACA,EAAE,IAAI,OAAO,CAAC,IAAK,KAAI,MAAM,EAAE;AAC/B,IAAI,cAAc,CAAC,MAAM;AACzB,MAAM,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAA;AACpC;AACA,MAAM,OAAO,CAAC,KAAK,CAAC,UAAU,MAAM,CAAC,KAAA,GAAQ,MAAM,CAAC,KAAM,GAAE,MAAM,CAAC,CAAA;AACnE,KAAK,CAAC,CAAA;AACN,GAAE,MAAO,IAAI,OAAO,CAAC,IAAA,KAAS,QAAQ,EAAE;AACxC,IAAI,cAAc,CAAC,MAAM;AACzB,MAAM,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAA;AACpC,KAAK,CAAC,CAAA;AACN,IAAI,iBAAiB,CAAC,MAAM,CAAC,CAAA;AAC7B,GAAE;AACF;AACA;;;;"}

package/esm/integrations/spotlight.js

@@ -0,0 +1,106 @@
+import * as http from 'http';
+import { defineIntegration } from '@sentry/core';
+import { logger, serializeEnvelope } from '@sentry/utils';
+
+const INTEGRATION_NAME = 'Spotlight';
+
+const _spotlightIntegration = ((options = {}) => {
+  const _options = {
+    sidecarUrl: options.sidecarUrl || 'http://localhost:8969/stream',
+  };
+
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      if (typeof process === 'object' && process.env && process.env.NODE_ENV !== 'development') {
+        logger.warn("[Spotlight] It seems you're not in dev mode. Do you really want to have Spotlight enabled?");
+      }
+      connectToSpotlight(client, _options);
+    },
+  };
+}) ;
+
+/**
+ * Use this integration to send errors and transactions to Spotlight.
+ *
+ * Learn more about spotlight at https://spotlightjs.com
+ *
+ * Important: This integration only works with Node 18 or newer.
+ */
+const spotlightIntegration = defineIntegration(_spotlightIntegration);
+
+function connectToSpotlight(client, options) {
+  const spotlightUrl = parseSidecarUrl(options.sidecarUrl);
+  if (!spotlightUrl) {
+    return;
+  }
+
+  let failedRequests = 0;
+
+  client.on('beforeEnvelope', (envelope) => {
+    if (failedRequests > 3) {
+      logger.warn('[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests');
+      return;
+    }
+
+    const serializedEnvelope = serializeEnvelope(envelope);
+
+    const request = getNativeHttpRequest();
+    const req = request(
+      {
+        method: 'POST',
+        path: spotlightUrl.pathname,
+        hostname: spotlightUrl.hostname,
+        port: spotlightUrl.port,
+        headers: {
+          'Content-Type': 'application/x-sentry-envelope',
+        },
+      },
+      res => {
+        res.on('data', () => {
+          // Drain socket
+        });
+
+        res.on('end', () => {
+          // Drain socket
+        });
+        res.setEncoding('utf8');
+      },
+    );
+
+    req.on('error', () => {
+      failedRequests++;
+      logger.warn('[Spotlight] Failed to send envelope to Spotlight Sidecar');
+    });
+    req.write(serializedEnvelope);
+    req.end();
+  });
+}
+
+function parseSidecarUrl(url) {
+  try {
+    return new URL(`${url}`);
+  } catch (e) {
+    logger.warn(`[Spotlight] Invalid sidecar URL: ${url}`);
+    return undefined;
+  }
+}
+
+/**
+ * We want to get an unpatched http request implementation to avoid capturing our own calls.
+ */
+function getNativeHttpRequest() {
+  const { request } = http;
+  if (isWrapped(request)) {
+    return request.__sentry_original__;
+  }
+
+  return request;
+}
+
+function isWrapped(impl) {
+  return '__sentry_original__' in impl;
+}
+
+export { getNativeHttpRequest, spotlightIntegration };
+//# sourceMappingURL=spotlight.js.map

package/esm/integrations/spotlight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spotlight.js","sources":["../../../src/integrations/spotlight.ts"],"sourcesContent":["import * as http from 'http';\nimport { defineIntegration } from '@sentry/core';\nimport type { Client, Envelope, IntegrationFn } from '@sentry/types';\nimport { logger, serializeEnvelope } from '@sentry/utils';\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\nconst INTEGRATION_NAME = 'Spotlight';\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      if (typeof process === 'object' && process.env && process.env.NODE_ENV !== 'development') {\n        logger.warn(\"[Spotlight] It seems you're not in dev mode. Do you really want to have Spotlight enabled?\");\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 *\n * Important: This integration only works with Node 18 or newer.\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      logger.warn('[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests');\n      return;\n    }\n\n    const serializedEnvelope = serializeEnvelope(envelope);\n\n    const request = getNativeHttpRequest();\n    const req = 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        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      logger.warn('[Spotlight] Failed to send envelope to Spotlight Sidecar');\n    });\n    req.write(serializedEnvelope);\n    req.end();\n  });\n}\n\nfunction parseSidecarUrl(url: string): URL | undefined {\n  try {\n    return new URL(`${url}`);\n  } catch {\n    logger.warn(`[Spotlight] Invalid sidecar URL: ${url}`);\n    return undefined;\n  }\n}\n\ntype HttpRequestImpl = typeof http.request;\ntype WrappedHttpRequest = HttpRequestImpl & { __sentry_original__: HttpRequestImpl };\n\n/**\n * We want to get an unpatched http request implementation to avoid capturing our own calls.\n */\nexport function getNativeHttpRequest(): HttpRequestImpl {\n  const { request } = http;\n  if (isWrapped(request)) {\n    return request.__sentry_original__;\n  }\n\n  return request;\n}\n\nfunction isWrapped(impl: HttpRequestImpl): impl is WrappedHttpRequest {\n  return '__sentry_original__' in impl;\n}\n"],"names":[],"mappings":"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"}

package/esm/integrations/tracing/connect.js

@@ -0,0 +1,38 @@
+import { isWrapped } from '@opentelemetry/core';
+import { ConnectInstrumentation } from '@opentelemetry/instrumentation-connect';
+import { defineIntegration, isEnabled, captureException } from '@sentry/core';
+import { addOpenTelemetryInstrumentation } from '@sentry/opentelemetry';
+import { consoleSandbox } from '@sentry/utils';
+
+const _connectIntegration = (() => {
+  return {
+    name: 'Connect',
+    setupOnce() {
+      addOpenTelemetryInstrumentation(new ConnectInstrumentation({}));
+    },
+  };
+}) ;
+
+const connectIntegration = defineIntegration(_connectIntegration);
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function connectErrorMiddleware(err, req, res, next) {
+  captureException(err);
+  next(err);
+}
+
+const setupConnectErrorHandler = (app) => {
+  app.use(connectErrorMiddleware);
+
+  if (!isWrapped(app.use) && isEnabled()) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[Sentry] Connect is not instrumented. This is likely because you required/imported connect before calling `Sentry.init()`.',
+      );
+    });
+  }
+};
+
+export { connectIntegration, setupConnectErrorHandler };
+//# sourceMappingURL=connect.js.map

package/esm/integrations/tracing/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","sources":["../../../../src/integrations/tracing/connect.ts"],"sourcesContent":["import { isWrapped } from '@opentelemetry/core';\nimport { ConnectInstrumentation } from '@opentelemetry/instrumentation-connect';\nimport { captureException, defineIntegration, isEnabled } from '@sentry/core';\nimport { addOpenTelemetryInstrumentation } from '@sentry/opentelemetry';\nimport type { IntegrationFn } from '@sentry/types';\nimport { consoleSandbox } from '@sentry/utils';\n\ntype ConnectApp = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  use: (middleware: any) => void;\n};\n\nconst _connectIntegration = (() => {\n  return {\n    name: 'Connect',\n    setupOnce() {\n      addOpenTelemetryInstrumentation(new ConnectInstrumentation({}));\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const connectIntegration = defineIntegration(_connectIntegration);\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction connectErrorMiddleware(err: any, req: any, res: any, next: any): void {\n  captureException(err);\n  next(err);\n}\n\nexport const setupConnectErrorHandler = (app: ConnectApp): void => {\n  app.use(connectErrorMiddleware);\n\n  if (!isWrapped(app.use) && isEnabled()) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[Sentry] Connect is not instrumented. This is likely because you required/imported connect before calling `Sentry.init()`.',\n      );\n    });\n  }\n};\n"],"names":[],"mappings":";;;;;;AAYA,MAAM,mBAAoB,IAAG,MAAM;AACnC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,SAAS;AACnB,IAAI,SAAS,GAAG;AAChB,MAAM,+BAA+B,CAAC,IAAI,sBAAsB,CAAC,EAAE,CAAC,CAAC,CAAA;AACrE,KAAK;AACL,GAAG,CAAA;AACH,CAAC,CAAE,EAAA;AACH;MACa,kBAAmB,GAAE,iBAAiB,CAAC,mBAAmB,EAAC;AACxE;AACA;AACA,SAAS,sBAAsB,CAAC,GAAG,EAAO,GAAG,EAAO,GAAG,EAAO,IAAI,EAAa;AAC/E,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAA;AACvB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAA;AACX,CAAA;AACA;AACa,MAAA,wBAAA,GAA2B,CAAC,GAAG,KAAuB;AACnE,EAAE,GAAG,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAA;AACjC;AACA,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAE,IAAG,SAAS,EAAE,EAAE;AAC1C,IAAI,cAAc,CAAC,MAAM;AACzB;AACA,MAAM,OAAO,CAAC,IAAI;AAClB,QAAQ,4HAA4H;AACpI,OAAO,CAAA;AACP,KAAK,CAAC,CAAA;AACN,GAAE;AACF;;;;"}

package/esm/integrations/tracing/express.js

@@ -0,0 +1,120 @@
+import { _optionalChain } from '@sentry/utils';
+import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
+import { defineIntegration, getIsolationScope, getDefaultIsolationScope, getClient, captureException, isEnabled } from '@sentry/core';
+import { addOpenTelemetryInstrumentation } from '@sentry/opentelemetry';
+import { isWrapped } from '@opentelemetry/core';
+import { logger, consoleSandbox } from '@sentry/utils';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { addOriginToSpan } from '../../utils/addOriginToSpan.js';
+
+const _expressIntegration = (() => {
+  return {
+    name: 'Express',
+    setupOnce() {
+      addOpenTelemetryInstrumentation(
+        new ExpressInstrumentation({
+          requestHook(span) {
+            addOriginToSpan(span, 'auto.http.otel.express');
+          },
+          spanNameHook(info, defaultName) {
+            if (getIsolationScope() === getDefaultIsolationScope()) {
+              DEBUG_BUILD &&
+                logger.warn('Isolation scope is still default isolation scope - skipping setting transactionName');
+              return defaultName;
+            }
+            if (info.layerType === 'request_handler') {
+              // type cast b/c Otel unfortunately types info.request as any :(
+              const req = info.request ;
+              const method = req.method ? req.method.toUpperCase() : 'GET';
+              getIsolationScope().setTransactionName(`${method} ${info.route}`);
+            }
+            return defaultName;
+          },
+        }),
+      );
+    },
+  };
+}) ;
+
+/**
+ * Express integration
+ *
+ * Capture tracing data for express.
+ * In order to capture exceptions, you have to call `setupExpressErrorHandler(app)` before any other middleware and after all controllers.
+ */
+const expressIntegration = defineIntegration(_expressIntegration);
+
+/**
+ * An Express-compatible error handler.
+ */
+function expressErrorHandler(options
+
+) {
+  return function sentryErrorMiddleware(
+    error,
+    _req,
+    res,
+    next,
+  ) {
+    const shouldHandleError = _optionalChain([options, 'optionalAccess', _ => _.shouldHandleError]) || defaultShouldHandleError;
+
+    if (shouldHandleError(error)) {
+      const client = getClient();
+      if (client && client.getOptions().autoSessionTracking) {
+        // Check if the `SessionFlusher` is instantiated on the client to go into this branch that marks the
+        // `requestSession.status` as `Crashed`, and this check is necessary because the `SessionFlusher` is only
+        // instantiated when the the`requestHandler` middleware is initialised, which indicates that we should be
+        // running in SessionAggregates mode
+        const isSessionAggregatesMode = client['_sessionFlusher'] !== undefined;
+        if (isSessionAggregatesMode) {
+          const requestSession = getIsolationScope().getRequestSession();
+          // If an error bubbles to the `errorHandler`, then this is an unhandled error, and should be reported as a
+          // Crashed session. The `_requestSession.status` is checked to ensure that this error is happening within
+          // the bounds of a request, and if so the status is updated
+          if (requestSession && requestSession.status !== undefined) {
+            requestSession.status = 'crashed';
+          }
+        }
+      }
+
+      const eventId = captureException(error, { mechanism: { type: 'middleware', handled: false } });
+      (res ).sentry = eventId;
+      next(error);
+
+      return;
+    }
+
+    next(error);
+  };
+}
+
+/**
+ * Setup an error handler for Express.
+ * The error handler must be before any other middleware and after all controllers.
+ */
+function setupExpressErrorHandler(app) {
+  app.use(expressErrorHandler());
+
+  if (!isWrapped(app.use) && isEnabled()) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[Sentry] Express is not instrumented. This is likely because you required/imported express before calling `Sentry.init()`.',
+      );
+    });
+  }
+}
+
+function getStatusCodeFromResponse(error) {
+  const statusCode = error.status || error.statusCode || error.status_code || (error.output && error.output.statusCode);
+  return statusCode ? parseInt(statusCode , 10) : 500;
+}
+
+/** Returns true if response code is internal server error */
+function defaultShouldHandleError(error) {
+  const status = getStatusCodeFromResponse(error);
+  return status >= 500;
+}
+
+export { expressErrorHandler, expressIntegration, setupExpressErrorHandler };
+//# sourceMappingURL=express.js.map