@sentry/node 8.4.0 → 8.5.0

package/cjs/sdk/{init.js → index.js}

@@ -7,7 +7,6 @@ const debugBuild = require('../debug-build.js');
 const console$1 = require('../integrations/console.js');
 const context = require('../integrations/context.js');
 const contextlines = require('../integrations/contextlines.js');
-const moduleModule = require('module');
 const http = require('../integrations/http.js');
 const index = require('../integrations/local-variables/index.js');
 const modules = require('../integrations/modules.js');
@@ -22,7 +21,6 @@ const api = require('./api.js');
 const client = require('./client.js');
 const initOtel = require('./initOtel.js');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function getCjsOnlyIntegrations() {
   return commonjs.isCjs() ? [modules.modulesIntegration()] : [];
 }
@@ -109,31 +107,7 @@ function _init(
   }
 
   if (!commonjs.isCjs()) {
-    const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(Number);
-
-    // Register hook was added in v20.6.0 and v18.19.0
-    if (nodeMajor >= 22 || (nodeMajor === 20 && nodeMinor >= 6) || (nodeMajor === 18 && nodeMinor >= 19)) {
-      // We need to work around using import.meta.url directly because jest complains about it.
-      const importMetaUrl =
-        typeof (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('sdk/init.js', document.baseURI).href)) !== 'undefined' ? (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('sdk/init.js', document.baseURI).href)) : undefined;
-
-      if (!utils.GLOBAL_OBJ._sentryEsmLoaderHookRegistered && importMetaUrl) {
-        try {
-          // @ts-expect-error register is available in these versions
-          moduleModule.default.register('@opentelemetry/instrumentation/hook.mjs', importMetaUrl);
-          utils.GLOBAL_OBJ._sentryEsmLoaderHookRegistered = true;
-        } catch (error) {
-          utils.logger.warn('Failed to register ESM hook', error);
-        }
-      }
-    } else {
-      utils.consoleSandbox(() => {
-        // eslint-disable-next-line no-console
-        console.warn(
-          '[Sentry] You are using Node.js in ESM mode ("import syntax"). The Sentry Node.js SDK is not compatible with ESM in Node.js versions before 18.19.0 or before 20.6.0. Please either build your application with CommonJS ("require() syntax"), or use version 7.x of the Sentry Node.js SDK.',
-        );
-      });
-    }
+    initOtel.maybeInitializeEsmLoader();
   }
 
   opentelemetry.setOpenTelemetryContextAsyncContextStrategy();
@@ -175,11 +149,15 @@ function _init(
   // There is no way to use this SDK without OpenTelemetry!
   if (!options.skipOpenTelemetrySetup) {
     initOtel.initOpenTelemetry(client$1);
+    validateOpenTelemetrySetup();
   }
 
-  validateOpenTelemetrySetup();
+  opentelemetry.setupEventContextTrace(client$1);
 }
 
