npm - @sentry/node - Versions diffs - 10.68.0 → 11.0.0-alpha.0 - Mend

@sentry/node 10.68.0 → 11.0.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1194) hide show

package/build/cjs/index.js CHANGED Viewed

@@ -1,90 +1,95 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const http = require('./integrations/http.js');
-const nodeFetch = require('./integrations/node-fetch.js');
-const index$6 = require('./integrations/fs/index.js');
+const index$6 = require('./integrations/http/index.js');
+const index$8 = require('./integrations/node-fetch/index.js');
+const index$3 = require('./integrations/fs/index.js');
 const express = require('./integrations/tracing/express.js');
-const index$5 = require('./integrations/tracing/fastify/index.js');
-const index$a = require('./integrations/tracing/graphql/index.js');
-const index$d = require('./integrations/tracing/kafka/index.js');
-const index$i = require('./integrations/tracing/lrumemoizer/index.js');
-const index$j = require('./integrations/tracing/mongo/index.js');
-const index$k = require('./integrations/tracing/mongoose/index.js');
-const index$m = require('./integrations/tracing/mysql/index.js');
-const index$l = require('./integrations/tracing/mysql2/index.js');
-const index$p = require('./integrations/tracing/redis/index.js');
-const index$o = require('./integrations/tracing/postgres/index.js');
-const postgresjs = require('./integrations/tracing/postgresjs.js');
+const index$2 = require('./integrations/tracing/fastify/index.js');
+const orchestrion = require('@sentry/server-utils/orchestrion');
+const index$9 = require('./integrations/tracing/redis/index.js');
 const serverUtils = require('@sentry/server-utils');
-const index$b = require('./integrations/tracing/hapi/index.js');
-const index$c = require('./integrations/tracing/hono/index.js');
-const index$f = require('./integrations/tracing/koa/index.js');
-const index$3 = require('./integrations/tracing/connect/index.js');
-const index$e = require('./integrations/tracing/knex/index.js');
-const index$q = require('./integrations/tracing/tedious/index.js');
-const index$7 = require('./integrations/tracing/genericPool/index.js');
-const index$4 = require('./integrations/tracing/dataloader/index.js');
-const index = require('./integrations/tracing/amqplib/index.js');
-const index$r = require('./integrations/tracing/vercelai/index.js');
-const index$n = require('./integrations/tracing/openai/index.js');
-const index$1 = require('./integrations/tracing/anthropic-ai/index.js');
-const index$9 = require('./integrations/tracing/google-genai/index.js');
-const index$g = require('./integrations/tracing/langchain/index.js');
-const index$h = require('./integrations/tracing/langgraph/index.js');
+const index$a = require('./integrations/tracing/hapi/index.js');
+const index$b = require('./integrations/tracing/koa/index.js');
 const launchDarkly = require('./integrations/featureFlagShims/launchDarkly.js');
 const openFeature = require('./integrations/featureFlagShims/openFeature.js');
 const statsig = require('./integrations/featureFlagShims/statsig.js');
 const unleash = require('./integrations/featureFlagShims/unleash.js');
 const growthbook = require('./integrations/featureFlagShims/growthbook.js');
-const firebase = require('./integrations/tracing/firebase/firebase.js');
-const index$2 = require('./sdk/index.js');
-const experimentalUseDiagnosticsChannelInjection = require('./sdk/experimentalUseDiagnosticsChannelInjection.js');
-const diagnosticsChannelInjection = require('./sdk/diagnosticsChannelInjection.js');
+const index$5 = require('./sdk/index.js');
 const initOtel = require('./sdk/initOtel.js');
-const index$8 = require('./integrations/tracing/index.js');
+const index$4 = require('./integrations/tracing/index.js');
 const opentelemetry = require('@sentry/opentelemetry');
 const core = require('@sentry/core');
-const nodeCore = require('@sentry/node-core');
+const exports$1 = require('./logs/exports.js');
+const childProcess = require('./integrations/childProcess.js');
+const console = require('./integrations/console.js');
+const context = require('./integrations/context.js');
+const contextlines = require('./integrations/contextlines.js');
+const index$7 = require('./integrations/local-variables/index.js');
+const modules = require('./integrations/modules.js');
+const nodeRuntimeMetrics = require('./integrations/nodeRuntimeMetrics.js');
+const onuncaughtexception = require('./integrations/onuncaughtexception.js');
+const onunhandledrejection = require('./integrations/onunhandledrejection.js');
+const pino = require('./integrations/pino.js');
+const spotlight = require('./integrations/spotlight.js');
+const systemError = require('./integrations/systemError.js');
+const winston = require('./integrations/winston.js');
+const index$1 = require('./cron/index.js');
+const nodeVersion = require('./nodeVersion.js');
+const api = require('./sdk/api.js');
+const http = require('./transports/http.js');
+const module$1 = require('./utils/module.js');
+const httpServerIntegration = require('./integrations/http/httpServerIntegration.js');
+const httpServerSpansIntegration = require('./integrations/http/httpServerSpansIntegration.js');
+const processSession = require('./integrations/processSession.js');
+const client = require('./sdk/client.js');
+const index = require('./integrations/anr/index.js');
-exports.httpIntegration = http.httpIntegration;
-exports.nativeNodeFetchIntegration = nodeFetch.nativeNodeFetchIntegration;
-exports.fsIntegration = index$6.fsIntegration;
-exports.expressIntegration = express.expressIntegration;
+exports.httpIntegration = index$6.httpIntegration;
+exports.nativeNodeFetchIntegration = index$8.nativeNodeFetchIntegration;
+exports.fsIntegration = index$3.fsIntegration;
 exports.setupExpressErrorHandler = express.setupExpressErrorHandler;
-exports.fastifyIntegration = index$5.fastifyIntegration;
-exports.setupFastifyErrorHandler = index$5.setupFastifyErrorHandler;
-exports.graphqlIntegration = index$a.graphqlIntegration;
-exports.kafkaIntegration = index$d.kafkaIntegration;
-exports.lruMemoizerIntegration = index$i.lruMemoizerIntegration;
-exports.mongoIntegration = index$j.mongoIntegration;
-exports.mongooseIntegration = index$k.mongooseIntegration;
-exports.mysqlIntegration = index$m.mysqlIntegration;
-exports.mysql2Integration = index$l.mysql2Integration;
-exports.redisIntegration = index$p.redisIntegration;
-exports.postgresIntegration = index$o.postgresIntegration;
-exports.postgresJsIntegration = postgresjs.postgresJsIntegration;
+exports.fastifyIntegration = index$2.fastifyIntegration;
+exports.setupFastifyErrorHandler = index$2.setupFastifyErrorHandler;
+exports.amqplibIntegration = orchestrion.amqplibIntegration;
+exports.anthropicAIIntegration = orchestrion.anthropicIntegration;
+exports.dataloaderIntegration = orchestrion.dataloaderIntegration;
+exports.expressIntegration = orchestrion.expressIntegration;
+exports.firebaseIntegration = orchestrion.firebaseIntegration;
+exports.genericPoolIntegration = orchestrion.genericPoolIntegration;
+exports.googleGenAIIntegration = orchestrion.googleGenAIIntegration;
+exports.graphqlIntegration = orchestrion.graphqlDiagnosticsIntegration;
+exports.hapiIntegration = orchestrion.hapiIntegration;
+exports.kafkaIntegration = orchestrion.kafkajsIntegration;
+exports.knexIntegration = orchestrion.knexIntegration;
+exports.koaIntegration = orchestrion.koaIntegration;
+exports.langChainIntegration = orchestrion.langChainIntegration;
+exports.langGraphIntegration = orchestrion.langGraphIntegration;
+exports.lruMemoizerIntegration = orchestrion.lruMemoizerIntegration;
+exports.mongoIntegration = orchestrion.mongodbIntegration;
+exports.mongooseIntegration = orchestrion.mongooseIntegration;
+exports.mysql2Integration = orchestrion.mysql2Integration;
+exports.mysqlIntegration = orchestrion.mysqlIntegration;
+exports.openAIIntegration = orchestrion.openaiIntegration;
+exports.postgresIntegration = orchestrion.postgresIntegration;
+exports.postgresJsIntegration = orchestrion.postgresJsIntegration;
+exports.tediousIntegration = orchestrion.tediousIntegration;
+exports.vercelAIIntegration = orchestrion.vercelAiIntegration;
+exports.redisIntegration = index$9.redisIntegration;
+exports.createLangChainCallbackHandler = serverUtils.createLangChainCallbackHandler;
+exports.getOtlpTracesEndpoint = serverUtils.getOtlpTracesEndpoint;
+exports.instrumentAnthropicAiClient = serverUtils.instrumentAnthropicAiClient;
+exports.instrumentGoogleGenAIClient = serverUtils.instrumentGoogleGenAIClient;
+exports.instrumentLangChainEmbeddings = serverUtils.instrumentLangChainEmbeddings;
+exports.instrumentOpenAiClient = serverUtils.instrumentOpenAiClient;
+exports.instrumentStateGraph = serverUtils.instrumentStateGraph;
+exports.instrumentStateGraphCompile = serverUtils.instrumentStateGraphCompile;
+exports.otlpIntegration = serverUtils.otlpIntegration;
 exports.prismaIntegration = serverUtils.prismaIntegration;
