@sentry/node 11.0.0-beta.1 → 11.0.0-rc.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 (43) hide show
  1. package/build/cjs/index.js +7 -0
  2. package/build/cjs/index.js.map +1 -1
  3. package/build/cjs/integrations/anr/index.js +12 -4
  4. package/build/cjs/integrations/anr/index.js.map +1 -1
  5. package/build/cjs/integrations/contextlines.js +1 -1
  6. package/build/cjs/integrations/contextlines.js.map +1 -1
  7. package/build/cjs/integrations/local-variables/local-variables-async.js +1 -1
  8. package/build/cjs/integrations/node-fetch/undici-instrumentation.js +4 -3
  9. package/build/cjs/integrations/node-fetch/undici-instrumentation.js.map +1 -1
  10. package/build/cjs/sdk/client.js +4 -0
  11. package/build/cjs/sdk/client.js.map +1 -1
  12. package/build/cjs/sdk/index.js +0 -4
  13. package/build/cjs/sdk/index.js.map +1 -1
  14. package/build/cjs/utils/errorhandling.js +6 -0
  15. package/build/cjs/utils/errorhandling.js.map +1 -1
  16. package/build/esm/index.js +1 -1
  17. package/build/esm/integrations/anr/index.js +12 -4
  18. package/build/esm/integrations/anr/index.js.map +1 -1
  19. package/build/esm/integrations/anr/worker-script.js +2 -2
  20. package/build/esm/integrations/contextlines.js +1 -1
  21. package/build/esm/integrations/contextlines.js.map +1 -1
  22. package/build/esm/integrations/local-variables/local-variables-async.js +1 -1
  23. package/build/esm/integrations/local-variables/worker-script.js +1 -1
  24. package/build/esm/integrations/node-fetch/undici-instrumentation.js +4 -3
  25. package/build/esm/integrations/node-fetch/undici-instrumentation.js.map +1 -1
  26. package/build/esm/package.json +1 -1
  27. package/build/esm/sdk/client.js +4 -0
  28. package/build/esm/sdk/client.js.map +1 -1
  29. package/build/esm/sdk/index.js +0 -4
  30. package/build/esm/sdk/index.js.map +1 -1
  31. package/build/esm/utils/errorhandling.js +6 -0
  32. package/build/esm/utils/errorhandling.js.map +1 -1
  33. package/build/types/index.d.ts +3 -2
  34. package/build/types/index.d.ts.map +1 -1
  35. package/build/types/integrations/anr/index.d.ts +1 -0
  36. package/build/types/integrations/anr/index.d.ts.map +1 -1
  37. package/build/types/integrations/contextlines.d.ts +1 -1
  38. package/build/types/integrations/contextlines.d.ts.map +1 -1
  39. package/build/types/integrations/node-fetch/undici-instrumentation.d.ts.map +1 -1
  40. package/build/types/sdk/client.d.ts.map +1 -1
  41. package/build/types/sdk/index.d.ts.map +1 -1
  42. package/build/types/utils/errorhandling.d.ts.map +1 -1
  43. package/package.json +7 -7
package/build/cjs/index.js CHANGED
@@ -49,15 +49,19 @@ const index = require('./integrations/anr/index.js');
49
49
  exports.httpIntegration = index$5.httpIntegration;
50
50
  exports.nativeNodeFetchIntegration = index$7.nativeNodeFetchIntegration;
51
51
  exports.fsIntegration = index$2.fsIntegration;
52
+ exports.SentryMastraExporter = serverUtils.SentryMastraExporter;
52
53
  exports.amqplibIntegration = serverUtils.amqplibIntegration;
53
54
  exports.anthropicAIIntegration = serverUtils.anthropicAIIntegration;
55
+ exports.createFlueInstrumentation = serverUtils.createFlueInstrumentation;
54
56
  exports.createLangChainCallbackHandler = serverUtils.createLangChainCallbackHandler;
55
57
  exports.dataloaderIntegration = serverUtils.dataloaderIntegration;
58
+ exports.eveConversationHook = serverUtils.eveConversationHook;
56
59
  exports.expressErrorHandler = serverUtils.expressErrorHandler;
57
60
  exports.expressIntegration = serverUtils.expressIntegration;
58
61
  exports.fastifyIntegration = serverUtils.fastifyIntegration;
59
62
  exports.firebaseIntegration = serverUtils.firebaseIntegration;
60
63
  exports.genericPoolIntegration = serverUtils.genericPoolIntegration;
64
+ exports.getInstrumentedModuleNames = serverUtils.getInstrumentedModuleNames;
61
65
  exports.getOtlpTracesEndpoint = serverUtils.getOtlpTracesEndpoint;
62
66
  exports.googleGenAIIntegration = serverUtils.googleGenAIIntegration;
63
67
  exports.graphqlIntegration = serverUtils.graphqlIntegration;
@@ -65,6 +69,7 @@ exports.hapiIntegration = serverUtils.hapiIntegration;
65
69
  exports.instrumentAnthropicAiClient = serverUtils.instrumentAnthropicAiClient;
66
70
  exports.instrumentGoogleGenAIClient = serverUtils.instrumentGoogleGenAIClient;
67
71
  exports.instrumentLangChainEmbeddings = serverUtils.instrumentLangChainEmbeddings;
72
+ exports.instrumentMistralAiClient = serverUtils.instrumentMistralAiClient;
68
73
  exports.instrumentOpenAiClient = serverUtils.instrumentOpenAiClient;
69
74
  exports.instrumentStateGraph = serverUtils.instrumentStateGraph;
70
75
  exports.instrumentStateGraphCompile = serverUtils.instrumentStateGraphCompile;
@@ -74,6 +79,8 @@ exports.koaIntegration = serverUtils.koaIntegration;
74
79
  exports.langChainIntegration = serverUtils.langChainIntegration;
75
80
  exports.langGraphIntegration = serverUtils.langGraphIntegration;
76
81
  exports.lruMemoizerIntegration = serverUtils.lruMemoizerIntegration;
82
+ exports.mastraIntegration = serverUtils.mastraIntegration;
83
+ exports.mistralAIIntegration = serverUtils.mistralAIIntegration;
77
84
  exports.mongoIntegration = serverUtils.mongoIntegration;
78
85
  exports.mongooseIntegration = serverUtils.mongooseIntegration;
79
86
  exports.mysql2Integration = serverUtils.mysql2Integration;
package/build/cjs/index.js.map CHANGED
@@ -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 CHANGED
@@ -6,7 +6,7 @@ const core = require('@sentry/core');
6
6
  const debug = require('../../utils/debug.js');
7
7
 
8
8
  const { isPromise } = util.types;