+/**
+ * Validate that your OpenTelemetry setup is correct.
+ */
 function validateOpenTelemetrySetup() {
   if (!debugBuild.DEBUG_BUILD) {
     return;
@@ -331,4 +309,5 @@ exports.getDefaultIntegrations = getDefaultIntegrations;
 exports.getDefaultIntegrationsWithoutPerformance = getDefaultIntegrationsWithoutPerformance;
 exports.init = init;
 exports.initWithoutDefaultIntegrations = initWithoutDefaultIntegrations;
-//# sourceMappingURL=init.js.map
+exports.validateOpenTelemetrySetup = validateOpenTelemetrySetup;
+//# sourceMappingURL=index.js.map

package/cjs/sdk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/sdk/index.ts"],"sourcesContent":["import {\n  endSession,\n  functionToStringIntegration,\n  getClient,\n  getCurrentScope,\n  getIntegrationsToSetup,\n  getIsolationScope,\n  hasTracingEnabled,\n  inboundFiltersIntegration,\n  linkedErrorsIntegration,\n  requestDataIntegration,\n  startSession,\n} from '@sentry/core';\nimport {\n  openTelemetrySetupCheck,\n  setOpenTelemetryContextAsyncContextStrategy,\n  setupEventContextTrace,\n} from '@sentry/opentelemetry';\nimport type { Client, Integration, Options } from '@sentry/types';\nimport {\n  consoleSandbox,\n  dropUndefinedKeys,\n  logger,\n  propagationContextFromHeaders,\n  stackParserFromStackParserOptions,\n} from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { consoleIntegration } from '../integrations/console';\nimport { nodeContextIntegration } from '../integrations/context';\nimport { contextLinesIntegration } from '../integrations/contextlines';\n\nimport { httpIntegration } from '../integrations/http';\nimport { localVariablesIntegration } from '../integrations/local-variables';\nimport { modulesIntegration } from '../integrations/modules';\nimport { nativeNodeFetchIntegration } from '../integrations/node-fetch';\nimport { onUncaughtExceptionIntegration } from '../integrations/onuncaughtexception';\nimport { onUnhandledRejectionIntegration } from '../integrations/onunhandledrejection';\nimport { spotlightIntegration } from '../integrations/spotlight';\nimport { getAutoPerformanceIntegrations } from '../integrations/tracing';\nimport { makeNodeTransport } from '../transports';\nimport type { NodeClientOptions, NodeOptions } from '../types';\nimport { isCjs } from '../utils/commonjs';\nimport { defaultStackParser, getSentryRelease } from './api';\nimport { NodeClient } from './client';\nimport { initOpenTelemetry, maybeInitializeEsmLoader } from './initOtel';\n\nfunction getCjsOnlyIntegrations(): Integration[] {\n  return isCjs() ? [modulesIntegration()] : [];\n}\n\n/**\n * Get default integrations, excluding performance.\n */\nexport function getDefaultIntegrationsWithoutPerformance(): Integration[] {\n  return [\n    // Common\n    inboundFiltersIntegration(),\n    functionToStringIntegration(),\n    linkedErrorsIntegration(),\n    requestDataIntegration(),\n    // Native Wrappers\n    consoleIntegration(),\n    httpIntegration(),\n    nativeNodeFetchIntegration(),\n    // Global Handlers\n    onUncaughtExceptionIntegration(),\n    onUnhandledRejectionIntegration(),\n    // Event Info\n    contextLinesIntegration(),\n    localVariablesIntegration(),\n    nodeContextIntegration(),\n    ...getCjsOnlyIntegrations(),\n  ];\n}\n\n/** Get the default integrations for the Node SDK. */\nexport function getDefaultIntegrations(options: Options): Integration[] {\n  return [\n    ...getDefaultIntegrationsWithoutPerformance(),\n    // We only add performance integrations if tracing is enabled\n    // Note that this means that without tracing enabled, e.g. `expressIntegration()` will not be added\n    // This means that generally request isolation will work (because that is done by httpIntegration)\n    // But `transactionName` will not be set automatically\n    ...(shouldAddPerformanceIntegrations(options) ? getAutoPerformanceIntegrations() : []),\n  ];\n}\n\nfunction shouldAddPerformanceIntegrations(options: Options): boolean {\n  if (!hasTracingEnabled(options)) {\n    return false;\n  }\n\n  // We want to ensure `tracesSampleRate` is not just undefined/null here\n  return options.enableTracing || options.tracesSampleRate != null || 'tracesSampler' in options;\n}\n\n/**\n * Initialize Sentry for Node.\n */\nexport function init(options: NodeOptions | undefined = {}): void {\n  return _init(options, getDefaultIntegrations);\n}\n\n/**\n * Initialize Sentry for Node, without any integrations added by default.\n */\nexport function initWithoutDefaultIntegrations(options: NodeOptions | undefined = {}): void {\n  return _init(options, () => []);\n}\n\n/**\n * Initialize Sentry for Node, without performance instrumentation.\n */\nfunction _init(\n  options: NodeOptions | undefined = {},\n  getDefaultIntegrationsImpl: (options: Options) => Integration[],\n): void {\n  const clientOptions = getClientOptions(options, getDefaultIntegrationsImpl);\n\n  if (clientOptions.debug === true) {\n    if (DEBUG_BUILD) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n      consoleSandbox(() => {\n        // eslint-disable-next-line no-console\n        console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n      });\n    }\n  }\n\n  if (!isCjs()) {\n    maybeInitializeEsmLoader();\n  }\n\n  setOpenTelemetryContextAsyncContextStrategy();\n\n  const scope = getCurrentScope();\n  scope.update(options.initialScope);\n\n  const client = new NodeClient(clientOptions);\n  // The client is on the current scope, from where it generally is inherited\n  getCurrentScope().setClient(client);\n\n  if (isEnabled(client)) {\n    client.init();\n  }\n\n  logger.log(`Running in ${isCjs() ? 'CommonJS' : 'ESM'} mode.`);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n\n  updateScopeFromEnvVariables();\n\n  if (options.spotlight) {\n    // force integrations to be setup even if no DSN was set\n    // If they have already been added before, they will be ignored anyhow\n    const integrations = client.getOptions().integrations;\n    for (const integration of integrations) {\n      client.addIntegration(integration);\n    }\n    client.addIntegration(\n      spotlightIntegration({\n        sidecarUrl: typeof options.spotlight === 'string' ? options.spotlight : undefined,\n      }),\n    );\n  }\n\n  // If users opt-out of this, they _have_ to set up OpenTelemetry themselves\n  // There is no way to use this SDK without OpenTelemetry!\n  if (!options.skipOpenTelemetrySetup) {\n    initOpenTelemetry(client);\n    validateOpenTelemetrySetup();\n  }\n\n  setupEventContextTrace(client);\n}\n\n/**\n * Validate that your OpenTelemetry setup is correct.\n */\nexport function validateOpenTelemetrySetup(): void {\n  if (!DEBUG_BUILD) {\n    return;\n  }\n\n  const setup = openTelemetrySetupCheck();\n\n  const required = ['SentrySpanProcessor', 'SentryContextManager', 'SentryPropagator'] as const;\n  for (const k of required) {\n    if (!setup.includes(k)) {\n      logger.error(\n        `You have to set up the ${k}. Without this, the OpenTelemetry & Sentry integration will not work properly.`,\n      );\n    }\n  }\n\n  if (!setup.includes('SentrySampler')) {\n    logger.warn(\n      'You have to set up the SentrySampler. Without this, the OpenTelemetry & Sentry integration may still work, but sample rates set for the Sentry SDK will not be respected.',\n    );\n  }\n}\n\nfunction getClientOptions(\n  options: NodeOptions,\n  getDefaultIntegrationsImpl: (options: Options) => Integration[],\n): NodeClientOptions {\n  const release = getRelease(options.release);\n\n  const autoSessionTracking =\n    typeof release !== 'string'\n      ? false\n      : options.autoSessionTracking === undefined\n        ? true\n        : options.autoSessionTracking;\n\n  const tracesSampleRate = getTracesSampleRate(options.tracesSampleRate);\n\n  const baseOptions = dropUndefinedKeys({\n    transport: makeNodeTransport,\n    dsn: process.env.SENTRY_DSN,\n    environment: process.env.SENTRY_ENVIRONMENT,\n  });\n\n  const overwriteOptions = dropUndefinedKeys({\n    release,\n    autoSessionTracking,\n    tracesSampleRate,\n  });\n\n  const mergedOptions = {\n    ...baseOptions,\n    ...options,\n    ...overwriteOptions,\n  };\n\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = getDefaultIntegrationsImpl(mergedOptions);\n  }\n\n  const clientOptions: NodeClientOptions = {\n    ...mergedOptions,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup({\n      defaultIntegrations: options.defaultIntegrations,\n      integrations: options.integrations,\n    }),\n  };\n\n  return clientOptions;\n}\n\nfunction getRelease(release: NodeOptions['release']): string | undefined {\n  if (release !== undefined) {\n    return release;\n  }\n\n  const detectedRelease = getSentryRelease();\n  if (detectedRelease !== undefined) {\n    return detectedRelease;\n  }\n\n  return undefined;\n}\n\nfunction getTracesSampleRate(tracesSampleRate: NodeOptions['tracesSampleRate']): number | undefined {\n  if (tracesSampleRate !== undefined) {\n    return tracesSampleRate;\n  }\n\n  const sampleRateFromEnv = process.env.SENTRY_TRACES_SAMPLE_RATE;\n  if (!sampleRateFromEnv) {\n    return undefined;\n  }\n\n  const parsed = parseFloat(sampleRateFromEnv);\n  return isFinite(parsed) ? parsed : undefined;\n}\n\n/**\n * Update scope and propagation context based on environmental variables.\n *\n * See https://github.com/getsentry/rfcs/blob/main/text/0071-continue-trace-over-process-boundaries.md\n * for more details.\n */\nfunction updateScopeFromEnvVariables(): void {\n  const sentryUseEnvironment = (process.env.SENTRY_USE_ENVIRONMENT || '').toLowerCase();\n  if (!['false', 'n', 'no', 'off', '0'].includes(sentryUseEnvironment)) {\n    const sentryTraceEnv = process.env.SENTRY_TRACE;\n    const baggageEnv = process.env.SENTRY_BAGGAGE;\n    const propagationContext = propagationContextFromHeaders(sentryTraceEnv, baggageEnv);\n    getCurrentScope().setPropagationContext(propagationContext);\n  }\n}\n\n/**\n * Enable automatic Session Tracking for the node process.\n */\nfunction startSessionTracking(): void {\n  const client = getClient<NodeClient>();\n  if (client && client.getOptions().autoSessionTracking) {\n    client.initSessionFlusher();\n  }\n\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 the Session exists on Scope and SessionStatus is not a\n    // Terminal Status i.e. Exited or Crashed because\n    // \"When a session is moved away from ok it must not be updated anymore.\"\n    // Ref: https://develop.sentry.dev/sdk/sessions/\n    if (session && session.status !== 'ok') {\n      endSession();\n    }\n  });\n}\n\nfunction isEnabled(client: Client): boolean {\n  return client.getOptions().enabled !== false && client.getTransport() !== undefined;\n}\n"],"names":["isCjs","modulesIntegration","inboundFiltersIntegration","functionToStringIntegration","linkedErrorsIntegration","requestDataIntegration","consoleIntegration","httpIntegration","nativeNodeFetchIntegration","onUncaughtExceptionIntegration","onUnhandledRejectionIntegration","contextLinesIntegration","localVariablesIntegration","nodeContextIntegration","getAutoPerformanceIntegrations","hasTracingEnabled","DEBUG_BUILD","logger","consoleSandbox","maybeInitializeEsmLoader","setOpenTelemetryContextAsyncContextStrategy","getCurrentScope","client","NodeClient","spotlightIntegration","initOpenTelemetry","setupEventContextTrace","openTelemetrySetupCheck","dropUndefinedKeys","makeNodeTransport","stackParserFromStackParserOptions","defaultStackParser","getIntegrationsToSetup","getSentryRelease","propagationContextFromHeaders","getClient","startSession","getIsolationScope","endSession"],"mappings":"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"}

package/cjs/sdk/initOtel.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
+const moduleModule = require('module');
 const api = require('@opentelemetry/api');
 const resources = require('@opentelemetry/resources');
 const sdkTraceBase = require('@opentelemetry/sdk-trace-base');
@@ -7,27 +8,87 @@ const semanticConventions = require('@opentelemetry/semantic-conventions');
 const core = require('@sentry/core');
 const opentelemetry = require('@sentry/opentelemetry');
 const utils = require('@sentry/utils');
+const index = require('../integrations/tracing/index.js');
 const contextManager = require('../otel/contextManager.js');
+const commonjs = require('../utils/commonjs.js');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 /**
  * Initialize OpenTelemetry for Node.
  */
 function initOpenTelemetry(client) {
   if (client.getOptions().debug) {
-    const otelLogger = new Proxy(utils.logger , {
-      get(target, prop, receiver) {
-        const actualProp = prop === 'verbose' ? 'debug' : prop;
-        return Reflect.get(target, actualProp, receiver);
-      },
+    setupOpenTelemetryLogger();
+  }
+
+  const provider = setupOtel(client);
+  client.traceProvider = provider;
+}
+
+/** Initialize the ESM loader. */
+function maybeInitializeEsmLoader() {
+  const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(Number);
+
+  // Register hook was added in v20.6.0 and v18.19.0
+  if (nodeMajor >= 22 || (nodeMajor === 20 && nodeMinor >= 6) || (nodeMajor === 18 && nodeMinor >= 19)) {
+    // We need to work around using import.meta.url directly because jest complains about it.
+    const importMetaUrl =
+      typeof (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('sdk/initOtel.js', document.baseURI).href)) !== 'undefined' ? (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('sdk/initOtel.js', document.baseURI).href)) : undefined;
+
+    if (!utils.GLOBAL_OBJ._sentryEsmLoaderHookRegistered && importMetaUrl) {
+      try {
+        // @ts-expect-error register is available in these versions
+        moduleModule.default.register('@opentelemetry/instrumentation/hook.mjs', importMetaUrl);
+        utils.GLOBAL_OBJ._sentryEsmLoaderHookRegistered = true;
+      } catch (error) {
+        utils.logger.warn('Failed to register ESM hook', error);
+      }
+    }
+  } else {
+    utils.consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[Sentry] You are using Node.js in ESM mode ("import syntax"). The Sentry Node.js SDK is not compatible with ESM in Node.js versions before 18.19.0 or before 20.6.0. Please either build your application with CommonJS ("require() syntax"), or use version 7.x of the Sentry Node.js SDK.',
+      );
     });
+  }
+}
 
-    api.diag.setLogger(otelLogger, api.DiagLogLevel.DEBUG);
+/**
+ * Preload OpenTelemetry for Node.
+ * This can be used to preload instrumentation early, but set up Sentry later.
+ * By preloading the OTEL instrumentation wrapping still happens early enough that everything works.
+ */
+function preloadOpenTelemetry(options = {}) {
+  const { debug } = options;
+
+  if (debug) {
+    utils.logger.enable();
+    setupOpenTelemetryLogger();
   }
 
-  opentelemetry.setupEventContextTrace(client);
+  if (!commonjs.isCjs()) {
+    maybeInitializeEsmLoader();
+  }
 
-  const provider = setupOtel(client);
-  client.traceProvider = provider;
+  // These are all integrations that we need to pre-load to ensure they are set up before any other code runs
+  getPreloadMethods(options.integrations).forEach(fn => {
+    fn();
+
+    if (debug) {
+      utils.logger.log(`[Sentry] Preloaded ${fn.id} instrumentation`);
+    }
+  });
+}
+
+function getPreloadMethods(integrationNames) {
+  const instruments = index.getOpenTelemetryInstrumentationToPreload();
+
+  if (!integrationNames) {
+    return instruments;
+  }
+
+  return instruments.filter(instrumentation => integrationNames.includes(instrumentation.id));
 }
 
 /** Just exported for tests. */
@@ -53,6 +114,24 @@ function setupOtel(client) {
   return provider;
 }
 
+/**
+ * Setup the OTEL logger to use our own logger.
+ */
+function setupOpenTelemetryLogger() {
+  const otelLogger = new Proxy(utils.logger , {
+    get(target, prop, receiver) {
+      const actualProp = prop === 'verbose' ? 'debug' : prop;
+      return Reflect.get(target, actualProp, receiver);
+    },
+  });
+
+  // Disable diag, to ensure this works even if called multiple times
+  api.diag.disable();
+  api.diag.setLogger(otelLogger, api.DiagLogLevel.DEBUG);
+}
+
 exports.initOpenTelemetry = initOpenTelemetry;
+exports.maybeInitializeEsmLoader = maybeInitializeEsmLoader;
+exports.preloadOpenTelemetry = preloadOpenTelemetry;
 exports.setupOtel = setupOtel;
 //# sourceMappingURL=initOtel.js.map

package/cjs/sdk/initOtel.js.map

@@ -1 +1 @@
-{"version":3,"file":"initOtel.js","sources":["../../../src/sdk/initOtel.ts"],"sourcesContent":["import { DiagLogLevel, diag } from '@opentelemetry/api';\nimport { Resource } from '@opentelemetry/resources';\nimport { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';\nimport {\n  SEMRESATTRS_SERVICE_NAME,\n  SEMRESATTRS_SERVICE_NAMESPACE,\n  SEMRESATTRS_SERVICE_VERSION,\n} from '@opentelemetry/semantic-conventions';\nimport { SDK_VERSION } from '@sentry/core';\nimport { SentryPropagator, SentrySampler, SentrySpanProcessor, setupEventContextTrace } from '@sentry/opentelemetry';\nimport { logger } from '@sentry/utils';\n\nimport { SentryContextManager } from '../otel/contextManager';\nimport type { NodeClient } from './client';\n\n/**\n * Initialize OpenTelemetry for Node.\n */\nexport function initOpenTelemetry(client: NodeClient): void {\n  if (client.getOptions().debug) {\n    const otelLogger = new Proxy(logger as typeof logger & { verbose: (typeof logger)['debug'] }, {\n      get(target, prop, receiver) {\n        const actualProp = prop === 'verbose' ? 'debug' : prop;\n        return Reflect.get(target, actualProp, receiver);\n      },\n    });\n\n    diag.setLogger(otelLogger, DiagLogLevel.DEBUG);\n  }\n\n  setupEventContextTrace(client);\n\n  const provider = setupOtel(client);\n  client.traceProvider = provider;\n}\n\n/** Just exported for tests. */\nexport function setupOtel(client: NodeClient): BasicTracerProvider {\n  // Create and configure NodeTracerProvider\n  const provider = new BasicTracerProvider({\n    sampler: new SentrySampler(client),\n    resource: new Resource({\n      [SEMRESATTRS_SERVICE_NAME]: 'node',\n      [SEMRESATTRS_SERVICE_NAMESPACE]: 'sentry',\n      [SEMRESATTRS_SERVICE_VERSION]: SDK_VERSION,\n    }),\n    forceFlushTimeoutMillis: 500,\n  });\n  provider.addSpanProcessor(new SentrySpanProcessor());\n\n  // Initialize the provider\n  provider.register({\n    propagator: new SentryPropagator(),\n    contextManager: new SentryContextManager(),\n  });\n\n  return provider;\n}\n"],"names":["logger","diag","DiagLogLevel","setupEventContextTrace","BasicTracerProvider","SentrySampler","Resource","SEMRESATTRS_SERVICE_NAME","SEMRESATTRS_SERVICE_NAMESPACE","SEMRESATTRS_SERVICE_VERSION","SDK_VERSION","SentrySpanProcessor","SentryPropagator","SentryContextManager"],"mappings":";;;;;;;;;;;AAeA;AACA;AACA;AACO,SAAS,iBAAiB,CAAC,MAAM,EAAoB;AAC5D,EAAE,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE;AACjC,IAAI,MAAM,UAAW,GAAE,IAAI,KAAK,CAACA,eAAiE;AAClG,MAAM,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE;AAClC,QAAQ,MAAM,aAAa,IAAA,KAAS,SAAU,GAAE,OAAQ,GAAE,IAAI,CAAA;AAC9D,QAAQ,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAA;AACxD,OAAO;AACP,KAAK,CAAC,CAAA;AACN;AACA,IAAIC,QAAI,CAAC,SAAS,CAAC,UAAU,EAAEC,gBAAY,CAAC,KAAK,CAAC,CAAA;AAClD,GAAE;AACF;AACA,EAAEC,oCAAsB,CAAC,MAAM,CAAC,CAAA;AAChC;AACA,EAAE,MAAM,QAAS,GAAE,SAAS,CAAC,MAAM,CAAC,CAAA;AACpC,EAAE,MAAM,CAAC,aAAc,GAAE,QAAQ,CAAA;AACjC,CAAA;AACA;AACA;AACO,SAAS,SAAS,CAAC,MAAM,EAAmC;AACnE;AACA,EAAE,MAAM,QAAA,GAAW,IAAIC,gCAAmB,CAAC;AAC3C,IAAI,OAAO,EAAE,IAAIC,2BAAa,CAAC,MAAM,CAAC;AACtC,IAAI,QAAQ,EAAE,IAAIC,kBAAQ,CAAC;AAC3B,MAAM,CAACC,4CAAwB,GAAG,MAAM;AACxC,MAAM,CAACC,iDAA6B,GAAG,QAAQ;AAC/C,MAAM,CAACC,+CAA2B,GAAGC,gBAAW;AAChD,KAAK,CAAC;AACN,IAAI,uBAAuB,EAAE,GAAG;AAChC,GAAG,CAAC,CAAA;AACJ,EAAE,QAAQ,CAAC,gBAAgB,CAAC,IAAIC,iCAAmB,EAAE,CAAC,CAAA;AACtD;AACA;AACA,EAAE,QAAQ,CAAC,QAAQ,CAAC;AACpB,IAAI,UAAU,EAAE,IAAIC,8BAAgB,EAAE;AACtC,IAAI,cAAc,EAAE,IAAIC,mCAAoB,EAAE;AAC9C,GAAG,CAAC,CAAA;AACJ;AACA,EAAE,OAAO,QAAQ,CAAA;AACjB;;;;;"}
+{"version":3,"file":"initOtel.js","sources":["../../../src/sdk/initOtel.ts"],"sourcesContent":["import moduleModule from 'module';\nimport { DiagLogLevel, diag } from '@opentelemetry/api';\nimport { Resource } from '@opentelemetry/resources';\nimport { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';\nimport {\n  SEMRESATTRS_SERVICE_NAME,\n  SEMRESATTRS_SERVICE_NAMESPACE,\n  SEMRESATTRS_SERVICE_VERSION,\n} from '@opentelemetry/semantic-conventions';\nimport { SDK_VERSION } from '@sentry/core';\nimport { SentryPropagator, SentrySampler, SentrySpanProcessor } from '@sentry/opentelemetry';\nimport { GLOBAL_OBJ, consoleSandbox, logger } from '@sentry/utils';\n\nimport { getOpenTelemetryInstrumentationToPreload } from '../integrations/tracing';\nimport { SentryContextManager } from '../otel/contextManager';\nimport { isCjs } from '../utils/commonjs';\nimport type { NodeClient } from './client';\n\ndeclare const __IMPORT_META_URL_REPLACEMENT__: string;\n\n/**\n * Initialize OpenTelemetry for Node.\n */\nexport function initOpenTelemetry(client: NodeClient): void {\n  if (client.getOptions().debug) {\n    setupOpenTelemetryLogger();\n  }\n\n  const provider = setupOtel(client);\n  client.traceProvider = provider;\n}\n\n/** Initialize the ESM loader. */\nexport function maybeInitializeEsmLoader(): void {\n  const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(Number);\n\n  // Register hook was added in v20.6.0 and v18.19.0\n  if (nodeMajor >= 22 || (nodeMajor === 20 && nodeMinor >= 6) || (nodeMajor === 18 && nodeMinor >= 19)) {\n    // We need to work around using import.meta.url directly because jest complains about it.\n    const importMetaUrl =\n      typeof __IMPORT_META_URL_REPLACEMENT__ !== 'undefined' ? __IMPORT_META_URL_REPLACEMENT__ : undefined;\n\n    if (!GLOBAL_OBJ._sentryEsmLoaderHookRegistered && importMetaUrl) {\n      try {\n        // @ts-expect-error register is available in these versions\n        moduleModule.register('@opentelemetry/instrumentation/hook.mjs', importMetaUrl);\n        GLOBAL_OBJ._sentryEsmLoaderHookRegistered = true;\n      } catch (error) {\n        logger.warn('Failed to register ESM hook', error);\n      }\n    }\n  } else {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[Sentry] You are using Node.js in ESM mode (\"import syntax\"). The Sentry Node.js SDK is not compatible with ESM in Node.js versions before 18.19.0 or before 20.6.0. Please either build your application with CommonJS (\"require() syntax\"), or use version 7.x of the Sentry Node.js SDK.',\n      );\n    });\n  }\n}\n\ninterface NodePreloadOptions {\n  debug?: boolean;\n  integrations?: string[];\n}\n\n/**\n * Preload OpenTelemetry for Node.\n * This can be used to preload instrumentation early, but set up Sentry later.\n * By preloading the OTEL instrumentation wrapping still happens early enough that everything works.\n */\nexport function preloadOpenTelemetry(options: NodePreloadOptions = {}): void {\n  const { debug } = options;\n\n  if (debug) {\n    logger.enable();\n    setupOpenTelemetryLogger();\n  }\n\n  if (!isCjs()) {\n    maybeInitializeEsmLoader();\n  }\n\n  // These are all integrations that we need to pre-load to ensure they are set up before any other code runs\n  getPreloadMethods(options.integrations).forEach(fn => {\n    fn();\n\n    if (debug) {\n      logger.log(`[Sentry] Preloaded ${fn.id} instrumentation`);\n    }\n  });\n}\n\nfunction getPreloadMethods(integrationNames?: string[]): ((() => void) & { id: string })[] {\n  const instruments = getOpenTelemetryInstrumentationToPreload();\n\n  if (!integrationNames) {\n    return instruments;\n  }\n\n  return instruments.filter(instrumentation => integrationNames.includes(instrumentation.id));\n}\n\n/** Just exported for tests. */\nexport function setupOtel(client: NodeClient): BasicTracerProvider {\n  // Create and configure NodeTracerProvider\n  const provider = new BasicTracerProvider({\n    sampler: new SentrySampler(client),\n    resource: new Resource({\n      [SEMRESATTRS_SERVICE_NAME]: 'node',\n      [SEMRESATTRS_SERVICE_NAMESPACE]: 'sentry',\n      [SEMRESATTRS_SERVICE_VERSION]: SDK_VERSION,\n    }),\n    forceFlushTimeoutMillis: 500,\n  });\n  provider.addSpanProcessor(new SentrySpanProcessor());\n\n  // Initialize the provider\n  provider.register({\n    propagator: new SentryPropagator(),\n    contextManager: new SentryContextManager(),\n  });\n\n  return provider;\n}\n\n/**\n * Setup the OTEL logger to use our own logger.\n */\nfunction setupOpenTelemetryLogger(): void {\n  const otelLogger = new Proxy(logger as typeof logger & { verbose: (typeof logger)['debug'] }, {\n    get(target, prop, receiver) {\n      const actualProp = prop === 'verbose' ? 'debug' : prop;\n      return Reflect.get(target, actualProp, receiver);\n    },\n  });\n\n  // Disable diag, to ensure this works even if called multiple times\n  diag.disable();\n  diag.setLogger(otelLogger, DiagLogLevel.DEBUG);\n}\n"],"names":["GLOBAL_OBJ","moduleModule","logger","consoleSandbox","isCjs","getOpenTelemetryInstrumentationToPreload","BasicTracerProvider","SentrySampler","Resource","SEMRESATTRS_SERVICE_NAME","SEMRESATTRS_SERVICE_NAMESPACE","SEMRESATTRS_SERVICE_VERSION","SDK_VERSION","SentrySpanProcessor","SentryPropagator","SentryContextManager","diag","DiagLogLevel"],"mappings":"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"}

package/esm/index.js

@@ -23,8 +23,9 @@ export { hapiIntegration, setupHapiErrorHandler } from './integrations/tracing/h
 export { koaIntegration, setupKoaErrorHandler } from './integrations/tracing/koa.js';
 export { connectIntegration, setupConnectErrorHandler } from './integrations/tracing/connect.js';
 export { spotlightIntegration } from './integrations/spotlight.js';
-export { getDefaultIntegrations, getDefaultIntegrationsWithoutPerformance, init, initWithoutDefaultIntegrations } from './sdk/init.js';
-export { initOpenTelemetry } from './sdk/initOtel.js';
+export { SentryContextManager } from './otel/contextManager.js';
+export { getDefaultIntegrations, getDefaultIntegrationsWithoutPerformance, init, initWithoutDefaultIntegrations, validateOpenTelemetrySetup } from './sdk/index.js';
+export { initOpenTelemetry, preloadOpenTelemetry } from './sdk/initOtel.js';
 export { getAutoPerformanceIntegrations } from './integrations/tracing/index.js';
 export { defaultStackParser, getSentryRelease } from './sdk/api.js';
 export { createGetModuleFromFilename } from './utils/module.js';
@@ -33,5 +34,5 @@ export { NodeClient } from './sdk/client.js';
 export { cron } from './cron/index.js';
 export { DEFAULT_USER_INCLUDES, addRequestDataToEvent, extractRequestData } from '@sentry/utils';
 export { addOpenTelemetryInstrumentation, continueTrace, setOpenTelemetryContextAsyncContextStrategy as setNodeAsyncContextStrategy } from '@sentry/opentelemetry';
-export { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, Scope, addBreadcrumb, addEventProcessor, addIntegration, captureCheckIn, captureConsoleIntegration, captureEvent, captureException, captureFeedback, captureMessage, captureSession, close, createTransport, debugIntegration, dedupeIntegration, endSession, extraErrorDataIntegration, flush, functionToStringIntegration, getActiveSpan, getClient, getCurrentHub, getCurrentScope, getGlobalScope, getIsolationScope, getRootSpan, getSpanDescendants, getSpanStatusFromHttpCode, inboundFiltersIntegration, isInitialized, lastEventId, linkedErrorsIntegration, metricsDefault as metrics, parameterize, requestDataIntegration, rewriteFramesIntegration, sessionTimingIntegration, setContext, setCurrentClient, setExtra, setExtras, setHttpStatus, setMeasurement, setTag, setTags, setUser, spanToBaggageHeader, spanToJSON, spanToTraceHeader, startInactiveSpan, startSession, startSpan, startSpanManual, trpcMiddleware, withActiveSpan, withIsolationScope, withMonitor, withScope, zodErrorsIntegration } from '@sentry/core';
+export { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, Scope, addBreadcrumb, addEventProcessor, addIntegration, captureCheckIn, captureConsoleIntegration, captureEvent, captureException, captureFeedback, captureMessage, captureSession, close, createTransport, debugIntegration, dedupeIntegration, endSession, extraErrorDataIntegration, flush, functionToStringIntegration, getActiveSpan, getClient, getCurrentHub, getCurrentScope, getGlobalScope, getIsolationScope, getRootSpan, getSpanDescendants, getSpanStatusFromHttpCode, inboundFiltersIntegration, isInitialized, lastEventId, linkedErrorsIntegration, metricsDefault as metrics, parameterize, requestDataIntegration, rewriteFramesIntegration, sessionTimingIntegration, setContext, setCurrentClient, setExtra, setExtras, setHttpStatus, setMeasurement, setTag, setTags, setUser, spanToBaggageHeader, spanToJSON, spanToTraceHeader, startInactiveSpan, startNewTrace, startSession, startSpan, startSpanManual, trpcMiddleware, withActiveSpan, withIsolationScope, withMonitor, withScope, zodErrorsIntegration } from '@sentry/core';
 //# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/esm/init.js

@@ -1,4 +1,4 @@
-import { init } from './sdk/init.js';
+import { init } from './sdk/index.js';
 
 /**
  * The @sentry/node/init export can be used with the node --import and --require args to initialize the SDK entirely via

package/esm/init.js.map

@@ -1 +1 @@
-{"version":3,"file":"init.js","sources":["../../src/init.ts"],"sourcesContent":["import { init } from './sdk/init';\n\n/**\n * The @sentry/node/init export can be used with the node --import and --require args to initialize the SDK entirely via\n * environment variables.\n *\n * > SENTRY_DSN=https://examplePublicKey@o0.ingest.sentry.io/0 SENTRY_TRACES_SAMPLE_RATE=1.0 node --import=@sentry/node/init app.mjs\n */\ninit();\n"],"names":[],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,EAAE"}
+{"version":3,"file":"init.js","sources":["../../src/init.ts"],"sourcesContent":["import { init } from './sdk';\n\n/**\n * The @sentry/node/init export can be used with the node --import and --require args to initialize the SDK entirely via\n * environment variables.\n *\n * > SENTRY_DSN=https://examplePublicKey@o0.ingest.sentry.io/0 SENTRY_TRACES_SAMPLE_RATE=1.0 node --import=@sentry/node/init app.mjs\n */\ninit();\n"],"names":[],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,EAAE"}

package/esm/integrations/anr/index.js

@@ -1,12 +1,11 @@
 import { _optionalChain, _optionalChainDelete } from '@sentry/utils';
-import * as inspector from 'node:inspector';
 import { Worker } from 'node:worker_threads';
 import { defineIntegration, getGlobalScope, mergeScopeData, getIsolationScope, getCurrentScope } from '@sentry/core';
 import { logger, GLOBAL_OBJ } from '@sentry/utils';
 import { NODE_VERSION } from '../../nodeVersion.js';
 
 // This string is a placeholder that gets overwritten with the worker code.
-const base64WorkerScript = '/*! @sentry/node 8.4.0 (fa14035) | https://github.com/getsentry/sentry-javascript */
import{parentPort as t,workerData as e}from"node:worker_threads";import{Session as n}from"inspector";import{posix as r,sep as o}from"node:path";import*as s from"node:http";import*as i from"node:https";import{Readable as c}from"node:stream";import{createGzip as u}from"node:zlib";import*as a from"node:net";import*as f from"node:tls";const h=Object.prototype.toString;function p(t,e){return h.call(t)===`[object ${e}]`}function l(t){return p(t,"Object")}function d(t){return Boolean(t&&t.then&&"function"==typeof t.then)}function m(t,e){try{return t instanceof e}catch(t){return!1}}const g=globalThis;function y(t,e,n){const r=n||g,o=r.__SENTRY__=r.__SENTRY__||{};return o[t]||(o[t]=e())}const b=g,v=80;function _(t,e){const n=t,r=[];let o,s,i,c,u;if(!n||!n.tagName)return"";if(b.HTMLElement&&n instanceof HTMLElement&&n.dataset){if(n.dataset.sentryComponent)return n.dataset.sentryComponent;if(n.dataset.sentryElement)return n.dataset.sentryElement}r.push(n.tagName.toLowerCase());const a=e&&e.length?e.filter((t=>n.getAttribute(t))).map((t=>[t,n.getAttribute(t)])):null;if(a&&a.length)a.forEach((t=>{r.push(`[${t[0]}="${t[1]}"]`)}));else if(n.id&&r.push(`#${n.id}`),o=n.className,o&&p(o,"String"))for(s=o.split(/\s+/),u=0;u<s.length;u++)r.push(`.${s[u]}`);const f=["aria-label","type","name","title","alt"];for(u=0;u<f.length;u++)i=f[u],c=n.getAttribute(i),c&&r.push(`[${i}="${c}"]`);return r.join("")}const w="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__,S=["debug","info","warn","error","log","assert","trace"],$={};function E(t){if(!("console"in g))return t();const e=g.console,n={},r=Object.keys($);r.forEach((t=>{const r=$[t];n[t]=e[t],e[t]=r}));try{return t()}finally{r.forEach((t=>{e[t]=n[t]}))}}const x=function(){let t=!1;const e={enable:()=>{t=!0},disable:()=>{t=!1},isEnabled:()=>t};return w?S.forEach((n=>{e[n]=(...e)=>{t&&E((()=>{g.console[n](`Sentry Logger [${n}]:`,...e)}))}})):S.forEach((t=>{e[t]=()=>{}})),e}();function N(t,e=!1){const{host:n,path:r,pass:o,port:s,projectId:i,protocol:c,publicKey:u}=t;return`${c}://${u}${e&&o?`:${o}`:""}@${n}${s?`:${s}`:""}/${r?`${r}/`:r}${i}`}class k extends Error{constructor(t,e="warn"){super(t),this.message=t,this.name=new.target.prototype.constructor.name,Object.setPrototypeOf(this,new.target.prototype),this.logLevel=e}}function C(t){if(function(t){switch(h.call(t)){case"[object Error]":case"[object Exception]":case"[object DOMException]":return!0;default:return m(t,Error)}}(t))return{message:t.message,name:t.name,stack:t.stack,...T(t)};if(e=t,"undefined"!=typeof Event&&m(e,Event)){const e={type:t.type,target:D(t.target),currentTarget:D(t.currentTarget),...T(t)};return"undefined"!=typeof CustomEvent&&m(t,CustomEvent)&&(e.detail=t.detail),e}return t;var e}function D(t){try{return e=t,"undefined"!=typeof Element&&m(e,Element)?function(t,e={}){if(!t)return"<unknown>";try{let n=t;const r=5,o=[];let s=0,i=0;const c=" > ",u=c.length;let a;const f=Array.isArray(e)?e:e.keyAttrs,h=!Array.isArray(e)&&e.maxStringLength||v;for(;n&&s++<r&&(a=_(n,f),!("html"===a||s>1&&i+o.length*u+a.length>=h));)o.push(a),i+=a.length,n=n.parentNode;return o.reverse().join(c)}catch(t){return"<unknown>"}}(t):Object.prototype.toString.call(t)}catch(t){return"<unknown>"}var e}function T(t){if("object"==typeof t&&null!==t){const e={};for(const n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n]);return e}return{}}function O(t){return j(t,new Map)}function j(t,e){if(function(t){if(!l(t))return!1;try{const e=Object.getPrototypeOf(t).constructor.name;return!e||"Object"===e}catch(t){return!0}}(t)){const n=e.get(t);if(void 0!==n)return n;const r={};e.set(t,r);for(const n of Object.keys(t))void 0!==t[n]&&(r[n]=j(t[n],e));return r}if(Array.isArray(t)){const n=e.get(t);if(void 0!==n)return n;const r=[];return e.set(t,r),t.forEach((t=>{r.push(j(t,e))})),r}return t}const R=50,A="?",I=/captureMessage|captureException/;const P="<anonymous>";const U=1e3;function M(){return Date.now()/U}const L=function(){const{performance:t}=g;if(!t||!t.now)return M;const e=Date.now()-t.now(),n=null==t.timeOrigin?e:t.timeOrigin;return()=>(n+t.now())/U}();function B(){const t=g,e=t.crypto||t.msCrypto;let n=()=>16*Math.random();try{if(e&&e.randomUUID)return e.randomUUID().replace(/-/g,"");e&&e.getRandomValues&&(n=()=>{const t=new Uint8Array(1);return e.getRandomValues(t),t[0]})}catch(t){}return([1e7]+1e3+4e3+8e3+1e11).replace(/[018]/g,(t=>(t^(15&n())>>t/4).toString(16)))}function G(t,e=100,n=1/0){try{return J("",t,e,n)}catch(t){return{ERROR:`**non-serializable** (${t})`}}}function J(t,e,n=1/0,r=1/0,o=function(){const t="function"==typeof WeakSet,e=t?new WeakSet:[];return[function(n){if(t)return!!e.has(n)||(e.add(n),!1);for(let t=0;t<e.length;t++)if(e[t]===n)return!0;return e.push(n),!1},function(n){if(t)e.delete(n);else for(let t=0;t<e.length;t++)if(e[t]===n){e.splice(t,1);break}}]}()){const[s,i]=o;if(null==e||["number","boolean","string"].includes(typeof e)&&!Number.isNaN(e))return e;const c=function(t,e){try{if("domain"===t&&e&&"object"==typeof e&&e.t)return"[Domain]";if("domainEmitter"===t)return"[DomainEmitter]";if("undefined"!=typeof global&&e===global)return"[Global]";if("undefined"!=typeof window&&e===window)return"[Window]";if("undefined"!=typeof document&&e===document)return"[Document]";if("object"==typeof(n=e)&&null!==n&&(n.__isVue||n.o))return"[VueViewModel]";if(function(t){return l(t)&&"nativeEvent"in t&&"preventDefault"in t&&"stopPropagation"in t}(e))return"[SyntheticEvent]";if("number"==typeof e&&e!=e)return"[NaN]";if("function"==typeof e)return`[Function: ${function(t){try{return t&&"function"==typeof t&&t.name||P}catch(t){return P}}(e)}]`;if("symbol"==typeof e)return`[${String(e)}]`;if("bigint"==typeof e)return`[BigInt: ${String(e)}]`;const r=function(t){const e=Object.getPrototypeOf(t);return e?e.constructor.name:"null prototype"}(e);return/^HTML(\w*)Element$/.test(r)?`[HTMLElement: ${r}]`:`[object ${r}]`}catch(t){return`**non-serializable** (${t})`}var n}(t,e);if(!c.startsWith("[object "))return c;if(e.__sentry_skip_normalization__)return e;const u="number"==typeof e.__sentry_override_normalization_depth__?e.__sentry_override_normalization_depth__:n;if(0===u)return c.replace("object ","");if(s(e))return"[Circular ~]";const a=e;if(a&&"function"==typeof a.toJSON)try{return J("",a.toJSON(),u-1,r,o)}catch(t){}const f=Array.isArray(e)?[]:{};let h=0;const p=C(e);for(const t in p){if(!Object.prototype.hasOwnProperty.call(p,t))continue;if(h>=r){f[t]="[MaxProperties ~]";break}const e=p[t];f[t]=J(t,e,u-1,r,o),h++}return i(e),f}function z(t,e){const n=e.replace(/\\/g,"/").replace(/[|\\{}()[\]^$+*?.]/g,"\\$&");let r=t;try{r=decodeURI(t)}catch(t){}return r.replace(/\\/g,"/").replace(/webpack:\/?/g,"").replace(new RegExp(`(file://)?/*${n}/*`,"ig"),"app:///")}(()=>{const{performance:t}=g;if(!t||!t.now)return;const e=36e5,n=t.now(),r=Date.now(),o=t.timeOrigin?Math.abs(t.timeOrigin+n-r):e,s=o<e,i=t.timing&&t.timing.navigationStart,c="number"==typeof i?Math.abs(i+n-r):e;(s||c<e)&&(o<=c&&t.timeOrigin)})();const H=/^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;function W(t){const e=function(t){const e=t.length>1024?`<truncated>${t.slice(-1024)}`:t,n=H.exec(e);return n?n.slice(1):[]}(t),n=e[0];let r=e[1];return n||r?(r&&(r=r.slice(0,r.length-1)),n+r):"."}var Y;function q(t){return new F((e=>{e(t)}))}!function(t){t[t.PENDING=0]="PENDING";t[t.RESOLVED=1]="RESOLVED";t[t.REJECTED=2]="REJECTED"}(Y||(Y={}));class F{constructor(t){F.prototype.__init.call(this),F.prototype.__init2.call(this),F.prototype.__init3.call(this),F.prototype.__init4.call(this),this.i=Y.PENDING,this.u=[];try{t(this.h,this.p)}catch(t){this.p(t)}}then(t,e){return new F(((n,r)=>{this.u.push([!1,e=>{if(t)try{n(t(e))}catch(t){r(t)}else n(e)},t=>{if(e)try{n(e(t))}catch(t){r(t)}else r(t)}]),this.l()}))}catch(t){return this.then((t=>t),t)}finally(t){return new F(((e,n)=>{let r,o;return this.then((e=>{o=!1,r=e,t&&t()}),(e=>{o=!0,r=e,t&&t()})).then((()=>{o?n(r):e(r)}))}))}__init(){this.h=t=>{this.m(Y.RESOLVED,t)}}__init2(){this.p=t=>{this.m(Y.REJECTED,t)}}__init3(){this.m=(t,e)=>{this.i===Y.PENDING&&(d(e)?e.then(this.h,this.p):(this.i=t,this.v=e,this.l()))}}__init4(){this.l=()=>{if(this.i===Y.PENDING)return;const t=this.u.slice();this.u=[],t.forEach((t=>{t[0]||(this.i===Y.RESOLVED&&t[1](this.v),this.i===Y.REJECTED&&t[2](this.v),t[0]=!0)}))}}}function K(t){const e=[];function n(t){return e.splice(e.indexOf(t),1)[0]}return{$:e,add:function(r){if(!(void 0===t||e.length<t))return o=new k("Not adding Promise because buffer limit was reached."),new F(((t,e)=>{e(o)}));var o;const s=r();return-1===e.indexOf(s)&&e.push(s),s.then((()=>n(s))).then(null,(()=>n(s).then(null,(()=>{})))),s},drain:function(t){return new F(((n,r)=>{let o=e.length;if(!o)return n(!0);const s=setTimeout((()=>{t&&t>0&&n(!1)}),t);e.forEach((t=>{q(t).then((()=>{--o||(clearTimeout(s),n(!0))}),r)}))}))}}}function V(t,e=!1){return!(e||t&&!t.startsWith("/")&&!t.match(/^[A-Z]:/)&&!t.startsWith(".")&&!t.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//))&&void 0!==t&&!t.includes("node_modules/")}function Z(t,e=[]){return[t,e]}function Q(t,e){const n=t[1];for(const t of n){if(e(t,t[0].type))return!0}return!1}function X(t){return g.__SENTRY__&&g.__SENTRY__.encodePolyfill?g.__SENTRY__.encodePolyfill(t):(new TextEncoder).encode(t)}function tt(t){const[e,n]=t;let r=JSON.stringify(e);function o(t){"string"==typeof r?r="string"==typeof t?r+t:[X(r),t]:r.push("string"==typeof t?X(t):t)}for(const t of n){const[e,n]=t;if(o(`\n${JSON.stringify(e)}\n`),"string"==typeof n||n instanceof Uint8Array)o(n);else{let t;try{t=JSON.stringify(n)}catch(e){t=JSON.stringify(G(n))}o(t)}}return"string"==typeof r?r:function(t){const e=t.reduce(((t,e)=>t+e.length),0),n=new Uint8Array(e);let r=0;for(const e of t)n.set(e,r),r+=e.length;return n}(r)}const et={session:"session",sessions:"session",attachment:"attachment",transaction:"transaction",event:"error",client_report:"internal",user_report:"default",profile:"profile",replay_event:"replay",replay_recording:"replay",check_in:"monitor",feedback:"feedback",span:"span",statsd:"metric_bucket"};function nt(t){return et[t]}function rt(t){if(!t||!t.sdk)return;const{name:e,version:n}=t.sdk;return{name:e,version:n}}const ot=6e4;function st(t,{statusCode:e,headers:n},r=Date.now()){const o={...t},s=n&&n["x-sentry-rate-limits"],i=n&&n["retry-after"];if(s)for(const t of s.trim().split(",")){const[e,n,,,s]=t.split(":",5),i=parseInt(e,10),c=1e3*(isNaN(i)?60:i);if(n)for(const t of n.split(";"))"metric_bucket"===t&&s&&!s.split(";").includes("custom")||(o[t]=r+c);else o.all=r+c}else i?o.all=r+function(t,e=Date.now()){const n=parseInt(`${t}`,10);if(!isNaN(n))return 1e3*n;const r=Date.parse(`${t}`);return isNaN(r)?ot:r-e}(i,r):429===e&&(o.all=r+6e4);return o}const it="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__;function ct(){return ut(g),g}function ut(t){return t.__SENTRY__||(t.__SENTRY__={extensions:{}}),t.__SENTRY__}function at(t){const e=L(),n={sid:B(),init:!0,timestamp:e,started:e,duration:0,status:"ok",errors:0,ignoreDuration:!1,toJSON:()=>function(t){return O({sid:`${t.sid}`,init:t.init,started:new Date(1e3*t.started).toISOString(),timestamp:new Date(1e3*t.timestamp).toISOString(),status:t.status,errors:t.errors,did:"number"==typeof t.did||"string"==typeof t.did?`${t.did}`:void 0,duration:t.duration,abnormal_mechanism:t.abnormal_mechanism,attrs:{release:t.release,environment:t.environment,ip_address:t.ipAddress,user_agent:t.userAgent}})}(n)};return t&&ft(n,t),n}function ft(t,e={}){if(e.user&&(!t.ipAddress&&e.user.ip_address&&(t.ipAddress=e.user.ip_address),t.did||e.did||(t.did=e.user.id||e.user.email||e.user.username)),t.timestamp=e.timestamp||L(),e.abnormal_mechanism&&(t.abnormal_mechanism=e.abnormal_mechanism),e.ignoreDuration&&(t.ignoreDuration=e.ignoreDuration),e.sid&&(t.sid=32===e.sid.length?e.sid:B()),void 0!==e.init&&(t.init=e.init),!t.did&&e.did&&(t.did=`${e.did}`),"number"==typeof e.started&&(t.started=e.started),t.ignoreDuration)t.duration=void 0;else if("number"==typeof e.duration)t.duration=e.duration;else{const e=t.timestamp-t.started;t.duration=e>=0?e:0}e.release&&(t.release=e.release),e.environment&&(t.environment=e.environment),!t.ipAddress&&e.ipAddress&&(t.ipAddress=e.ipAddress),!t.userAgent&&e.userAgent&&(t.userAgent=e.userAgent),"number"==typeof e.errors&&(t.errors=e.errors),e.status&&(t.status=e.status)}const ht="_sentrySpan";function pt(t,e){e?function(t,e,n){try{Object.defineProperty(t,e,{value:n,writable:!0,configurable:!0})}catch(n){w&&x.log(`Failed to add non-enumerable property "${e}" to object`,t)}}(t,ht,e):delete t[ht]}function lt(t){return t[ht]}class dt{constructor(){this._=!1,this.S=[],this.N=[],this.k=[],this.C=[],this.D={},this.T={},this.O={},this.j={},this.R={},this.A=gt()}clone(){const t=new dt;return t.k=[...this.k],t.T={...this.T},t.O={...this.O},t.j={...this.j},t.D=this.D,t.I=this.I,t.P=this.P,t.U=this.U,t.M=this.M,t.N=[...this.N],t.L=this.L,t.C=[...this.C],t.R={...this.R},t.A={...this.A},t.B=this.B,t.G=this.G,pt(t,lt(this)),t}setClient(t){this.B=t}setLastEventId(t){this.G=t}getClient(){return this.B}lastEventId(){return this.G}addScopeListener(t){this.S.push(t)}addEventProcessor(t){return this.N.push(t),this}setUser(t){return this.D=t||{email:void 0,id:void 0,ip_address:void 0,username:void 0},this.P&&ft(this.P,{user:t}),this.J(),this}getUser(){return this.D}getRequestSession(){return this.L}setRequestSession(t){return this.L=t,this}setTags(t){return this.T={...this.T,...t},this.J(),this}setTag(t,e){return this.T={...this.T,[t]:e},this.J(),this}setExtras(t){return this.O={...this.O,...t},this.J(),this}setExtra(t,e){return this.O={...this.O,[t]:e},this.J(),this}setFingerprint(t){return this.M=t,this.J(),this}setLevel(t){return this.I=t,this.J(),this}setTransactionName(t){return this.U=t,this.J(),this}setContext(t,e){return null===e?delete this.j[t]:this.j[t]=e,this.J(),this}setSession(t){return t?this.P=t:delete this.P,this.J(),this}getSession(){return this.P}update(t){if(!t)return this;const e="function"==typeof t?t(this):t,[n,r]=e instanceof mt?[e.getScopeData(),e.getRequestSession()]:l(e)?[t,t.requestSession]:[],{tags:o,extra:s,user:i,contexts:c,level:u,fingerprint:a=[],propagationContext:f}=n||{};return this.T={...this.T,...o},this.O={...this.O,...s},this.j={...this.j,...c},i&&Object.keys(i).length&&(this.D=i),u&&(this.I=u),a.length&&(this.M=a),f&&(this.A=f),r&&(this.L=r),this}clear(){return this.k=[],this.T={},this.O={},this.D={},this.j={},this.I=void 0,this.U=void 0,this.M=void 0,this.L=void 0,this.P=void 0,pt(this,void 0),this.C=[],this.A=gt(),this.J(),this}addBreadcrumb(t,e){const n="number"==typeof e?e:100;if(n<=0)return this;const r={timestamp:M(),...t},o=this.k;return o.push(r),this.k=o.length>n?o.slice(-n):o,this.J(),this}getLastBreadcrumb(){return this.k[this.k.length-1]}clearBreadcrumbs(){return this.k=[],this.J(),this}addAttachment(t){return this.C.push(t),this}clearAttachments(){return this.C=[],this}getScopeData(){return{breadcrumbs:this.k,attachments:this.C,contexts:this.j,tags:this.T,extra:this.O,user:this.D,level:this.I,fingerprint:this.M||[],eventProcessors:this.N,propagationContext:this.A,sdkProcessingMetadata:this.R,transactionName:this.U,span:lt(this)}}setSDKProcessingMetadata(t){return this.R={...this.R,...t},this}setPropagationContext(t){return this.A=t,this}getPropagationContext(){return this.A}captureException(t,e){const n=e&&e.event_id?e.event_id:B();if(!this.B)return x.warn("No client configured on scope - will not capture exception!"),n;const r=new Error("Sentry syntheticException");return this.B.captureException(t,{originalException:t,syntheticException:r,...e,event_id:n},this),n}captureMessage(t,e,n){const r=n&&n.event_id?n.event_id:B();if(!this.B)return x.warn("No client configured on scope - will not capture message!"),r;const o=new Error(t);return this.B.captureMessage(t,e,{originalException:t,syntheticException:o,...n,event_id:r},this),r}captureEvent(t,e){const n=e&&e.event_id?e.event_id:B();return this.B?(this.B.captureEvent(t,{...e,event_id:n},this),n):(x.warn("No client configured on scope - will not capture event!"),n)}J(){this._||(this._=!0,this.S.forEach((t=>{t(this)})),this._=!1)}}const mt=dt;function gt(){return{traceId:B(),spanId:B().substring(16)}}class yt{constructor(t,e){let n,r;n=t||new mt,r=e||new mt,this.H=[{scope:n}],this.W=r}withScope(t){const e=this.Y();let n;try{n=t(e)}catch(t){throw this.q(),t}return d(n)?n.then((t=>(this.q(),t)),(t=>{throw this.q(),t})):(this.q(),n)}getClient(){return this.getStackTop().client}getScope(){return this.getStackTop().scope}getIsolationScope(){return this.W}getStack(){return this.H}getStackTop(){return this.H[this.H.length-1]}Y(){const t=this.getScope().clone();return this.getStack().push({client:this.getClient(),scope:t}),t}q(){return!(this.getStack().length<=1)&&!!this.getStack().pop()}}function bt(){const t=ut(ct());return t.hub||(t.hub=new yt(y("defaultCurrentScope",(()=>new mt)),y("defaultIsolationScope",(()=>new mt)))),t.hub}function vt(t){return bt().withScope(t)}function _t(t,e){const n=bt();return n.withScope((()=>(n.getStackTop().scope=t,e(t))))}function wt(t){return bt().withScope((()=>t(bt().getIsolationScope())))}function St(t){const e=ut(t);return e.acs?e.acs:{withIsolationScope:wt,withScope:vt,withSetScope:_t,withSetIsolationScope:(t,e)=>wt(e),getCurrentScope:()=>bt().getScope(),getIsolationScope:()=>bt().getIsolationScope()}}function $t(){return St(ct()).getCurrentScope().getClient()}const Et="sentry.source",xt="sentry.sample_rate",Nt="sentry.op",kt="sentry.origin",Ct=0,Dt=1,Tt=1;function Ot(t){const{spanId:e,traceId:n}=t.spanContext(),{parent_span_id:r}=At(t);return O({parent_span_id:r,span_id:e,trace_id:n})}function jt(t){return"number"==typeof t?Rt(t):Array.isArray(t)?t[0]+t[1]/1e9:t instanceof Date?Rt(t.getTime()):L()}function Rt(t){return t>9999999999?t/1e3:t}function At(t){if(function(t){return"function"==typeof t.getSpanJSON}(t))return t.getSpanJSON();try{const{spanId:e,traceId:n}=t.spanContext();if(function(t){const e=t;return!!(e.attributes&&e.startTime&&e.name&&e.endTime&&e.status)}(t)){const{attributes:r,startTime:o,name:s,endTime:i,parentSpanId:c,status:u}=t;return O({span_id:e,trace_id:n,data:r,description:s,parent_span_id:c,start_timestamp:jt(o),timestamp:jt(i)||void 0,status:It(u),op:r[Nt],origin:r[kt],F:void 0})}return{span_id:e,trace_id:n}}catch(t){return{}}}function It(t){if(t&&t.code!==Ct)return t.code===Dt?"ok":t.message||"unknown_error"}const Pt="_sentryRootSpan";function Ut(t){return t[Pt]||t}const Mt="production",Lt="_frozenDsc";function Bt(t){const e=$t();if(!e)return{};const n=function(t,e){const n=e.getOptions(),{publicKey:r}=e.getDsn()||{},o=O({environment:n.environment||Mt,release:n.release,public_key:r,trace_id:t});return e.emit("createDsc",o),o}(At(t).trace_id||"",e),r=Ut(t);if(!r)return n;const o=r[Lt];if(o)return o;const s=At(r),i=s.data||{},c=i[xt];null!=c&&(n.sample_rate=`${c}`);const u=i[Et];return u&&"url"!==u&&(n.transaction=s.description),n.sampled=String(function(t){const{traceFlags:e}=t.spanContext();return e===Tt}(r)),e.emit("createDsc",n),n}function Gt(t,e,n,r){const o=rt(n),s=t.type&&"replay_event"!==t.type?t.type:"event";!function(t,e){e&&(t.sdk=t.sdk||{},t.sdk.name=t.sdk.name||e.name,t.sdk.version=t.sdk.version||e.version,t.sdk.integrations=[...t.sdk.integrations||[],...e.integrations||[]],t.sdk.packages=[...t.sdk.packages||[],...e.packages||[]])}(t,n&&n.sdk);const i=function(t,e,n,r){const o=t.sdkProcessingMetadata&&t.sdkProcessingMetadata.dynamicSamplingContext;return{event_id:t.event_id,sent_at:(new Date).toISOString(),...e&&{sdk:e},...!!n&&r&&{dsn:N(r)},...o&&{trace:O({...o})}}}(t,o,r,e);delete t.sdkProcessingMetadata;return Z(i,[[{type:s},t]])}const Jt="__SENTRY_SUPPRESS_TRACING__";function zt(t){const e=St(ct());return e.suppressTracing?e.suppressTracing(t):function(...t){const e=St(ct());if(2===t.length){const[n,r]=t;return n?e.withSetScope(n,r):e.withScope(r)}return e.withScope(t[0])}((e=>(e.setSDKProcessingMetadata({[Jt]:!0}),t())))}function Ht(t,e){const{fingerprint:n,span:r,breadcrumbs:o,sdkProcessingMetadata:s}=e;!function(t,e){const{extra:n,tags:r,user:o,contexts:s,level:i,transactionName:c}=e,u=O(n);u&&Object.keys(u).length&&(t.extra={...u,...t.extra});const a=O(r);a&&Object.keys(a).length&&(t.tags={...a,...t.tags});const f=O(o);f&&Object.keys(f).length&&(t.user={...f,...t.user});const h=O(s);h&&Object.keys(h).length&&(t.contexts={...h,...t.contexts});i&&(t.level=i);c&&"transaction"!==t.type&&(t.transaction=c)}(t,e),r&&function(t,e){t.contexts={trace:Ot(e),...t.contexts},t.sdkProcessingMetadata={dynamicSamplingContext:Bt(e),...t.sdkProcessingMetadata};const n=Ut(e),r=At(n).description;r&&!t.transaction&&"transaction"===t.type&&(t.transaction=r)}(t,r),function(t,e){t.fingerprint=t.fingerprint?function(t){return Array.isArray(t)?t:[t]}(t.fingerprint):[],e&&(t.fingerprint=t.fingerprint.concat(e));t.fingerprint&&!t.fingerprint.length&&delete t.fingerprint}(t,n),function(t,e){const n=[...t.breadcrumbs||[],...e];t.breadcrumbs=n.length?n:void 0}(t,o),function(t,e){t.sdkProcessingMetadata={...t.sdkProcessingMetadata,...e}}(t,s)}const Wt="7";function Yt(t,e){return n={sentry_key:t.publicKey,sentry_version:Wt,...e&&{sentry_client:`${e.name}/${e.version}`}},Object.keys(n).map((t=>`${encodeURIComponent(t)}=${encodeURIComponent(n[t])}`)).join("&");var n}const qt=64;function Ft(t,e,n=K(t.bufferSize||qt)){let r={};return{send:function(o){const s=[];if(Q(o,((e,n)=>{const o=nt(n);if(function(t,e,n=Date.now()){return function(t,e){return t[e]||t.all||0}(t,e)>n}(r,o)){const r=Kt(e,n);t.recordDroppedEvent("ratelimit_backoff",o,r)}else s.push(e)})),0===s.length)return q({});const i=Z(o[0],s),c=e=>{Q(i,((n,r)=>{const o=Kt(n,r);t.recordDroppedEvent(e,nt(r),o)}))};return n.add((()=>e({body:tt(i)}).then((t=>(void 0!==t.statusCode&&(t.statusCode<200||t.statusCode>=300)&&it&&x.warn(`Sentry responded with status code ${t.statusCode} to sent event.`),r=st(r,t),t)),(t=>{throw c("network_error"),t})))).then((t=>t),(t=>{if(t instanceof k)return it&&x.error("Skipped sending event because buffer is full."),c("queue_overflow"),q({});throw t}))},flush:t=>n.drain(t)}}function Kt(t,e){if("event"===e||"transaction"===e)return Array.isArray(t)?t[1]:void 0}const Vt=Symbol("AgentBaseInternalState");class Zt extends s.Agent{[Vt];options;keepAlive;constructor(t){super(t),this[Vt]={}}isSecureEndpoint(t){if(t){if("boolean"==typeof t.secureEndpoint)return t.secureEndpoint;if("string"==typeof t.protocol)return"https:"===t.protocol}const{stack:e}=new Error;return"string"==typeof e&&e.split("\n").some((t=>-1!==t.indexOf("(https.js:")||-1!==t.indexOf("node:https:")))}createSocket(t,e,n){const r={...e,secureEndpoint:this.isSecureEndpoint(e)};Promise.resolve().then((()=>this.connect(t,r))).then((o=>{if(o instanceof s.Agent)return o.addRequest(t,r);this[Vt].currentSocket=o,super.createSocket(t,e,n)}),n)}createConnection(){const t=this[Vt].currentSocket;if(this[Vt].currentSocket=void 0,!t)throw new Error("No socket was returned in the `connect()` function");return t}get defaultPort(){return this[Vt].defaultPort??("https:"===this.protocol?443:80)}set defaultPort(t){this[Vt]&&(this[Vt].defaultPort=t)}get protocol(){return this[Vt].protocol??(this.isSecureEndpoint()?"https:":"http:")}set protocol(t){this[Vt]&&(this[Vt].protocol=t)}}function Qt(...t){x.log("[https-proxy-agent:parse-proxy-response]",...t)}function Xt(t){return new Promise(((e,n)=>{let r=0;const o=[];function s(){const c=t.read();c?function(c){o.push(c),r+=c.length;const u=Buffer.concat(o,r),a=u.indexOf("\r\n\r\n");if(-1===a)return Qt("have not received end of HTTP headers yet..."),void s();const f=u.slice(0,a).toString("ascii").split("\r\n"),h=f.shift();if(!h)return t.destroy(),n(new Error("No header received from proxy CONNECT response"));const p=h.split(" "),l=+p[1],d=p.slice(2).join(" "),m={};for(const e of f){if(!e)continue;const r=e.indexOf(":");if(-1===r)return t.destroy(),n(new Error(`Invalid header from proxy CONNECT response: "${e}"`));const o=e.slice(0,r).toLowerCase(),s=e.slice(r+1).trimStart(),i=m[o];"string"==typeof i?m[o]=[i,s]:Array.isArray(i)?i.push(s):m[o]=s}Qt("got proxy server response: %o %o",h,m),i(),e({connect:{statusCode:l,statusText:d,headers:m},buffered:u})}(c):t.once("readable",s)}function i(){t.removeListener("end",c),t.removeListener("error",u),t.removeListener("readable",s)}function c(){i(),Qt("onend"),n(new Error("Proxy connection ended before receiving CONNECT response"))}function u(t){i(),Qt("onerror %o",t),n(t)}t.on("error",u),t.on("end",c),s()}))}function te(...t){x.log("[https-proxy-agent]",...t)}class ee extends Zt{static protocols=["http","https"];proxy;proxyHeaders;connectOpts;constructor(t,e){super(e),this.options={},this.proxy="string"==typeof t?new URL(t):t,this.proxyHeaders=e?.headers??{},te("Creating new HttpsProxyAgent instance: %o",this.proxy.href);const n=(this.proxy.hostname||this.proxy.host).replace(/^\[|\]$/g,""),r=this.proxy.port?parseInt(this.proxy.port,10):"https:"===this.proxy.protocol?443:80;this.connectOpts={ALPNProtocols:["http/1.1"],...e?re(e,"headers"):null,host:n,port:r}}async connect(t,e){const{proxy:n}=this;if(!e.host)throw new TypeError('No "host" provided');let r;if("https:"===n.protocol){te("Creating `tls.Socket`: %o",this.connectOpts);const t=this.connectOpts.servername||this.connectOpts.host;r=f.connect({...this.connectOpts,servername:t&&a.isIP(t)?void 0:t})}else te("Creating `net.Socket`: %o",this.connectOpts),r=a.connect(this.connectOpts);const o="function"==typeof this.proxyHeaders?this.proxyHeaders():{...this.proxyHeaders},s=a.isIPv6(e.host)?`[${e.host}]`:e.host;let i=`CONNECT ${s}:${e.port} HTTP/1.1\r\n`;if(n.username||n.password){const t=`${decodeURIComponent(n.username)}:${decodeURIComponent(n.password)}`;o["Proxy-Authorization"]=`Basic ${Buffer.from(t).toString("base64")}`}o.Host=`${s}:${e.port}`,o["Proxy-Connection"]||(o["Proxy-Connection"]=this.keepAlive?"Keep-Alive":"close");for(const t of Object.keys(o))i+=`${t}: ${o[t]}\r\n`;const c=Xt(r);r.write(`${i}\r\n`);const{connect:u,buffered:h}=await c;if(t.emit("proxyConnect",u),this.emit("proxyConnect",u,t),200===u.statusCode){if(t.once("socket",ne),e.secureEndpoint){te("Upgrading socket connection to TLS");const t=e.servername||e.host;return f.connect({...re(e,"host","path","port"),socket:r,servername:a.isIP(t)?void 0:t})}return r}r.destroy();const p=new a.Socket({writable:!1});return p.readable=!0,t.once("socket",(t=>{te("Replaying proxy buffer for failed request"),t.push(h),t.push(null)})),p}}function ne(t){t.resume()}function re(t,...e){const n={};let r;for(r in t)e.includes(r)||(n[r]=t[r]);return n}const oe=32768;function se(t){return t.replace(/^[A-Z]:/,"").replace(/\\/g,"/")}const ie=e;let ce,ue=!1;function ae(t){ie.debug&&console.log(`[ANR Worker] ${t}`)}var fe,he,pe;const le=function(t){let e;try{e=new URL(t.url)}catch(e){return E((()=>{console.warn("[@sentry/node]: Invalid dsn or tunnel option, will not send any events. The tunnel option must be a full URL when used.")})),Ft(t,(()=>Promise.resolve({})))}const n="https:"===e.protocol,r=function(t,e){const{no_proxy:n}=process.env;return n&&n.split(",").some((e=>t.host.endsWith(e)||t.hostname.endsWith(e)))?void 0:e}(e,t.proxy||(n?process.env.https_proxy:void 0)||process.env.http_proxy),o=n?i:s,a=void 0!==t.keepAlive&&t.keepAlive,f=r?new ee(r):new o.Agent({keepAlive:a,maxSockets:30,timeout:2e3});return zt((()=>{const e=function(t,e,n){const{hostname:r,pathname:o,port:s,protocol:i,search:a}=new URL(t.url);return function(f){return new Promise(((h,p)=>{let l=function(t){return new c({read(){this.push(t),this.push(null)}})}(f.body);const d={...t.headers};f.body.length>oe&&(d["content-encoding"]="gzip",l=l.pipe(u()));const m=e.request({method:"POST",agent:n,headers:d,hostname:r,path:`${o}${a}`,port:s,protocol:i,ca:t.caCerts},(t=>{t.on("data",(()=>{})),t.on("end",(()=>{})),t.setEncoding("utf8");const e=t.headers["retry-after"]??null,n=t.headers["x-sentry-rate-limits"]??null;h({statusCode:t.statusCode,headers:{"retry-after":e,"x-sentry-rate-limits":Array.isArray(n)?n[0]:n}})}));m.on("error",p),l.pipe(m)}))}}(t,t.httpModule??o,f);return Ft(t,e)}))}({url:(fe=ie.dsn,he=ie.tunnel,pe=ie.sdkMetadata.sdk,he||`${function(t){return`${function(t){const e=t.protocol?`${t.protocol}:`:"",n=t.port?`:${t.port}`:"";return`${e}//${t.host}${n}${t.path?`/${t.path}`:""}/api/`}(t)}${t.projectId}/envelope/`}(fe)}?${Yt(fe,pe)}`),recordDroppedEvent:()=>{}});async function de(){if(ce){ae("Sending abnormal session"),ft(ce,{status:"abnormal",abnormal_mechanism:"anr_foreground"});const e=function(t,e,n,r){const o=rt(n);return Z({sent_at:(new Date).toISOString(),...o&&{sdk:o},...!!r&&e&&{dsn:N(e)}},["aggregates"in t?[{type:"sessions"},t]:[{type:"session"},t.toJSON()]])}(ce,ie.dsn,ie.sdkMetadata,ie.tunnel);ae(JSON.stringify(e)),await le.send(e);try{t?.postMessage("session-ended")}catch(t){}}}function me(t){if(!t)return;const e=function(t){if(!t.length)return[];const e=Array.from(t);return/sentryWrapped/.test(e[e.length-1].function||"")&&e.pop(),e.reverse(),I.test(e[e.length-1].function||"")&&(e.pop(),I.test(e[e.length-1].function||"")&&e.pop()),e.slice(0,R).map((t=>({...t,filename:t.filename||e[e.length-1].filename,function:t.function||A})))}(t);if(ie.appRootPath)for(const t of e)t.filename&&(t.filename=z(t.filename,ie.appRootPath));return e}async function ge(t,e){if(ue)return;ue=!0,await de(),ae("Sending event");const n={event_id:B(),contexts:ie.contexts,release:ie.release,environment:ie.environment,dist:ie.dist,platform:"node",level:"error",exception:{values:[{type:"ApplicationNotResponding",value:`Application Not Responding for at least ${ie.anrThreshold} ms`,stacktrace:{frames:me(t)},mechanism:{type:"ANR"}}]},tags:ie.staticTags};e&&function(t,e){if(Ht(t,e),!t.contexts?.trace){const{traceId:n,spanId:r,parentSpanId:o}=e.propagationContext;t.contexts={trace:{trace_id:n,span_id:r,parent_span_id:o},...t.contexts}}}(n,e);const r=Gt(n,ie.dsn,ie.sdkMetadata,ie.tunnel);ae(JSON.stringify(r)),await le.send(r),await le.flush(2e3),setTimeout((()=>{process.exit(0)}),5e3)}let ye;if(ae("Started"),ie.captureStackTrace){ae("Connecting to debugger");const t=new n;t.connectToMainThread(),ae("Connected to debugger");const e=new Map;t.on("Debugger.scriptParsed",(t=>{e.set(t.params.scriptId,t.params.url)})),t.on("Debugger.paused",(n=>{if("other"===n.params.reason)try{ae("Debugger paused");const s=[...n.params.callFrames],i=ie.appRootPath?function(t=(process.argv[1]?W(process.argv[1]):process.cwd()),e="\\"===o){const n=e?se(t):t;return t=>{if(!t)return;const o=e?se(t):t;let{dir:s,base:i,ext:c}=r.parse(o);".js"!==c&&".mjs"!==c&&".cjs"!==c||(i=i.slice(0,-1*c.length)),s||(s=".");const u=s.lastIndexOf("/node_modules");if(u>-1)return`${s.slice(u+14).replace(/\//g,".")}:${i}`;if(s.startsWith(n)){let t=s.slice(n.length+1).replace(/\//g,".");return t&&(t+=":"),t+=i,t}return i}}(ie.appRootPath):()=>{},c=s.map((t=>function(t,e,n){const r=e?e.replace(/^file:\/\//,""):void 0,o=t.location.columnNumber?t.location.columnNumber+1:void 0,s=t.location.lineNumber?t.location.lineNumber+1:void 0;return O({filename:r,module:n(r),function:t.functionName||A,colno:o,lineno:s,in_app:r?V(r):void 0})}(t,e.get(t.location.scriptId),i))),u=setTimeout((()=>{ge(c).then(null,(()=>{ae("Sending ANR event failed.")}))}),5e3);t.post("Runtime.evaluate",{expression:"global.__SENTRY_GET_SCOPES__();",silent:!0,returnByValue:!0},((e,n)=>{e&&ae(`Error executing script: '${e.message}'`),clearTimeout(u);const r=n&&n.result?n.result.value:void 0;t.post("Debugger.resume"),t.post("Debugger.disable"),ge(c,r).then(null,(()=>{ae("Sending ANR event failed.")}))}))}catch(e){throw t.post("Debugger.resume"),t.post("Debugger.disable"),e}})),ye=()=>{try{t.post("Debugger.enable",(()=>{t.post("Debugger.pause")}))}catch(t){}}}const{poll:be}=function(t,e,n,r){const o=t();let s=!1,i=!0;return setInterval((()=>{const t=o.getTimeMs();!1===s&&t>e+n&&(s=!0,i&&r()),t<e+n&&(s=!1)}),20),{poll:()=>{o.reset()},enabled:t=>{i=t}}}((function(){let t=process.hrtime();return{getTimeMs:()=>{const[e,n]=process.hrtime(t);return Math.floor(1e3*e+n/1e6)},reset:()=>{t=process.hrtime()}}}),ie.pollInterval,ie.anrThreshold,(function(){ae("Watchdog timeout"),ye?(ae("Pausing debugger to capture stack trace"),ye()):(ae("Capturing event without a stack trace"),ge().then(null,(()=>{ae("Sending ANR event failed on watchdog timeout.")})))}));t?.on("message",(t=>{t.session&&(ce=at(t.session)),be()}));';
+const base64WorkerScript = '/*! @sentry/node 8.5.0 (63d8ba4) | https://github.com/getsentry/sentry-javascript */
import{Session as t}from"node:inspector";import{parentPort as e,workerData as n}from"node:worker_threads";import{posix as r,sep as o}from"node:path";import*as s from"node:http";import*as i from"node:https";import{Readable as c}from"node:stream";import{createGzip as u}from"node:zlib";import*as a from"node:net";import*as f from"node:tls";const h=Object.prototype.toString;function p(t,e){return h.call(t)===`[object ${e}]`}function l(t){return p(t,"Object")}function d(t){return Boolean(t&&t.then&&"function"==typeof t.then)}function m(t,e){try{return t instanceof e}catch(t){return!1}}const g=globalThis;function y(t,e,n){const r=n||g,o=r.__SENTRY__=r.__SENTRY__||{};return o[t]||(o[t]=e())}const b=g,v=80;function _(t,e){const n=t,r=[];let o,s,i,c,u;if(!n||!n.tagName)return"";if(b.HTMLElement&&n instanceof HTMLElement&&n.dataset){if(n.dataset.sentryComponent)return n.dataset.sentryComponent;if(n.dataset.sentryElement)return n.dataset.sentryElement}r.push(n.tagName.toLowerCase());const a=e&&e.length?e.filter((t=>n.getAttribute(t))).map((t=>[t,n.getAttribute(t)])):null;if(a&&a.length)a.forEach((t=>{r.push(`[${t[0]}="${t[1]}"]`)}));else if(n.id&&r.push(`#${n.id}`),o=n.className,o&&p(o,"String"))for(s=o.split(/\s+/),u=0;u<s.length;u++)r.push(`.${s[u]}`);const f=["aria-label","type","name","title","alt"];for(u=0;u<f.length;u++)i=f[u],c=n.getAttribute(i),c&&r.push(`[${i}="${c}"]`);return r.join("")}const w="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__,S=["debug","info","warn","error","log","assert","trace"],$={};function E(t){if(!("console"in g))return t();const e=g.console,n={},r=Object.keys($);r.forEach((t=>{const r=$[t];n[t]=e[t],e[t]=r}));try{return t()}finally{r.forEach((t=>{e[t]=n[t]}))}}const x=function(){let t=!1;const e={enable:()=>{t=!0},disable:()=>{t=!1},isEnabled:()=>t};return w?S.forEach((n=>{e[n]=(...e)=>{t&&E((()=>{g.console[n](`Sentry Logger [${n}]:`,...e)}))}})):S.forEach((t=>{e[t]=()=>{}})),e}();function N(t,e=!1){const{host:n,path:r,pass:o,port:s,projectId:i,protocol:c,publicKey:u}=t;return`${c}://${u}${e&&o?`:${o}`:""}@${n}${s?`:${s}`:""}/${r?`${r}/`:r}${i}`}class k extends Error{constructor(t,e="warn"){super(t),this.message=t,this.name=new.target.prototype.constructor.name,Object.setPrototypeOf(this,new.target.prototype),this.logLevel=e}}function C(t){if(function(t){switch(h.call(t)){case"[object Error]":case"[object Exception]":case"[object DOMException]":return!0;default:return m(t,Error)}}(t))return{message:t.message,name:t.name,stack:t.stack,...T(t)};if(e=t,"undefined"!=typeof Event&&m(e,Event)){const e={type:t.type,target:D(t.target),currentTarget:D(t.currentTarget),...T(t)};return"undefined"!=typeof CustomEvent&&m(t,CustomEvent)&&(e.detail=t.detail),e}return t;var e}function D(t){try{return e=t,"undefined"!=typeof Element&&m(e,Element)?function(t,e={}){if(!t)return"<unknown>";try{let n=t;const r=5,o=[];let s=0,i=0;const c=" > ",u=c.length;let a;const f=Array.isArray(e)?e:e.keyAttrs,h=!Array.isArray(e)&&e.maxStringLength||v;for(;n&&s++<r&&(a=_(n,f),!("html"===a||s>1&&i+o.length*u+a.length>=h));)o.push(a),i+=a.length,n=n.parentNode;return o.reverse().join(c)}catch(t){return"<unknown>"}}(t):Object.prototype.toString.call(t)}catch(t){return"<unknown>"}var e}function T(t){if("object"==typeof t&&null!==t){const e={};for(const n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n]);return e}return{}}function O(t){return j(t,new Map)}function j(t,e){if(function(t){if(!l(t))return!1;try{const e=Object.getPrototypeOf(t).constructor.name;return!e||"Object"===e}catch(t){return!0}}(t)){const n=e.get(t);if(void 0!==n)return n;const r={};e.set(t,r);for(const n of Object.keys(t))void 0!==t[n]&&(r[n]=j(t[n],e));return r}if(Array.isArray(t)){const n=e.get(t);if(void 0!==n)return n;const r=[];return e.set(t,r),t.forEach((t=>{r.push(j(t,e))})),r}return t}const R=50,A="?",I=/captureMessage|captureException/;const P="<anonymous>";const U=1e3;function M(){return Date.now()/U}const L=function(){const{performance:t}=g;if(!t||!t.now)return M;const e=Date.now()-t.now(),n=null==t.timeOrigin?e:t.timeOrigin;return()=>(n+t.now())/U}();function B(){const t=g,e=t.crypto||t.msCrypto;let n=()=>16*Math.random();try{if(e&&e.randomUUID)return e.randomUUID().replace(/-/g,"");e&&e.getRandomValues&&(n=()=>{const t=new Uint8Array(1);return e.getRandomValues(t),t[0]})}catch(t){}return([1e7]+1e3+4e3+8e3+1e11).replace(/[018]/g,(t=>(t^(15&n())>>t/4).toString(16)))}function G(t,e=100,n=1/0){try{return J("",t,e,n)}catch(t){return{ERROR:`**non-serializable** (${t})`}}}function J(t,e,n=1/0,r=1/0,o=function(){const t="function"==typeof WeakSet,e=t?new WeakSet:[];return[function(n){if(t)return!!e.has(n)||(e.add(n),!1);for(let t=0;t<e.length;t++)if(e[t]===n)return!0;return e.push(n),!1},function(n){if(t)e.delete(n);else for(let t=0;t<e.length;t++)if(e[t]===n){e.splice(t,1);break}}]}()){const[s,i]=o;if(null==e||["number","boolean","string"].includes(typeof e)&&!Number.isNaN(e))return e;const c=function(t,e){try{if("domain"===t&&e&&"object"==typeof e&&e.t)return"[Domain]";if("domainEmitter"===t)return"[DomainEmitter]";if("undefined"!=typeof global&&e===global)return"[Global]";if("undefined"!=typeof window&&e===window)return"[Window]";if("undefined"!=typeof document&&e===document)return"[Document]";if("object"==typeof(n=e)&&null!==n&&(n.__isVue||n.o))return"[VueViewModel]";if(function(t){return l(t)&&"nativeEvent"in t&&"preventDefault"in t&&"stopPropagation"in t}(e))return"[SyntheticEvent]";if("number"==typeof e&&e!=e)return"[NaN]";if("function"==typeof e)return`[Function: ${function(t){try{return t&&"function"==typeof t&&t.name||P}catch(t){return P}}(e)}]`;if("symbol"==typeof e)return`[${String(e)}]`;if("bigint"==typeof e)return`[BigInt: ${String(e)}]`;const r=function(t){const e=Object.getPrototypeOf(t);return e?e.constructor.name:"null prototype"}(e);return/^HTML(\w*)Element$/.test(r)?`[HTMLElement: ${r}]`:`[object ${r}]`}catch(t){return`**non-serializable** (${t})`}var n}(t,e);if(!c.startsWith("[object "))return c;if(e.__sentry_skip_normalization__)return e;const u="number"==typeof e.__sentry_override_normalization_depth__?e.__sentry_override_normalization_depth__:n;if(0===u)return c.replace("object ","");if(s(e))return"[Circular ~]";const a=e;if(a&&"function"==typeof a.toJSON)try{return J("",a.toJSON(),u-1,r,o)}catch(t){}const f=Array.isArray(e)?[]:{};let h=0;const p=C(e);for(const t in p){if(!Object.prototype.hasOwnProperty.call(p,t))continue;if(h>=r){f[t]="[MaxProperties ~]";break}const e=p[t];f[t]=J(t,e,u-1,r,o),h++}return i(e),f}function z(t,e){const n=e.replace(/\\/g,"/").replace(/[|\\{}()[\]^$+*?.]/g,"\\$&");let r=t;try{r=decodeURI(t)}catch(t){}return r.replace(/\\/g,"/").replace(/webpack:\/?/g,"").replace(new RegExp(`(file://)?/*${n}/*`,"ig"),"app:///")}(()=>{const{performance:t}=g;if(!t||!t.now)return;const e=36e5,n=t.now(),r=Date.now(),o=t.timeOrigin?Math.abs(t.timeOrigin+n-r):e,s=o<e,i=t.timing&&t.timing.navigationStart,c="number"==typeof i?Math.abs(i+n-r):e;(s||c<e)&&(o<=c&&t.timeOrigin)})();const H=/^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;function W(t){const e=function(t){const e=t.length>1024?`<truncated>${t.slice(-1024)}`:t,n=H.exec(e);return n?n.slice(1):[]}(t),n=e[0];let r=e[1];return n||r?(r&&(r=r.slice(0,r.length-1)),n+r):"."}var Y;function q(t){return new F((e=>{e(t)}))}!function(t){t[t.PENDING=0]="PENDING";t[t.RESOLVED=1]="RESOLVED";t[t.REJECTED=2]="REJECTED"}(Y||(Y={}));class F{constructor(t){F.prototype.__init.call(this),F.prototype.__init2.call(this),F.prototype.__init3.call(this),F.prototype.__init4.call(this),this.i=Y.PENDING,this.u=[];try{t(this.h,this.p)}catch(t){this.p(t)}}then(t,e){return new F(((n,r)=>{this.u.push([!1,e=>{if(t)try{n(t(e))}catch(t){r(t)}else n(e)},t=>{if(e)try{n(e(t))}catch(t){r(t)}else r(t)}]),this.l()}))}catch(t){return this.then((t=>t),t)}finally(t){return new F(((e,n)=>{let r,o;return this.then((e=>{o=!1,r=e,t&&t()}),(e=>{o=!0,r=e,t&&t()})).then((()=>{o?n(r):e(r)}))}))}__init(){this.h=t=>{this.m(Y.RESOLVED,t)}}__init2(){this.p=t=>{this.m(Y.REJECTED,t)}}__init3(){this.m=(t,e)=>{this.i===Y.PENDING&&(d(e)?e.then(this.h,this.p):(this.i=t,this.v=e,this.l()))}}__init4(){this.l=()=>{if(this.i===Y.PENDING)return;const t=this.u.slice();this.u=[],t.forEach((t=>{t[0]||(this.i===Y.RESOLVED&&t[1](this.v),this.i===Y.REJECTED&&t[2](this.v),t[0]=!0)}))}}}function K(t){const e=[];function n(t){return e.splice(e.indexOf(t),1)[0]}return{$:e,add:function(r){if(!(void 0===t||e.length<t))return o=new k("Not adding Promise because buffer limit was reached."),new F(((t,e)=>{e(o)}));var o;const s=r();return-1===e.indexOf(s)&&e.push(s),s.then((()=>n(s))).then(null,(()=>n(s).then(null,(()=>{})))),s},drain:function(t){return new F(((n,r)=>{let o=e.length;if(!o)return n(!0);const s=setTimeout((()=>{t&&t>0&&n(!1)}),t);e.forEach((t=>{q(t).then((()=>{--o||(clearTimeout(s),n(!0))}),r)}))}))}}}function V(t,e=!1){return!(e||t&&!t.startsWith("/")&&!t.match(/^[A-Z]:/)&&!t.startsWith(".")&&!t.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//))&&void 0!==t&&!t.includes("node_modules/")}function Z(t,e=[]){return[t,e]}function Q(t,e){const n=t[1];for(const t of n){if(e(t,t[0].type))return!0}return!1}function X(t){return g.__SENTRY__&&g.__SENTRY__.encodePolyfill?g.__SENTRY__.encodePolyfill(t):(new TextEncoder).encode(t)}function tt(t){const[e,n]=t;let r=JSON.stringify(e);function o(t){"string"==typeof r?r="string"==typeof t?r+t:[X(r),t]:r.push("string"==typeof t?X(t):t)}for(const t of n){const[e,n]=t;if(o(`\n${JSON.stringify(e)}\n`),"string"==typeof n||n instanceof Uint8Array)o(n);else{let t;try{t=JSON.stringify(n)}catch(e){t=JSON.stringify(G(n))}o(t)}}return"string"==typeof r?r:function(t){const e=t.reduce(((t,e)=>t+e.length),0),n=new Uint8Array(e);let r=0;for(const e of t)n.set(e,r),r+=e.length;return n}(r)}const et={session:"session",sessions:"session",attachment:"attachment",transaction:"transaction",event:"error",client_report:"internal",user_report:"default",profile:"profile",replay_event:"replay",replay_recording:"replay",check_in:"monitor",feedback:"feedback",span:"span",statsd:"metric_bucket"};function nt(t){return et[t]}function rt(t){if(!t||!t.sdk)return;const{name:e,version:n}=t.sdk;return{name:e,version:n}}const ot=6e4;function st(t,{statusCode:e,headers:n},r=Date.now()){const o={...t},s=n&&n["x-sentry-rate-limits"],i=n&&n["retry-after"];if(s)for(const t of s.trim().split(",")){const[e,n,,,s]=t.split(":",5),i=parseInt(e,10),c=1e3*(isNaN(i)?60:i);if(n)for(const t of n.split(";"))"metric_bucket"===t&&s&&!s.split(";").includes("custom")||(o[t]=r+c);else o.all=r+c}else i?o.all=r+function(t,e=Date.now()){const n=parseInt(`${t}`,10);if(!isNaN(n))return 1e3*n;const r=Date.parse(`${t}`);return isNaN(r)?ot:r-e}(i,r):429===e&&(o.all=r+6e4);return o}function it(){return{traceId:B(),spanId:B().substring(16)}}const ct="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__;function ut(){return at(g),g}function at(t){return t.__SENTRY__||(t.__SENTRY__={extensions:{}}),t.__SENTRY__}function ft(t){const e=L(),n={sid:B(),init:!0,timestamp:e,started:e,duration:0,status:"ok",errors:0,ignoreDuration:!1,toJSON:()=>function(t){return O({sid:`${t.sid}`,init:t.init,started:new Date(1e3*t.started).toISOString(),timestamp:new Date(1e3*t.timestamp).toISOString(),status:t.status,errors:t.errors,did:"number"==typeof t.did||"string"==typeof t.did?`${t.did}`:void 0,duration:t.duration,abnormal_mechanism:t.abnormal_mechanism,attrs:{release:t.release,environment:t.environment,ip_address:t.ipAddress,user_agent:t.userAgent}})}(n)};return t&&ht(n,t),n}function ht(t,e={}){if(e.user&&(!t.ipAddress&&e.user.ip_address&&(t.ipAddress=e.user.ip_address),t.did||e.did||(t.did=e.user.id||e.user.email||e.user.username)),t.timestamp=e.timestamp||L(),e.abnormal_mechanism&&(t.abnormal_mechanism=e.abnormal_mechanism),e.ignoreDuration&&(t.ignoreDuration=e.ignoreDuration),e.sid&&(t.sid=32===e.sid.length?e.sid:B()),void 0!==e.init&&(t.init=e.init),!t.did&&e.did&&(t.did=`${e.did}`),"number"==typeof e.started&&(t.started=e.started),t.ignoreDuration)t.duration=void 0;else if("number"==typeof e.duration)t.duration=e.duration;else{const e=t.timestamp-t.started;t.duration=e>=0?e:0}e.release&&(t.release=e.release),e.environment&&(t.environment=e.environment),!t.ipAddress&&e.ipAddress&&(t.ipAddress=e.ipAddress),!t.userAgent&&e.userAgent&&(t.userAgent=e.userAgent),"number"==typeof e.errors&&(t.errors=e.errors),e.status&&(t.status=e.status)}const pt="_sentrySpan";function lt(t,e){e?function(t,e,n){try{Object.defineProperty(t,e,{value:n,writable:!0,configurable:!0})}catch(n){w&&x.log(`Failed to add non-enumerable property "${e}" to object`,t)}}(t,pt,e):delete t[pt]}function dt(t){return t[pt]}class mt{constructor(){this._=!1,this.S=[],this.N=[],this.k=[],this.C=[],this.D={},this.T={},this.O={},this.j={},this.R={},this.A=it()}clone(){const t=new mt;return t.k=[...this.k],t.T={...this.T},t.O={...this.O},t.j={...this.j},t.D=this.D,t.I=this.I,t.P=this.P,t.U=this.U,t.M=this.M,t.N=[...this.N],t.L=this.L,t.C=[...this.C],t.R={...this.R},t.A={...this.A},t.B=this.B,t.G=this.G,lt(t,dt(this)),t}setClient(t){this.B=t}setLastEventId(t){this.G=t}getClient(){return this.B}lastEventId(){return this.G}addScopeListener(t){this.S.push(t)}addEventProcessor(t){return this.N.push(t),this}setUser(t){return this.D=t||{email:void 0,id:void 0,ip_address:void 0,username:void 0},this.P&&ht(this.P,{user:t}),this.J(),this}getUser(){return this.D}getRequestSession(){return this.L}setRequestSession(t){return this.L=t,this}setTags(t){return this.T={...this.T,...t},this.J(),this}setTag(t,e){return this.T={...this.T,[t]:e},this.J(),this}setExtras(t){return this.O={...this.O,...t},this.J(),this}setExtra(t,e){return this.O={...this.O,[t]:e},this.J(),this}setFingerprint(t){return this.M=t,this.J(),this}setLevel(t){return this.I=t,this.J(),this}setTransactionName(t){return this.U=t,this.J(),this}setContext(t,e){return null===e?delete this.j[t]:this.j[t]=e,this.J(),this}setSession(t){return t?this.P=t:delete this.P,this.J(),this}getSession(){return this.P}update(t){if(!t)return this;const e="function"==typeof t?t(this):t,[n,r]=e instanceof gt?[e.getScopeData(),e.getRequestSession()]:l(e)?[t,t.requestSession]:[],{tags:o,extra:s,user:i,contexts:c,level:u,fingerprint:a=[],propagationContext:f}=n||{};return this.T={...this.T,...o},this.O={...this.O,...s},this.j={...this.j,...c},i&&Object.keys(i).length&&(this.D=i),u&&(this.I=u),a.length&&(this.M=a),f&&(this.A=f),r&&(this.L=r),this}clear(){return this.k=[],this.T={},this.O={},this.D={},this.j={},this.I=void 0,this.U=void 0,this.M=void 0,this.L=void 0,this.P=void 0,lt(this,void 0),this.C=[],this.A=it(),this.J(),this}addBreadcrumb(t,e){const n="number"==typeof e?e:100;if(n<=0)return this;const r={timestamp:M(),...t},o=this.k;return o.push(r),this.k=o.length>n?o.slice(-n):o,this.J(),this}getLastBreadcrumb(){return this.k[this.k.length-1]}clearBreadcrumbs(){return this.k=[],this.J(),this}addAttachment(t){return this.C.push(t),this}clearAttachments(){return this.C=[],this}getScopeData(){return{breadcrumbs:this.k,attachments:this.C,contexts:this.j,tags:this.T,extra:this.O,user:this.D,level:this.I,fingerprint:this.M||[],eventProcessors:this.N,propagationContext:this.A,sdkProcessingMetadata:this.R,transactionName:this.U,span:dt(this)}}setSDKProcessingMetadata(t){return this.R={...this.R,...t},this}setPropagationContext(t){return this.A=t,this}getPropagationContext(){return this.A}captureException(t,e){const n=e&&e.event_id?e.event_id:B();if(!this.B)return x.warn("No client configured on scope - will not capture exception!"),n;const r=new Error("Sentry syntheticException");return this.B.captureException(t,{originalException:t,syntheticException:r,...e,event_id:n},this),n}captureMessage(t,e,n){const r=n&&n.event_id?n.event_id:B();if(!this.B)return x.warn("No client configured on scope - will not capture message!"),r;const o=new Error(t);return this.B.captureMessage(t,e,{originalException:t,syntheticException:o,...n,event_id:r},this),r}captureEvent(t,e){const n=e&&e.event_id?e.event_id:B();return this.B?(this.B.captureEvent(t,{...e,event_id:n},this),n):(x.warn("No client configured on scope - will not capture event!"),n)}J(){this._||(this._=!0,this.S.forEach((t=>{t(this)})),this._=!1)}}const gt=mt;class yt{constructor(t,e){let n,r;n=t||new gt,r=e||new gt,this.H=[{scope:n}],this.W=r}withScope(t){const e=this.Y();let n;try{n=t(e)}catch(t){throw this.q(),t}return d(n)?n.then((t=>(this.q(),t)),(t=>{throw this.q(),t})):(this.q(),n)}getClient(){return this.getStackTop().client}getScope(){return this.getStackTop().scope}getIsolationScope(){return this.W}getStack(){return this.H}getStackTop(){return this.H[this.H.length-1]}Y(){const t=this.getScope().clone();return this.getStack().push({client:this.getClient(),scope:t}),t}q(){return!(this.getStack().length<=1)&&!!this.getStack().pop()}}function bt(){const t=at(ut());return t.hub||(t.hub=new yt(y("defaultCurrentScope",(()=>new gt)),y("defaultIsolationScope",(()=>new gt)))),t.hub}function vt(t){return bt().withScope(t)}function _t(t,e){const n=bt();return n.withScope((()=>(n.getStackTop().scope=t,e(t))))}function wt(t){return bt().withScope((()=>t(bt().getIsolationScope())))}function St(t){const e=at(t);return e.acs?e.acs:{withIsolationScope:wt,withScope:vt,withSetScope:_t,withSetIsolationScope:(t,e)=>wt(e),getCurrentScope:()=>bt().getScope(),getIsolationScope:()=>bt().getIsolationScope()}}function $t(){return St(ut()).getCurrentScope().getClient()}const Et="sentry.source",xt="sentry.sample_rate",Nt="sentry.op",kt="sentry.origin",Ct=0,Dt=1,Tt=1;function Ot(t){const{spanId:e,traceId:n}=t.spanContext(),{parent_span_id:r}=At(t);return O({parent_span_id:r,span_id:e,trace_id:n})}function jt(t){return"number"==typeof t?Rt(t):Array.isArray(t)?t[0]+t[1]/1e9:t instanceof Date?Rt(t.getTime()):L()}function Rt(t){return t>9999999999?t/1e3:t}function At(t){if(function(t){return"function"==typeof t.getSpanJSON}(t))return t.getSpanJSON();try{const{spanId:e,traceId:n}=t.spanContext();if(function(t){const e=t;return!!(e.attributes&&e.startTime&&e.name&&e.endTime&&e.status)}(t)){const{attributes:r,startTime:o,name:s,endTime:i,parentSpanId:c,status:u}=t;return O({span_id:e,trace_id:n,data:r,description:s,parent_span_id:c,start_timestamp:jt(o),timestamp:jt(i)||void 0,status:It(u),op:r[Nt],origin:r[kt],F:void 0})}return{span_id:e,trace_id:n}}catch(t){return{}}}function It(t){if(t&&t.code!==Ct)return t.code===Dt?"ok":t.message||"unknown_error"}const Pt="_sentryRootSpan";function Ut(t){return t[Pt]||t}const Mt="production",Lt="_frozenDsc";function Bt(t){const e=$t();if(!e)return{};const n=function(t,e){const n=e.getOptions(),{publicKey:r}=e.getDsn()||{},o=O({environment:n.environment||Mt,release:n.release,public_key:r,trace_id:t});return e.emit("createDsc",o),o}(At(t).trace_id||"",e),r=Ut(t);if(!r)return n;const o=r[Lt];if(o)return o;const s=At(r),i=s.data||{},c=i[xt];null!=c&&(n.sample_rate=`${c}`);const u=i[Et];return u&&"url"!==u&&(n.transaction=s.description),n.sampled=String(function(t){const{traceFlags:e}=t.spanContext();return e===Tt}(r)),e.emit("createDsc",n),n}function Gt(t,e,n,r){const o=rt(n),s=t.type&&"replay_event"!==t.type?t.type:"event";!function(t,e){e&&(t.sdk=t.sdk||{},t.sdk.name=t.sdk.name||e.name,t.sdk.version=t.sdk.version||e.version,t.sdk.integrations=[...t.sdk.integrations||[],...e.integrations||[]],t.sdk.packages=[...t.sdk.packages||[],...e.packages||[]])}(t,n&&n.sdk);const i=function(t,e,n,r){const o=t.sdkProcessingMetadata&&t.sdkProcessingMetadata.dynamicSamplingContext;return{event_id:t.event_id,sent_at:(new Date).toISOString(),...e&&{sdk:e},...!!n&&r&&{dsn:N(r)},...o&&{trace:O({...o})}}}(t,o,r,e);delete t.sdkProcessingMetadata;return Z(i,[[{type:s},t]])}const Jt="__SENTRY_SUPPRESS_TRACING__";function zt(t){const e=St(ut());return e.suppressTracing?e.suppressTracing(t):function(...t){const e=St(ut());if(2===t.length){const[n,r]=t;return n?e.withSetScope(n,r):e.withScope(r)}return e.withScope(t[0])}((e=>(e.setSDKProcessingMetadata({[Jt]:!0}),t())))}function Ht(t,e){const{fingerprint:n,span:r,breadcrumbs:o,sdkProcessingMetadata:s}=e;!function(t,e){const{extra:n,tags:r,user:o,contexts:s,level:i,transactionName:c}=e,u=O(n);u&&Object.keys(u).length&&(t.extra={...u,...t.extra});const a=O(r);a&&Object.keys(a).length&&(t.tags={...a,...t.tags});const f=O(o);f&&Object.keys(f).length&&(t.user={...f,...t.user});const h=O(s);h&&Object.keys(h).length&&(t.contexts={...h,...t.contexts});i&&(t.level=i);c&&"transaction"!==t.type&&(t.transaction=c)}(t,e),r&&function(t,e){t.contexts={trace:Ot(e),...t.contexts},t.sdkProcessingMetadata={dynamicSamplingContext:Bt(e),...t.sdkProcessingMetadata};const n=Ut(e),r=At(n).description;r&&!t.transaction&&"transaction"===t.type&&(t.transaction=r)}(t,r),function(t,e){t.fingerprint=t.fingerprint?function(t){return Array.isArray(t)?t:[t]}(t.fingerprint):[],e&&(t.fingerprint=t.fingerprint.concat(e));t.fingerprint&&!t.fingerprint.length&&delete t.fingerprint}(t,n),function(t,e){const n=[...t.breadcrumbs||[],...e];t.breadcrumbs=n.length?n:void 0}(t,o),function(t,e){t.sdkProcessingMetadata={...t.sdkProcessingMetadata,...e}}(t,s)}const Wt="7";function Yt(t,e){return n={sentry_key:t.publicKey,sentry_version:Wt,...e&&{sentry_client:`${e.name}/${e.version}`}},Object.keys(n).map((t=>`${encodeURIComponent(t)}=${encodeURIComponent(n[t])}`)).join("&");var n}const qt=64;function Ft(t,e,n=K(t.bufferSize||qt)){let r={};return{send:function(o){const s=[];if(Q(o,((e,n)=>{const o=nt(n);if(function(t,e,n=Date.now()){return function(t,e){return t[e]||t.all||0}(t,e)>n}(r,o)){const r=Kt(e,n);t.recordDroppedEvent("ratelimit_backoff",o,r)}else s.push(e)})),0===s.length)return q({});const i=Z(o[0],s),c=e=>{Q(i,((n,r)=>{const o=Kt(n,r);t.recordDroppedEvent(e,nt(r),o)}))};return n.add((()=>e({body:tt(i)}).then((t=>(void 0!==t.statusCode&&(t.statusCode<200||t.statusCode>=300)&&ct&&x.warn(`Sentry responded with status code ${t.statusCode} to sent event.`),r=st(r,t),t)),(t=>{throw c("network_error"),t})))).then((t=>t),(t=>{if(t instanceof k)return ct&&x.error("Skipped sending event because buffer is full."),c("queue_overflow"),q({});throw t}))},flush:t=>n.drain(t)}}function Kt(t,e){if("event"===e||"transaction"===e)return Array.isArray(t)?t[1]:void 0}const Vt=Symbol("AgentBaseInternalState");class Zt extends s.Agent{[Vt];options;keepAlive;constructor(t){super(t),this[Vt]={}}isSecureEndpoint(t){if(t){if("boolean"==typeof t.secureEndpoint)return t.secureEndpoint;if("string"==typeof t.protocol)return"https:"===t.protocol}const{stack:e}=new Error;return"string"==typeof e&&e.split("\n").some((t=>-1!==t.indexOf("(https.js:")||-1!==t.indexOf("node:https:")))}createSocket(t,e,n){const r={...e,secureEndpoint:this.isSecureEndpoint(e)};Promise.resolve().then((()=>this.connect(t,r))).then((o=>{if(o instanceof s.Agent)return o.addRequest(t,r);this[Vt].currentSocket=o,super.createSocket(t,e,n)}),n)}createConnection(){const t=this[Vt].currentSocket;if(this[Vt].currentSocket=void 0,!t)throw new Error("No socket was returned in the `connect()` function");return t}get defaultPort(){return this[Vt].defaultPort??("https:"===this.protocol?443:80)}set defaultPort(t){this[Vt]&&(this[Vt].defaultPort=t)}get protocol(){return this[Vt].protocol??(this.isSecureEndpoint()?"https:":"http:")}set protocol(t){this[Vt]&&(this[Vt].protocol=t)}}function Qt(...t){x.log("[https-proxy-agent:parse-proxy-response]",...t)}function Xt(t){return new Promise(((e,n)=>{let r=0;const o=[];function s(){const c=t.read();c?function(c){o.push(c),r+=c.length;const u=Buffer.concat(o,r),a=u.indexOf("\r\n\r\n");if(-1===a)return Qt("have not received end of HTTP headers yet..."),void s();const f=u.slice(0,a).toString("ascii").split("\r\n"),h=f.shift();if(!h)return t.destroy(),n(new Error("No header received from proxy CONNECT response"));const p=h.split(" "),l=+p[1],d=p.slice(2).join(" "),m={};for(const e of f){if(!e)continue;const r=e.indexOf(":");if(-1===r)return t.destroy(),n(new Error(`Invalid header from proxy CONNECT response: "${e}"`));const o=e.slice(0,r).toLowerCase(),s=e.slice(r+1).trimStart(),i=m[o];"string"==typeof i?m[o]=[i,s]:Array.isArray(i)?i.push(s):m[o]=s}Qt("got proxy server response: %o %o",h,m),i(),e({connect:{statusCode:l,statusText:d,headers:m},buffered:u})}(c):t.once("readable",s)}function i(){t.removeListener("end",c),t.removeListener("error",u),t.removeListener("readable",s)}function c(){i(),Qt("onend"),n(new Error("Proxy connection ended before receiving CONNECT response"))}function u(t){i(),Qt("onerror %o",t),n(t)}t.on("error",u),t.on("end",c),s()}))}function te(...t){x.log("[https-proxy-agent]",...t)}class ee extends Zt{static protocols=["http","https"];proxy;proxyHeaders;connectOpts;constructor(t,e){super(e),this.options={},this.proxy="string"==typeof t?new URL(t):t,this.proxyHeaders=e?.headers??{},te("Creating new HttpsProxyAgent instance: %o",this.proxy.href);const n=(this.proxy.hostname||this.proxy.host).replace(/^\[|\]$/g,""),r=this.proxy.port?parseInt(this.proxy.port,10):"https:"===this.proxy.protocol?443:80;this.connectOpts={ALPNProtocols:["http/1.1"],...e?re(e,"headers"):null,host:n,port:r}}async connect(t,e){const{proxy:n}=this;if(!e.host)throw new TypeError('No "host" provided');let r;if("https:"===n.protocol){te("Creating `tls.Socket`: %o",this.connectOpts);const t=this.connectOpts.servername||this.connectOpts.host;r=f.connect({...this.connectOpts,servername:t&&a.isIP(t)?void 0:t})}else te("Creating `net.Socket`: %o",this.connectOpts),r=a.connect(this.connectOpts);const o="function"==typeof this.proxyHeaders?this.proxyHeaders():{...this.proxyHeaders},s=a.isIPv6(e.host)?`[${e.host}]`:e.host;let i=`CONNECT ${s}:${e.port} HTTP/1.1\r\n`;if(n.username||n.password){const t=`${decodeURIComponent(n.username)}:${decodeURIComponent(n.password)}`;o["Proxy-Authorization"]=`Basic ${Buffer.from(t).toString("base64")}`}o.Host=`${s}:${e.port}`,o["Proxy-Connection"]||(o["Proxy-Connection"]=this.keepAlive?"Keep-Alive":"close");for(const t of Object.keys(o))i+=`${t}: ${o[t]}\r\n`;const c=Xt(r);r.write(`${i}\r\n`);const{connect:u,buffered:h}=await c;if(t.emit("proxyConnect",u),this.emit("proxyConnect",u,t),200===u.statusCode){if(t.once("socket",ne),e.secureEndpoint){te("Upgrading socket connection to TLS");const t=e.servername||e.host;return f.connect({...re(e,"host","path","port"),socket:r,servername:a.isIP(t)?void 0:t})}return r}r.destroy();const p=new a.Socket({writable:!1});return p.readable=!0,t.once("socket",(t=>{te("Replaying proxy buffer for failed request"),t.push(h),t.push(null)})),p}}function ne(t){t.resume()}function re(t,...e){const n={};let r;for(r in t)e.includes(r)||(n[r]=t[r]);return n}const oe=32768;function se(t){return t.replace(/^[A-Z]:/,"").replace(/\\/g,"/")}const ie=n;let ce,ue=!1;function ae(t){ie.debug&&console.log(`[ANR Worker] ${t}`)}var fe,he,pe;const le=function(t){let e;try{e=new URL(t.url)}catch(e){return E((()=>{console.warn("[@sentry/node]: Invalid dsn or tunnel option, will not send any events. The tunnel option must be a full URL when used.")})),Ft(t,(()=>Promise.resolve({})))}const n="https:"===e.protocol,r=function(t,e){const{no_proxy:n}=process.env;return n&&n.split(",").some((e=>t.host.endsWith(e)||t.hostname.endsWith(e)))?void 0:e}(e,t.proxy||(n?process.env.https_proxy:void 0)||process.env.http_proxy),o=n?i:s,a=void 0!==t.keepAlive&&t.keepAlive,f=r?new ee(r):new o.Agent({keepAlive:a,maxSockets:30,timeout:2e3});return zt((()=>{const e=function(t,e,n){const{hostname:r,pathname:o,port:s,protocol:i,search:a}=new URL(t.url);return function(f){return new Promise(((h,p)=>{let l=function(t){return new c({read(){this.push(t),this.push(null)}})}(f.body);const d={...t.headers};f.body.length>oe&&(d["content-encoding"]="gzip",l=l.pipe(u()));const m=e.request({method:"POST",agent:n,headers:d,hostname:r,path:`${o}${a}`,port:s,protocol:i,ca:t.caCerts},(t=>{t.on("data",(()=>{})),t.on("end",(()=>{})),t.setEncoding("utf8");const e=t.headers["retry-after"]??null,n=t.headers["x-sentry-rate-limits"]??null;h({statusCode:t.statusCode,headers:{"retry-after":e,"x-sentry-rate-limits":Array.isArray(n)?n[0]:n}})}));m.on("error",p),l.pipe(m)}))}}(t,t.httpModule??o,f);return Ft(t,e)}))}({url:(fe=ie.dsn,he=ie.tunnel,pe=ie.sdkMetadata.sdk,he||`${function(t){return`${function(t){const e=t.protocol?`${t.protocol}:`:"",n=t.port?`:${t.port}`:"";return`${e}//${t.host}${n}${t.path?`/${t.path}`:""}/api/`}(t)}${t.projectId}/envelope/`}(fe)}?${Yt(fe,pe)}`),recordDroppedEvent:()=>{}});async function de(){if(ce){ae("Sending abnormal session"),ht(ce,{status:"abnormal",abnormal_mechanism:"anr_foreground"});const t=function(t,e,n,r){const o=rt(n);return Z({sent_at:(new Date).toISOString(),...o&&{sdk:o},...!!r&&e&&{dsn:N(e)}},["aggregates"in t?[{type:"sessions"},t]:[{type:"session"},t.toJSON()]])}(ce,ie.dsn,ie.sdkMetadata,ie.tunnel);ae(JSON.stringify(t)),await le.send(t);try{e?.postMessage("session-ended")}catch(t){}}}function me(t){if(!t)return;const e=function(t){if(!t.length)return[];const e=Array.from(t);return/sentryWrapped/.test(e[e.length-1].function||"")&&e.pop(),e.reverse(),I.test(e[e.length-1].function||"")&&(e.pop(),I.test(e[e.length-1].function||"")&&e.pop()),e.slice(0,R).map((t=>({...t,filename:t.filename||e[e.length-1].filename,function:t.function||A})))}(t);if(ie.appRootPath)for(const t of e)t.filename&&(t.filename=z(t.filename,ie.appRootPath));return e}async function ge(t,e){if(ue)return;ue=!0,await de(),ae("Sending event");const n={event_id:B(),contexts:ie.contexts,release:ie.release,environment:ie.environment,dist:ie.dist,platform:"node",level:"error",exception:{values:[{type:"ApplicationNotResponding",value:`Application Not Responding for at least ${ie.anrThreshold} ms`,stacktrace:{frames:me(t)},mechanism:{type:"ANR"}}]},tags:ie.staticTags};e&&function(t,e){if(Ht(t,e),!t.contexts?.trace){const{traceId:n,spanId:r,parentSpanId:o}=e.propagationContext;t.contexts={trace:{trace_id:n,span_id:r,parent_span_id:o},...t.contexts}}}(n,e);const r=Gt(n,ie.dsn,ie.sdkMetadata,ie.tunnel);ae(JSON.stringify(r)),await le.send(r),await le.flush(2e3),setTimeout((()=>{process.exit(0)}),5e3)}let ye;if(ae("Started"),ie.captureStackTrace){ae("Connecting to debugger");const e=new t;e.connectToMainThread(),ae("Connected to debugger");const n=new Map;e.on("Debugger.scriptParsed",(t=>{n.set(t.params.scriptId,t.params.url)})),e.on("Debugger.paused",(t=>{if("other"===t.params.reason)try{ae("Debugger paused");const s=[...t.params.callFrames],i=ie.appRootPath?function(t=(process.argv[1]?W(process.argv[1]):process.cwd()),e="\\"===o){const n=e?se(t):t;return t=>{if(!t)return;const o=e?se(t):t;let{dir:s,base:i,ext:c}=r.parse(o);".js"!==c&&".mjs"!==c&&".cjs"!==c||(i=i.slice(0,-1*c.length)),s||(s=".");const u=s.lastIndexOf("/node_modules");if(u>-1)return`${s.slice(u+14).replace(/\//g,".")}:${i}`;if(s.startsWith(n)){let t=s.slice(n.length+1).replace(/\//g,".");return t&&(t+=":"),t+=i,t}return i}}(ie.appRootPath):()=>{},c=s.map((t=>function(t,e,n){const r=e?e.replace(/^file:\/\//,""):void 0,o=t.location.columnNumber?t.location.columnNumber+1:void 0,s=t.location.lineNumber?t.location.lineNumber+1:void 0;return O({filename:r,module:n(r),function:t.functionName||A,colno:o,lineno:s,in_app:r?V(r):void 0})}(t,n.get(t.location.scriptId),i))),u=setTimeout((()=>{ge(c).then(null,(()=>{ae("Sending ANR event failed.")}))}),5e3);e.post("Runtime.evaluate",{expression:"global.__SENTRY_GET_SCOPES__();",silent:!0,returnByValue:!0},((t,n)=>{t&&ae(`Error executing script: '${t.message}'`),clearTimeout(u);const r=n&&n.result?n.result.value:void 0;e.post("Debugger.resume"),e.post("Debugger.disable"),ge(c,r).then(null,(()=>{ae("Sending ANR event failed.")}))}))}catch(t){throw e.post("Debugger.resume"),e.post("Debugger.disable"),t}})),ye=()=>{try{e.post("Debugger.enable",(()=>{e.post("Debugger.pause")}))}catch(t){}}}const{poll:be}=function(t,e,n,r){const o=t();let s=!1,i=!0;return setInterval((()=>{const t=o.getTimeMs();!1===s&&t>e+n&&(s=!0,i&&r()),t<e+n&&(s=!1)}),20),{poll:()=>{o.reset()},enabled:t=>{i=t}}}((function(){let t=process.hrtime();return{getTimeMs:()=>{const[e,n]=process.hrtime(t);return Math.floor(1e3*e+n/1e6)},reset:()=>{t=process.hrtime()}}}),ie.pollInterval,ie.anrThreshold,(function(){ae("Watchdog timeout"),ye?(ae("Pausing debugger to capture stack trace"),ye()):(ae("Capturing event without a stack trace"),ge().then(null,(()=>{ae("Sending ANR event failed on watchdog timeout.")})))}));e?.on("message",(t=>{t.session&&(ce=ft(t.session)),be()}));';
 
 const DEFAULT_INTERVAL = 50;
 const DEFAULT_HANG_THRESHOLD = 5000;
@@ -142,6 +141,7 @@ async function _startWorker(
   };
 
   if (options.captureStackTrace) {
+    const inspector = await import('node:inspector');
     if (!inspector.url()) {
       inspector.open(0);
     }