-exports.hapiIntegration = index$b.hapiIntegration;
-exports.setupHapiErrorHandler = index$b.setupHapiErrorHandler;
-exports.honoIntegration = index$c.honoIntegration;
-exports.setupHonoErrorHandler = index$c.setupHonoErrorHandler;
-exports.koaIntegration = index$f.koaIntegration;
-exports.setupKoaErrorHandler = index$f.setupKoaErrorHandler;
-exports.connectIntegration = index$3.connectIntegration;
-exports.setupConnectErrorHandler = index$3.setupConnectErrorHandler;
-exports.knexIntegration = index$e.knexIntegration;
-exports.tediousIntegration = index$q.tediousIntegration;
-exports.genericPoolIntegration = index$7.genericPoolIntegration;
-exports.dataloaderIntegration = index$4.dataloaderIntegration;
-exports.amqplibIntegration = index.amqplibIntegration;
-exports.vercelAIIntegration = index$r.vercelAIIntegration;
-exports.openAIIntegration = index$n.openAIIntegration;
-exports.anthropicAIIntegration = index$1.anthropicAIIntegration;
-exports.googleGenAIIntegration = index$9.googleGenAIIntegration;
-exports.langChainIntegration = index$g.langChainIntegration;
-exports.langGraphIntegration = index$h.langGraphIntegration;
+exports.setupHapiErrorHandler = index$a.setupHapiErrorHandler;
+exports.setupKoaErrorHandler = index$b.setupKoaErrorHandler;
 exports.buildLaunchDarklyFlagUsedHandler = launchDarkly.buildLaunchDarklyFlagUsedHandlerShim;
 exports.launchDarklyIntegration = launchDarkly.launchDarklyIntegrationShim;
 exports.OpenFeatureIntegrationHook = openFeature.OpenFeatureIntegrationHookShim;
@@ -92,19 +97,13 @@ exports.openFeatureIntegration = openFeature.openFeatureIntegrationShim;
 exports.statsigIntegration = statsig.statsigIntegrationShim;
 exports.unleashIntegration = unleash.unleashIntegrationShim;
 exports.growthbookIntegration = growthbook.growthbookIntegrationShim;
-exports.firebaseIntegration = firebase.firebaseIntegration;
-exports.applyDiagnosticsChannelInjectionIntegrations = index$2.applyDiagnosticsChannelInjectionIntegrations;
-exports.getDefaultIntegrations = index$2.getDefaultIntegrations;
-exports.getDefaultIntegrationsWithoutPerformance = index$2.getDefaultIntegrationsWithoutPerformance;
-exports.init = index$2.init;
-exports.initWithoutDefaultIntegrations = index$2.initWithoutDefaultIntegrations;
-exports.diagnosticsChannelInjectionIntegrations = experimentalUseDiagnosticsChannelInjection.diagnosticsChannelInjectionIntegrations;
-exports.experimentalUseDiagnosticsChannelInjection = experimentalUseDiagnosticsChannelInjection.experimentalUseDiagnosticsChannelInjection;
-exports.isDiagnosticsChannelInjectionEnabled = diagnosticsChannelInjection.isDiagnosticsChannelInjectionEnabled;
+exports.getDefaultIntegrations = index$5.getDefaultIntegrations;
+exports.getDefaultIntegrationsWithoutPerformance = index$5.getDefaultIntegrationsWithoutPerformance;
+exports.init = index$5.init;
+exports.initWithoutDefaultIntegrations = index$5.initWithoutDefaultIntegrations;
 exports.initOpenTelemetry = initOtel.initOpenTelemetry;
-exports.preloadOpenTelemetry = initOtel.preloadOpenTelemetry;
-exports.getAutoPerformanceIntegrations = index$8.getAutoPerformanceIntegrations;
-exports.setNodeAsyncContextStrategy = opentelemetry.setOpenTelemetryContextAsyncContextStrategy;
+exports.getAutoPerformanceIntegrations = index$4.getAutoPerformanceIntegrations;
+exports.setOpenTelemetryContextAsyncContextStrategy = opentelemetry.setOpenTelemetryContextAsyncContextStrategy;
 exports.SDK_VERSION = core.SDK_VERSION;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_OP = core.SEMANTIC_ATTRIBUTE_SENTRY_OP;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN;
@@ -126,7 +125,6 @@ exports.close = core.close;
 exports.consoleLoggingIntegration = core.consoleLoggingIntegration;
 exports.continueTrace = core.continueTrace;
 exports.createConsolaReporter = core.createConsolaReporter;
-exports.createLangChainCallbackHandler = core.createLangChainCallbackHandler;
 exports.createTransport = core.createTransport;
 exports.dedupeIntegration = core.dedupeIntegration;
 exports.endSession = core.endSession;
@@ -147,19 +145,12 @@ exports.getSpanStatusFromHttpCode = core.getSpanStatusFromHttpCode;
 exports.getTraceData = core.getTraceData;
 exports.getTraceMetaTags = core.getTraceMetaTags;
 exports.httpHeadersToSpanAttributes = core.httpHeadersToSpanAttributes;
-exports.inboundFiltersIntegration = core.inboundFiltersIntegration;
-exports.instrumentAnthropicAiClient = core.instrumentAnthropicAiClient;
-exports.instrumentGoogleGenAIClient = core.instrumentGoogleGenAIClient;
-exports.instrumentLangChainEmbeddings = core.instrumentLangChainEmbeddings;
-exports.instrumentLangGraph = core.instrumentLangGraph;
-exports.instrumentOpenAiClient = core.instrumentOpenAiClient;
-exports.instrumentStateGraph = core.instrumentStateGraph;
-exports.instrumentStateGraphCompile = core.instrumentStateGraphCompile;
 exports.instrumentSupabaseClient = core.instrumentSupabaseClient;
 exports.isEnabled = core.isEnabled;
 exports.isInitialized = core.isInitialized;
 exports.lastEventId = core.lastEventId;
 exports.linkedErrorsIntegration = core.linkedErrorsIntegration;
+exports.metrics = core.metrics;
 exports.parameterize = core.parameterize;
 exports.profiler = core.profiler;
 exports.requestDataIntegration = core.requestDataIntegration;
@@ -194,38 +185,35 @@ exports.withActiveSpan = core.withActiveSpan;
 exports.withIsolationScope = core.withIsolationScope;
 exports.withMonitor = core.withMonitor;
 exports.withScope = core.withScope;
+exports.withStaticSpan = core.withStaticSpan;
+exports.withStreamedSpan = core.withStreamedSpan;
 exports.wrapMcpServerWithSentry = core.wrapMcpServerWithSentry;
 exports.zodErrorsIntegration = core.zodErrorsIntegration;
-exports.NODE_VERSION = nodeCore.NODE_VERSION;
-exports.NodeClient = nodeCore.NodeClient;
-exports.SentryContextManager = nodeCore.SentryContextManager;
-exports._INTERNAL_normalizeCollectionInterval = nodeCore._INTERNAL_normalizeCollectionInterval;
-exports.anrIntegration = nodeCore.anrIntegration;
-exports.childProcessIntegration = nodeCore.childProcessIntegration;
-exports.consoleIntegration = nodeCore.consoleIntegration;
-exports.contextLinesIntegration = nodeCore.contextLinesIntegration;
-exports.createGetModuleFromFilename = nodeCore.createGetModuleFromFilename;
-exports.createSentryWinstonTransport = nodeCore.createSentryWinstonTransport;
-exports.cron = nodeCore.cron;
-exports.defaultStackParser = nodeCore.defaultStackParser;
-exports.disableAnrDetectionForCallback = nodeCore.disableAnrDetectionForCallback;
-exports.generateInstrumentOnce = nodeCore.generateInstrumentOnce;
-exports.getSentryRelease = nodeCore.getSentryRelease;
-exports.httpServerIntegration = nodeCore.httpServerIntegration;
-exports.httpServerSpansIntegration = nodeCore.httpServerSpansIntegration;
-exports.localVariablesIntegration = nodeCore.localVariablesIntegration;
-exports.logger = nodeCore.logger;
-exports.makeNodeTransport = nodeCore.makeNodeTransport;
-exports.metrics = nodeCore.metrics;
-exports.modulesIntegration = nodeCore.modulesIntegration;
-exports.nodeContextIntegration = nodeCore.nodeContextIntegration;
-exports.nodeRuntimeMetricsIntegration = nodeCore.nodeRuntimeMetricsIntegration;
-exports.onUncaughtExceptionIntegration = nodeCore.onUncaughtExceptionIntegration;
-exports.onUnhandledRejectionIntegration = nodeCore.onUnhandledRejectionIntegration;
-exports.pinoIntegration = nodeCore.pinoIntegration;
-exports.processSessionIntegration = nodeCore.processSessionIntegration;
-exports.spotlightIntegration = nodeCore.spotlightIntegration;
-exports.systemErrorIntegration = nodeCore.systemErrorIntegration;
-exports.validateOpenTelemetrySetup = nodeCore.validateOpenTelemetrySetup;
-exports.withStreamedSpan = nodeCore.withStreamedSpan;
+exports.logger = exports$1;
+exports.childProcessIntegration = childProcess.childProcessIntegration;
+exports.consoleIntegration = console.consoleIntegration;
+exports.nodeContextIntegration = context.nodeContextIntegration;
+exports.contextLinesIntegration = contextlines.contextLinesIntegration;
+exports.localVariablesIntegration = index$7.localVariablesIntegration;
+exports.modulesIntegration = modules.modulesIntegration;
+exports._INTERNAL_normalizeCollectionInterval = nodeRuntimeMetrics._INTERNAL_normalizeCollectionInterval;
+exports.nodeRuntimeMetricsIntegration = nodeRuntimeMetrics.nodeRuntimeMetricsIntegration;
+exports.onUncaughtExceptionIntegration = onuncaughtexception.onUncaughtExceptionIntegration;
+exports.onUnhandledRejectionIntegration = onunhandledrejection.onUnhandledRejectionIntegration;
+exports.pinoIntegration = pino.pinoIntegration;
+exports.spotlightIntegration = spotlight.spotlightIntegration;
+exports.systemErrorIntegration = systemError.systemErrorIntegration;
+exports.createSentryWinstonTransport = winston.createSentryWinstonTransport;
+exports.cron = index$1.cron;
+exports.NODE_VERSION = nodeVersion.NODE_VERSION;
+exports.defaultStackParser = api.defaultStackParser;
+exports.getSentryRelease = api.getSentryRelease;
+exports.makeNodeTransport = http.makeNodeTransport;
+exports.createGetModuleFromFilename = module$1.createGetModuleFromFilename;
+exports.httpServerIntegration = httpServerIntegration.httpServerIntegration;
+exports.httpServerSpansIntegration = httpServerSpansIntegration.httpServerSpansIntegration;
+exports.processSessionIntegration = processSession.processSessionIntegration;
+exports.NodeClient = client.NodeClient;
+exports.anrIntegration = index.anrIntegration;
+exports.disableAnrDetectionForCallback = index.disableAnrDetectionForCallback;
 //# sourceMappingURL=index.js.map