9
- const base64WorkerScript = "/*! @sentry/node 11.0.0-beta.1 (cb239e0) | https://github.com/getsentry/sentry-javascript */
import{Session as t}from"node:inspector";import{workerData as e,parentPort 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="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__,p=globalThis,l="11.0.0-beta.1";function d(){return g(p),p}function g(t){const e=t.__SENTRY__=t.__SENTRY__||{};return e.version=e.version||l,e[l]=e[l]||{}}function m(t,e,n=p){const r=n.__SENTRY__=n.__SENTRY__||{},o=r[l]=r[l]||{};return o[t]||(o[t]=e())}const y={};function b(t){if(!("console"in p))return t();const e=p.console,n={},r=Object.keys(y);r.forEach(t=>{const r=y[t];n[t]=e[t],e[t]=r});try{return t()}finally{r.forEach(t=>{e[t]=n[t]})}}function v(){return S().enabled}function w(t,...e){h&&v()&&b(()=>{p.console[t](`Sentry Logger [${t}]:`,...e)})}function S(){return h?m("loggerSettings",()=>({enabled:!1})):{enabled:!1}}const _={enable:function(){S().enabled=!0},disable:function(){S().enabled=!1},isEnabled:v,log:function(...t){w("log",...t)},warn:function(...t){w("warn",...t)},error:function(...t){w("error",...t)}},$=/captureMessage|captureException/;function E(t){return t[t.length-1]||{}}const x="<anonymous>";const N=Object.prototype.toString;function C(t){return function(t,e){return N.call(t)===`[object ${e}]`}(t,"Object")}function j(t){return Boolean(t?.then&&"function"==typeof t.then)}function O(t,e){try{return t instanceof e}catch{return!1}}function P(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 O(t,Error)}}(t))return{message:t.message,name:t.name,stack:t.stack,...A(t)};if(e=t,"undefined"!=typeof Event&&O(e,Event)){const{type:e,target:n,currentTarget:r,detail:o}=t;return{type:e,target:n,currentTarget:r,...o?{detail:o}:{},...A(t)}}var e;return t}function A(t){return"object"==typeof(e=t)&&null!==e?Object.fromEntries(Object.entries(t)):{};var e}let T;function k(t){if(void 0!==T)return T?T(t):t();const e=Symbol.for("__SENTRY_SAFE_RANDOM_ID_WRAPPER__"),n=p;return e in n&&"function"==typeof n[e]?(T=n[e],T(t)):(T=null,t())}function R(){return k(()=>Math.random())}function I(){return k(()=>Date.now())}const D=Symbol.for("sentry.skipNormalization"),U=Symbol.for("sentry.overrideNormalizationDepth");function B(t,e=100,n=1/0){try{return L("",t,e,n)}catch(t){return{ERROR:`**non-serializable** (${t})`}}}function L(t,e,n=1/0,r=1/0,o=function(){const t=new WeakSet;function e(e){return!!t.has(e)||(t.add(e),!1)}function n(e){t.delete(e)}return[e,n]}()){const[s,i]=o;if(null==e||["boolean","string"].includes(typeof e)||"number"==typeof e&&Number.isFinite(e))return e;const c=function(t,e){try{if("undefined"!=typeof global&&e===global)return"[Global]";if("number"==typeof e&&!Number.isFinite(e))return`[${e}]`;if("function"==typeof e)return`[Function: ${function(t){try{return t&&"function"==typeof t&&t.name||x}catch{return x}}(e)}]`;if("symbol"==typeof e)return`[${String(e)}]`;if("bigint"==typeof e)return`[BigInt: ${String(e)}]`;const t=function(t){const e=Object.getPrototypeOf(t);return e?.constructor?e.constructor.name:"null prototype"}(e);return`[object ${t}]`}catch(t){return`**non-serializable** (${t})`}}(0,e);if(!c.startsWith("[object "))return c;if(function(t){return Boolean(t[D])}(e))return e;const u=function(t){const e=t[U];return"number"==typeof e?e:void 0}(e),a=void 0!==u?u:n;if(0===a)return c.replace("object ","");if(s(e))return"[Circular ~]";const f=e;if(f&&"function"==typeof f.toJSON)try{return L("",f.toJSON(),a-1,r,o)}catch{}const h=Array.isArray(e)?[]:{};let p=0;const l=P(e);for(const t in l){if(!Object.prototype.hasOwnProperty.call(l,t))continue;if(p>=r){h[t]="[MaxProperties ~]";break}const e=l[t];h[t]=L(t,e,a-1,r,o),p++}return i(e),h}function M(t,e){const n=e.replace(/\\/g,"/").replace(/[|\\{}()[\]^$+*?.]/g,"\\$&");let r=t;try{r=decodeURI(t)}catch{}return r.replace(/\\/g,"/").replace(/webpack:\/?/g,"").replace(new RegExp(`(file://)?/*${n}/*`,"ig"),"app:///")}function z(t,e=0){return"string"!=typeof t||0===e||t.length<=e?t:`${t.slice(0,e)}...`}let J;function W(t=function(){const t=p;return t.crypto||t.msCrypto}()){try{if(t?.randomUUID)return k(()=>t.randomUUID()).replace(/-/g,"")}catch{}return J||(J="10000000100040008000100000000000"),J.replace(/[018]/g,t=>(t^(16*R()&15)>>t/4).toString(16))}function F(){return I()/1e3}let G;function Y(){return(G??(G=function(){const{performance:t}=p;if(!t?.now||!t.timeOrigin)return F;const e=t.timeOrigin;return()=>(e+k(()=>t.now()))/1e3}()))()}function H(t){const e=Y(),n={sid:W(),init:!0,timestamp:e,started:e,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}}}(n)};return t&&Z(n,t),n}function Z(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||Y(),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:W()),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)}function q(t,e,n=2){if(!e||"object"!=typeof e||n<=0)return e;if(t&&0===Object.keys(e).length)return t;const r={...t};for(const t in e)Object.prototype.hasOwnProperty.call(e,t)&&(r[t]=q(r[t],e[t],n-1));return r}class K{constructor(){this.t=!1,this.o=[],this.i=[],this.u=[],this.h=[],this.p={},this.l={},this.m={},this.v={},this.S={},this._={},function(t,e,n){try{Object.defineProperty(t,e,{value:n,writable:!0,configurable:!0})}catch{h&&_.log(`Failed to add non-enumerable property "${String(e)}" to object`,t)}}(this,"refs",{}),this.N={traceId:W(),sampleRand:R()}}clone(){const t=new K;return t.u=[...this.u],t.l={...this.l},t.m={...this.m},t.v={...this.v},t.S={...this.S},this.S.flags&&(t.S.flags={values:[...this.S.flags.values]}),t.p=this.p,t.C=this.C,t.j=this.j,t.O=this.O,t.P=this.P,t.i=[...this.i],t.h=[...this.h],t._={...this._},t.N={...this.N},t.A=this.A,t.T=this.T,t.k=this.k,t.refs={...this.refs},t}setClient(t){this.A=t}setLastEventId(t){this.T=t}getClient(){return this.A}lastEventId(){return this.T}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.j&&Z(this.j,{user:t}),this.R(),this}getUser(){return this.p}setConversationId(t){return this.k=t||void 0,this.R(),this}setTags(t){return this.l={...this.l,...t},this.R(),this}setTag(t,e){return this.setTags({[t]:e})}setAttributes(t){return this.m={...this.m,...t},this.R(),this}setAttribute(t,e){return this.setAttributes({[t]:e})}removeAttribute(t){return t in this.m&&(delete this.m[t],this.R()),this}setExtras(t){return this.v={...this.v,...t},this.R(),this}setExtra(t,e){return this.v={...this.v,[t]:e},this.R(),this}setFingerprint(t){return this.P=t,this.R(),this}setLevel(t){return this.C=t,this.R(),this}setTransactionName(t){return this.O=t,this.R(),this}setContext(t,e){return null===e?delete this.S[t]:this.S[t]=e,this.R(),this}setSession(t){return t?this.j=t:delete this.j,this.R(),this}getSession(){return this.j}update(t){if(!t)return this;const e="function"==typeof t?t(this):t,n=e instanceof K?e.getScopeData():C(e)?t:void 0,{tags:r,attributes:o,extra:s,user:i,contexts:c,level:u,fingerprint:a=[],propagationContext:f,conversationId:h}=n||{};return this.l={...this.l,...r},this.m={...this.m,...o},this.v={...this.v,...s},this.S={...this.S,...c},i&&Object.keys(i).length&&(this.p=i),u&&(this.C=u),a.length&&(this.P=a),f&&(this.N=f),h&&(this.k=h),this}addBreadcrumb(t,e){const n="number"==typeof e?e:100;if(n<=0)return this;const r={timestamp:F(),...t,message:t.message?z(t.message,2048):t.message};return this.u.push(r),this.u.length>n&&(this.u=this.u.slice(-n),this.A?.recordDroppedEvent("buffer_overflow","log_item")),this.R(),this}getLastBreadcrumb(){return this.u[this.u.length-1]}clearBreadcrumbs(){return this.u=[],this.R(),this}addAttachment(t){return this.h.push(t),this}clearAttachments(){return this.h=[],this}getScopeData(){return{breadcrumbs:this.u,attachments:this.h,contexts:this.S,tags:this.l,attributes:this.m,extra:this.v,user:this.p,level:this.C,fingerprint:this.P||[],eventProcessors:this.i,propagationContext:this.N,sdkProcessingMetadata:this._,transactionName:this.O,conversationId:this.k}}setSDKProcessingMetadata(t){return this._=q(this._,t,2),this}setPropagationContext(t){return this.N=t,this}getPropagationContext(){return this.N}captureException(t,e){const n=e?.event_id||W();if(!this.A)return h&&_.warn("No client configured on scope - will not capture exception!"),n;const r=new Error("Sentry syntheticException");return this.A.captureException(t,{originalException:t,syntheticException:r,...e,event_id:n},this),n}captureMessage(t,e,n){const r=n?.event_id||W();if(!this.A)return h&&_.warn("No client configured on scope - will not capture message!"),r;const o=n?.syntheticException??new Error(t);return this.A.captureMessage(t,e,{originalException:t,syntheticException:o,...n,event_id:r},this),r}captureEvent(t,e){const n=t.event_id||e?.event_id||W();return this.A?(this.A.captureEvent(t,{...e,event_id:n},this),n):(h&&_.warn("No client configured on scope - will not capture event!"),n)}R(){this.t||(this.t=!0,this.o.forEach(t=>{t(this)}),this.t=!1)}}const V="__SENTRY_SUPPRESS_TRACING__",Q=t=>t instanceof Promise&&!t[X],X=Symbol("chained PromiseLike"),tt=(t,e)=>{if(!e)return t;let n=!1;for(const r in t){if(r in e)continue;n=!0;const o=t[r];"function"==typeof o?Object.defineProperty(e,r,{value:(...e)=>o.apply(t,e),enumerable:!0,configurable:!0,writable:!0}):e[r]=o}return n&&Object.assign(e,{[X]:!0}),e};class et{constructor(t,e){let n,r;n=t||new K,r=e||new K,this.I=[{scope:n}],this.D=r}withScope(t){const e=this.U();let n;try{n=t(e)}catch(t){throw this.B(),t}return j(n)?((t,e,n)=>{const r=t.then(t=>(e(t),t),t=>{throw n(t),t});return Q(r)&&Q(t)?r:tt(t,r)})(n,()=>this.B(),()=>this.B()):(this.B(),n)}getClient(){return this.getStackTop().client}getScope(){return this.getStackTop().scope}getIsolationScope(){return this.D}getStackTop(){return this.I[this.I.length-1]}U(){const t=this.getScope().clone();return this.I.push({client:this.getClient(),scope:t}),t}B(){return!(this.I.length<=1)&&!!this.I.pop()}}function nt(){const t=g(d());return t.stack=t.stack||new et(m("defaultCurrentScope",()=>new K),m("defaultIsolationScope",()=>new K))}function rt(t){return nt().withScope(t)}function ot(t,e){const n=nt();return n.withScope(()=>(n.getStackTop().scope=t,e(t)))}function st(t){return nt().withScope(()=>t(nt().getIsolationScope()))}function it(t){return rt(e=>{e.setSDKProcessingMetadata({[V]:!0});const n=t();return e.setSDKProcessingMetadata({[V]:void 0}),n})}function ct(t){const e=g(t);return e.acs?e.acs:{suppressTracing:it,withIsolationScope:st,withScope:rt,withSetScope:ot,withSetIsolationScope:(t,e)=>st(e),getCurrentScope:()=>nt().getScope(),getIsolationScope:()=>nt().getIsolationScope()}}function ut(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}`}function at(t,e){const{fingerprint:n,breadcrumbs:r,sdkProcessingMetadata:o}=e;!function(t,e){const{extra:n,tags:r,user:o,contexts:s,level:i,transactionName:c}=e;Object.keys(n).length&&(t.extra={...n,...t.extra});Object.keys(r).length&&(t.tags={...r,...t.tags});Object.keys(o).length&&(t.user={...o,...t.user});Object.keys(s).length&&(t.contexts={...s,...t.contexts});i&&(t.level=i);c&&"transaction"!==t.type&&(t.transaction=c)}(t,e),function(t,e){t.fingerprint=t.fingerprint?Array.isArray(t.fingerprint)?t.fingerprint:[t.fingerprint]:[],e&&(t.fingerprint=t.fingerprint.concat(e));t.fingerprint.length||delete t.fingerprint}(t,n),function(t,e){const n=[...t.breadcrumbs||[],...e];t.breadcrumbs=n.length?n:void 0}(t,r),function(t,e){t.sdkProcessingMetadata={...t.sdkProcessingMetadata,...e}}(t,o)}function ft(t,e=[]){return[t,e]}function ht(t,e){const n=t[1];for(const t of n){if(e(t,t[0].type))return!0}return!1}function pt(t){const e=g(p);return e.encodePolyfill?e.encodePolyfill(t):(new TextEncoder).encode(t)}function lt(t){const[e,n]=t;let r=JSON.stringify(e);function o(t){"string"==typeof r?r="string"==typeof t?r+t:[pt(r),t]:r.push("string"==typeof t?pt(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{t=JSON.stringify(B(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 dt={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 gt(t){return function(t){return t in dt}(t)?dt[t]:t}function mt(t){if(!t?.sdk)return;const{name:e,version:n}=t.sdk;return{name:e,version:n}}function yt(t){const e=ct(d());return e.suppressTracing?e.suppressTracing(t):function(...t){const e=ct(d());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({[V]:!0}),t()))}function bt(t,e,n,r){const o=mt(n),s=t.type&&"replay_event"!==t.type?t.type:"event";!function(t,e){if(!e)return t;const n=t.sdk||{};t.sdk={...n,name:n.name||e.name,version:n.version||e.version,integrations:[...t.sdk?.integrations||[],...e.integrations||[]],packages:[...t.sdk?.packages||[],...e.packages||[]],settings:t.sdk?.settings||e.settings?{...t.sdk?.settings,...e.settings}:void 0}}(t,n?.sdk);const i=function(t,e,n,r){const o=t.sdkProcessingMetadata?.dynamicSamplingContext;return{event_id:t.event_id,sent_at:new Date(I()).toISOString(),...e&&{sdk:e},...!!n&&r&&{dsn:ut(r)},...o&&{trace:o}}}(t,o,r,e);delete t.sdkProcessingMetadata;return ft(i,[[{type:s},t]])}class vt{constructor(t){this.L=0,this.M=[],this.J(t)}then(t,e){return new vt((n,r)=>{this.M.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.W()})}catch(t){return this.then(t=>t,t)}finally(t){return new vt((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)})})}W(){if(0===this.L)return;const t=this.M.slice();this.M=[],t.forEach(t=>{t[0]||(1===this.L&&t[1](this.F),2===this.L&&t[2](this.F),t[0]=!0)})}J(t){const e=(t,e)=>{0===this.L&&(j(e)?e.then(n,r):(this.L=t,this.F=e,this.W()))},n=t=>{e(1,t)},r=t=>{e(2,t)};try{t(n,r)}catch(t){r(t)}}}const wt=Symbol.for("SentryBufferFullError");function St(t=100){const e=new Set;function n(t){e.delete(t)}return{get $(){return Array.from(e)},add:function(r){if(!(e.size<t))return o=wt,new vt((t,e)=>{e(o)});var o;const s=r();return e.add(s),s.then(()=>n(s),()=>n(s)),s},drain:function(t){if(!e.size)return n=!0,new vt(t=>{t(n)});var n;const r=Promise.allSettled(Array.from(e)).then(()=>!0);if(!t)return r;const o=[r,new Promise(e=>{return"object"==typeof(n=setTimeout(()=>e(!1),t))&&"function"==typeof n.unref&&n.unref(),n;var n})];return Promise.race(o)}}}function _t(t,{statusCode:e,headers:n},r=I()){const o={...t},s=n?.["x-sentry-rate-limits"],i=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=I()){const n=parseInt(`${t}`,10);if(!isNaN(n))return 1e3*n;const r=Date.parse(`${t}`);return isNaN(r)?6e4:r-e}(i,r):429===e&&(o.all=r+6e4);return o}function $t(t,e,n=St(t.bufferSize||64)){let r={};return{send:function(t){const o=[];if(ht(t,(t,e)=>{const n=gt(e);(function(t,e,n=I()){return function(t,e){return t[e]||t.all||0}(t,e)>n})(r,n)||o.push(t)}),0===o.length)return Promise.resolve({});const s=ft(t[0],o),i=t=>{!function(t,e){return ht(t,(t,n)=>e.includes(n))}(s,["client_report"])?ht(s,(t,e)=>{}):h&&_.warn(`Dropping client report. Will not send outcomes (reason: ${t}).`)};return n.add(()=>e({body:lt(s)}).then(t=>413===t.statusCode?(h&&_.error("Sentry responded with status code 413. Envelope was discarded due to exceeding size limits."),i("send_error"),t):(h&&void 0!==t.statusCode&&(t.statusCode<200||t.statusCode>=300)&&_.warn(`Sentry responded with status code ${t.statusCode} to sent event.`),r=_t(r,t),t),t=>{throw i("network_error"),h&&_.error("Encountered error running transport request:",t),t})).then(t=>t,t=>{if(t===wt)return h&&_.error("Skipped sending event because buffer is full."),i("queue_overflow"),Promise.resolve({});throw t})},flush:t=>n.drain(t)}}const Et=/^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;function xt(t){const e=function(t){const e=t.length>1024?`<truncated>${t.slice(-1024)}`:t,n=Et.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):"."}function Nt(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/")}var Ct;const jt=Symbol("AgentBaseInternalState");class Ot extends(Ct=s.Agent,Ct){constructor(t){super(t),this[jt]={}}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[jt].currentSocket=o,super.createSocket(t,e,n)},n)}createConnection(){const t=this[jt].currentSocket;if(this[jt].currentSocket=void 0,!t)throw new Error("No socket was returned in the `connect()` function");return t}get defaultPort(){return this[jt].defaultPort??("https:"===this.protocol?443:80)}set defaultPort(t){this[jt]&&(this[jt].defaultPort=t)}get protocol(){return this[jt].protocol??(this.isSecureEndpoint()?"https:":"http:")}set protocol(t){this[jt]&&(this[jt].protocol=t)}}function Pt(...t){_.log("[https-proxy-agent:parse-proxy-response]",...t)}function At(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 Pt("have not received end of HTTP headers yet..."),void s();const f=u.subarray(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]||0),d=p.slice(2).join(" "),g={};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=g[o];"string"==typeof i?g[o]=[i,s]:Array.isArray(i)?i.push(s):g[o]=s}Pt("got proxy server response: %o %o",h,g),i(),e({connect:{statusCode:l,statusText:d,headers:g},buffered:u})}(c):t.once("readable",s)}function i(){t.removeListener("end",c),t.removeListener("error",u),t.removeListener("readable",s)}function c(){i(),Pt("onend"),n(new Error("Proxy connection ended before receiving CONNECT response"))}function u(t){i(),Pt("onerror %o",t),n(t)}t.on("error",u),t.on("end",c),s()})}function Tt(...t){_.log("[https-proxy-agent]",...t)}class kt extends Ot{constructor(t,e){super(e),this.options={},this.proxy="string"==typeof t?new URL(t):t,this.proxyHeaders=e?.headers??{},Tt("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?It(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){Tt("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 Tt("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=At(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",Rt),e.secureEndpoint){Tt("Upgrading socket connection to TLS");const t=e.servername||e.host;return f.connect({...It(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=>{Tt("Replaying proxy buffer for failed request"),t.push(h),t.push(null)}),p}}function Rt(t){t.resume()}function It(t,...e){const n={};let r;for(r in t)e.includes(r)||(n[r]=t[r]);return n}kt.protocols=["http","https"];function Dt(t){return t.replace(/^[A-Z]:/,"").replace(/\\/g,"/")}const Ut=e;let Bt,Lt=0,Mt={};function zt(t){Ut.debug&&console.log(`[ANR Worker] ${t}`)}var Jt,Wt,Ft;const Gt=function(t){let e;try{e=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.")}),$t(t,()=>Promise.resolve({}))}const n="https:"===e.protocol,r=function(t,e){const{no_proxy:n}=process.env,r=n?.split(",").some(e=>t.host.endsWith(e)||t.hostname.endsWith(e));return r?void 0:e}(e,t.proxy||(n?process.env.https_proxy:void 0)||process.env.http_proxy),o=n?i:s,a=t.keepAlive??!0,f=r?new kt(r):new o.Agent({keepAlive:a,maxSockets:30,timeout:2e3}),h=function(t,e,n){const{hostname:r,pathname:o,port:s,protocol:i,search:a}=new URL(t.url);return function(f){const h=p=>new Promise((l,d)=>{yt(()=>{let g=function(t){return new c({read(){this.push(t),this.push(null)}})}(f.body);const m={...t.headers};f.body.length>32768&&(m["content-encoding"]="gzip",g=g.pipe(u()));const y=r.startsWith("["),b=e.request({method:"POST",agent:n,headers:m,hostname:y?r.slice(1,-1):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;l({statusCode:t.statusCode,headers:{"retry-after":e,"x-sentry-rate-limits":Array.isArray(n)?n[0]||null:n}})});b.on("error",t=>{p&&b.reusedSocket&&"ECONNRESET"===t.code?l(h(!1)):d(t)}),g.pipe(b)})});return h(!0)}}(t,t.httpModule??o,f);return $t(t,h)}({url:(Jt=Ut.dsn,Wt=Ut.tunnel,Ft=Ut.sdkMetadata.sdk,Wt||`${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/`}(Jt)}?${function(t,e){const n={sentry_version:"7"};return t.publicKey&&(n.sentry_key=t.publicKey),e&&(n.sentry_client=`${e.name}/${e.version}`),new URLSearchParams(n).toString()}(Jt,Ft)}`)});async function Yt(){if(Bt){zt("Sending abnormal session"),Z(Bt,{status:"abnormal",abnormal_mechanism:"anr_foreground",release:Ut.release,environment:Ut.environment});const t=function(t,e,n,r){const o=mt(n);return ft({sent_at:new Date(I()).toISOString(),...o&&{sdk:o},...!!r&&e&&{dsn:ut(e)}},["aggregates"in t?[{type:"sessions"},t]:[{type:"session"},t.toJSON()]])}(Bt,Ut.dsn,Ut.sdkMetadata,Ut.tunnel);zt(JSON.stringify(t)),await Gt.send(t);try{n?.postMessage("session-ended")}catch{}}}function Ht(t){if(!t)return;const e=function(t){if(!t.length)return[];const e=Array.from(t);return/sentryWrapped/.test(E(e).function||"")&&e.pop(),e.reverse(),$.test(E(e).function||"")&&(e.pop(),$.test(E(e).function||"")&&e.pop()),e.slice(0,50).map(t=>({...t,filename:t.filename||E(e).filename,function:t.function||"?"}))}(t);if(Ut.appRootPath)for(const t of e)t.filename&&(t.filename=M(t.filename,Ut.appRootPath));return e}async function Zt(t,e){if(Lt>=Ut.maxAnrEvents)return;Lt+=1,await Yt(),zt("Sending event");const n={event_id:W(),contexts:Ut.contexts,release:Ut.release,environment:Ut.environment,dist:Ut.dist,platform:"node",level:"error",exception:{values:[{type:"ApplicationNotResponding",value:`Application Not Responding for at least ${Ut.anrThreshold} ms`,stacktrace:{frames:Ht(t)},mechanism:{type:"ANR"}}]},tags:Ut.staticTags};e&&function(t,e){if(at(t,e),!t.contexts?.trace){const{traceId:n,parentSpanId:r,propagationSpanId:o}=e.propagationContext;t.contexts={trace:{trace_id:n,span_id:o||W().substring(16),parent_span_id:r},...t.contexts}}}(n,e),function(t){if(0===Object.keys(Mt).length)return;const e=Ut.appRootPath?{}:Mt;if(Ut.appRootPath)for(const[t,n]of Object.entries(Mt))e[M(t,Ut.appRootPath)]=n;const n=new Map;for(const r of t.exception?.values||[])for(const t of r.stacktrace?.frames||[]){const r=t.abs_path||t.filename;r&&e[r]&&n.set(r,e[r])}if(n.size>0){const e=[];for(const[t,r]of n.entries())e.push({type:"sourcemap",code_file:t,debug_id:r});t.debug_meta={images:e}}}(n);const r=bt(n,Ut.dsn,Ut.sdkMetadata,Ut.tunnel);zt(JSON.stringify(r)),await Gt.send(r),await Gt.flush(2e3),Lt>=Ut.maxAnrEvents&&setTimeout(()=>{process.exit(0)},5e3)}let qt;if(zt("Started"),Ut.captureStackTrace){zt("Connecting to debugger");const e=new t;e.connectToMainThread(),zt("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{zt("Debugger paused");const s=[...t.params.callFrames],i=Ut.appRootPath?function(t=(process.argv[1]?xt(process.argv[1]):process.cwd()),e="\\"===o){const n=e?Dt(t):t;return t=>{if(!t)return;const o=e?Dt(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));const u=decodeURIComponent(i);s||(s=".");const a=s.lastIndexOf("/node_modules");if(a>-1)return`${s.slice(a+14).replace(/\//g,".")}:${u}`;if(s.startsWith(n)){const t=s.slice(n.length+1).replace(/\//g,".");return t?`${t}:${u}`:u}return u}}(Ut.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{filename:r,module:n(r),function:t.functionName||"?",colno:o,lineno:s,in_app:r?Nt(r):void 0}}(t,n.get(t.location.scriptId),i)),u=setTimeout(()=>{Zt(c).then(null,()=>{zt("Sending ANR event failed.")})},5e3);e.post("Runtime.evaluate",{expression:"global.__SENTRY_GET_SCOPES__();",silent:!0,returnByValue:!0},(t,n)=>{t&&zt(`Error executing script: '${t.message}'`),clearTimeout(u);const r=n?.result?n.result.value:void 0;e.post("Debugger.resume"),e.post("Debugger.disable"),Zt(c,r).then(null,()=>{zt("Sending ANR event failed.")})})}catch(t){throw e.post("Debugger.resume"),e.post("Debugger.disable"),t}}),qt=()=>{try{e.post("Debugger.enable",()=>{e.post("Debugger.pause")})}catch{}}}const{poll:Kt}=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()}}},Ut.pollInterval,Ut.anrThreshold,function(){zt("Watchdog timeout"),qt?(zt("Pausing debugger to capture stack trace"),qt()):(zt("Capturing event without a stack trace"),Zt().then(null,()=>{zt("Sending ANR event failed on watchdog timeout.")}))});n?.on("message",t=>{t.session&&(Bt=H(t.session)),t.debugImages&&(Mt=t.debugImages),Kt()});";
9
+ const base64WorkerScript = "/*! @sentry/node 11.0.0-rc.0 (b652097) | https://github.com/getsentry/sentry-javascript */
import{Session as t}from"node:inspector";import{workerData as e,parentPort 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="undefined"==typeof __SENTRY_DEBUG__||__SENTRY_DEBUG__,p=globalThis,l="11.0.0-rc.0";function d(){return g(p),p}function g(t){const e=t.__SENTRY__=t.__SENTRY__||{};return e.version=e.version||l,e[l]=e[l]||{}}function m(t,e,n=p){const r=n.__SENTRY__=n.__SENTRY__||{},o=r[l]=r[l]||{};return o[t]||(o[t]=e())}const y={};function b(t){if(!("console"in p))return t();const e=p.console,n={},r=Object.keys(y);r.forEach(t=>{const r=y[t];n[t]=e[t],e[t]=r});try{return t()}finally{r.forEach(t=>{e[t]=n[t]})}}function v(){return S().enabled}function w(t,...e){h&&v()&&b(()=>{p.console[t](`Sentry Logger [${t}]:`,...e)})}function S(){return h?m("loggerSettings",()=>({enabled:!1})):{enabled:!1}}const _={enable:function(){S().enabled=!0},disable:function(){S().enabled=!1},isEnabled:v,log:function(...t){w("log",...t)},warn:function(...t){w("warn",...t)},error:function(...t){w("error",...t)}},$=/captureMessage|captureException/;function E(t){return t[t.length-1]||{}}const x="<anonymous>";const N=Object.prototype.toString;function C(t){return function(t,e){return N.call(t)===`[object ${e}]`}(t,"Object")}function j(t){return Boolean(t?.then&&"function"==typeof t.then)}function O(t,e){try{return t instanceof e}catch{return!1}}function P(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 O(t,Error)}}(t))return{message:t.message,name:t.name,stack:t.stack,...k(t)};if(e=t,"undefined"!=typeof Event&&O(e,Event)){const{type:e,target:n,currentTarget:r,detail:o}=t;return{type:e,target:n,currentTarget:r,...o?{detail:o}:{},...k(t)}}var e;return t}function k(t){return"object"==typeof(e=t)&&null!==e?Object.fromEntries(Object.entries(t)):{};var e}let A;function T(t){if(void 0!==A)return A?A(t):t();const e=Symbol.for("__SENTRY_SAFE_RANDOM_ID_WRAPPER__"),n=p;return e in n&&"function"==typeof n[e]?(A=n[e],A(t)):(A=null,t())}function R(){return T(()=>Math.random())}function I(){return T(()=>Date.now())}const D=Symbol.for("sentry.skipNormalization"),U=Symbol.for("sentry.overrideNormalizationDepth");function B(t,e=100,n=1/0){try{return L("",t,e,n)}catch(t){return{ERROR:`**non-serializable** (${t})`}}}function L(t,e,n=1/0,r=1/0,o=function(){const t=new WeakSet;function e(e){return!!t.has(e)||(t.add(e),!1)}function n(e){t.delete(e)}return[e,n]}()){const[s,i]=o;if(null==e||["boolean","string"].includes(typeof e)||"number"==typeof e&&Number.isFinite(e))return e;const c=function(t,e){try{if("undefined"!=typeof global&&e===global)return"[Global]";if("number"==typeof e&&!Number.isFinite(e))return`[${e}]`;if("function"==typeof e)return`[Function: ${function(t){try{return t&&"function"==typeof t&&t.name||x}catch{return x}}(e)}]`;if("symbol"==typeof e)return`[${String(e)}]`;if("bigint"==typeof e)return`[BigInt: ${String(e)}]`;const t=function(t){const e=Object.getPrototypeOf(t);return e?.constructor?e.constructor.name:"null prototype"}(e);return`[object ${t}]`}catch(t){return`**non-serializable** (${t})`}}(0,e);if(!c.startsWith("[object "))return c;if(function(t){return Boolean(t[D])}(e))return e;const u=function(t){const e=t[U];return"number"==typeof e?e:void 0}(e),a=void 0!==u?u:n;if(0===a)return c.replace("object ","");if(s(e))return"[Circular ~]";const f=e;if(f&&"function"==typeof f.toJSON)try{return L("",f.toJSON(),a-1,r,o)}catch{}const h=Array.isArray(e)?[]:{};let p=0;const l=P(e);for(const t in l){if(!Object.prototype.hasOwnProperty.call(l,t))continue;if(p>=r){h[t]="[MaxProperties ~]";break}const e=l[t];h[t]=L(t,e,a-1,r,o),p++}return i(e),h}function M(t,e){const n=e.replace(/\\/g,"/").replace(/[|\\{}()[\]^$+*?.]/g,"\\$&");let r=t;try{r=decodeURI(t)}catch{}return r.replace(/\\/g,"/").replace(/webpack:\/?/g,"").replace(new RegExp(`(file://)?/*${n}/*`,"ig"),"app:///")}function z(t,e=0){return"string"!=typeof t||0===e||t.length<=e?t:`${t.slice(0,e)}...`}let J;function W(t=function(){const t=p;return t.crypto||t.msCrypto}()){try{if(t?.randomUUID)return T(()=>t.randomUUID()).replace(/-/g,"")}catch{}return J||(J="10000000100040008000100000000000"),J.replace(/[018]/g,t=>(t^(16*R()&15)>>t/4).toString(16))}function F(){return I()/1e3}let G;function Y(){return(G??(G=function(){const{performance:t}=p;if(!t?.now||!t.timeOrigin)return F;const e=t.timeOrigin;return()=>(e+T(()=>t.now()))/1e3}()))()}function H(t){const e=Y(),n={sid:W(),init:!0,timestamp:e,started:e,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}}}(n)};return t&&Z(n,t),n}function Z(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||Y(),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:W()),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)}function q(t,e,n=2){if(!e||"object"!=typeof e||n<=0)return e;if(t&&0===Object.keys(e).length)return t;const r={...t};for(const t in e)Object.prototype.hasOwnProperty.call(e,t)&&(r[t]=q(r[t],e[t],n-1));return r}class K{constructor(){this.t=!1,this.o=[],this.i=[],this.u=[],this.h=[],this.p={},this.l={},this.m={},this.v={},this.S={},this._={},function(t,e,n){try{Object.defineProperty(t,e,{value:n,writable:!0,configurable:!0})}catch{h&&_.log(`Failed to add non-enumerable property "${String(e)}" to object`,t)}}(this,"refs",{}),this.N={traceId:W(),sampleRand:R()}}clone(){const t=new K;return t.u=[...this.u],t.l={...this.l},t.m={...this.m},t.v={...this.v},t.S={...this.S},this.S.flags&&(t.S.flags={values:[...this.S.flags.values]}),t.p=this.p,t.C=this.C,t.j=this.j,t.O=this.O,t.P=this.P,t.i=[...this.i],t.h=[...this.h],t._={...this._},t.N={...this.N},t.k=this.k,t.A=this.A,t.T=this.T,t.refs={...this.refs},t}setClient(t){this.k=t}setLastEventId(t){this.A=t}getClient(){return this.k}lastEventId(){return this.A}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.j&&Z(this.j,{user:t}),this.R(),this}getUser(){return this.p}setConversationId(t){return this.T=t||void 0,this.R(),this}setTags(t){return this.l={...this.l,...t},this.R(),this}setTag(t,e){return this.setTags({[t]:e})}setAttributes(t){return this.m={...this.m,...t},this.R(),this}setAttribute(t,e){return this.setAttributes({[t]:e})}removeAttribute(t){return t in this.m&&(delete this.m[t],this.R()),this}setExtras(t){return this.v={...this.v,...t},this.R(),this}setExtra(t,e){return this.v={...this.v,[t]:e},this.R(),this}setFingerprint(t){return this.P=t,this.R(),this}setLevel(t){return this.C=t,this.R(),this}setTransactionName(t){return this.O=t,this.R(),this}setContext(t,e){return null===e?delete this.S[t]:this.S[t]=e,this.R(),this}setSession(t){return t?this.j=t:delete this.j,this.R(),this}getSession(){return this.j}update(t){if(!t)return this;const e="function"==typeof t?t(this):t,n=e instanceof K?e.getScopeData():C(e)?t:void 0,{tags:r,attributes:o,extra:s,user:i,contexts:c,level:u,fingerprint:a=[],propagationContext:f,conversationId:h}=n||{};return this.l={...this.l,...r},this.m={...this.m,...o},this.v={...this.v,...s},this.S={...this.S,...c},i&&Object.keys(i).length&&(this.p=i),u&&(this.C=u),a.length&&(this.P=a),f&&(this.N=f),h&&(this.T=h),this}addBreadcrumb(t,e){const n="number"==typeof e?e:100;if(n<=0)return this;const r={timestamp:F(),...t,message:t.message?z(t.message,2048):t.message};return this.u.push(r),this.u.length>n&&(this.u=this.u.slice(-n),this.k?.recordDroppedEvent("buffer_overflow","log_item")),this.R(),this}getLastBreadcrumb(){return this.u[this.u.length-1]}clearBreadcrumbs(){return this.u=[],this.R(),this}addAttachment(t){return this.h.push(t),this}clearAttachments(){return this.h=[],this}getScopeData(){return{breadcrumbs:this.u,attachments:this.h,contexts:this.S,tags:this.l,attributes:this.m,extra:this.v,user:this.p,level:this.C,fingerprint:this.P||[],eventProcessors:this.i,propagationContext:this.N,sdkProcessingMetadata:this._,transactionName:this.O,conversationId:this.T}}setSDKProcessingMetadata(t){return this._=q(this._,t,2),this}setPropagationContext(t){return this.N=t,this}getPropagationContext(){return this.N}captureException(t,e){const n=e?.event_id||W();if(!this.k)return h&&_.warn("No client configured on scope - will not capture exception!"),n;const r=new Error("Sentry syntheticException");return this.k.captureException(t,{originalException:t,syntheticException:r,...e,event_id:n},this),n}captureMessage(t,e,n){const r=n?.event_id||W();if(!this.k)return h&&_.warn("No client configured on scope - will not capture message!"),r;const o=n?.syntheticException??new Error(t);return this.k.captureMessage(t,e,{originalException:t,syntheticException:o,...n,event_id:r},this),r}captureEvent(t,e){const n=t.event_id||e?.event_id||W();return this.k?(this.k.captureEvent(t,{...e,event_id:n},this),n):(h&&_.warn("No client configured on scope - will not capture event!"),n)}R(){this.t||(this.t=!0,this.o.forEach(t=>{t(this)}),this.t=!1)}}const V="__SENTRY_SUPPRESS_TRACING__",Q=t=>t instanceof Promise&&!t[X],X=Symbol("chained PromiseLike"),tt=(t,e)=>{if(!e)return t;let n=!1;for(const r in t){if(r in e)continue;n=!0;const o=t[r];"function"==typeof o?Object.defineProperty(e,r,{value:(...e)=>o.apply(t,e),enumerable:!0,configurable:!0,writable:!0}):e[r]=o}return n&&Object.assign(e,{[X]:!0}),e};class et{constructor(t,e){let n,r;n=t||new K,r=e||new K,this.I=[{scope:n}],this.D=r}withScope(t){const e=this.U();let n;try{n=t(e)}catch(t){throw this.B(),t}return j(n)?((t,e,n)=>{const r=t.then(t=>(e(t),t),t=>{throw n(t),t});return Q(r)&&Q(t)?r:tt(t,r)})(n,()=>this.B(),()=>this.B()):(this.B(),n)}getClient(){return this.getStackTop().client}getScope(){return this.getStackTop().scope}getIsolationScope(){return this.D}getStackTop(){return this.I[this.I.length-1]}U(){const t=this.getScope().clone();return this.I.push({client:this.getClient(),scope:t}),t}B(){return!(this.I.length<=1)&&!!this.I.pop()}}function nt(){const t=g(d());return t.stack=t.stack||new et(m("defaultCurrentScope",()=>new K),m("defaultIsolationScope",()=>new K))}function rt(t){return nt().withScope(t)}function ot(t,e){const n=nt();return n.withScope(()=>(n.getStackTop().scope=t,e(t)))}function st(t){return nt().withScope(()=>t(nt().getIsolationScope()))}function it(t){return rt(e=>{e.setSDKProcessingMetadata({[V]:!0});const n=t();return e.setSDKProcessingMetadata({[V]:void 0}),n})}function ct(t){const e=g(t);return e.acs?e.acs:{suppressTracing:it,withIsolationScope:st,withScope:rt,withSetScope:ot,withSetIsolationScope:(t,e)=>st(e),getCurrentScope:()=>nt().getScope(),getIsolationScope:()=>nt().getIsolationScope()}}function ut(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}`}function at(t,e){const{fingerprint:n,breadcrumbs:r,sdkProcessingMetadata:o}=e;!function(t,e){const{extra:n,tags:r,user:o,contexts:s,level:i,transactionName:c}=e;Object.keys(n).length&&(t.extra={...n,...t.extra});Object.keys(r).length&&(t.tags={...r,...t.tags});Object.keys(o).length&&(t.user={...o,...t.user});Object.keys(s).length&&(t.contexts={...s,...t.contexts});i&&(t.level=i);c&&"transaction"!==t.type&&(t.transaction=c)}(t,e),function(t,e){t.fingerprint=t.fingerprint?Array.isArray(t.fingerprint)?t.fingerprint:[t.fingerprint]:[],e&&(t.fingerprint=t.fingerprint.concat(e));t.fingerprint.length||delete t.fingerprint}(t,n),function(t,e){const n=[...t.breadcrumbs||[],...e];t.breadcrumbs=n.length?n:void 0}(t,r),function(t,e){t.sdkProcessingMetadata={...t.sdkProcessingMetadata,...e}}(t,o)}function ft(t,e=[]){return[t,e]}function ht(t,e){const n=t[1];for(const t of n){if(e(t,t[0].type))return!0}return!1}function pt(t){const e=g(p);return e.encodePolyfill?e.encodePolyfill(t):(new TextEncoder).encode(t)}function lt(t){const[e,n]=t;let r=JSON.stringify(e);function o(t){"string"==typeof r?r="string"==typeof t?r+t:[pt(r),t]:r.push("string"==typeof t?pt(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{t=JSON.stringify(B(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 dt={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 gt(t){return function(t){return t in dt}(t)?dt[t]:t}function mt(t){if(!t?.sdk)return;const{name:e,version:n}=t.sdk;return{name:e,version:n}}function yt(t){const e=ct(d());return e.suppressTracing?e.suppressTracing(t):function(...t){const e=ct(d());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({[V]:!0}),t()))}function bt(t,e,n,r){const o=mt(n),s=t.type&&"replay_event"!==t.type?t.type:"event";!function(t,e){if(!e)return t;const n=t.sdk||{};t.sdk={...n,name:n.name||e.name,version:n.version||e.version,integrations:[...t.sdk?.integrations||[],...e.integrations||[]],packages:[...t.sdk?.packages||[],...e.packages||[]],settings:t.sdk?.settings||e.settings?{...t.sdk?.settings,...e.settings}:void 0}}(t,n?.sdk);const i=function(t,e,n,r){const o=t.sdkProcessingMetadata?.dynamicSamplingContext;return{event_id:t.event_id,sent_at:new Date(I()).toISOString(),...e&&{sdk:e},...!!n&&r&&{dsn:ut(r)},...o&&{trace:o}}}(t,o,r,e);delete t.sdkProcessingMetadata;return ft(i,[[{type:s},t]])}class vt{constructor(t){this.L=0,this.M=[],this.J(t)}then(t,e){return new vt((n,r)=>{this.M.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.W()})}catch(t){return this.then(t=>t,t)}finally(t){return new vt((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)})})}W(){if(0===this.L)return;const t=this.M.slice();this.M=[],t.forEach(t=>{t[0]||(1===this.L&&t[1](this.F),2===this.L&&t[2](this.F),t[0]=!0)})}J(t){const e=(t,e)=>{0===this.L&&(j(e)?e.then(n,r):(this.L=t,this.F=e,this.W()))},n=t=>{e(1,t)},r=t=>{e(2,t)};try{t(n,r)}catch(t){r(t)}}}const wt=Symbol.for("SentryBufferFullError");function St(t=100){const e=new Set;function n(t){e.delete(t)}return{get $(){return Array.from(e)},add:function(r){if(!(e.size<t))return o=wt,new vt((t,e)=>{e(o)});var o;const s=r();return e.add(s),s.then(()=>n(s),()=>n(s)),s},drain:function(t){if(!e.size)return n=!0,new vt(t=>{t(n)});var n;const r=Promise.allSettled(Array.from(e)).then(()=>!0);if(!t)return r;const o=[r,new Promise(e=>{return"object"==typeof(n=setTimeout(()=>e(!1),t))&&"function"==typeof n.unref&&n.unref(),n;var n})];return Promise.race(o)}}}function _t(t,{statusCode:e,headers:n},r=I()){const o={...t},s=n?.["x-sentry-rate-limits"],i=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=I()){const n=parseInt(`${t}`,10);if(!isNaN(n))return 1e3*n;const r=Date.parse(`${t}`);return isNaN(r)?6e4:r-e}(i,r):429===e&&(o.all=r+6e4);return o}function $t(t,e,n=St(t.bufferSize||64)){let r={};return{send:function(t){const o=[];if(ht(t,(t,e)=>{const n=gt(e);(function(t,e,n=I()){return function(t,e){return t[e]||t.all||0}(t,e)>n})(r,n)||o.push(t)}),0===o.length)return Promise.resolve({});const s=ft(t[0],o),i=t=>{!function(t,e){return ht(t,(t,n)=>e.includes(n))}(s,["client_report"])?ht(s,(t,e)=>{}):h&&_.warn(`Dropping client report. Will not send outcomes (reason: ${t}).`)};return n.add(()=>e({body:lt(s)}).then(t=>413===t.statusCode?(h&&_.error("Sentry responded with status code 413. Envelope was discarded due to exceeding size limits."),i("send_error"),t):(h&&void 0!==t.statusCode&&(t.statusCode<200||t.statusCode>=300)&&_.warn(`Sentry responded with status code ${t.statusCode} to sent event.`),r=_t(r,t),t),t=>{throw i("network_error"),h&&_.error("Encountered error running transport request:",t),t})).then(t=>t,t=>{if(t===wt)return h&&_.error("Skipped sending event because buffer is full."),i("queue_overflow"),Promise.resolve({});throw t})},flush:t=>n.drain(t)}}const Et=/^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;function xt(t){const e=function(t){const e=t.length>1024?`<truncated>${t.slice(-1024)}`:t,n=Et.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):"."}function Nt(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/")}var Ct;const jt=Symbol("AgentBaseInternalState");class Ot extends(Ct=s.Agent,Ct){constructor(t){super(t),this[jt]={}}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[jt].currentSocket=o,super.createSocket(t,e,n)},n)}createConnection(){const t=this[jt].currentSocket;if(this[jt].currentSocket=void 0,!t)throw new Error("No socket was returned in the `connect()` function");return t}get defaultPort(){return this[jt].defaultPort??("https:"===this.protocol?443:80)}set defaultPort(t){this[jt]&&(this[jt].defaultPort=t)}get protocol(){return this[jt].protocol??(this.isSecureEndpoint()?"https:":"http:")}set protocol(t){this[jt]&&(this[jt].protocol=t)}}function Pt(...t){_.log("[https-proxy-agent:parse-proxy-response]",...t)}function kt(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 Pt("have not received end of HTTP headers yet..."),void s();const f=u.subarray(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]||0),d=p.slice(2).join(" "),g={};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=g[o];"string"==typeof i?g[o]=[i,s]:Array.isArray(i)?i.push(s):g[o]=s}Pt("got proxy server response: %o %o",h,g),i(),e({connect:{statusCode:l,statusText:d,headers:g},buffered:u})}(c):t.once("readable",s)}function i(){t.removeListener("end",c),t.removeListener("error",u),t.removeListener("readable",s)}function c(){i(),Pt("onend"),n(new Error("Proxy connection ended before receiving CONNECT response"))}function u(t){i(),Pt("onerror %o",t),n(t)}t.on("error",u),t.on("end",c),s()})}function At(...t){_.log("[https-proxy-agent]",...t)}class Tt extends Ot{constructor(t,e){super(e),this.options={},this.proxy="string"==typeof t?new URL(t):t,this.proxyHeaders=e?.headers??{},At("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?It(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){At("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 At("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=kt(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",Rt),e.secureEndpoint){At("Upgrading socket connection to TLS");const t=e.servername||e.host;return f.connect({...It(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=>{At("Replaying proxy buffer for failed request"),t.push(h),t.push(null)}),p}}function Rt(t){t.resume()}function It(t,...e){const n={};let r;for(r in t)e.includes(r)||(n[r]=t[r]);return n}Tt.protocols=["http","https"];function Dt(t){return t.replace(/^[A-Z]:/,"").replace(/\\/g,"/")}const Ut=e;let Bt,Lt=0,Mt={};function zt(t){Ut.debug&&console.log(`[ANR Worker] ${t}`)}var Jt,Wt,Ft;const Gt=function(t){let e;try{e=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.")}),$t(t,()=>Promise.resolve({}))}const n="https:"===e.protocol,r=function(t,e){const{no_proxy:n}=process.env,r=n?.split(",").some(e=>t.host.endsWith(e)||t.hostname.endsWith(e));return r?void 0:e}(e,t.proxy||(n?process.env.https_proxy:void 0)||process.env.http_proxy),o=n?i:s,a=t.keepAlive??!0,f=r?new Tt(r):new o.Agent({keepAlive:a,maxSockets:30,timeout:2e3}),h=function(t,e,n){const{hostname:r,pathname:o,port:s,protocol:i,search:a}=new URL(t.url);return function(f){const h=p=>new Promise((l,d)=>{yt(()=>{let g=function(t){return new c({read(){this.push(t),this.push(null)}})}(f.body);const m={...t.headers};f.body.length>32768&&(m["content-encoding"]="gzip",g=g.pipe(u()));const y=r.startsWith("["),b=e.request({method:"POST",agent:n,headers:m,hostname:y?r.slice(1,-1):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;l({statusCode:t.statusCode,headers:{"retry-after":e,"x-sentry-rate-limits":Array.isArray(n)?n[0]||null:n}})});b.on("error",t=>{p&&b.reusedSocket&&"ECONNRESET"===t.code?l(h(!1)):d(t)}),g.pipe(b)})});return h(!0)}}(t,t.httpModule??o,f);return $t(t,h)}({url:(Jt=Ut.dsn,Wt=Ut.tunnel,Ft=Ut.sdkMetadata.sdk,Wt||`${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/`}(Jt)}?${function(t,e){const n={sentry_version:"7"};return t.publicKey&&(n.sentry_key=t.publicKey),e&&(n.sentry_client=`${e.name}/${e.version}`),new URLSearchParams(n).toString()}(Jt,Ft)}`)});async function Yt(){if(Bt){zt("Sending abnormal session"),Z(Bt,{status:"abnormal",abnormal_mechanism:"anr_foreground",release:Ut.release,environment:Ut.environment});const t=function(t,e,n,r){const o=mt(n);return ft({sent_at:new Date(I()).toISOString(),...o&&{sdk:o},...!!r&&e&&{dsn:ut(e)}},["aggregates"in t?[{type:"sessions"},t]:[{type:"session"},t.toJSON()]])}(Bt,Ut.dsn,Ut.sdkMetadata,Ut.tunnel);zt(JSON.stringify(t)),await Gt.send(t);try{n?.postMessage("session-ended")}catch{}}}function Ht(t){if(!t)return;const e=function(t){if(!t.length)return[];const e=Array.from(t);return/sentryWrapped/.test(E(e).function||"")&&e.pop(),e.reverse(),$.test(E(e).function||"")&&(e.pop(),$.test(E(e).function||"")&&e.pop()),e.slice(0,50).map(t=>({...t,filename:t.filename||E(e).filename,function:t.function||"?"}))}(t);if(Ut.appRootPath)for(const t of e)t.filename&&(t.filename=M(t.filename,Ut.appRootPath));return e}async function Zt(t,e){if(Lt>=Ut.maxAnrEvents)return;Lt+=1,await Yt(),zt("Sending event");const n={event_id:W(),contexts:Ut.contexts,release:Ut.release,environment:Ut.environment,dist:Ut.dist,platform:"node",level:"error",exception:{values:[{type:"ApplicationNotResponding",value:`Application Not Responding for at least ${Ut.anrThreshold} ms`,stacktrace:{frames:Ht(t)},mechanism:{type:"ANR"}}]},tags:Ut.staticTags};e&&function(t,e){if(at(t,e),!t.contexts?.trace){const{traceId:n,parentSpanId:r,propagationSpanId:o}=e.propagationContext;t.contexts={trace:{trace_id:n,span_id:o||W().substring(16),parent_span_id:r},...t.contexts}}}(n,e),function(t){if(0===Object.keys(Mt).length)return;const e=Ut.appRootPath?{}:Mt;if(Ut.appRootPath)for(const[t,n]of Object.entries(Mt))e[M(t,Ut.appRootPath)]=n;const n=new Map;for(const r of t.exception?.values||[])for(const t of r.stacktrace?.frames||[]){const r=t.abs_path||t.filename;r&&e[r]&&n.set(r,e[r])}if(n.size>0){const e=[];for(const[t,r]of n.entries())e.push({type:"sourcemap",code_file:t,debug_id:r});t.debug_meta={images:e}}}(n);const r=bt(n,Ut.dsn,Ut.sdkMetadata,Ut.tunnel);zt(JSON.stringify(r)),await Gt.send(r),await Gt.flush(2e3),Lt>=Ut.maxAnrEvents&&setTimeout(()=>{process.exit(0)},5e3)}let qt;if(zt("Started"),Ut.captureStackTrace){zt("Connecting to debugger");const e=new t;e.connectToMainThread(),zt("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{zt("Debugger paused");const s=[...t.params.callFrames],i=Ut.appRootPath?function(t=(process.argv[1]?xt(process.argv[1]):process.cwd()),e="\\"===o){const n=e?Dt(t):t;return t=>{if(!t)return;const o=e?Dt(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));const u=decodeURIComponent(i);s||(s=".");const a=s.lastIndexOf("/node_modules");if(a>-1)return`${s.slice(a+14).replace(/\//g,".")}:${u}`;if(s.startsWith(n)){const t=s.slice(n.length+1).replace(/\//g,".");return t?`${t}:${u}`:u}return u}}(Ut.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{filename:r,module:n(r),function:t.functionName||"?",colno:o,lineno:s,in_app:r?Nt(r):void 0}}(t,n.get(t.location.scriptId),i)),u=setTimeout(()=>{Zt(c).then(null,()=>{zt("Sending ANR event failed.")})},5e3);e.post("Runtime.evaluate",{expression:"global.__SENTRY_GET_SCOPES__();",silent:!0,returnByValue:!0},(t,n)=>{t&&zt(`Error executing script: '${t.message}'`),clearTimeout(u);const r=n?.result?n.result.value:void 0;e.post("Debugger.resume"),e.post("Debugger.disable"),Zt(c,r).then(null,()=>{zt("Sending ANR event failed.")})})}catch(t){throw e.post("Debugger.resume"),e.post("Debugger.disable"),t}}),qt=()=>{try{e.post("Debugger.enable",()=>{e.post("Debugger.pause")})}catch{}}}const{poll:Kt}=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.bigint();return{getTimeMs:()=>Number((process.hrtime.bigint()-t)/1000000n),reset:()=>{t=process.hrtime.bigint()}}},Ut.pollInterval,Ut.anrThreshold,function(){zt("Watchdog timeout"),qt?(zt("Pausing debugger to capture stack trace"),qt()):(zt("Capturing event without a stack trace"),Zt().then(null,()=>{zt("Sending ANR event failed on watchdog timeout.")}))});n?.on("message",t=>{t.session&&(Bt=H(t.session)),t.debugImages&&(Mt=t.debugImages),Kt()}),n?.postMessage("worker-ready");";
10
10
  const DEFAULT_INTERVAL = 50;
11
11
  const DEFAULT_HANG_THRESHOLD = 5e3;
12
12
  function log(message, ...args) {
@@ -34,6 +34,7 @@ const INTEGRATION_NAME = "Anr";
34
34
  const _anrIntegration = ((options = {}) => {
35
35
  let worker;
36
36
  let client;
37
+ let workerReady;
37
38
  const gbl = globalWithScopeFetchFn();
38
39
  gbl.__SENTRY_GET_SCOPES__ = getScopeData;
39
40
  return {
@@ -42,18 +43,23 @@ const _anrIntegration = ((options = {}) => {
42
43
  if (worker) {
43
44
  return;
44
45
  }
45
- if (client) {
46
- worker = _startWorker(client, options);
46
+ const initializedClient = client;
47
+ if (initializedClient) {
48
+ workerReady = new Promise((resolve) => {
49
+ worker = _startWorker(initializedClient, options, resolve);
50
+ });
47
51
  }
48
52
  },
49
53
  stopWorker: () => {
50
54
  if (worker) {
55
+ workerReady = void 0;
51
56
  worker.then((stop) => {
52
57
  stop();
53
58
  worker = void 0;
54
59
  });
55
60
  }
56
61
  },
62
+ waitUntilWorkerReady: () => workerReady ?? Promise.resolve(),
57
63
  async setup(initClient) {
58
64
  client = initClient;
59
65
  if (options.captureStackTrace && await debug.isDebuggerEnabled()) {
@@ -65,7 +71,7 @@ const _anrIntegration = ((options = {}) => {
65
71
  };
66
72
  });
67
73
  const anrIntegration = core.defineIntegration(_anrIntegration);
68
- async function _startWorker(client, integrationOptions) {
74
+ async function _startWorker(client, integrationOptions, onReady) {
69
75
  const dsn = client.getDsn();
70
76
  if (!dsn) {
71
77
  return () => {
@@ -123,6 +129,8 @@ async function _startWorker(client, integrationOptions) {
123
129
  if (msg === "session-ended") {
124
130
  log("ANR event sent from ANR worker. Clearing session in this thread.");
125
131
  core.getIsolationScope().setSession(void 0);
132
+ } else if (msg === "worker-ready") {
133
+ onReady?.();
126
134
  }
127
135
  });
128
136
  worker.once("error", (err) => {
package/build/cjs/integrations/anr/index.js.map CHANGED
@@ -1 +1 @@
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":";;;;;;;AAiBA,MAAM,EAAE,WAAU,GAAIA,UAAA;AAGf,MAAM,kBAAA,GAAqB;AAElC,MAAM,gBAAA,GAAmB,EAAA;AACzB,MAAM,sBAAA,GAAyB,GAAA;AAE/B,SAAS,GAAA,CAAI,YAAoB,IAAA,EAAuB;AACtD,EAAAC,UAAA,CAAM,GAAA,CAAI,CAAA,MAAA,EAAS,OAAO,CAAA,CAAA,EAAI,GAAG,IAAI,CAAA;AACvC;AAEA,SAAS,sBAAA,GAA0F;AACjG,EAAA,OAAOC,eAAA;AACT;AAGA,SAAS,YAAA,GAA0B;AACjC,EAAA,MAAM,KAAA,GAAQC,yBAAA,CAAqBC,sBAAA,EAAkB,EAAGC,sBAAiB,CAAA;AAGzE,EAAA,KAAA,CAAM,cAAc,EAAC;AAErB,EAAA,KAAA,CAAM,kBAAkB,EAAC;AAEzB,EAAA,OAAO,KAAA;AACT;AAKA,eAAe,YAAY,MAAA,EAAuC;AAChE,EAAA,IAAI,KAAA,GAAsB,EAAE,OAAA,EAAS,KAAA,EAAM;AAC3C,EAAA,MAAM,YAAuB,EAAC;AAE9B,EAAA,KAAA,MAAW,SAAA,IAAa,MAAA,CAAO,kBAAA,EAAmB,EAAG;AACnD,IAAA,IAAI,UAAU,IAAA,EAAM;AACpB,IAAA,KAAA,GAAQ,MAAM,SAAA,CAAU,KAAA,EAAO,SAAS,CAAA;AAAA,EAC1C;AAEA,EAAA,OAAO,KAAA,EAAO,YAAY,EAAC;AAC7B;AAEA,MAAM,gBAAA,GAAmB,KAAA;AAKzB,MAAM,eAAA,IAAmB,CAAC,OAAA,GAA0C,EAAC,KAAM;AACzE,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI,MAAA;AAIJ,EAAA,MAAM,MAAM,sBAAA,EAAuB;AACnC,EAAA,GAAA,CAAI,qBAAA,GAAwB,YAAA;AAE5B,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,aAAa,MAAM;AACjB,MAAA,IAAI,MAAA,EAAQ;AACV,QAAA;AAAA,MACF;AAEA,MAAA,IAAI,MAAA,EAAQ;AACV,QAAA,MAAA,GAAS,YAAA,CAAa,QAAQ,OAAO,CAAA;AAAA,MACvC;AAAA,IACF,CAAA;AAAA,IACA,YAAY,MAAM;AAChB,MAAA,IAAI,MAAA,EAAQ;AAEV,QAAA,MAAA,CAAO,KAAK,CAAA,IAAA,KAAQ;AAClB,UAAA,IAAA,EAAK;AACL,UAAA,MAAA,GAAS,MAAA;AAAA,QACX,CAAC,CAAA;AAAA,MACH;AAAA,IACF,CAAA;AAAA,IACA,MAAM,MAAM,UAAA,EAAwB;AAClC,MAAA,MAAA,GAAS,UAAA;AAET,MAAA,IAAI,OAAA,CAAQ,iBAAA,IAAsB,MAAMC,uBAAA,EAAkB,EAAI;AAC5D,QAAAL,UAAA,CAAM,KAAK,kFAAkF,CAAA;AAC7F,QAAA,OAAA,CAAQ,iBAAA,GAAoB,KAAA;AAAA,MAC9B;AAIA,MAAA,YAAA,CAAa,MAAM,IAAA,CAAK,WAAA,EAAa,CAAA;AAAA,IACvC;AAAA,GACF;AACF,CAAA,CAAA;AAyCO,MAAM,cAAA,GAAiBM,uBAAkB,eAAe;AAO/D,eAAe,YAAA,CACb,QAEA,kBAAA,EACqB;AACrB,EAAA,MAAM,GAAA,GAAM,OAAO,MAAA,EAAO;AAE1B,EAAA,IAAI,CAAC,GAAA,EAAK;AACR,IAAA,OAAO,MAAM;AAAA,IAEb,CAAA;AAAA,EACF;AAEA,EAAA,MAAM,QAAA,GAAW,MAAM,WAAA,CAAY,MAAM,CAAA;AAGzC,EAAA,OAAO,SAAS,GAAA,EAAK,UAAA;AACrB,EAAA,OAAO,SAAS,MAAA,EAAQ,WAAA;AAExB,EAAA,MAAM,WAAA,GAAc,OAAO,UAAA,EAAW;AAEtC,EAAA,MAAM,WAAA,GAAc,MAAA,CAAO,cAAA,EAAe,IAAK,EAAC;AAChD,EAAA,IAAI,YAAY,GAAA,EAAK;AACnB,IAAA,WAAA,CAAY,IAAI,YAAA,GAAe,WAAA,CAAY,aAAa,GAAA,CAAI,CAAA,CAAA,KAAK,EAAE,IAAI,CAAA;AAAA,EACzE;AAEA,EAAA,MAAM,OAAA,GAA2B;AAAA,IAC/B,KAAA,EAAON,WAAM,SAAA,EAAU;AAAA,IACvB,GAAA;AAAA,IACA,QAAQ,WAAA,CAAY,MAAA;AAAA,IACpB,WAAA,EAAa,YAAY,WAAA,IAAe,YAAA;AAAA,IACxC,SAAS,WAAA,CAAY,OAAA;AAAA,IACrB,MAAM,WAAA,CAAY,IAAA;AAAA,IAClB,WAAA;AAAA,IACA,aAAa,kBAAA,CAAmB,WAAA;AAAA,IAChC,YAAA,EAAc,mBAAmB,YAAA,IAAgB,gBAAA;AAAA,IACjD,YAAA,EAAc,mBAAmB,YAAA,IAAgB,sBAAA;AAAA,IACjD,iBAAA,EAAmB,CAAC,CAAC,kBAAA,CAAmB,iBAAA;AAAA,IACxC,YAAA,EAAc,mBAAmB,YAAA,IAAgB,CAAA;AAAA,IACjD,UAAA,EAAY,kBAAA,CAAmB,UAAA,IAAc,EAAC;AAAA,IAC9C;AAAA,GACF;AAEA,EAAA,IAAI,QAAQ,iBAAA,EAAmB;AAC7B,IAAA,MAAM,SAAA,GAAY,MAAM,OAAO,gBAAgB,CAAA;AAC/C,IAAA,IAAI,CAAC,SAAA,CAAU,GAAA,EAAI,EAAG;AACpB,MAAA,SAAA,CAAU,KAAK,CAAC,CAAA;AAAA,IAClB;AAAA,EACF;AAEA,EAAA,MAAM,MAAA,GAAS,IAAIO,0BAAA,CAAO,IAAI,IAAI,CAAA,mCAAA,EAAsC,kBAAkB,EAAE,CAAA,EAAG;AAAA,IAC7F,UAAA,EAAY,OAAA;AAAA;AAAA,IAEZ,UAAU,EAAC;AAAA,IACX,KAAK,EAAE,GAAG,OAAA,CAAQ,GAAA,EAAK,cAAc,MAAA;AAAU,GAChD,CAAA;AAED,EAAA,OAAA,CAAQ,EAAA,CAAG,QAAQ,MAAM;AAEvB,IAAA,MAAA,CAAO,SAAA,EAAU;AAAA,EACnB,CAAC,CAAA;AAED,EAAA,MAAM,KAAA,GAAQ,YAAY,MAAM;AAC9B,IAAA,IAAI;AACF,MAAA,MAAM,cAAA,GAAiBJ,sBAAA,EAAkB,CAAE,UAAA,EAAW;AAGtD,MAAA,MAAM,UAAU,cAAA,GAAiB,EAAE,GAAG,cAAA,EAAgB,MAAA,EAAQ,QAAU,GAAI,KAAA,CAAA;AAE5E,MAAA,MAAA,CAAO,WAAA,CAAY,EAAE,OAAA,EAAS,WAAA,EAAaK,6BAAwB,WAAA,CAAY,WAAW,GAAG,CAAA;AAAA,IAC/F,CAAA,CAAA,MAAQ;AAAA,IAER;AAAA,EACF,CAAA,EAAG,QAAQ,YAAY,CAAA;AAEvB,EAAA,KAAA,CAAM,KAAA,EAAM;AAEZ,EAAA,MAAA,CAAO,EAAA,CAAG,SAAA,EAAW,CAAC,GAAA,KAAgB;AACpC,IAAA,IAAI,QAAQ,eAAA,EAAiB;AAC3B,MAAA,GAAA,CAAI,kEAAkE,CAAA;AACtE,MAAAL,sBAAA,EAAkB,CAAE,WAAW,MAAS,CAAA;AAAA,IAC1C;AAAA,EACF,CAAC,CAAA;AAED,EAAA,MAAA,CAAO,IAAA,CAAK,OAAA,EAAS,CAAC,GAAA,KAAe;AACnC,IAAA,aAAA,CAAc,KAAK,CAAA;AACnB,IAAA,GAAA,CAAI,oBAAoB,GAAG,CAAA;AAAA,EAC7B,CAAC,CAAA;AAED,EAAA,MAAA,CAAO,IAAA,CAAK,MAAA,EAAQ,CAAC,IAAA,KAAiB;AACpC,IAAA,aAAA,CAAc,KAAK,CAAA;AACnB,IAAA,GAAA,CAAI,mBAAmB,IAAI,CAAA;AAAA,EAC7B,CAAC,CAAA;AAGD,EAAA,MAAA,CAAO,KAAA,EAAM;AAEb,EAAA,OAAO,MAAM;AAEX,IAAA,MAAA,CAAO,SAAA,EAAU;AACjB,IAAA,aAAA,CAAc,KAAK,CAAA;AAAA,EACrB,CAAA;AACF;AAuBO,SAAS,+BAAkC,QAAA,EAAgD;AAChG,EAAA,MAAM,WAAA,GAAcM,cAAA,EAAU,EAAG,oBAAA,CAAqB,gBAAgB,CAAA;AAEtE,EAAA,IAAI,CAAC,WAAA,EAAa;AAChB,IAAA,OAAO,QAAA,EAAS;AAAA,EAClB;AAEA,EAAA,WAAA,CAAY,UAAA,EAAW;AAEvB,EAAA,MAAM,SAAS,QAAA,EAAS;AACxB,EAAA,IAAI,SAAA,CAAU,MAAM,CAAA,EAAG;AACrB,IAAA,OAAO,MAAA,CAAO,OAAA,CAAQ,MAAM,WAAA,CAAY,aAAa,CAAA;AAAA,EACvD;AAEA,EAAA,WAAA,CAAY,WAAA,EAAY;AACxB,EAAA,OAAO,MAAA;AACT;;;;;;"}
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 = {\n startWorker: () => void;\n stopWorker: () => void;\n waitUntilWorkerReady: () => Promise<void>;\n};\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 let workerReady: Promise<void> | 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 const initializedClient = client;\n if (initializedClient) {\n workerReady = new Promise<void>(resolve => {\n worker = _startWorker(initializedClient, options, resolve);\n });\n }\n },\n stopWorker: () => {\n if (worker) {\n workerReady = undefined;\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n worker.then(stop => {\n stop();\n worker = undefined;\n });\n }\n },\n waitUntilWorkerReady: () => workerReady ?? Promise.resolve(),\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 onReady?: () => void,\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 } else if (msg === 'worker-ready') {\n onReady?.();\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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"}
package/build/cjs/integrations/contextlines.js CHANGED
@@ -7,7 +7,7 @@ const debugBuild = require('../debug-build.js');
7
7
 
8
8
  const LRU_FILE_CONTENTS_CACHE = new core.LRUMap(10);
9
9
  const LRU_FILE_CONTENTS_FS_READ_FAILED = new core.LRUMap(20);
10
- const DEFAULT_LINES_OF_CONTEXT = 7;
10
+ const DEFAULT_LINES_OF_CONTEXT = 5;
11
11
  const INTEGRATION_NAME = "ContextLines";
12
12
  const MAX_CONTEXTLINES_COLNO = 1e3;
13
13
  const MAX_CONTEXTLINES_LINENO = 1e4;
package/build/cjs/integrations/contextlines.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"contextlines.js","sources":["../../../src/integrations/contextlines.ts"],"sourcesContent":["import { createReadStream } from 'node:fs';\nimport { createInterface } from 'node:readline';\nimport type { Event, IntegrationFn, StackFrame } from '@sentry/core';\nimport { debug, defineIntegration, LRUMap, snipLine } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\n\nconst LRU_FILE_CONTENTS_CACHE = new LRUMap<string, Record<number, string>>(10);\nconst LRU_FILE_CONTENTS_FS_READ_FAILED = new LRUMap<string, 1>(20);\nconst DEFAULT_LINES_OF_CONTEXT = 7;\nconst INTEGRATION_NAME = 'ContextLines' as const;\n// Determines the upper bound of lineno/colno that we will attempt to read. Large colno values are likely to be\n// minified code while large lineno values are likely to be bundled code.\n// Exported for testing purposes.\nexport const MAX_CONTEXTLINES_COLNO: number = 1000;\nexport const MAX_CONTEXTLINES_LINENO: number = 10000;\n\n// TODO(v11): Use `dataCollection.frameContextLines` default (5)\ninterface ContextLinesOptions {\n /**\n * Sets the number of context lines for each frame when loading a file.\n * Defaults to 7.\n *\n * Set to 0 to disable loading and inclusion of source files.\n *\n * When set, this option takes precedence over `dataCollection.frameContextLines`.\n **/\n frameContextLines?: number;\n}\n\n/**\n * Exported for testing purposes.\n */\nexport function resetFileContentCache(): void {\n LRU_FILE_CONTENTS_CACHE.clear();\n}\n\n/**\n * Get or init map value\n */\nfunction emplace<T extends LRUMap<K, V>, K extends string, V>(map: T, key: K, contents: V): V {\n const value = map.get(key);\n\n if (value === undefined) {\n map.set(key, contents);\n return contents;\n }\n\n return value;\n}\n\n/**\n * Determines if context lines should be skipped for a file.\n * - .min.(mjs|cjs|js) files are and not useful since they dont point to the original source\n * - node: prefixed modules are part of the runtime and cannot be resolved to a file\n * - data: skip json, wasm and inline js https://nodejs.org/api/esm.html#data-imports\n */\nfunction shouldSkipContextLinesForFile(path: string): boolean {\n // Test the most common prefix and extension first. These are the ones we\n // are most likely to see in user applications and are the ones we can break out of first.\n if (path.startsWith('node:')) return true;\n if (path.endsWith('.min.js')) return true;\n if (path.endsWith('.min.cjs')) return true;\n if (path.endsWith('.min.mjs')) return true;\n if (path.startsWith('data:')) return true;\n return false;\n}\n\n/**\n * Determines if we should skip contextlines based off the max lineno and colno values.\n */\nfunction shouldSkipContextLinesForFrame(frame: StackFrame): boolean {\n if (frame.lineno !== undefined && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;\n if (frame.colno !== undefined && frame.colno > MAX_CONTEXTLINES_COLNO) return true;\n return false;\n}\n/**\n * Checks if we have all the contents that we need in the cache.\n */\nfunction rangeExistsInContentCache(file: string, range: ReadlineRange): boolean {\n const contents = LRU_FILE_CONTENTS_CACHE.get(file);\n if (contents === undefined) return false;\n\n for (let i = range[0]; i <= range[1]; i++) {\n if (contents[i] === undefined) {\n return false;\n }\n }\n\n return true;\n}\n\n/**\n * Creates contiguous ranges of lines to read from a file. In the case where context lines overlap,\n * the ranges are merged to create a single range.\n */\nfunction makeLineReaderRanges(lines: number[], linecontext: number): ReadlineRange[] {\n if (!lines.length) {\n return [];\n }\n\n let i = 0;\n const line = lines[0];\n\n if (typeof line !== 'number') {\n return [];\n }\n\n let current = makeContextRange(line, linecontext);\n const out: ReadlineRange[] = [];\n // eslint-disable-next-line no-constant-condition\n while (true) {\n if (i === lines.length - 1) {\n out.push(current);\n break;\n }\n\n // If the next line falls into the current range, extend the current range to lineno + linecontext.\n const next = lines[i + 1];\n if (typeof next !== 'number') {\n break;\n }\n if (next <= current[1]) {\n current[1] = next + linecontext;\n } else {\n out.push(current);\n current = makeContextRange(next, linecontext);\n }\n\n i++;\n }\n\n return out;\n}\n\n/**\n * Extracts lines from a file and stores them in a cache.\n */\nfunction getContextLinesFromFile(path: string, ranges: ReadlineRange[], output: Record<number, string>): Promise<void> {\n return new Promise((resolve, _reject) => {\n // It is important *not* to have any async code between createInterface and the 'line' event listener\n // as it will cause the 'line' event to\n // be emitted before the listener is attached.\n const stream = createReadStream(path);\n const lineReaded = createInterface({\n input: stream,\n });\n\n // We need to explicitly destroy the stream to prevent memory leaks,\n // removing the listeners on the readline interface is not enough.\n // See: https://github.com/nodejs/node/issues/9002 and https://github.com/getsentry/sentry-javascript/issues/14892\n function destroyStreamAndResolve(): void {\n stream.destroy();\n resolve();\n }\n\n // Init at zero and increment at the start of the loop because lines are 1 indexed.\n let lineNumber = 0;\n let currentRangeIndex = 0;\n const range = ranges[currentRangeIndex];\n if (range === undefined) {\n // We should never reach this point, but if we do, we should resolve the promise to prevent it from hanging.\n destroyStreamAndResolve();\n return;\n }\n let rangeStart = range[0];\n let rangeEnd = range[1];\n\n // We use this inside Promise.all, so we need to resolve the promise even if there is an error\n // to prevent Promise.all from short circuiting the rest.\n function onStreamError(e: Error): void {\n // Mark file path as failed to read and prevent multiple read attempts.\n LRU_FILE_CONTENTS_FS_READ_FAILED.set(path, 1);\n DEBUG_BUILD && debug.error(`Failed to read file: ${path}. Error: ${e}`);\n lineReaded.close();\n lineReaded.removeAllListeners();\n destroyStreamAndResolve();\n }\n\n // We need to handle the error event to prevent the process from crashing in < Node 16\n // https://github.com/nodejs/node/pull/31603\n stream.on('error', onStreamError);\n lineReaded.on('error', onStreamError);\n lineReaded.on('close', destroyStreamAndResolve);\n\n lineReaded.on('line', line => {\n lineNumber++;\n if (lineNumber < rangeStart) return;\n\n // !Warning: This mutates the cache by storing the snipped line into the cache.\n output[lineNumber] = snipLine(line, 0);\n\n if (lineNumber >= rangeEnd) {\n if (currentRangeIndex === ranges.length - 1) {\n // We need to close the file stream and remove listeners, else the reader will continue to run our listener;\n lineReaded.close();\n lineReaded.removeAllListeners();\n return;\n }\n currentRangeIndex++;\n const range = ranges[currentRangeIndex];\n if (range === undefined) {\n // This should never happen as it means we have a bug in the context.\n lineReaded.close();\n lineReaded.removeAllListeners();\n return;\n }\n rangeStart = range[0];\n rangeEnd = range[1];\n }\n });\n });\n}\n\n/**\n * Adds surrounding (context) lines of the line that an exception occurred on to the event.\n * This is done by reading the file line by line and extracting the lines. The extracted lines are stored in\n * a cache to prevent multiple reads of the same file. Failures to read a file are similarly cached to prevent multiple\n * failing reads from happening.\n */\n/* eslint-disable complexity */\nasync function addSourceContext(event: Event, contextLines: number): Promise<Event> {\n // keep a lookup map of which files we've already enqueued to read,\n // so we don't enqueue the same file multiple times which would cause multiple i/o reads\n const filesToLines: Record<string, number[]> = {};\n\n if (contextLines > 0 && event.exception?.values) {\n for (const exception of event.exception.values) {\n if (!exception.stacktrace?.frames?.length) {\n continue;\n }\n\n // Maps preserve insertion order, so we iterate in reverse, starting at the\n // outermost frame and closer to where the exception has occurred (poor mans priority)\n for (let i = exception.stacktrace.frames.length - 1; i >= 0; i--) {\n const frame: StackFrame | undefined = exception.stacktrace.frames[i];\n const filename = frame?.filename;\n\n if (\n !frame ||\n typeof filename !== 'string' ||\n typeof frame.lineno !== 'number' ||\n shouldSkipContextLinesForFile(filename) ||\n shouldSkipContextLinesForFrame(frame)\n ) {\n continue;\n }\n\n const filesToLinesOutput = filesToLines[filename];\n if (!filesToLinesOutput) filesToLines[filename] = [];\n // @ts-expect-error this is defined above\n filesToLines[filename].push(frame.lineno);\n }\n }\n }\n\n const files = Object.keys(filesToLines);\n if (files.length == 0) {\n return event;\n }\n\n const readlinePromises: Promise<void>[] = [];\n for (const file of files) {\n // If we failed to read this before, dont try reading it again.\n if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) {\n continue;\n }\n\n const filesToLineRanges = filesToLines[file];\n if (!filesToLineRanges) {\n continue;\n }\n\n // Sort ranges so that they are sorted by line increasing order and match how the file is read.\n filesToLineRanges.sort((a, b) => a - b);\n // Check if the contents are already in the cache and if we can avoid reading the file again.\n const ranges = makeLineReaderRanges(filesToLineRanges, contextLines);\n if (ranges.every(r => rangeExistsInContentCache(file, r))) {\n continue;\n }\n\n const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});\n readlinePromises.push(getContextLinesFromFile(file, ranges, cache));\n }\n\n // The promise rejections are caught in order to prevent them from short circuiting Promise.all\n await Promise.all(readlinePromises).catch(() => {\n DEBUG_BUILD && debug.log('Failed to read one or more source files and resolve context lines');\n });\n\n // Perform the same loop as above, but this time we can assume all files are in the cache\n // and attempt to add source context to frames.\n if (contextLines > 0 && event.exception?.values) {\n for (const exception of event.exception.values) {\n if (exception.stacktrace?.frames && exception.stacktrace.frames.length > 0) {\n addSourceContextToFrames(exception.stacktrace.frames, contextLines, LRU_FILE_CONTENTS_CACHE);\n }\n }\n }\n\n return event;\n}\n/* eslint-enable complexity */\n\n/** Adds context lines to frames */\nfunction addSourceContextToFrames(\n frames: StackFrame[],\n contextLines: number,\n cache: LRUMap<string, Record<number, string>>,\n): void {\n for (const frame of frames) {\n // Only add context if we have a filename and it hasn't already been added\n if (frame.filename && frame.context_line === undefined && typeof frame.lineno === 'number') {\n const contents = cache.get(frame.filename);\n if (contents === undefined) {\n continue;\n }\n\n addContextToFrame(frame.lineno, frame, contextLines, contents);\n }\n }\n}\n\n/**\n * Clears the context lines from a frame, used to reset a frame to its original state\n * if we fail to resolve all context lines for it.\n */\nfunction clearLineContext(frame: StackFrame): void {\n delete frame.pre_context;\n delete frame.context_line;\n delete frame.post_context;\n}\n\n/**\n * Resolves context lines before and after the given line number and appends them to the frame;\n */\nexport function addContextToFrame(\n lineno: number,\n frame: StackFrame,\n contextLines: number,\n contents: Record<number, string> | undefined,\n): void {\n // When there is no line number in the frame, attaching context is nonsensical and will even break grouping.\n // We already check for lineno before calling this, but since StackFrame lineno ism optional, we check it again.\n if (frame.lineno === undefined || contents === undefined) {\n DEBUG_BUILD && debug.error('Cannot resolve context for frame with no lineno or file contents');\n return;\n }\n\n frame.pre_context = [];\n for (let i = makeRangeStart(lineno, contextLines); i < lineno; i++) {\n // We always expect the start context as line numbers cannot be negative. If we dont find a line, then\n // something went wrong somewhere. Clear the context and return without adding any linecontext.\n const line = contents[i];\n if (line === undefined) {\n clearLineContext(frame);\n DEBUG_BUILD && debug.error(`Could not find line ${i} in file ${frame.filename}`);\n return;\n }\n\n frame.pre_context.push(line);\n }\n\n // We should always have the context line. If we dont, something went wrong, so we clear the context and return\n // without adding any linecontext.\n if (contents[lineno] === undefined) {\n clearLineContext(frame);\n DEBUG_BUILD && debug.error(`Could not find line ${lineno} in file ${frame.filename}`);\n return;\n }\n\n frame.context_line = contents[lineno];\n\n const end = makeRangeEnd(lineno, contextLines);\n frame.post_context = [];\n for (let i = lineno + 1; i <= end; i++) {\n // Since we dont track when the file ends, we cant clear the context if we dont find a line as it could\n // just be that we reached the end of the file.\n const line = contents[i];\n if (line === undefined) {\n break;\n }\n frame.post_context.push(line);\n }\n}\n\n// Helper functions for generating line context ranges. They take a line number and the number of lines of context to\n// include before and after the line and generate an inclusive range of indices.\ntype ReadlineRange = [start: number, end: number];\n// Compute inclusive end context range\nfunction makeRangeStart(line: number, linecontext: number): number {\n return Math.max(1, line - linecontext);\n}\n// Compute inclusive start context range\nfunction makeRangeEnd(line: number, linecontext: number): number {\n return line + linecontext;\n}\n// Determine start and end indices for context range (inclusive);\nfunction makeContextRange(line: number, linecontext: number): [start: number, end: number] {\n return [makeRangeStart(line, linecontext), makeRangeEnd(line, linecontext)];\n}\n\n/** Exported only for tests, as a type-safe variant. */\nexport const _contextLinesIntegration = ((options: ContextLinesOptions = {}) => {\n return {\n name: INTEGRATION_NAME,\n processEvent(event, _hint, client) {\n const contextLines =\n options.frameContextLines ?? client?.getDataCollectionOptions().frameContextLines ?? DEFAULT_LINES_OF_CONTEXT;\n return addSourceContext(event, contextLines);\n },\n };\n}) satisfies IntegrationFn;\n\n/**\n * Capture the lines before and after the frame's context.\n */\nexport const contextLinesIntegration = defineIntegration(_contextLinesIntegration);\n"],"names":["LRUMap","createReadStream","createInterface","DEBUG_BUILD","debug","snipLine","range","defineIntegration"],"mappings":"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"}
1
+ {"version":3,"file":"contextlines.js","sources":["../../../src/integrations/contextlines.ts"],"sourcesContent":["import { createReadStream } from 'node:fs';\nimport { createInterface } from 'node:readline';\nimport type { Event, IntegrationFn, StackFrame } from '@sentry/core';\nimport { debug, defineIntegration, LRUMap, snipLine } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\n\nconst LRU_FILE_CONTENTS_CACHE = new LRUMap<string, Record<number, string>>(10);\nconst LRU_FILE_CONTENTS_FS_READ_FAILED = new LRUMap<string, 1>(20);\nconst DEFAULT_LINES_OF_CONTEXT = 5;\nconst INTEGRATION_NAME = 'ContextLines' as const;\n// Determines the upper bound of lineno/colno that we will attempt to read. Large colno values are likely to be\n// minified code while large lineno values are likely to be bundled code.\n// Exported for testing purposes.\nexport const MAX_CONTEXTLINES_COLNO: number = 1000;\nexport const MAX_CONTEXTLINES_LINENO: number = 10000;\n\ninterface ContextLinesOptions {\n /**\n * Sets the number of context lines for each frame when loading a file.\n * Defaults to `dataCollection.frameContextLines` (5).\n *\n * Set to 0 to disable loading and inclusion of source files.\n *\n * When set, this option takes precedence over `dataCollection.frameContextLines`.\n **/\n frameContextLines?: number;\n}\n\n/**\n * Exported for testing purposes.\n */\nexport function resetFileContentCache(): void {\n LRU_FILE_CONTENTS_CACHE.clear();\n}\n\n/**\n * Get or init map value\n */\nfunction emplace<T extends LRUMap<K, V>, K extends string, V>(map: T, key: K, contents: V): V {\n const value = map.get(key);\n\n if (value === undefined) {\n map.set(key, contents);\n return contents;\n }\n\n return value;\n}\n\n/**\n * Determines if context lines should be skipped for a file.\n * - .min.(mjs|cjs|js) files are and not useful since they dont point to the original source\n * - node: prefixed modules are part of the runtime and cannot be resolved to a file\n * - data: skip json, wasm and inline js https://nodejs.org/api/esm.html#data-imports\n */\nfunction shouldSkipContextLinesForFile(path: string): boolean {\n // Test the most common prefix and extension first. These are the ones we\n // are most likely to see in user applications and are the ones we can break out of first.\n if (path.startsWith('node:')) return true;\n if (path.endsWith('.min.js')) return true;\n if (path.endsWith('.min.cjs')) return true;\n if (path.endsWith('.min.mjs')) return true;\n if (path.startsWith('data:')) return true;\n return false;\n}\n\n/**\n * Determines if we should skip contextlines based off the max lineno and colno values.\n */\nfunction shouldSkipContextLinesForFrame(frame: StackFrame): boolean {\n if (frame.lineno !== undefined && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;\n if (frame.colno !== undefined && frame.colno > MAX_CONTEXTLINES_COLNO) return true;\n return false;\n}\n/**\n * Checks if we have all the contents that we need in the cache.\n */\nfunction rangeExistsInContentCache(file: string, range: ReadlineRange): boolean {\n const contents = LRU_FILE_CONTENTS_CACHE.get(file);\n if (contents === undefined) return false;\n\n for (let i = range[0]; i <= range[1]; i++) {\n if (contents[i] === undefined) {\n return false;\n }\n }\n\n return true;\n}\n\n/**\n * Creates contiguous ranges of lines to read from a file. In the case where context lines overlap,\n * the ranges are merged to create a single range.\n */\nfunction makeLineReaderRanges(lines: number[], linecontext: number): ReadlineRange[] {\n if (!lines.length) {\n return [];\n }\n\n let i = 0;\n const line = lines[0];\n\n if (typeof line !== 'number') {\n return [];\n }\n\n let current = makeContextRange(line, linecontext);\n const out: ReadlineRange[] = [];\n // eslint-disable-next-line no-constant-condition\n while (true) {\n if (i === lines.length - 1) {\n out.push(current);\n break;\n }\n\n // If the next line falls into the current range, extend the current range to lineno + linecontext.\n const next = lines[i + 1];\n if (typeof next !== 'number') {\n break;\n }\n if (next <= current[1]) {\n current[1] = next + linecontext;\n } else {\n out.push(current);\n current = makeContextRange(next, linecontext);\n }\n\n i++;\n }\n\n return out;\n}\n\n/**\n * Extracts lines from a file and stores them in a cache.\n */\nfunction getContextLinesFromFile(path: string, ranges: ReadlineRange[], output: Record<number, string>): Promise<void> {\n return new Promise((resolve, _reject) => {\n // It is important *not* to have any async code between createInterface and the 'line' event listener\n // as it will cause the 'line' event to\n // be emitted before the listener is attached.\n const stream = createReadStream(path);\n const lineReaded = createInterface({\n input: stream,\n });\n\n // We need to explicitly destroy the stream to prevent memory leaks,\n // removing the listeners on the readline interface is not enough.\n // See: https://github.com/nodejs/node/issues/9002 and https://github.com/getsentry/sentry-javascript/issues/14892\n function destroyStreamAndResolve(): void {\n stream.destroy();\n resolve();\n }\n\n // Init at zero and increment at the start of the loop because lines are 1 indexed.\n let lineNumber = 0;\n let currentRangeIndex = 0;\n const range = ranges[currentRangeIndex];\n if (range === undefined) {\n // We should never reach this point, but if we do, we should resolve the promise to prevent it from hanging.\n destroyStreamAndResolve();\n return;\n }\n let rangeStart = range[0];\n let rangeEnd = range[1];\n\n // We use this inside Promise.all, so we need to resolve the promise even if there is an error\n // to prevent Promise.all from short circuiting the rest.\n function onStreamError(e: Error): void {\n // Mark file path as failed to read and prevent multiple read attempts.\n LRU_FILE_CONTENTS_FS_READ_FAILED.set(path, 1);\n DEBUG_BUILD && debug.error(`Failed to read file: ${path}. Error: ${e}`);\n lineReaded.close();\n lineReaded.removeAllListeners();\n destroyStreamAndResolve();\n }\n\n // We need to handle the error event to prevent the process from crashing in < Node 16\n // https://github.com/nodejs/node/pull/31603\n stream.on('error', onStreamError);\n lineReaded.on('error', onStreamError);\n lineReaded.on('close', destroyStreamAndResolve);\n\n lineReaded.on('line', line => {\n lineNumber++;\n if (lineNumber < rangeStart) return;\n\n // !Warning: This mutates the cache by storing the snipped line into the cache.\n output[lineNumber] = snipLine(line, 0);\n\n if (lineNumber >= rangeEnd) {\n if (currentRangeIndex === ranges.length - 1) {\n // We need to close the file stream and remove listeners, else the reader will continue to run our listener;\n lineReaded.close();\n lineReaded.removeAllListeners();\n return;\n }\n currentRangeIndex++;\n const range = ranges[currentRangeIndex];\n if (range === undefined) {\n // This should never happen as it means we have a bug in the context.\n lineReaded.close();\n lineReaded.removeAllListeners();\n return;\n }\n rangeStart = range[0];\n rangeEnd = range[1];\n }\n });\n });\n}\n\n/**\n * Adds surrounding (context) lines of the line that an exception occurred on to the event.\n * This is done by reading the file line by line and extracting the lines. The extracted lines are stored in\n * a cache to prevent multiple reads of the same file. Failures to read a file are similarly cached to prevent multiple\n * failing reads from happening.\n */\n/* eslint-disable complexity */\nasync function addSourceContext(event: Event, contextLines: number): Promise<Event> {\n // keep a lookup map of which files we've already enqueued to read,\n // so we don't enqueue the same file multiple times which would cause multiple i/o reads\n const filesToLines: Record<string, number[]> = {};\n\n if (contextLines > 0 && event.exception?.values) {\n for (const exception of event.exception.values) {\n if (!exception.stacktrace?.frames?.length) {\n continue;\n }\n\n // Maps preserve insertion order, so we iterate in reverse, starting at the\n // outermost frame and closer to where the exception has occurred (poor mans priority)\n for (let i = exception.stacktrace.frames.length - 1; i >= 0; i--) {\n const frame: StackFrame | undefined = exception.stacktrace.frames[i];\n const filename = frame?.filename;\n\n if (\n !frame ||\n typeof filename !== 'string' ||\n typeof frame.lineno !== 'number' ||\n shouldSkipContextLinesForFile(filename) ||\n shouldSkipContextLinesForFrame(frame)\n ) {\n continue;\n }\n\n const filesToLinesOutput = filesToLines[filename];\n if (!filesToLinesOutput) filesToLines[filename] = [];\n // @ts-expect-error this is defined above\n filesToLines[filename].push(frame.lineno);\n }\n }\n }\n\n const files = Object.keys(filesToLines);\n if (files.length == 0) {\n return event;\n }\n\n const readlinePromises: Promise<void>[] = [];\n for (const file of files) {\n // If we failed to read this before, dont try reading it again.\n if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) {\n continue;\n }\n\n const filesToLineRanges = filesToLines[file];\n if (!filesToLineRanges) {\n continue;\n }\n\n // Sort ranges so that they are sorted by line increasing order and match how the file is read.\n filesToLineRanges.sort((a, b) => a - b);\n // Check if the contents are already in the cache and if we can avoid reading the file again.\n const ranges = makeLineReaderRanges(filesToLineRanges, contextLines);\n if (ranges.every(r => rangeExistsInContentCache(file, r))) {\n continue;\n }\n\n const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});\n readlinePromises.push(getContextLinesFromFile(file, ranges, cache));\n }\n\n // The promise rejections are caught in order to prevent them from short circuiting Promise.all\n await Promise.all(readlinePromises).catch(() => {\n DEBUG_BUILD && debug.log('Failed to read one or more source files and resolve context lines');\n });\n\n // Perform the same loop as above, but this time we can assume all files are in the cache\n // and attempt to add source context to frames.\n if (contextLines > 0 && event.exception?.values) {\n for (const exception of event.exception.values) {\n if (exception.stacktrace?.frames && exception.stacktrace.frames.length > 0) {\n addSourceContextToFrames(exception.stacktrace.frames, contextLines, LRU_FILE_CONTENTS_CACHE);\n }\n }\n }\n\n return event;\n}\n/* eslint-enable complexity */\n\n/** Adds context lines to frames */\nfunction addSourceContextToFrames(\n frames: StackFrame[],\n contextLines: number,\n cache: LRUMap<string, Record<number, string>>,\n): void {\n for (const frame of frames) {\n // Only add context if we have a filename and it hasn't already been added\n if (frame.filename && frame.context_line === undefined && typeof frame.lineno === 'number') {\n const contents = cache.get(frame.filename);\n if (contents === undefined) {\n continue;\n }\n\n addContextToFrame(frame.lineno, frame, contextLines, contents);\n }\n }\n}\n\n/**\n * Clears the context lines from a frame, used to reset a frame to its original state\n * if we fail to resolve all context lines for it.\n */\nfunction clearLineContext(frame: StackFrame): void {\n delete frame.pre_context;\n delete frame.context_line;\n delete frame.post_context;\n}\n\n/**\n * Resolves context lines before and after the given line number and appends them to the frame;\n */\nexport function addContextToFrame(\n lineno: number,\n frame: StackFrame,\n contextLines: number,\n contents: Record<number, string> | undefined,\n): void {\n // When there is no line number in the frame, attaching context is nonsensical and will even break grouping.\n // We already check for lineno before calling this, but since StackFrame lineno ism optional, we check it again.\n if (frame.lineno === undefined || contents === undefined) {\n DEBUG_BUILD && debug.error('Cannot resolve context for frame with no lineno or file contents');\n return;\n }\n\n frame.pre_context = [];\n for (let i = makeRangeStart(lineno, contextLines); i < lineno; i++) {\n // We always expect the start context as line numbers cannot be negative. If we dont find a line, then\n // something went wrong somewhere. Clear the context and return without adding any linecontext.\n const line = contents[i];\n if (line === undefined) {\n clearLineContext(frame);\n DEBUG_BUILD && debug.error(`Could not find line ${i} in file ${frame.filename}`);\n return;\n }\n\n frame.pre_context.push(line);\n }\n\n // We should always have the context line. If we dont, something went wrong, so we clear the context and return\n // without adding any linecontext.\n if (contents[lineno] === undefined) {\n clearLineContext(frame);\n DEBUG_BUILD && debug.error(`Could not find line ${lineno} in file ${frame.filename}`);\n return;\n }\n\n frame.context_line = contents[lineno];\n\n const end = makeRangeEnd(lineno, contextLines);\n frame.post_context = [];\n for (let i = lineno + 1; i <= end; i++) {\n // Since we dont track when the file ends, we cant clear the context if we dont find a line as it could\n // just be that we reached the end of the file.\n const line = contents[i];\n if (line === undefined) {\n break;\n }\n frame.post_context.push(line);\n }\n}\n\n// Helper functions for generating line context ranges. They take a line number and the number of lines of context to\n// include before and after the line and generate an inclusive range of indices.\ntype ReadlineRange = [start: number, end: number];\n// Compute inclusive end context range\nfunction makeRangeStart(line: number, linecontext: number): number {\n return Math.max(1, line - linecontext);\n}\n// Compute inclusive start context range\nfunction makeRangeEnd(line: number, linecontext: number): number {\n return line + linecontext;\n}\n// Determine start and end indices for context range (inclusive);\nfunction makeContextRange(line: number, linecontext: number): [start: number, end: number] {\n return [makeRangeStart(line, linecontext), makeRangeEnd(line, linecontext)];\n}\n\n/** Exported only for tests, as a type-safe variant. */\nexport const _contextLinesIntegration = ((options: ContextLinesOptions = {}) => {\n return {\n name: INTEGRATION_NAME,\n processEvent(event, _hint, client) {\n const contextLines =\n options.frameContextLines ?? client?.getDataCollectionOptions().frameContextLines ?? DEFAULT_LINES_OF_CONTEXT;\n return addSourceContext(event, contextLines);\n },\n };\n}) satisfies IntegrationFn;\n\n/**\n * Capture the lines before and after the frame's context.\n */\nexport const contextLinesIntegration = defineIntegration(_contextLinesIntegration);\n"],"names":["LRUMap","createReadStream","createInterface","DEBUG_BUILD","debug","snipLine","range","defineIntegration"],"mappings":"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"}
package/build/cjs/integrations/local-variables/local-variables-async.js CHANGED
@@ -5,7 +5,7 @@ const core = require('@sentry/core');
5
5
  const debug = require('../../utils/debug.js');
6
6
  const common = require('./common.js');
7
7
 
8
- const base64WorkerScript = "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";
8
+ const base64WorkerScript = "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";
9
9
  function log(...args) {
10
10
  core.debug.log("[LocalVariables]", ...args);
11
11
  }
package/build/cjs/integrations/node-fetch/undici-instrumentation.js CHANGED
@@ -9,14 +9,15 @@ const op = require('@sentry/conventions/op');
9
9
  const debugBuild = require('../../debug-build.js');
10
10
 
11
11
  const ATTR_HTTP_REQUEST_METHOD_ORIGINAL = "http.request.method_original";
12
- const _channelSubs = [];
12
+ let _isInstrumented = false;
13
13
  const spanFromReq = /* @__PURE__ */ new WeakMap();
14
14
  const ignoreRequestMap = /* @__PURE__ */ new WeakMap();
15
15
  const propagationDecisionMap = new core.LRUMap(100);
16
16
  function instrumentUndici(config = {}) {
17
- if (_channelSubs.length) {
17
+ if (_isInstrumented) {
18
18
  return;
19
19
  }
20
+ _isInstrumented = true;
20
21
  subscribeToChannel("undici:request:create", (message) => onRequestCreated(config, message));
21
22
  subscribeToChannel(
22
23
  "undici:client:sendHeaders",
@@ -27,7 +28,7 @@ function instrumentUndici(config = {}) {
27
28
  subscribeToChannel("undici:request:error", (message) => onError(message));
28
29
  }
29
30
  function subscribeToChannel(diagnosticChannel, onMessage) {
30
- _channelSubs.push(diagch.subscribe?.(diagnosticChannel, onMessage));
31
+ diagch.subscribe?.(diagnosticChannel, onMessage);
31
32
  }
32
33
  function parseRequestHeaders(request) {
33
34
  const result = /* @__PURE__ */ new Map();