package/build/cjs/index.js.map CHANGED Viewed

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

package/build/cjs/integrations/anr/index.js ADDED Viewed

@@ -0,0 +1,159 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const util = require('node:util');
+const node_worker_threads = require('node:worker_threads');
+const core = require('@sentry/core');
+const debug = require('../../utils/debug.js');
+const { isPromise } = util.types;
+const base64WorkerScript = "/*! @sentry/node 11.0.0-alpha.0 (474a5dc) | https://github.com/getsentry/sentry-javascript */
import{Session as t}from"node:inspector";import{workerData as n,parentPort as e}from"node:worker_threads";import{posix as r,sep as o}from"node:path";import*as i from"node:http";import*as s 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="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__,p=globalThis,d="11.0.0-alpha.0";function l(){return g(p),p}function g(t){const n=t.__SENTRY__=t.__SENTRY__||{};return n.version=n.version||d,n[d]=n[d]||{}}function m(t,n,e=p){const r=e.__SENTRY__=e.__SENTRY__||{},o=r[d]=r[d]||{};return o[t]||(o[t]=n())}const y={};function b(t){if(!("console"in p))return t();const n=p.console,e={},r=Object.keys(y);r.forEach(t=>{const r=y[t];e[t]=n[t],n[t]=r});try{return t()}finally{r.forEach(t=>{n[t]=e[t]})}}function _(){return S().enabled}function v(t,...n){h&&_()&&b(()=>{p.console[t](`Sentry Logger [${t}]:`,...n)})}function S(){return h?m("loggerSettings",()=>({enabled:!1})):{enabled:!1}}const w={enable:function(){S().enabled=!0},disable:function(){S().enabled=!1},isEnabled:_,log:function(...t){v("log",...t)},warn:function(...t){v("warn",...t)},error:function(...t){v("error",...t)}},$=/captureMessage|captureException/;function x(t){return t[t.length-1]||{}}const E="<anonymous>";const N=Object.prototype.toString;function k(t,n){return N.call(t)===`[object ${n}]`}function C(t){return Boolean(t?.then&&"function"==typeof t.then)}function j(t,n){try{return t instanceof n}catch{return!1}}function R(t){if(function(t){switch(N.call(t)){case"[object Error]":case"[object Exception]":case"[object DOMException]":case"[object WebAssembly.Exception]":return!0;default:return j(t,Error)}}(t))return{message:t.message,name:t.name,stack:t.stack,...A(t)};if(n=t,"undefined"!=typeof Event&&j(n,Event)){const{type:n,target:e,currentTarget:r,detail:o}=t;return{type:n,target:e,currentTarget:r,...o?{detail:o}:{},...A(t)}}var n;return t}function A(t){return"object"==typeof(n=t)&&null!==n?Object.fromEntries(Object.entries(t)):{};var n}let I;function T(t){if(void 0!==I)return I?I(t):t();const n=Symbol.for("__SENTRY_SAFE_RANDOM_ID_WRAPPER__"),e=p;return n in e&&"function"==typeof e[n]?(I=e[n],I(t)):(I=null,t())}function O(){return T(()=>Math.random())}function P(){return T(()=>Date.now())}const D=Symbol.for("sentry.skipNormalization"),U=Symbol.for("sentry.overrideNormalizationDepth");function B(t,n=100,e=1/0){try{return L("",t,n,e)}catch(t){return{ERROR:`**non-serializable** (${t})`}}}function L(t,n,e=1/0,r=1/0,o=function(){const t=new WeakSet;function n(n){return!!t.has(n)||(t.add(n),!1)}function e(n){t.delete(n)}return[n,e]}()){const[i,s]=o;if(null==n||["boolean","string"].includes(typeof n)||"number"==typeof n&&Number.isFinite(n))return n;const c=function(t,n){try{if("undefined"!=typeof global&&n===global)return"[Global]";if("number"==typeof n&&!Number.isFinite(n))return`[${n}]`;if("function"==typeof n)return`[Function: ${function(t){try{return t&&"function"==typeof t&&t.name||E}catch{return E}}(n)}]`;if("symbol"==typeof n)return`[${String(n)}]`;if("bigint"==typeof n)return`[BigInt: ${String(n)}]`;const t=function(t){const n=Object.getPrototypeOf(t);return n?.constructor?n.constructor.name:"null prototype"}(n);return`[object ${t}]`}catch(t){return`**non-serializable** (${t})`}}(0,n);if(!c.startsWith("[object "))return c;if(function(t){return Boolean(t[D])}(n))return n;const u=function(t){const n=t[U];return"number"==typeof n?n:void 0}(n),a=void 0!==u?u:e;if(0===a)return c.replace("object ","");if(i(n))return"[Circular ~]";const f=n;if(f&&"function"==typeof f.toJSON)try{return L("",f.toJSON(),a-1,r,o)}catch{}const h=Array.isArray(n)?[]:{};let p=0;const d=R(n);for(const t in d){if(!Object.prototype.hasOwnProperty.call(d,t))continue;if(p>=r){h[t]="[MaxProperties ~]";break}const n=d[t];h[t]=L(t,n,a-1,r,o),p++}return s(n),h}function M(t,n){const e=n.replace(/\\/g,"/").replace(/[|\\{}()[\]^$+*?.]/g,"\\$&");let r=t;try{r=decodeURI(t)}catch{}return r.replace(/\\/g,"/").replace(/webpack:\/?/g,"").replace(new RegExp(`(file://)?/*${e}/*`,"ig"),"app:///")}function z(t,n=0){return"string"!=typeof t||0===n||t.length<=n?t:`${t.slice(0,n)}...`}let F;function G(t=function(){const t=p;return t.crypto||t.msCrypto}()){try{if(t?.randomUUID)return T(()=>t.randomUUID()).replace(/-/g,"")}catch{}return F||(F="10000000100040008000100000000000"),F.replace(/[018]/g,t=>(t^(16*O()&15)>>t/4).toString(16))}function J(){return P()/1e3}let W;function Y(){return(W??(W=function(){const{performance:t}=p;if(!t?.now||!t.timeOrigin)return J;const n=t.timeOrigin;return()=>(n+T(()=>t.now()))/1e3}()))()}function H(t){const n=Y(),e={sid:G(),init:!0,timestamp:n,started:n,duration:0,status:"ok",errors:0,ignoreDuration:!1,toJSON:()=>function(t){return{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}}}(e)};return t&&K(e,t),e}function K(t,n={}){if(n.user&&(!t.ipAddress&&n.user.ip_address&&(t.ipAddress=n.user.ip_address),t.did||n.did||(t.did=n.user.id||n.user.email||n.user.username)),t.timestamp=n.timestamp||Y(),n.abnormal_mechanism&&(t.abnormal_mechanism=n.abnormal_mechanism),n.ignoreDuration&&(t.ignoreDuration=n.ignoreDuration),n.sid&&(t.sid=32===n.sid.length?n.sid:G()),void 0!==n.init&&(t.init=n.init),!t.did&&n.did&&(t.did=`${n.did}`),"number"==typeof n.started&&(t.started=n.started),t.ignoreDuration)t.duration=void 0;else if("number"==typeof n.duration)t.duration=n.duration;else{const n=t.timestamp-t.started;t.duration=n>=0?n:0}n.release&&(t.release=n.release),n.environment&&(t.environment=n.environment),!t.ipAddress&&n.ipAddress&&(t.ipAddress=n.ipAddress),!t.userAgent&&n.userAgent&&(t.userAgent=n.userAgent),"number"==typeof n.errors&&(t.errors=n.errors),n.status&&(t.status=n.status)}function Z(t,n,e=2){if(!n||"object"!=typeof n||e<=0)return n;if(t&&0===Object.keys(n).length)return t;const r={...t};for(const t in n)Object.prototype.hasOwnProperty.call(n,t)&&(r[t]=Z(r[t],n[t],e-1));return r}function q(){return G()}function V(){return G().substring(16)}function Q(t){if(t){if("object"==typeof t&&"deref"in t&&"function"==typeof t.deref)try{return t.deref()}catch{return}return t}}const X="_sentrySpan";function tt(t,n){n?function(t,n,e){try{Object.defineProperty(t,n,{value:e,writable:!0,configurable:!0})}catch{h&&w.log(`Failed to add non-enumerable property "${String(n)}" to object`,t)}}(t,X,function(t){try{const n=p.WeakRef;if("function"==typeof n)return new n(t)}catch{}return t}(n)):delete t[X]}function nt(t){return Q(t[X])}class et{constructor(){this.t=!1,this.o=[],this.i=[],this.u=[],this.h=[],this.p={},this.l={},this.m={},this._={},this.v={},this.S={},this.N={traceId:q(),sampleRand:O()}}clone(){const t=new et;return t.u=[...this.u],t.l={...this.l},t.m={...this.m},t._={...this._},t.v={...this.v},this.v.flags&&(t.v.flags={values:[...this.v.flags.values]}),t.p=this.p,t.k=this.k,t.C=this.C,t.j=this.j,t.R=this.R,t.i=[...this.i],t.h=[...this.h],t.S={...this.S},t.N={...this.N},t.A=this.A,t.I=this.I,t.T=this.T,tt(t,nt(this)),t}setClient(t){this.A=t}setLastEventId(t){this.I=t}getClient(){return this.A}lastEventId(){return this.I}addScopeListener(t){this.o.push(t)}addEventProcessor(t){return this.i.push(t),this}setUser(t){return this.p=t||{email:void 0,id:void 0,ip_address:void 0,username:void 0},this.C&&K(this.C,{user:t}),this.O(),this}getUser(){return this.p}setConversationId(t){return this.T=t||void 0,this.O(),this}setTags(t){return this.l={...this.l,...t},this.O(),this}setTag(t,n){return this.setTags({[t]:n})}setAttributes(t){return this.m={...this.m,...t},this.O(),this}setAttribute(t,n){return this.setAttributes({[t]:n})}removeAttribute(t){return t in this.m&&(delete this.m[t],this.O()),this}setExtras(t){return this._={...this._,...t},this.O(),this}setExtra(t,n){return this._={...this._,[t]:n},this.O(),this}setFingerprint(t){return this.R=t,this.O(),this}setLevel(t){return this.k=t,this.O(),this}setTransactionName(t){return this.j=t,this.O(),this}setContext(t,n){return null===n?delete this.v[t]:this.v[t]=n,this.O(),this}setSession(t){return t?this.C=t:delete this.C,this.O(),this}getSession(){return this.C}update(t){if(!t)return this;const n="function"==typeof t?t(this):t,e=n instanceof et?n.getScopeData():k(n,"Object")?t:void 0;const{tags:r,attributes:o,extra:i,user:s,contexts:c,level:u,fingerprint:a=[],propagationContext:f,conversationId:h}=e||{};return this.l={...this.l,...r},this.m={...this.m,...o},this._={...this._,...i},this.v={...this.v,...c},s&&Object.keys(s).length&&(this.p=s),u&&(this.k=u),a.length&&(this.R=a),f&&(this.N=f),h&&(this.T=h),this}clear(){return this.u=[],this.l={},this.m={},this._={},this.p={},this.v={},this.k=void 0,this.j=void 0,this.R=void 0,this.C=void 0,this.T=void 0,tt(this,void 0),this.h=[],this.setPropagationContext({traceId:q(),sampleRand:O()}),this.O(),this}addBreadcrumb(t,n){const e="number"==typeof n?n:100;if(e<=0)return this;const r={timestamp:J(),...t,message:t.message?z(t.message,2048):t.message};return this.u.push(r),this.u.length>e&&(this.u=this.u.slice(-e),this.A?.recordDroppedEvent("buffer_overflow","log_item")),this.O(),this}getLastBreadcrumb(){return this.u[this.u.length-1]}clearBreadcrumbs(){return this.u=[],this.O(),this}addAttachment(t){return this.h.push(t),this}clearAttachments(){return this.h=[],this}getScopeData(){return{breadcrumbs:this.u,attachments:this.h,contexts:this.v,tags:this.l,attributes:this.m,extra:this._,user:this.p,level:this.k,fingerprint:this.R||[],eventProcessors:this.i,propagationContext:this.N,sdkProcessingMetadata:this.S,transactionName:this.j,span:nt(this),conversationId:this.T}}setSDKProcessingMetadata(t){return this.S=Z(this.S,t,2),this}setPropagationContext(t){return this.N=t,this}getPropagationContext(){return this.N}captureException(t,n){const e=n?.event_id||G();if(!this.A)return h&&w.warn("No client configured on scope - will not capture exception!"),e;const r=new Error("Sentry syntheticException");return this.A.captureException(t,{originalException:t,syntheticException:r,...n,event_id:e},this),e}captureMessage(t,n,e){const r=e?.event_id||G();if(!this.A)return h&&w.warn("No client configured on scope - will not capture message!"),r;const o=e?.syntheticException??new Error(t);return this.A.captureMessage(t,n,{originalException:t,syntheticException:o,...e,event_id:r},this),r}captureEvent(t,n){const e=t.event_id||n?.event_id||G();return this.A?(this.A.captureEvent(t,{...n,event_id:e},this),e):(h&&w.warn("No client configured on scope - will not capture event!"),e)}O(){this.t||(this.t=!0,this.o.forEach(t=>{t(this)}),this.t=!1)}}const rt="__SENTRY_SUPPRESS_TRACING__",ot=t=>t instanceof Promise&&!t[it],it=Symbol("chained PromiseLike"),st=(t,n)=>{if(!n)return t;let e=!1;for(const r in t){if(r in n)continue;e=!0;const o=t[r];"function"==typeof o?Object.defineProperty(n,r,{value:(...n)=>o.apply(t,n),enumerable:!0,configurable:!0,writable:!0}):n[r]=o}return e&&Object.assign(n,{[it]:!0}),n};class ct{constructor(t,n){let e,r;e=t||new et,r=n||new et,this.P=[{scope:e}],this.D=r}withScope(t){const n=this.U();let e;try{e=t(n)}catch(t){throw this.B(),t}return C(e)?((t,n,e)=>{const r=t.then(t=>(n(t),t),t=>{throw e(t),t});return ot(r)&&ot(t)?r:st(t,r)})(e,()=>this.B(),()=>this.B()):(this.B(),e)}getClient(){return this.getStackTop().client}getScope(){return this.getStackTop().scope}getIsolationScope(){return this.D}getStackTop(){return this.P[this.P.length-1]}U(){const t=this.getScope().clone();return this.P.push({client:this.getClient(),scope:t}),t}B(){return!(this.P.length<=1)&&!!this.P.pop()}}function ut(){const t=g(l());return t.stack=t.stack||new ct(m("defaultCurrentScope",()=>new et),m("defaultIsolationScope",()=>new et))}function at(t){return ut().withScope(t)}function ft(t,n){const e=ut();return e.withScope(()=>(e.getStackTop().scope=t,n(t)))}function ht(t){return ut().withScope(()=>t(ut().getIsolationScope()))}function pt(t){return at(n=>{n.setSDKProcessingMetadata({[rt]:!0});const e=t();return n.setSDKProcessingMetadata({[rt]:void 0}),e})}function dt(t){const n=g(t);return n.acs?n.acs:{suppressTracing:pt,withIsolationScope:ht,withScope:at,withSetScope:ft,withSetIsolationScope:(t,n)=>ht(n),getCurrentScope:()=>ut().getScope(),getIsolationScope:()=>ut().getIsolationScope()}}function lt(){return dt(l()).getCurrentScope().getClient()}const gt=["ok","deadline_exceeded","unauthenticated","permission_denied","not_found","resource_exhausted","invalid_argument","unimplemented","unavailable","internal_error","unknown_error","cancelled","already_exists","failed_precondition","aborted","out_of_range","data_loss"];function mt(t){const n=t;return{scope:n._sentryScope,isolationScope:Q(n._sentryIsolationScope)}}const yt="sentry-";function bt(t){const n=function(t){if(!t||(n=t,!k(n,"String")&&!Array.isArray(t)))return;var n;if(Array.isArray(t))return t.reduce((t,n)=>{const e=_t(n);return Object.entries(e).forEach(([n,e])=>{t[n]=e}),t},{});return _t(t)}(t);if(!n)return;const e=Object.entries(n).reduce((t,[n,e])=>{if(n.startsWith(yt)){t[n.slice(7)]=e}return t},{});return Object.keys(e).length>0?e:void 0}function _t(t){return t.split(",").map(t=>{const n=t.indexOf("=");if(-1===n)return[];return[t.slice(0,n),t.slice(n+1)].map(t=>{try{return decodeURIComponent(t.trim())}catch{return}})}).reduce((t,[n,e])=>(n&&e&&(t[n]=e),t),{})}const vt=/^o(\d+)\./;function St(t,n=!1){const{host:e,path:r,pass:o,port:i,projectId:s,protocol:c,publicKey:u}=t;return`${c}://${u}${n&&o?`:${o}`:""}@${e}${i?`:${i}`:""}/${r?`${r}/`:r}${s}`}function wt(t){const n=t.getOptions(),{host:e}=t.getDsn()||{};let r;return n.orgId?r=String(n.orgId):e&&(r=function(t){const n=t.match(vt);return n?.[1]}(e)),r}function $t(t){const{spanId:n,traceId:e,isRemote:r}=t.spanContext(),o=r?n:kt(t).parent_span_id,i=mt(t).scope;return{parent_span_id:o,span_id:r?i?.getPropagationContext().propagationSpanId||V():n,trace_id:e}}function xt(t){return t&&t.length>0?t.map(({context:{spanId:t,traceId:n,traceFlags:e,...r},attributes:o})=>({span_id:t,trace_id:n,sampled:1===e,attributes:o,...r})):void 0}function Et(t){return"number"==typeof t?Nt(t):Array.isArray(t)?t[0]+t[1]/1e9:t instanceof Date?Nt(t.getTime()):Y()}function Nt(t){return t>9999999999?t/1e3:t}function kt(t){if(function(t){return"function"==typeof t.getSpanJSON}(t))return t.getSpanJSON();const{spanId:n,traceId:e}=t.spanContext();if(function(t){const n=t;return!!(n.attributes&&n.startTime&&n.name&&n.endTime&&n.status)}(t)){const{attributes:r,startTime:o,name:i,endTime:s,status:c,links:u}=t;return{span_id:n,trace_id:e,data:r,description:i,parent_span_id:Ct(t),start_timestamp:Et(o),timestamp:Et(s)||void 0,status:jt(c),op:r["sentry.op"],origin:r["sentry.origin"],links:xt(u)}}return{span_id:n,trace_id:e,start_timestamp:0,status:"ok",data:{}}}function Ct(t){return"parentSpanId"in t?t.parentSpanId:"parentSpanContext"in t?t.parentSpanContext?.spanId:void 0}function jt(t){return t&&0!==t.code?1===t.code?"ok":t.message&&("ok"!==(n=t.message)&&gt.includes(n))?t.message:"internal_error":"ok";var n}const Rt=function(t){return t._sentryRootSpan||t};function At(t){if("boolean"==typeof __SENTRY_TRACING__&&!__SENTRY_TRACING__)return!1;const n=t||lt()?.getOptions();return!(!n||null==n.tracesSampleRate&&!n.tracesSampler)}const It=Symbol.for("sentry.nonRecordingSpan");function Tt(t,n){const e=n.getOptions(),{publicKey:r}=n.getDsn()||{},o={environment:e.environment||"production",release:e.release,public_key:r,trace_id:t,org_id:wt(n)};return n.emit("createDsc",o),o}function Ot(t){const n=lt();if(!n)return{};const e=Rt(t),r=kt(e),o=r.data,i=e.spanContext().traceState,s=i?.get("sentry.sample_rate")??o["sentry.sample_rate"]??o["sentry.previous_trace_sample_rate"];function c(t){return"number"!=typeof s&&"string"!=typeof s||(t.sample_rate=`${s}`),t}const u=e._frozenDsc;if(u)return c(u);const a=function(t){return!!t&&!0===t[It]}(e),f=a&&"ignored"===e.dropReason;if(a&&(!At(n.getOptions())||f)){const t=mt(e).scope,r=t&&function(t,n){const e=n.getPropagationContext();return e.dsc||Tt(e.traceId,t)}(n,t);if(r){const t={...r};return f&&(t.sampled="false"),c(t)}}const h=i?.get("sentry.dsc"),p=h&&bt(h);if(p)return c(p);const d=Tt(t.spanContext().traceId,n),l=o["sentry.source"]??o["sentry.segment.name.source"],g=r.description;return"url"!==l&&g&&(d.transaction=g),At()&&(d.sampled=String(function(t){const{traceFlags:n}=t.spanContext();return 1===n}(e)),d.sample_rand=i?.get("sentry.sample_rand")??mt(e).scope?.getPropagationContext().sampleRand.toString()),c(d),n.emit("createDsc",d,e),d}function Pt(t,n){const{fingerprint:e,span:r,breadcrumbs:o,sdkProcessingMetadata:i}=n;!function(t,n){const{extra:e,tags:r,user:o,contexts:i,level:s,transactionName:c}=n;Object.keys(e).length&&(t.extra={...e,...t.extra});Object.keys(r).length&&(t.tags={...r,...t.tags});Object.keys(o).length&&(t.user={...o,...t.user});Object.keys(i).length&&(t.contexts={...i,...t.contexts});s&&(t.level=s);c&&"transaction"!==t.type&&(t.transaction=c)}(t,n),r&&function(t,n){t.contexts={trace:$t(n),...t.contexts},t.sdkProcessingMetadata={dynamicSamplingContext:Ot(n),...t.sdkProcessingMetadata};const e=Rt(n),r=kt(e).description;r&&!t.transaction&&"transaction"===t.type&&(t.transaction=r)}(t,r),function(t,n){t.fingerprint=t.fingerprint?Array.isArray(t.fingerprint)?t.fingerprint:[t.fingerprint]:[],n&&(t.fingerprint=t.fingerprint.concat(n));t.fingerprint.length||delete t.fingerprint}(t,e),function(t,n){const e=[...t.breadcrumbs||[],...n];t.breadcrumbs=e.length?e:void 0}(t,o),function(t,n){t.sdkProcessingMetadata={...t.sdkProcessingMetadata,...n}}(t,i)}function Dt(t,n=[]){return[t,n]}function Ut(t,n){const e=t[1];for(const t of e){if(n(t,t[0].type))return!0}return!1}function Bt(t){const n=g(p);return n.encodePolyfill?n.encodePolyfill(t):(new TextEncoder).encode(t)}function Lt(t){const[n,e]=t;let r=JSON.stringify(n);function o(t){"string"==typeof r?r="string"==typeof t?r+t:[Bt(r),t]:r.push("string"==typeof t?Bt(t):t)}for(const t of e){const[n,e]=t;if(o(`\n${JSON.stringify(n)}\n`),"string"==typeof e||e instanceof Uint8Array)o(e);else{let t;try{t=JSON.stringify(e)}catch{t=JSON.stringify(B(e))}o(t)}}return"string"==typeof r?r:function(t){const n=t.reduce((t,n)=>t+n.length,0),e=new Uint8Array(n);let r=0;for(const n of t)e.set(n,r),r+=n.length;return e}(r)}const Mt={sessions:"session",event:"error",client_report:"internal",user_report:"default",profile_chunk:"profile",replay_event:"replay",replay_recording:"replay",check_in:"monitor",raw_security:"security",log:"log_item",trace_metric:"metric"};function zt(t){return function(t){return t in Mt}(t)?Mt[t]:t}function Ft(t){if(!t?.sdk)return;const{name:n,version:e}=t.sdk;return{name:n,version:e}}function Gt(t){const n=dt(l());return n.suppressTracing?n.suppressTracing(t):function(...t){const n=dt(l());if(2===t.length){const[e,r]=t;return e?n.withSetScope(e,r):n.withScope(r)}return n.withScope(t[0])}(n=>(n.setSDKProcessingMetadata({[rt]:!0}),t()))}function Jt(t,n,e,r){const o=Ft(e),i=t.type&&"replay_event"!==t.type?t.type:"event";!function(t,n){if(!n)return t;const e=t.sdk||{};t.sdk={...e,name:e.name||n.name,version:e.version||n.version,integrations:[...t.sdk?.integrations||[],...n.integrations||[]],packages:[...t.sdk?.packages||[],...n.packages||[]],settings:t.sdk?.settings||n.settings?{...t.sdk?.settings,...n.settings}:void 0}}(t,e?.sdk);const s=function(t,n,e,r){const o=t.sdkProcessingMetadata?.dynamicSamplingContext;return{event_id:t.event_id,sent_at:new Date(P()).toISOString(),...n&&{sdk:n},...!!e&&r&&{dsn:St(r)},...o&&{trace:o}}}(t,o,r,n);delete t.sdkProcessingMetadata;return Dt(s,[[{type:i},t]])}class Wt{constructor(t){this.L=0,this.M=[],this.F(t)}then(t,n){return new Wt((e,r)=>{this.M.push([!1,n=>{if(t)try{e(t(n))}catch(t){r(t)}else e(n)},t=>{if(n)try{e(n(t))}catch(t){r(t)}else r(t)}]),this.G()})}catch(t){return this.then(t=>t,t)}finally(t){return new Wt((n,e)=>{let r,o;return this.then(n=>{o=!1,r=n,t&&t()},n=>{o=!0,r=n,t&&t()}).then(()=>{o?e(r):n(r)})})}G(){if(0===this.L)return;const t=this.M.slice();this.M=[],t.forEach(t=>{t[0]||(1===this.L&&t[1](this.J),2===this.L&&t[2](this.J),t[0]=!0)})}F(t){const n=(t,n)=>{0===this.L&&(C(n)?n.then(e,r):(this.L=t,this.J=n,this.G()))},e=t=>{n(1,t)},r=t=>{n(2,t)};try{t(e,r)}catch(t){r(t)}}}const Yt=Symbol.for("SentryBufferFullError");function Ht(t=100){const n=new Set;function e(t){n.delete(t)}return{get $(){return Array.from(n)},add:function(r){if(!(n.size<t))return o=Yt,new Wt((t,n)=>{n(o)});var o;const i=r();return n.add(i),i.then(()=>e(i),()=>e(i)),i},drain:function(t){if(!n.size)return e=!0,new Wt(t=>{t(e)});var e;const r=Promise.allSettled(Array.from(n)).then(()=>!0);if(!t)return r;const o=[r,new Promise(n=>{return"object"==typeof(e=setTimeout(()=>n(!1),t))&&"function"==typeof e.unref&&e.unref(),e;var e})];return Promise.race(o)}}}function Kt(t,{statusCode:n,headers:e},r=P()){const o={...t},i=e?.["x-sentry-rate-limits"],s=e?.["retry-after"];if(i)for(const t of i.trim().split(",")){const[n,e,,,i]=t.split(":",5),s=parseInt(n,10),c=1e3*(isNaN(s)?60:s);if(e)for(const t of e.split(";"))"metric_bucket"===t&&i&&!i.split(";").includes("custom")||(o[t]=r+c);else o.all=r+c}else s?o.all=r+function(t,n=P()){const e=parseInt(`${t}`,10);if(!isNaN(e))return 1e3*e;const r=Date.parse(`${t}`);return isNaN(r)?6e4:r-n}(s,r):429===n&&(o.all=r+6e4);return o}function Zt(t,n,e=Ht(t.bufferSize||64)){let r={};return{send:function(t){const o=[];if(Ut(t,(t,n)=>{const e=zt(n);(function(t,n,e=P()){return function(t,n){return t[n]||t.all||0}(t,n)>e})(r,e)||o.push(t)}),0===o.length)return Promise.resolve({});const i=Dt(t[0],o),s=t=>{!function(t,n){return Ut(t,(t,e)=>n.includes(e))}(i,["client_report"])?Ut(i,(t,n)=>{}):h&&w.warn(`Dropping client report. Will not send outcomes (reason: ${t}).`)};return e.add(()=>n({body:Lt(i)}).then(t=>413===t.statusCode?(h&&w.error("Sentry responded with status code 413. Envelope was discarded due to exceeding size limits."),s("send_error"),t):(h&&void 0!==t.statusCode&&(t.statusCode<200||t.statusCode>=300)&&w.warn(`Sentry responded with status code ${t.statusCode} to sent event.`),r=Kt(r,t),t),t=>{throw s("network_error"),h&&w.error("Encountered error running transport request:",t),t})).then(t=>t,t=>{if(t===Yt)return h&&w.error("Skipped sending event because buffer is full."),s("queue_overflow"),Promise.resolve({});throw t})},flush:t=>e.drain(t)}}const qt=/^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;function Vt(t){const n=function(t){const n=t.length>1024?`<truncated>${t.slice(-1024)}`:t,e=qt.exec(n);return e?e.slice(1):[]}(t),e=n[0]||"";let r=n[1];return e||r?(r&&(r=r.slice(0,r.length-1)),e+r):"."}function Qt(t,n=!1){return!(n||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/")}var Xt;const tn=Symbol("AgentBaseInternalState");class nn extends(Xt=i.Agent,Xt){constructor(t){super(t),this[tn]={}}isSecureEndpoint(t){if(t){if("boolean"==typeof t.secureEndpoint)return t.secureEndpoint;if("string"==typeof t.protocol)return"https:"===t.protocol}const{stack:n}=new Error;return"string"==typeof n&&n.split("\n").some(t=>-1!==t.indexOf("(https.js:")||-1!==t.indexOf("node:https:"))}createSocket(t,n,e){const r={...n,secureEndpoint:this.isSecureEndpoint(n)};Promise.resolve().then(()=>this.connect(t,r)).then(o=>{if(o instanceof i.Agent)return o.addRequest(t,r);this[tn].currentSocket=o,super.createSocket(t,n,e)},e)}createConnection(){const t=this[tn].currentSocket;if(this[tn].currentSocket=void 0,!t)throw new Error("No socket was returned in the `connect()` function");return t}get defaultPort(){return this[tn].defaultPort??("https:"===this.protocol?443:80)}set defaultPort(t){this[tn]&&(this[tn].defaultPort=t)}get protocol(){return this[tn].protocol??(this.isSecureEndpoint()?"https:":"http:")}set protocol(t){this[tn]&&(this[tn].protocol=t)}}function en(...t){w.log("[https-proxy-agent:parse-proxy-response]",...t)}function rn(t){return new Promise((n,e)=>{let r=0;const o=[];function i(){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 en("have not received end of HTTP headers yet..."),void i();const f=u.subarray(0,a).toString("ascii").split("\r\n"),h=f.shift();if(!h)return t.destroy(),e(new Error("No header received from proxy CONNECT response"));const p=h.split(" "),d=+(p[1]||0),l=p.slice(2).join(" "),g={};for(const n of f){if(!n)continue;const r=n.indexOf(":");if(-1===r)return t.destroy(),e(new Error(`Invalid header from proxy CONNECT response: "${n}"`));const o=n.slice(0,r).toLowerCase(),i=n.slice(r+1).trimStart(),s=g[o];"string"==typeof s?g[o]=[s,i]:Array.isArray(s)?s.push(i):g[o]=i}en("got proxy server response: %o %o",h,g),s(),n({connect:{statusCode:d,statusText:l,headers:g},buffered:u})}(c):t.once("readable",i)}function s(){t.removeListener("end",c),t.removeListener("error",u),t.removeListener("readable",i)}function c(){s(),en("onend"),e(new Error("Proxy connection ended before receiving CONNECT response"))}function u(t){s(),en("onerror %o",t),e(t)}t.on("error",u),t.on("end",c),i()})}function on(...t){w.log("[https-proxy-agent]",...t)}class sn extends nn{constructor(t,n){super(n),this.options={},this.proxy="string"==typeof t?new URL(t):t,this.proxyHeaders=n?.headers??{},on("Creating new HttpsProxyAgent instance: %o",this.proxy.href);const e=(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"],...n?un(n,"headers"):null,host:e,port:r}}async connect(t,n){const{proxy:e}=this;if(!n.host)throw new TypeError('No "host" provided');let r;if("https:"===e.protocol){on("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 on("Creating `net.Socket`: %o",this.connectOpts),r=a.connect(this.connectOpts);const o="function"==typeof this.proxyHeaders?this.proxyHeaders():{...this.proxyHeaders},i=a.isIPv6(n.host)?`[${n.host}]`:n.host;let s=`CONNECT ${i}:${n.port} HTTP/1.1\r\n`;if(e.username||e.password){const t=`${decodeURIComponent(e.username)}:${decodeURIComponent(e.password)}`;o["Proxy-Authorization"]=`Basic ${Buffer.from(t).toString("base64")}`}o.Host=`${i}:${n.port}`,o["Proxy-Connection"]||(o["Proxy-Connection"]=this.keepAlive?"Keep-Alive":"close");for(const t of Object.keys(o))s+=`${t}: ${o[t]}\r\n`;const c=rn(r);r.write(`${s}\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",cn),n.secureEndpoint){on("Upgrading socket connection to TLS");const t=n.servername||n.host;return f.connect({...un(n,"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=>{on("Replaying proxy buffer for failed request"),t.push(h),t.push(null)}),p}}function cn(t){t.resume()}function un(t,...n){const e={};let r;for(r in t)n.includes(r)||(e[r]=t[r]);return e}sn.protocols=["http","https"];function an(t){return t.replace(/^[A-Z]:/,"").replace(/\\/g,"/")}const fn=n;let hn,pn=0,dn={};function ln(t){fn.debug&&console.log(`[ANR Worker] ${t}`)}var gn,mn,yn;const bn=function(t){let n;try{n=new URL(t.url)}catch{return b(()=>{console.warn("[@sentry/node]: Invalid dsn or tunnel option, will not send any events. The tunnel option must be a full URL when used.")}),Zt(t,()=>Promise.resolve({}))}const e="https:"===n.protocol,r=function(t,n){const{no_proxy:e}=process.env,r=e?.split(",").some(n=>t.host.endsWith(n)||t.hostname.endsWith(n));return r?void 0:n}(n,t.proxy||(e?process.env.https_proxy:void 0)||process.env.http_proxy),o=e?s:i,a=void 0!==t.keepAlive&&t.keepAlive,f=r?new sn(r):new o.Agent({keepAlive:a,maxSockets:30,timeout:2e3}),h=function(t,n,e){const{hostname:r,pathname:o,port:i,protocol:s,search:a}=new URL(t.url);return function(f){return new Promise((h,p)=>{Gt(()=>{let d=function(t){return new c({read(){this.push(t),this.push(null)}})}(f.body);const l={...t.headers};f.body.length>32768&&(l["content-encoding"]="gzip",d=d.pipe(u()));const g=r.startsWith("["),m=n.request({method:"POST",agent:e,headers:l,hostname:g?r.slice(1,-1):r,path:`${o}${a}`,port:i,protocol:s,ca:t.caCerts},t=>{t.on("data",()=>{}),t.on("end",()=>{}),t.setEncoding("utf8");const n=t.headers["retry-after"]??null,e=t.headers["x-sentry-rate-limits"]??null;h({statusCode:t.statusCode,headers:{"retry-after":n,"x-sentry-rate-limits":Array.isArray(e)?e[0]||null:e}})});m.on("error",p),d.pipe(m)})})}}(t,t.httpModule??o,f);return Zt(t,h)}({url:(gn=fn.dsn,mn=fn.tunnel,yn=fn.sdkMetadata.sdk,mn||`${function(t){return`${function(t){const n=t.protocol?`${t.protocol}:`:"",e=t.port?`:${t.port}`:"";return`${n}//${t.host}${e}${t.path?`/${t.path}`:""}/api/`}(t)}${t.projectId}/envelope/`}(gn)}?${function(t,n){const e={sentry_version:"7"};return t.publicKey&&(e.sentry_key=t.publicKey),n&&(e.sentry_client=`${n.name}/${n.version}`),new URLSearchParams(e).toString()}(gn,yn)}`)});async function _n(){if(hn){ln("Sending abnormal session"),K(hn,{status:"abnormal",abnormal_mechanism:"anr_foreground",release:fn.release,environment:fn.environment});const t=function(t,n,e,r){const o=Ft(e);return Dt({sent_at:new Date(P()).toISOString(),...o&&{sdk:o},...!!r&&n&&{dsn:St(n)}},["aggregates"in t?[{type:"sessions"},t]:[{type:"session"},t.toJSON()]])}(hn,fn.dsn,fn.sdkMetadata,fn.tunnel);ln(JSON.stringify(t)),await bn.send(t);try{e?.postMessage("session-ended")}catch{}}}function vn(t){if(!t)return;const n=function(t){if(!t.length)return[];const n=Array.from(t);return/sentryWrapped/.test(x(n).function||"")&&n.pop(),n.reverse(),$.test(x(n).function||"")&&(n.pop(),$.test(x(n).function||"")&&n.pop()),n.slice(0,50).map(t=>({...t,filename:t.filename||x(n).filename,function:t.function||"?"}))}(t);if(fn.appRootPath)for(const t of n)t.filename&&(t.filename=M(t.filename,fn.appRootPath));return n}async function Sn(t,n){if(pn>=fn.maxAnrEvents)return;pn+=1,await _n(),ln("Sending event");const e={event_id:G(),contexts:fn.contexts,release:fn.release,environment:fn.environment,dist:fn.dist,platform:"node",level:"error",exception:{values:[{type:"ApplicationNotResponding",value:`Application Not Responding for at least ${fn.anrThreshold} ms`,stacktrace:{frames:vn(t)},mechanism:{type:"ANR"}}]},tags:fn.staticTags};n&&function(t,n){if(Pt(t,n),!t.contexts?.trace){const{traceId:e,parentSpanId:r,propagationSpanId:o}=n.propagationContext;t.contexts={trace:{trace_id:e,span_id:o||V(),parent_span_id:r},...t.contexts}}}(e,n),function(t){if(0===Object.keys(dn).length)return;const n=fn.appRootPath?{}:dn;if(fn.appRootPath)for(const[t,e]of Object.entries(dn))n[M(t,fn.appRootPath)]=e;const e=new Map;for(const r of t.exception?.values||[])for(const t of r.stacktrace?.frames||[]){const r=t.abs_path||t.filename;r&&n[r]&&e.set(r,n[r])}if(e.size>0){const n=[];for(const[t,r]of e.entries())n.push({type:"sourcemap",code_file:t,debug_id:r});t.debug_meta={images:n}}}(e);const r=Jt(e,fn.dsn,fn.sdkMetadata,fn.tunnel);ln(JSON.stringify(r)),await bn.send(r),await bn.flush(2e3),pn>=fn.maxAnrEvents&&setTimeout(()=>{process.exit(0)},5e3)}let wn;if(ln("Started"),fn.captureStackTrace){ln("Connecting to debugger");const n=new t;n.connectToMainThread(),ln("Connected to debugger");const e=new Map;n.on("Debugger.scriptParsed",t=>{e.set(t.params.scriptId,t.params.url)}),n.on("Debugger.paused",t=>{if("other"===t.params.reason)try{ln("Debugger paused");const i=[...t.params.callFrames],s=fn.appRootPath?function(t=(process.argv[1]?Vt(process.argv[1]):process.cwd()),n="\\"===o){const e=n?an(t):t;return t=>{if(!t)return;const o=n?an(t):t;let{dir:i,base:s,ext:c}=r.parse(o);".js"!==c&&".mjs"!==c&&".cjs"!==c||(s=s.slice(0,-1*c.length));const u=decodeURIComponent(s);i||(i=".");const a=i.lastIndexOf("/node_modules");if(a>-1)return`${i.slice(a+14).replace(/\//g,".")}:${u}`;if(i.startsWith(e)){const t=i.slice(e.length+1).replace(/\//g,".");return t?`${t}:${u}`:u}return u}}(fn.appRootPath):()=>{},c=i.map(t=>function(t,n,e){const r=n?n.replace(/^file:\/\//,""):void 0,o=t.location.columnNumber?t.location.columnNumber+1:void 0,i=t.location.lineNumber?t.location.lineNumber+1:void 0;return{filename:r,module:e(r),function:t.functionName||"?",colno:o,lineno:i,in_app:r?Qt(r):void 0}}(t,e.get(t.location.scriptId),s)),u=setTimeout(()=>{Sn(c).then(null,()=>{ln("Sending ANR event failed.")})},5e3);n.post("Runtime.evaluate",{expression:"global.__SENTRY_GET_SCOPES__();",silent:!0,returnByValue:!0},(t,e)=>{t&&ln(`Error executing script: '${t.message}'`),clearTimeout(u);const r=e?.result?e.result.value:void 0;n.post("Debugger.resume"),n.post("Debugger.disable"),Sn(c,r).then(null,()=>{ln("Sending ANR event failed.")})})}catch(t){throw n.post("Debugger.resume"),n.post("Debugger.disable"),t}}),wn=()=>{try{n.post("Debugger.enable",()=>{n.post("Debugger.pause")})}catch{}}}const{poll:$n}=function(t,n,e,r){const o=t();let i=!1,s=!0;return setInterval(()=>{const t=o.getTimeMs();!1===i&&t>n+e&&(i=!0,s&&r()),t<n+e&&(i=!1)},20),{poll:()=>{o.reset()},enabled:t=>{s=t}}}(function(){let t=process.hrtime();return{getTimeMs:()=>{const[n,e]=process.hrtime(t);return Math.floor(1e3*n+e/1e6)},reset:()=>{t=process.hrtime()}}},fn.pollInterval,fn.anrThreshold,function(){ln("Watchdog timeout"),wn?(ln("Pausing debugger to capture stack trace"),wn()):(ln("Capturing event without a stack trace"),Sn().then(null,()=>{ln("Sending ANR event failed on watchdog timeout.")}))});e?.on("message",t=>{t.session&&(hn=H(t.session)),t.debugImages&&(dn=t.debugImages),$n()});";
+const DEFAULT_INTERVAL = 50;
+const DEFAULT_HANG_THRESHOLD = 5e3;
+function log(message, ...args) {
+  core.debug.log(`[ANR] ${message}`, ...args);
+}
+function globalWithScopeFetchFn() {
+  return core.GLOBAL_OBJ;
+}
+function getScopeData() {
+  const scope = core.getCombinedScopeData(core.getIsolationScope(), core.getCurrentScope());
+  scope.attachments = [];
+  scope.eventProcessors = [];
+  return scope;
+}
+async function getContexts(client) {
+  let event = { message: "ANR" };
+  const eventHint = {};
+  for (const processor of client.getEventProcessors()) {
+    if (event === null) break;
+    event = await processor(event, eventHint);
+  }
+  return event?.contexts || {};
+}
+const INTEGRATION_NAME = "Anr";
+const _anrIntegration = ((options = {}) => {
+  let worker;
+  let client;
+  const gbl = globalWithScopeFetchFn();
+  gbl.__SENTRY_GET_SCOPES__ = getScopeData;
+  return {
+    name: INTEGRATION_NAME,
+    startWorker: () => {
+      if (worker) {
+        return;
+      }
+      if (client) {
+        worker = _startWorker(client, options);
+      }
+    },
+    stopWorker: () => {
+      if (worker) {
+        worker.then((stop) => {
+          stop();
+          worker = void 0;
+        });
+      }
+    },
+    async setup(initClient) {
+      client = initClient;
+      if (options.captureStackTrace && await debug.isDebuggerEnabled()) {
+        core.debug.warn("ANR captureStackTrace has been disabled because the debugger was already enabled");
+        options.captureStackTrace = false;
+      }
+      setImmediate(() => this.startWorker());
+    }
+  };
+});
+const anrIntegration = core.defineIntegration(_anrIntegration);
+async function _startWorker(client, integrationOptions) {
+  const dsn = client.getDsn();
+  if (!dsn) {
+    return () => {
+    };
+  }
+  const contexts = await getContexts(client);
+  delete contexts.app?.app_memory;
+  delete contexts.device?.free_memory;
+  const initOptions = client.getOptions();
+  const sdkMetadata = client.getSdkMetadata() || {};
+  if (sdkMetadata.sdk) {
+    sdkMetadata.sdk.integrations = initOptions.integrations.map((i) => i.name);
+  }
+  const options = {
+    debug: core.debug.isEnabled(),
+    dsn,
+    tunnel: initOptions.tunnel,
+    environment: initOptions.environment || "production",
+    release: initOptions.release,
+    dist: initOptions.dist,
+    sdkMetadata,
+    appRootPath: integrationOptions.appRootPath,
+    pollInterval: integrationOptions.pollInterval || DEFAULT_INTERVAL,
+    anrThreshold: integrationOptions.anrThreshold || DEFAULT_HANG_THRESHOLD,
+    captureStackTrace: !!integrationOptions.captureStackTrace,
+    maxAnrEvents: integrationOptions.maxAnrEvents || 1,
+    staticTags: integrationOptions.staticTags || {},
+    contexts
+  };
+  if (options.captureStackTrace) {
+    const inspector = await import('node:inspector');
+    if (!inspector.url()) {
+      inspector.open(0);
+    }
+  }
+  const worker = new node_worker_threads.Worker(new URL(`data:application/javascript;base64,${base64WorkerScript}`), {
+    workerData: options,
+    // We don't want any Node args to be passed to the worker
+    execArgv: [],
+    env: { ...process.env, NODE_OPTIONS: void 0 }
+  });
+  process.on("exit", () => {
+    worker.terminate();
+  });
+  const timer = setInterval(() => {
+    try {
+      const currentSession = core.getIsolationScope().getSession();
+      const session = currentSession ? { ...currentSession, toJSON: void 0 } : void 0;
+      worker.postMessage({ session, debugImages: core.getFilenameToDebugIdMap(initOptions.stackParser) });
+    } catch {
+    }
+  }, options.pollInterval);
+  timer.unref();
+  worker.on("message", (msg) => {
+    if (msg === "session-ended") {
+      log("ANR event sent from ANR worker. Clearing session in this thread.");
+      core.getIsolationScope().setSession(void 0);
+    }
+  });
+  worker.once("error", (err) => {
+    clearInterval(timer);
+    log("ANR worker error", err);
+  });
+  worker.once("exit", (code) => {
+    clearInterval(timer);
+    log("ANR worker exit", code);
+  });
+  worker.unref();
+  return () => {
+    worker.terminate();
+    clearInterval(timer);
+  };
+}
+function disableAnrDetectionForCallback(callback) {
+  const integration = core.getClient()?.getIntegrationByName(INTEGRATION_NAME);
+  if (!integration) {
+    return callback();
+  }
+  integration.stopWorker();
+  const result = callback();
+  if (isPromise(result)) {
+    return result.finally(() => integration.startWorker());
+  }
+  integration.startWorker();
+  return result;
+}
+exports.anrIntegration = anrIntegration;
+exports.base64WorkerScript = base64WorkerScript;
+exports.disableAnrDetectionForCallback = disableAnrDetectionForCallback;
+//# sourceMappingURL=index.js.map

package/build/cjs/integrations/anr/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.js","sources":["../../../../src/integrations/anr/index.ts"],"sourcesContent":["import { types } from 'node:util';\nimport { Worker } from 'node:worker_threads';\nimport type { Contexts, Event, EventHint, Integration, IntegrationFn, ScopeData } from '@sentry/core';\nimport {\n debug,\n defineIntegration,\n getClient,\n getCombinedScopeData,\n getCurrentScope,\n getFilenameToDebugIdMap,\n getIsolationScope,\n GLOBAL_OBJ,\n} from '@sentry/core';\nimport type { NodeClient } from '../../sdk/client';\nimport { isDebuggerEnabled } from '../../utils/debug';\nimport type { AnrIntegrationOptions, WorkerStartData } from './common';\n\nconst { isPromise } = types;\n\n// This string is a placeholder that gets overwritten with the worker code.\nexport const base64WorkerScript = '###AnrWorkerScript###';\n\nconst DEFAULT_INTERVAL = 50;\nconst DEFAULT_HANG_THRESHOLD = 5000;\n\nfunction log(message: string, ...args: unknown[]): void {\n debug.log(`[ANR] ${message}`, ...args);\n}\n\nfunction globalWithScopeFetchFn(): typeof GLOBAL_OBJ & { __SENTRY_GET_SCOPES__?: () => ScopeData } {\n return GLOBAL_OBJ;\n}\n\n/** Fetches merged scope data */\nfunction getScopeData(): ScopeData {\n const scope = getCombinedScopeData(getIsolationScope(), getCurrentScope());\n\n // We remove attachments because they likely won't serialize well as json\n scope.attachments = [];\n // We can't serialize event processor functions\n scope.eventProcessors = [];\n\n return scope;\n}\n\n/**\n * Gets contexts by calling all event processors. This shouldn't be called until all integrations are setup\n */\nasync function getContexts(client: NodeClient): Promise<Contexts> {\n let event: Event | null = { message: 'ANR' };\n const eventHint: EventHint = {};\n\n for (const processor of client.getEventProcessors()) {\n if (event === null) break;\n event = await processor(event, eventHint);\n }\n\n return event?.contexts || {};\n}\n\nconst INTEGRATION_NAME = 'Anr' as const;\n\ntype AnrInternal = { startWorker: () => void; stopWorker: () => void };\n\n// eslint-disable-next-line typescript/no-deprecated\nconst _anrIntegration = ((options: Partial<AnrIntegrationOptions> = {}) => {\n let worker: Promise<() => void> | undefined;\n let client: NodeClient | undefined;\n\n // Hookup the scope fetch function to the global object so that it can be called from the worker thread via the\n // debugger when it pauses\n const gbl = globalWithScopeFetchFn();\n gbl.__SENTRY_GET_SCOPES__ = getScopeData;\n\n return {\n name: INTEGRATION_NAME,\n startWorker: () => {\n if (worker) {\n return;\n }\n\n if (client) {\n worker = _startWorker(client, options);\n }\n },\n stopWorker: () => {\n if (worker) {\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n worker.then(stop => {\n stop();\n worker = undefined;\n });\n }\n },\n async setup(initClient: NodeClient) {\n client = initClient;\n\n if (options.captureStackTrace && (await isDebuggerEnabled())) {\n debug.warn('ANR captureStackTrace has been disabled because the debugger was already enabled');\n options.captureStackTrace = false;\n }\n\n // setImmediate is used to ensure that all other integrations have had their setup called first.\n // This allows us to call into all integrations to fetch the full context\n setImmediate(() => this.startWorker());\n },\n } as Integration & AnrInternal;\n}) satisfies IntegrationFn;\n\n// eslint-disable-next-line typescript/no-deprecated\ntype AnrReturn = (options?: Partial<AnrIntegrationOptions>) => Integration & AnrInternal;\n\n/**\n * Application Not Responding (ANR) integration for Node.js applications.\n *\n * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.\n *\n * Detects when the Node.js main thread event loop is blocked for more than the configured\n * threshold (5 seconds by default) and reports these as Sentry events.\n *\n * ANR detection uses a worker thread to monitor the event loop in the main app thread.\n * The main app thread sends a heartbeat message to the ANR worker thread every 50ms by default.\n * If the ANR worker does not receive a heartbeat message for the configured threshold duration,\n * it triggers an ANR event.\n *\n * - Node.js 16.17.0 or higher\n * - Only supported in the Node.js runtime (not browsers)\n * - Not supported for Node.js clusters\n *\n * Overhead should be minimal:\n * - Main thread: Only polling the ANR worker over IPC every 50ms\n * - Worker thread: Consumes around 10-20 MB of RAM\n * - When ANR detected: Brief pause in debugger to capture stack trace (negligible compared to the blocking)\n *\n * @example\n * ```javascript\n * Sentry.init({\n * dsn: \"https://examplePublicKey@o0.ingest.sentry.io/0\",\n * integrations: [\n * Sentry.anrIntegration({\n * anrThreshold: 5000,\n * captureStackTrace: true,\n * pollInterval: 50,\n * }),\n * ],\n * });\n * ```\n */\nexport const anrIntegration = defineIntegration(_anrIntegration) as AnrReturn;\n\n/**\n * Starts the ANR worker thread\n *\n * @returns A function to stop the worker\n */\nasync function _startWorker(\n client: NodeClient,\n // eslint-disable-next-line typescript/no-deprecated\n integrationOptions: Partial<AnrIntegrationOptions>,\n): Promise<() => void> {\n const dsn = client.getDsn();\n\n if (!dsn) {\n return () => {\n //\n };\n }\n\n const contexts = await getContexts(client);\n\n // These will not be accurate if sent later from the worker thread\n delete contexts.app?.app_memory;\n delete contexts.device?.free_memory;\n\n const initOptions = client.getOptions();\n\n const sdkMetadata = client.getSdkMetadata() || {};\n if (sdkMetadata.sdk) {\n sdkMetadata.sdk.integrations = initOptions.integrations.map(i => i.name);\n }\n\n const options: WorkerStartData = {\n debug: debug.isEnabled(),\n dsn,\n tunnel: initOptions.tunnel,\n environment: initOptions.environment || 'production',\n release: initOptions.release,\n dist: initOptions.dist,\n sdkMetadata,\n appRootPath: integrationOptions.appRootPath,\n pollInterval: integrationOptions.pollInterval || DEFAULT_INTERVAL,\n anrThreshold: integrationOptions.anrThreshold || DEFAULT_HANG_THRESHOLD,\n captureStackTrace: !!integrationOptions.captureStackTrace,\n maxAnrEvents: integrationOptions.maxAnrEvents || 1,\n staticTags: integrationOptions.staticTags || {},\n contexts,\n };\n\n if (options.captureStackTrace) {\n const inspector = await import('node:inspector');\n if (!inspector.url()) {\n inspector.open(0);\n }\n }\n\n const worker = new Worker(new URL(`data:application/javascript;base64,${base64WorkerScript}`), {\n workerData: options,\n // We don't want any Node args to be passed to the worker\n execArgv: [],\n env: { ...process.env, NODE_OPTIONS: undefined },\n });\n\n process.on('exit', () => {\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n worker.terminate();\n });\n\n const timer = setInterval(() => {\n try {\n const currentSession = getIsolationScope().getSession();\n // We need to copy the session object and remove the toJSON method so it can be sent to the worker\n // serialized without making it a SerializedSession\n const session = currentSession ? { ...currentSession, toJSON: undefined } : undefined;\n // message the worker to tell it the main event loop is still running\n worker.postMessage({ session, debugImages: getFilenameToDebugIdMap(initOptions.stackParser) });\n } catch {\n //\n }\n }, options.pollInterval);\n // Timer should not block exit\n timer.unref();\n\n worker.on('message', (msg: string) => {\n if (msg === 'session-ended') {\n log('ANR event sent from ANR worker. Clearing session in this thread.');\n getIsolationScope().setSession(undefined);\n }\n });\n\n worker.once('error', (err: Error) => {\n clearInterval(timer);\n log('ANR worker error', err);\n });\n\n worker.once('exit', (code: number) => {\n clearInterval(timer);\n log('ANR worker exit', code);\n });\n\n // Ensure this thread can't block app exit\n worker.unref();\n\n return () => {\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n worker.terminate();\n clearInterval(timer);\n };\n}\n\n/**\n * @see {@link disableBlockDetectionForCallback}\n *\n * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.\n */\nexport function disableAnrDetectionForCallback<T>(callback: () => T): T;\n/**\n * @see {@link disableBlockDetectionForCallback}\n *\n * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.\n */\nexport function disableAnrDetectionForCallback<T>(callback: () => Promise<T>): Promise<T>;\n/**\n * Temporarily disables ANR detection for the duration of a callback function.\n *\n * This utility function allows you to disable ANR detection during operations that\n * are expected to block the event loop, such as intensive computational tasks or\n * synchronous I/O operations.\n *\n * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.\n */\nexport function disableAnrDetectionForCallback<T>(callback: () => T | Promise<T>): T | Promise<T> {\n const integration = getClient()?.getIntegrationByName(INTEGRATION_NAME) as AnrInternal | undefined;\n\n if (!integration) {\n return callback();\n }\n\n integration.stopWorker();\n\n const result = callback();\n if (isPromise(result)) {\n return result.finally(() => integration.startWorker());\n }\n\n integration.startWorker();\n return result;\n}\n"],"names":["types","debug","GLOBAL_OBJ","getCombinedScopeData","getIsolationScope","getCurrentScope","isDebuggerEnabled","defineIntegration","Worker","getFilenameToDebugIdMap","getClient"],"mappings":"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"}