@sentry/node 11.0.0-alpha.1 → 11.0.0-alpha.2

package/build/cjs/bundler-plugin/esbuild.js.map

@@ -1 +1 @@
-{"version":3,"file":"esbuild.js","sources":["../../../src/bundler-plugin/esbuild.ts"],"sourcesContent":["import { sentryEsbuildPlugin as sentryEsbuildBundlerPlugin } from '@sentry/bundler-plugins/esbuild';\nimport type { SentryEsbuildPluginOptions as SentryEsbuildPluginOptionsBase } from '@sentry/bundler-plugins/esbuild';\nimport { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/esbuild';\n\nexport type SentryEsbuildPluginOptions = SentryEsbuildPluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: NonNullable<Parameters<typeof sentryOrchestrionPlugin>[0]>['instrumentations'];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\ntype EsbuildPlugin = ReturnType<typeof sentryOrchestrionPlugin>;\n\n/**\n * esbuild plugin that bundles the Sentry esbuild bundler plugin (source maps,\n * release injection, …) together with the code transformer\n * (build-time `diagnostics_channel` instrumentation for Node libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/esbuild` and accepts\n * the same options.\n * @example\n * ```ts\n * // build.mjs\n * import { sentryEsbuildPlugin } from '@sentry/node/esbuild';\n * await esbuild.build({ plugins: [sentryEsbuildPlugin({ org: '…', project: '…' })] });\n * ```\n */\nexport function sentryEsbuildPlugin(options?: SentryEsbuildPluginOptions): EsbuildPlugin {\n  const bundlerPlugin = sentryEsbuildBundlerPlugin(options) as EsbuildPlugin;\n  const orchestrionPlugin = sentryOrchestrionPlugin(options);\n\n  return {\n    name: 'sentry-node-esbuild',\n    async setup(build): Promise<void> {\n      await bundlerPlugin.setup(build);\n      await orchestrionPlugin.setup(build);\n    },\n  };\n}\n"],"names":["sentryEsbuildBundlerPlugin","sentryOrchestrionPlugin"],"mappings":";;;;;AAoCO,SAAS,oBAAoB,OAAA,EAAqD;AACvF,EAAA,MAAM,aAAA,GAAgBA,4BAA2B,OAAO,CAAA;AACxD,EAAA,MAAM,iBAAA,GAAoBC,kCAAwB,OAAO,CAAA;AAEzD,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,qBAAA;AAAA,IACN,MAAM,MAAM,KAAA,EAAsB;AAChC,MAAA,MAAM,aAAA,CAAc,MAAM,KAAK,CAAA;AAC/B,MAAA,MAAM,iBAAA,CAAkB,MAAM,KAAK,CAAA;AAAA,IACrC;AAAA,GACF;AACF;;;;"}
+{"version":3,"file":"esbuild.js","sources":["../../../src/bundler-plugin/esbuild.ts"],"sourcesContent":["import { sentryEsbuildPlugin as sentryEsbuildBundlerPlugin } from '@sentry/bundler-plugins/esbuild';\nimport type { SentryEsbuildPluginOptions as SentryEsbuildPluginOptionsBase } from '@sentry/bundler-plugins/esbuild';\nimport type { InstrumentationConfig } from '@sentry/server-utils';\nimport { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/esbuild';\nimport type { EsbuildPlugin } from '@sentry/server-utils/orchestrion/esbuild';\n\nexport type SentryEsbuildPluginOptions = SentryEsbuildPluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: InstrumentationConfig[];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\n/**\n * esbuild plugin that bundles the Sentry esbuild bundler plugin (source maps,\n * release injection, …) together with the code transformer\n * (build-time `diagnostics_channel` instrumentation for Node libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/esbuild` and accepts\n * the same options.\n * @example\n * ```ts\n * // build.mjs\n * import { sentryEsbuildPlugin } from '@sentry/node/esbuild';\n * await esbuild.build({ plugins: [sentryEsbuildPlugin({ org: '…', project: '…' })] });\n * ```\n */\nexport function sentryEsbuildPlugin(options?: SentryEsbuildPluginOptions): EsbuildPlugin {\n  const bundlerPlugin = sentryEsbuildBundlerPlugin(options) as EsbuildPlugin;\n  const orchestrionPlugin = sentryOrchestrionPlugin(options);\n\n  return {\n    name: 'sentry-node-esbuild',\n    async setup(build): Promise<void> {\n      await bundlerPlugin.setup(build);\n      await orchestrionPlugin.setup(build);\n    },\n  };\n}\n"],"names":["sentryEsbuildBundlerPlugin","sentryOrchestrionPlugin"],"mappings":";;;;;AAoCO,SAAS,oBAAoB,OAAA,EAAqD;AACvF,EAAA,MAAM,aAAA,GAAgBA,4BAA2B,OAAO,CAAA;AACxD,EAAA,MAAM,iBAAA,GAAoBC,kCAAwB,OAAO,CAAA;AAEzD,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,qBAAA;AAAA,IACN,MAAM,MAAM,KAAA,EAAsB;AAChC,MAAA,MAAM,aAAA,CAAc,MAAM,KAAK,CAAA;AAC/B,MAAA,MAAM,iBAAA,CAAkB,MAAM,KAAK,CAAA;AAAA,IACrC;AAAA,GACF;AACF;;;;"}

package/build/cjs/bundler-plugin/rollup.js.map

@@ -1 +1 @@
-{"version":3,"file":"rollup.js","sources":["../../../src/bundler-plugin/rollup.ts"],"sourcesContent":["import { sentryRollupPlugin as sentryRollupBundlerPlugin } from '@sentry/bundler-plugins/rollup';\nimport type { SentryRollupPluginOptions as SentryRollupPluginOptionsBase } from '@sentry/bundler-plugins/rollup';\nimport { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/rollup';\n\nexport type SentryRollupPluginOptions = SentryRollupPluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: NonNullable<Parameters<typeof sentryOrchestrionPlugin>[0]>['instrumentations'];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\ntype RollupPlugin = ReturnType<typeof sentryOrchestrionPlugin>;\n\n/**\n * Rollup plugin that bundles the Sentry Rollup bundler plugin (source maps,\n * release injection, bundle size optimizations, …) together with the\n * code transformer (build-time `diagnostics_channel` instrumentation\n * for Node libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/rollup` and accepts\n * the same options.\n * @example\n * ```ts\n * // rollup.config.js\n * import { sentryRollupPlugin } from '@sentry/node/rollup';\n * export default { plugins: [sentryRollupPlugin({ org: '…', project: '…' })] };\n * ```\n */\nexport function sentryRollupPlugin(options?: SentryRollupPluginOptions): RollupPlugin[] {\n  const bundlerPlugins = sentryRollupBundlerPlugin(options);\n  return [...bundlerPlugins, sentryOrchestrionPlugin(options)];\n}\n"],"names":["sentryRollupBundlerPlugin","sentryOrchestrionPlugin"],"mappings":";;;;;AAqCO,SAAS,mBAAmB,OAAA,EAAqD;AACtF,EAAA,MAAM,cAAA,GAAiBA,0BAA0B,OAAO,CAAA;AACxD,EAAA,OAAO,CAAC,GAAG,cAAA,EAAgBC,gCAAA,CAAwB,OAAO,CAAC,CAAA;AAC7D;;;;"}
+{"version":3,"file":"rollup.js","sources":["../../../src/bundler-plugin/rollup.ts"],"sourcesContent":["import { sentryRollupPlugin as sentryRollupBundlerPlugin } from '@sentry/bundler-plugins/rollup';\nimport type { SentryRollupPluginOptions as SentryRollupPluginOptionsBase } from '@sentry/bundler-plugins/rollup';\nimport type { InstrumentationConfig } from '@sentry/server-utils';\nimport { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/rollup';\nimport type { RollupPlugin } from '@sentry/server-utils/orchestrion/rollup';\n\nexport type SentryRollupPluginOptions = SentryRollupPluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: InstrumentationConfig[];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\n/**\n * Rollup plugin that bundles the Sentry Rollup bundler plugin (source maps,\n * release injection, bundle size optimizations, …) together with the\n * code transformer (build-time `diagnostics_channel` instrumentation\n * for Node libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/rollup` and accepts\n * the same options.\n * @example\n * ```ts\n * // rollup.config.js\n * import { sentryRollupPlugin } from '@sentry/node/rollup';\n * export default { plugins: [sentryRollupPlugin({ org: '…', project: '…' })] };\n * ```\n */\nexport function sentryRollupPlugin(options?: SentryRollupPluginOptions): RollupPlugin[] {\n  const bundlerPlugins = sentryRollupBundlerPlugin(options);\n  return [...bundlerPlugins, sentryOrchestrionPlugin(options)];\n}\n"],"names":["sentryRollupBundlerPlugin","sentryOrchestrionPlugin"],"mappings":";;;;;AAqCO,SAAS,mBAAmB,OAAA,EAAqD;AACtF,EAAA,MAAM,cAAA,GAAiBA,0BAA0B,OAAO,CAAA;AACxD,EAAA,OAAO,CAAC,GAAG,cAAA,EAAgBC,gCAAA,CAAwB,OAAO,CAAC,CAAA;AAC7D;;;;"}

package/build/cjs/bundler-plugin/vite.js.map

@@ -1 +1 @@
-{"version":3,"file":"vite.js","sources":["../../../src/bundler-plugin/vite.ts"],"sourcesContent":["import { sentryVitePlugin as sentryViteBundlerPlugin } from '@sentry/bundler-plugins/vite';\nimport type { SentryVitePluginOptions as SentryVitePluginOptionsBase } from '@sentry/bundler-plugins/vite';\nimport { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/vite';\n\nexport type SentryVitePluginOptions = SentryVitePluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: NonNullable<Parameters<typeof sentryOrchestrionPlugin>[0]>['instrumentations'];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\ntype VitePlugin = ReturnType<typeof sentryOrchestrionPlugin>;\n\n/**\n * Vite plugin that bundles the Sentry Vite bundler plugin (source maps, release\n * injection, bundle size optimizations, …) together with the code\n * transformer (build-time `diagnostics_channel` instrumentation for Node\n * libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/vite` and accepts the\n * same options.\n *\n * @example\n * ```ts\n * // vite.config.ts\n * import { sentryVitePlugin } from '@sentry/node/vite';\n * export default { plugins: [sentryVitePlugin({ org: '…', project: '…' })] };\n * ```\n */\nexport function sentryVitePlugin(options?: SentryVitePluginOptions): VitePlugin[] {\n  const bundlerPlugins = sentryViteBundlerPlugin(options);\n  return [...bundlerPlugins, sentryOrchestrionPlugin(options)];\n}\n"],"names":["sentryViteBundlerPlugin","sentryOrchestrionPlugin"],"mappings":";;;;;AAsCO,SAAS,iBAAiB,OAAA,EAAiD;AAChF,EAAA,MAAM,cAAA,GAAiBA,sBAAwB,OAAO,CAAA;AACtD,EAAA,OAAO,CAAC,GAAG,cAAA,EAAgBC,8BAAA,CAAwB,OAAO,CAAC,CAAA;AAC7D;;;;"}
+{"version":3,"file":"vite.js","sources":["../../../src/bundler-plugin/vite.ts"],"sourcesContent":["import { sentryVitePlugin as sentryViteBundlerPlugin } from '@sentry/bundler-plugins/vite';\nimport type { SentryVitePluginOptions as SentryVitePluginOptionsBase } from '@sentry/bundler-plugins/vite';\nimport type { InstrumentationConfig } from '@sentry/server-utils';\nimport { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/vite';\nimport type { VitePlugin } from '@sentry/server-utils/orchestrion/vite';\n\nexport type SentryVitePluginOptions = SentryVitePluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: InstrumentationConfig[];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\n/**\n * Vite plugin that bundles the Sentry Vite bundler plugin (source maps, release\n * injection, bundle size optimizations, …) together with the code\n * transformer (build-time `diagnostics_channel` instrumentation for Node\n * libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/vite` and accepts the\n * same options.\n *\n * @example\n * ```ts\n * // vite.config.ts\n * import { sentryVitePlugin } from '@sentry/node/vite';\n * export default { plugins: [sentryVitePlugin({ org: '…', project: '…' })] };\n * ```\n */\nexport function sentryVitePlugin(options?: SentryVitePluginOptions): VitePlugin[] {\n  const bundlerPlugins = sentryViteBundlerPlugin(options);\n  return [...bundlerPlugins, sentryOrchestrionPlugin(options)];\n}\n"],"names":["sentryViteBundlerPlugin","sentryOrchestrionPlugin"],"mappings":";;;;;AAsCO,SAAS,iBAAiB,OAAA,EAAiD;AAChF,EAAA,MAAM,cAAA,GAAiBA,sBAAwB,OAAO,CAAA;AACtD,EAAA,OAAO,CAAC,GAAG,cAAA,EAAgBC,8BAAA,CAAwB,OAAO,CAAC,CAAA;AAC7D;;;;"}

package/build/cjs/bundler-plugin/webpack.js.map

@@ -1 +1 @@
-{"version":3,"file":"webpack.js","sources":["../../../src/bundler-plugin/webpack.ts"],"sourcesContent":["import { sentryWebpackPlugin as sentryWebpackBundlerPlugin } from '@sentry/bundler-plugins/webpack';\nimport type { SentryWebpackPluginOptions as SentryWebpackPluginOptionsBase } from '@sentry/bundler-plugins/webpack';\nimport { sentryOrchestrionWebpackPlugin } from '@sentry/server-utils/orchestrion/webpack';\n\nexport type SentryWebpackPluginOptions = SentryWebpackPluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: NonNullable<Parameters<typeof sentryOrchestrionWebpackPlugin>[0]>['instrumentations'];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\ntype WebpackCompiler = Parameters<ReturnType<typeof sentryWebpackBundlerPlugin>['apply']>[0];\n\n/**\n * webpack plugin that bundles the Sentry webpack bundler plugin (source maps,\n * release injection, …) together with the code transformer\n * (build-time `diagnostics_channel` instrumentation for Node libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/webpack` and accepts\n * the same options.\n * @example\n * ```ts\n * // webpack.config.mjs\n * import { sentryWebpackPlugin } from '@sentry/node/webpack';\n * export default { plugins: [sentryWebpackPlugin({ org: '…', project: '…' })] };\n * ```\n */\nexport function sentryWebpackPlugin(options?: SentryWebpackPluginOptions): {\n  apply: (compiler: WebpackCompiler) => void;\n} {\n  const bundlerPlugin = sentryWebpackBundlerPlugin(options) as { apply: (compiler: WebpackCompiler) => void };\n  const orchestrionPlugin = sentryOrchestrionWebpackPlugin(options) as { apply: (compiler: WebpackCompiler) => void };\n\n  return {\n    apply(compiler: WebpackCompiler): void {\n      bundlerPlugin.apply(compiler);\n      orchestrionPlugin.apply(compiler);\n    },\n  };\n}\n"],"names":["sentryWebpackBundlerPlugin","sentryOrchestrionWebpackPlugin"],"mappings":";;;;;AAoCO,SAAS,oBAAoB,OAAA,EAElC;AACA,EAAA,MAAM,aAAA,GAAgBA,4BAA2B,OAAO,CAAA;AACxD,EAAA,MAAM,iBAAA,GAAoBC,yCAA+B,OAAO,CAAA;AAEhE,EAAA,OAAO;AAAA,IACL,MAAM,QAAA,EAAiC;AACrC,MAAA,aAAA,CAAc,MAAM,QAAQ,CAAA;AAC5B,MAAA,iBAAA,CAAkB,MAAM,QAAQ,CAAA;AAAA,IAClC;AAAA,GACF;AACF;;;;"}
+{"version":3,"file":"webpack.js","sources":["../../../src/bundler-plugin/webpack.ts"],"sourcesContent":["import { sentryWebpackPlugin as sentryWebpackBundlerPlugin } from '@sentry/bundler-plugins/webpack';\nimport type { SentryWebpackPluginOptions as SentryWebpackPluginOptionsBase } from '@sentry/bundler-plugins/webpack';\nimport type { InstrumentationConfig } from '@sentry/server-utils';\nimport { sentryOrchestrionWebpackPlugin } from '@sentry/server-utils/orchestrion/webpack';\n\nexport type SentryWebpackPluginOptions = SentryWebpackPluginOptionsBase & {\n  /**\n   * @ignore This is for internal use only when this plugin is consumed by a framework SDK\n   */\n  instrumentations?: InstrumentationConfig[];\n\n  /**\n   * Automatic instrumentation of server-side dependencies at build time.\n   *\n   * Set to `false` to turn it off.\n   *\n   * @default true\n   */\n  buildTimeInstrumentation?: boolean;\n};\n\ntype WebpackCompiler = Parameters<ReturnType<typeof sentryWebpackBundlerPlugin>['apply']>[0];\n\n/**\n * webpack plugin that bundles the Sentry webpack bundler plugin (source maps,\n * release injection, …) together with the code transformer\n * (build-time `diagnostics_channel` instrumentation for Node libraries).\n *\n * It is a drop-in replacement for `@sentry/bundler-plugins/webpack` and accepts\n * the same options.\n * @example\n * ```ts\n * // webpack.config.mjs\n * import { sentryWebpackPlugin } from '@sentry/node/webpack';\n * export default { plugins: [sentryWebpackPlugin({ org: '…', project: '…' })] };\n * ```\n */\nexport function sentryWebpackPlugin(options?: SentryWebpackPluginOptions): {\n  apply: (compiler: WebpackCompiler) => void;\n} {\n  const bundlerPlugin = sentryWebpackBundlerPlugin(options) as { apply: (compiler: WebpackCompiler) => void };\n  const orchestrionPlugin = sentryOrchestrionWebpackPlugin(options) as { apply: (compiler: WebpackCompiler) => void };\n\n  return {\n    apply(compiler: WebpackCompiler): void {\n      bundlerPlugin.apply(compiler);\n      orchestrionPlugin.apply(compiler);\n    },\n  };\n}\n"],"names":["sentryWebpackBundlerPlugin","sentryOrchestrionWebpackPlugin"],"mappings":";;;;;AAqCO,SAAS,oBAAoB,OAAA,EAElC;AACA,EAAA,MAAM,aAAA,GAAgBA,4BAA2B,OAAO,CAAA;AACxD,EAAA,MAAM,iBAAA,GAAoBC,yCAA+B,OAAO,CAAA;AAEhE,EAAA,OAAO;AAAA,IACL,MAAM,QAAA,EAAiC;AACrC,MAAA,aAAA,CAAc,MAAM,QAAQ,CAAA;AAC5B,MAAA,iBAAA,CAAkB,MAAM,QAAQ,CAAA;AAAA,IAClC;AAAA,GACF;AACF;;;;"}

package/build/cjs/index.js

@@ -1,23 +1,19 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const index$6 = require('./integrations/http/index.js');
-const index$8 = require('./integrations/node-fetch/index.js');
-const index$3 = require('./integrations/fs/index.js');
-const express = require('./integrations/tracing/express.js');
-const index$2 = require('./integrations/tracing/fastify/index.js');
-const orchestrion = require('@sentry/server-utils/orchestrion');
-const index$9 = require('./integrations/tracing/redis/index.js');
+const index$5 = require('./integrations/http/index.js');
+const index$7 = require('./integrations/node-fetch/index.js');
+const index$2 = require('./integrations/fs/index.js');
 const serverUtils = require('@sentry/server-utils');
-const index$a = require('./integrations/tracing/hapi/index.js');
-const index$b = require('./integrations/tracing/koa/index.js');
+const hapi = require('./integrations/tracing/hapi.js');
+const koa = require('./integrations/tracing/koa.js');
 const launchDarkly = require('./integrations/featureFlagShims/launchDarkly.js');
 const openFeature = require('./integrations/featureFlagShims/openFeature.js');
 const statsig = require('./integrations/featureFlagShims/statsig.js');
 const unleash = require('./integrations/featureFlagShims/unleash.js');
 const growthbook = require('./integrations/featureFlagShims/growthbook.js');
-const index$5 = require('./sdk/index.js');
+const index$4 = require('./sdk/index.js');
 const initOtel = require('./sdk/initOtel.js');
-const index$4 = require('./integrations/tracing/index.js');
+const index$3 = require('./integrations/tracing/index.js');
 const opentelemetry = require('@sentry/opentelemetry');
 const core = require('@sentry/core');
 const exports$1 = require('./logs/exports.js');
@@ -25,7 +21,7 @@ const childProcess = require('./integrations/childProcess.js');
 const console = require('./integrations/console.js');
 const context = require('./integrations/context.js');
 const contextlines = require('./integrations/contextlines.js');
-const index$7 = require('./integrations/local-variables/index.js');
+const index$6 = require('./integrations/local-variables/index.js');
 const modules = require('./integrations/modules.js');
 const nodeRuntimeMetrics = require('./integrations/nodeRuntimeMetrics.js');
 const onuncaughtexception = require('./integrations/onuncaughtexception.js');
@@ -34,11 +30,13 @@ const pino = require('./integrations/pino.js');
 const spotlight = require('./integrations/spotlight.js');
 const systemError = require('./integrations/systemError.js');
 const winston = require('./integrations/winston.js');
+const workerThreads = require('./integrations/workerThreads.js');
 const index$1 = require('./cron/index.js');
 const nodeVersion = require('./nodeVersion.js');
 const api = require('./sdk/api.js');
 const http = require('./transports/http.js');
 const module$1 = require('./utils/module.js');
+const attributes = require('@sentry/conventions/attributes');
 const httpServerIntegration = require('./integrations/http/httpServerIntegration.js');
 const httpServerSpansIntegration = require('./integrations/http/httpServerSpansIntegration.js');
 const processSession = require('./integrations/processSession.js');
@@ -47,49 +45,50 @@ const index = require('./integrations/anr/index.js');
 
 
 
-exports.httpIntegration = index$6.httpIntegration;
-exports.nativeNodeFetchIntegration = index$8.nativeNodeFetchIntegration;
-exports.fsIntegration = index$3.fsIntegration;
-exports.setupExpressErrorHandler = express.setupExpressErrorHandler;
-exports.fastifyIntegration = index$2.fastifyIntegration;
-exports.setupFastifyErrorHandler = index$2.setupFastifyErrorHandler;
-exports.amqplibIntegration = orchestrion.amqplibIntegration;
-exports.anthropicAIIntegration = orchestrion.anthropicIntegration;
-exports.dataloaderIntegration = orchestrion.dataloaderIntegration;
-exports.expressIntegration = orchestrion.expressIntegration;
-exports.firebaseIntegration = orchestrion.firebaseIntegration;
-exports.genericPoolIntegration = orchestrion.genericPoolIntegration;
-exports.googleGenAIIntegration = orchestrion.googleGenAIIntegration;
-exports.graphqlIntegration = orchestrion.graphqlDiagnosticsIntegration;
-exports.hapiIntegration = orchestrion.hapiIntegration;
-exports.kafkaIntegration = orchestrion.kafkajsIntegration;
-exports.knexIntegration = orchestrion.knexIntegration;
-exports.koaIntegration = orchestrion.koaIntegration;
-exports.langChainIntegration = orchestrion.langChainIntegration;
-exports.langGraphIntegration = orchestrion.langGraphIntegration;
-exports.lruMemoizerIntegration = orchestrion.lruMemoizerIntegration;
-exports.mongoIntegration = orchestrion.mongodbIntegration;
-exports.mongooseIntegration = orchestrion.mongooseIntegration;
-exports.mysql2Integration = orchestrion.mysql2Integration;
-exports.mysqlIntegration = orchestrion.mysqlIntegration;
-exports.openAIIntegration = orchestrion.openaiIntegration;
-exports.postgresIntegration = orchestrion.postgresIntegration;
-exports.postgresJsIntegration = orchestrion.postgresJsIntegration;
-exports.tediousIntegration = orchestrion.tediousIntegration;
-exports.vercelAIIntegration = orchestrion.vercelAiIntegration;
-exports.redisIntegration = index$9.redisIntegration;
+exports.httpIntegration = index$5.httpIntegration;
+exports.nativeNodeFetchIntegration = index$7.nativeNodeFetchIntegration;
+exports.fsIntegration = index$2.fsIntegration;
+exports.amqplibIntegration = serverUtils.amqplibIntegration;
+exports.anthropicAIIntegration = serverUtils.anthropicAIIntegration;
 exports.createLangChainCallbackHandler = serverUtils.createLangChainCallbackHandler;
+exports.dataloaderIntegration = serverUtils.dataloaderIntegration;
+exports.expressErrorHandler = serverUtils.expressErrorHandler;
+exports.expressIntegration = serverUtils.expressIntegration;
+exports.fastifyIntegration = serverUtils.fastifyIntegration;
+exports.firebaseIntegration = serverUtils.firebaseIntegration;
+exports.genericPoolIntegration = serverUtils.genericPoolIntegration;
 exports.getOtlpTracesEndpoint = serverUtils.getOtlpTracesEndpoint;
+exports.googleGenAIIntegration = serverUtils.googleGenAIIntegration;
+exports.graphqlIntegration = serverUtils.graphqlIntegration;
+exports.hapiIntegration = serverUtils.hapiIntegration;
 exports.instrumentAnthropicAiClient = serverUtils.instrumentAnthropicAiClient;
 exports.instrumentGoogleGenAIClient = serverUtils.instrumentGoogleGenAIClient;
 exports.instrumentLangChainEmbeddings = serverUtils.instrumentLangChainEmbeddings;
 exports.instrumentOpenAiClient = serverUtils.instrumentOpenAiClient;
 exports.instrumentStateGraph = serverUtils.instrumentStateGraph;
 exports.instrumentStateGraphCompile = serverUtils.instrumentStateGraphCompile;
+exports.kafkaIntegration = serverUtils.kafkaIntegration;
+exports.knexIntegration = serverUtils.knexIntegration;
+exports.koaIntegration = serverUtils.koaIntegration;
+exports.langChainIntegration = serverUtils.langChainIntegration;
+exports.langGraphIntegration = serverUtils.langGraphIntegration;
+exports.lruMemoizerIntegration = serverUtils.lruMemoizerIntegration;
+exports.mongoIntegration = serverUtils.mongoIntegration;
+exports.mongooseIntegration = serverUtils.mongooseIntegration;
+exports.mysql2Integration = serverUtils.mysql2Integration;
+exports.mysqlIntegration = serverUtils.mysqlIntegration;
+exports.openAIIntegration = serverUtils.openAIIntegration;
 exports.otlpIntegration = serverUtils.otlpIntegration;
+exports.postgresIntegration = serverUtils.postgresIntegration;
+exports.postgresJsIntegration = serverUtils.postgresJsIntegration;
 exports.prismaIntegration = serverUtils.prismaIntegration;
-exports.setupHapiErrorHandler = index$a.setupHapiErrorHandler;
-exports.setupKoaErrorHandler = index$b.setupKoaErrorHandler;
+exports.redisIntegration = serverUtils.redisIntegration;
+exports.setupExpressErrorHandler = serverUtils.setupExpressErrorHandler;
+exports.setupFastifyErrorHandler = serverUtils.setupFastifyErrorHandler;
+exports.tediousIntegration = serverUtils.tediousIntegration;
+exports.vercelAIIntegration = serverUtils.vercelAIIntegration;
+exports.setupHapiErrorHandler = hapi.setupHapiErrorHandler;
+exports.setupKoaErrorHandler = koa.setupKoaErrorHandler;
 exports.buildLaunchDarklyFlagUsedHandler = launchDarkly.buildLaunchDarklyFlagUsedHandlerShim;
 exports.launchDarklyIntegration = launchDarkly.launchDarklyIntegrationShim;
 exports.OpenFeatureIntegrationHook = openFeature.OpenFeatureIntegrationHookShim;
@@ -97,18 +96,17 @@ exports.openFeatureIntegration = openFeature.openFeatureIntegrationShim;
 exports.statsigIntegration = statsig.statsigIntegrationShim;
 exports.unleashIntegration = unleash.unleashIntegrationShim;
 exports.growthbookIntegration = growthbook.growthbookIntegrationShim;
-exports.getDefaultIntegrations = index$5.getDefaultIntegrations;
-exports.getDefaultIntegrationsWithoutPerformance = index$5.getDefaultIntegrationsWithoutPerformance;
-exports.init = index$5.init;
-exports.initWithoutDefaultIntegrations = index$5.initWithoutDefaultIntegrations;
+exports.getDefaultIntegrations = index$4.getDefaultIntegrations;
+exports.getDefaultIntegrationsWithoutPerformance = index$4.getDefaultIntegrationsWithoutPerformance;
+exports.init = index$4.init;
+exports.initWithoutDefaultIntegrations = index$4.initWithoutDefaultIntegrations;
 exports.initOpenTelemetry = initOtel.initOpenTelemetry;
-exports.getAutoPerformanceIntegrations = index$4.getAutoPerformanceIntegrations;
+exports.getAutoPerformanceIntegrations = index$3.getAutoPerformanceIntegrations;
 exports.setOpenTelemetryContextAsyncContextStrategy = opentelemetry.setOpenTelemetryContextAsyncContextStrategy;
 exports.SDK_VERSION = core.SDK_VERSION;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_OP = core.SEMANTIC_ATTRIBUTE_SENTRY_OP;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = core.SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE;
-exports.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE;
 exports.Scope = core.Scope;
 exports.addBreadcrumb = core.addBreadcrumb;
 exports.addEventProcessor = core.addEventProcessor;
@@ -129,7 +127,6 @@ exports.createTransport = core.createTransport;
 exports.dedupeIntegration = core.dedupeIntegration;
 exports.endSession = core.endSession;
 exports.eventFiltersIntegration = core.eventFiltersIntegration;
-exports.expressErrorHandler = core.expressErrorHandler;
 exports.extraErrorDataIntegration = core.extraErrorDataIntegration;
 exports.featureFlagsIntegration = core.featureFlagsIntegration;
 exports.flush = core.flush;
@@ -195,7 +192,7 @@ exports.childProcessIntegration = childProcess.childProcessIntegration;
 exports.consoleIntegration = console.consoleIntegration;
 exports.nodeContextIntegration = context.nodeContextIntegration;
 exports.contextLinesIntegration = contextlines.contextLinesIntegration;
-exports.localVariablesIntegration = index$7.localVariablesIntegration;
+exports.localVariablesIntegration = index$6.localVariablesIntegration;
 exports.modulesIntegration = modules.modulesIntegration;
 exports._INTERNAL_normalizeCollectionInterval = nodeRuntimeMetrics._INTERNAL_normalizeCollectionInterval;
 exports.nodeRuntimeMetricsIntegration = nodeRuntimeMetrics.nodeRuntimeMetricsIntegration;
@@ -205,12 +202,14 @@ exports.pinoIntegration = pino.pinoIntegration;
 exports.spotlightIntegration = spotlight.spotlightIntegration;
 exports.systemErrorIntegration = systemError.systemErrorIntegration;
 exports.createSentryWinstonTransport = winston.createSentryWinstonTransport;
+exports.workerThreadsIntegration = workerThreads.workerThreadsIntegration;
 exports.cron = index$1.cron;
 exports.NODE_VERSION = nodeVersion.NODE_VERSION;
 exports.defaultStackParser = api.defaultStackParser;
 exports.getSentryRelease = api.getSentryRelease;
 exports.makeNodeTransport = http.makeNodeTransport;
 exports.createGetModuleFromFilename = module$1.createGetModuleFromFilename;
+exports.SENTRY_SEGMENT_NAME_SOURCE = attributes.SENTRY_SEGMENT_NAME_SOURCE;
 exports.httpServerIntegration = httpServerIntegration.httpServerIntegration;
 exports.httpServerSpansIntegration = httpServerSpansIntegration.httpServerSpansIntegration;
 exports.processSessionIntegration = processSession.processSessionIntegration;

package/build/cjs/index.js.map

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

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

@@ -6,7 +6,7 @@ const core = require('@sentry/core');
 const debug = require('../../utils/debug.js');
 
 const { isPromise } = util.types;
-const base64WorkerScript = "/*! @sentry/node 11.0.0-alpha.1 (6ab7efd) | 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-alpha.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 j(t){return function(t,e){return N.call(t)===`[object ${e}]`}(t,"Object")}function C(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 k;function T(t){if(void 0!==k)return k?k(t):t();const e=Symbol.for("__SENTRY_SAFE_RANDOM_ID_WRAPPER__"),n=p;return e in n&&"function"==typeof n[e]?(k=n[e],k(t)):(k=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.j=this.j,t.C=this.C,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.k=this.k,t.T=this.T,t.refs={...this.refs},t}setClient(t){this.A=t}setLastEventId(t){this.k=t}getClient(){return this.A}lastEventId(){return this.k}addScopeListener(t){this.o.push(t)}addEventProcessor(t){return this.i.push(t),this}setUser(t){return this.p=t||{email:void 0,id:void 0,ip_address:void 0,username:void 0},this.C&&Z(this.C,{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.j=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.C=t:delete this.C,this.R(),this}getSession(){return this.C}update(t){if(!t)return this;const e="function"==typeof t?t(this):t,n=e instanceof K?e.getScopeData():j(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.j=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.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.j,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.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 C(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&&(C(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 jt;const Ct=Symbol("AgentBaseInternalState");class Ot extends(jt=s.Agent,jt){constructor(t){super(t),this[Ct]={}}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[Ct].currentSocket=o,super.createSocket(t,e,n)},n)}createConnection(){const t=this[Ct].currentSocket;if(this[Ct].currentSocket=void 0,!t)throw new Error("No socket was returned in the `connect()` function");return t}get defaultPort(){return this[Ct].defaultPort??("https:"===this.protocol?443:80)}set defaultPort(t){this[Ct]&&(this[Ct].defaultPort=t)}get protocol(){return this[Ct].protocol??(this.isSecureEndpoint()?"https:":"http:")}set protocol(t){this[Ct]&&(this[Ct].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 kt(...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??{},kt("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){kt("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 kt("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){kt("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=>{kt("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=void 0!==t.keepAlive&&t.keepAlive,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){return new Promise((h,p)=>{yt(()=>{let l=function(t){return new c({read(){this.push(t),this.push(null)}})}(f.body);const d={...t.headers};f.body.length>32768&&(d["content-encoding"]="gzip",l=l.pipe(u()));const g=r.startsWith("["),m=e.request({method:"POST",agent:n,headers:d,hostname:g?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;h({statusCode:t.statusCode,headers:{"retry-after":e,"x-sentry-rate-limits":Array.isArray(n)?n[0]||null:n}})});m.on("error",p),l.pipe(m)})})}}(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()});";
+const base64WorkerScript = "/*! @sentry/node 11.0.0-alpha.2 (a71a943) | 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-alpha.2";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()});";
 const DEFAULT_INTERVAL = 50;
 const DEFAULT_HANG_THRESHOLD = 5e3;
 function log(message, ...args) {

package/build/cjs/integrations/childProcess.js

@@ -13,11 +13,6 @@ const childProcessIntegration = core.defineIntegration((options = {}) => {
           captureChildProcessEvents(event.process, options);
         }
       });
-      diagnosticsChannel.channel("worker_threads").subscribe((event) => {
-        if (core.isObjectLike(event) && "worker" in event) {
-          captureWorkerThreadEvents(event.worker, options);
-        }
-      });
     }
   };
 });
@@ -57,25 +52,6 @@ function captureChildProcessEvents(child, options) {
     }
   });
 }
-function captureWorkerThreadEvents(worker, options) {
-  let threadId;
-  worker.on("online", () => {
-    threadId = worker.threadId;
-  }).on("error", (error) => {
-    if (options.captureWorkerErrors !== false) {
-      core.captureException(error, {
-        mechanism: { type: "auto.child_process.worker_thread", handled: false, data: { threadId: String(threadId) } }
-      });
-    } else {
-      core.addBreadcrumb({
-        category: "worker_thread",
-        message: `Worker thread errored with '${error.message}'`,
-        level: "error",
-        data: { threadId }
-      });
-    }
-  });
-}
 
 exports.childProcessIntegration = childProcessIntegration;
 //# sourceMappingURL=childProcess.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"childProcess.js","sources":["../../../src/integrations/childProcess.ts"],"sourcesContent":["import type { ChildProcess } from 'node:child_process';\nimport * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { Worker } from 'node:worker_threads';\nimport { addBreadcrumb, captureException, defineIntegration, isObjectLike } from '@sentry/core';\n\ninterface Options {\n  /**\n   * Whether to include child process arguments in breadcrumbs data.\n   *\n   * @default false\n   */\n  includeChildProcessArgs?: boolean;\n\n  /**\n   * Whether to capture errors from worker threads.\n   *\n   * @default true\n   */\n  captureWorkerErrors?: boolean;\n}\n\nconst INTEGRATION_NAME = 'ChildProcess' as const;\n\n/**\n * Capture breadcrumbs and events for child processes and worker threads.\n */\nexport const childProcessIntegration = defineIntegration((options: Options = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    setup() {\n      diagnosticsChannel.channel('child_process').subscribe((event: unknown) => {\n        if (isObjectLike(event) && 'process' in event) {\n          captureChildProcessEvents(event.process as ChildProcess, options);\n        }\n      });\n\n      diagnosticsChannel.channel('worker_threads').subscribe((event: unknown) => {\n        if (isObjectLike(event) && 'worker' in event) {\n          captureWorkerThreadEvents(event.worker as Worker, options);\n        }\n      });\n    },\n  };\n});\n\nfunction captureChildProcessEvents(child: ChildProcess, options: Options): void {\n  let hasExited = false;\n  let data: Record<string, unknown> | undefined;\n\n  child\n    .on('spawn', () => {\n      // This is Sentry getting macOS OS context\n      if (child.spawnfile === '/usr/bin/sw_vers') {\n        hasExited = true;\n        return;\n      }\n\n      data = { spawnfile: child.spawnfile };\n      if (options.includeChildProcessArgs) {\n        data.spawnargs = child.spawnargs;\n      }\n    })\n    .on('exit', code => {\n      if (!hasExited) {\n        hasExited = true;\n\n        // Only log for non-zero exit codes\n        if (code !== null && code !== 0) {\n          addBreadcrumb({\n            category: 'child_process',\n            message: `Child process exited with code '${code}'`,\n            level: code === 0 ? 'info' : 'warning',\n            data,\n          });\n        }\n      }\n    })\n    .on('error', error => {\n      if (!hasExited) {\n        hasExited = true;\n\n        addBreadcrumb({\n          category: 'child_process',\n          message: `Child process errored with '${error.message}'`,\n          level: 'error',\n          data,\n        });\n      }\n    });\n}\n\nfunction captureWorkerThreadEvents(worker: Worker, options: Options): void {\n  let threadId: number | undefined;\n\n  worker\n    .on('online', () => {\n      threadId = worker.threadId;\n    })\n    .on('error', error => {\n      if (options.captureWorkerErrors !== false) {\n        captureException(error, {\n          mechanism: { type: 'auto.child_process.worker_thread', handled: false, data: { threadId: String(threadId) } },\n        });\n      } else {\n        addBreadcrumb({\n          category: 'worker_thread',\n          message: `Worker thread errored with '${error.message}'`,\n          level: 'error',\n          data: { threadId },\n        });\n      }\n    });\n}\n"],"names":["defineIntegration","isObjectLike","addBreadcrumb","captureException"],"mappings":";;;;;AAqBA,MAAM,gBAAA,GAAmB,cAAA;AAKlB,MAAM,uBAAA,GAA0BA,sBAAA,CAAkB,CAAC,OAAA,GAAmB,EAAC,KAAM;AAClF,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,KAAA,GAAQ;AACN,MAAA,kBAAA,CAAmB,OAAA,CAAQ,eAAe,CAAA,CAAE,SAAA,CAAU,CAAC,KAAA,KAAmB;AACxE,QAAA,IAAIC,iBAAA,CAAa,KAAK,CAAA,IAAK,SAAA,IAAa,KAAA,EAAO;AAC7C,UAAA,yBAAA,CAA0B,KAAA,CAAM,SAAyB,OAAO,CAAA;AAAA,QAClE;AAAA,MACF,CAAC,CAAA;AAED,MAAA,kBAAA,CAAmB,OAAA,CAAQ,gBAAgB,CAAA,CAAE,SAAA,CAAU,CAAC,KAAA,KAAmB;AACzE,QAAA,IAAIA,iBAAA,CAAa,KAAK,CAAA,IAAK,QAAA,IAAY,KAAA,EAAO;AAC5C,UAAA,yBAAA,CAA0B,KAAA,CAAM,QAAkB,OAAO,CAAA;AAAA,QAC3D;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAC;AAED,SAAS,yBAAA,CAA0B,OAAqB,OAAA,EAAwB;AAC9E,EAAA,IAAI,SAAA,GAAY,KAAA;AAChB,EAAA,IAAI,IAAA;AAEJ,EAAA,KAAA,CACG,EAAA,CAAG,SAAS,MAAM;AAEjB,IAAA,IAAI,KAAA,CAAM,cAAc,kBAAA,EAAoB;AAC1C,MAAA,SAAA,GAAY,IAAA;AACZ,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,GAAO,EAAE,SAAA,EAAW,KAAA,CAAM,SAAA,EAAU;AACpC,IAAA,IAAI,QAAQ,uBAAA,EAAyB;AACnC,MAAA,IAAA,CAAK,YAAY,KAAA,CAAM,SAAA;AAAA,IACzB;AAAA,EACF,CAAC,CAAA,CACA,EAAA,CAAG,MAAA,EAAQ,CAAA,IAAA,KAAQ;AAClB,IAAA,IAAI,CAAC,SAAA,EAAW;AACd,MAAA,SAAA,GAAY,IAAA;AAGZ,MAAA,IAAI,IAAA,KAAS,IAAA,IAAQ,IAAA,KAAS,CAAA,EAAG;AAC/B,QAAAC,kBAAA,CAAc;AAAA,UACZ,QAAA,EAAU,eAAA;AAAA,UACV,OAAA,EAAS,mCAAmC,IAAI,CAAA,CAAA,CAAA;AAAA,UAChD,KAAA,EAAO,IAAA,KAAS,CAAA,GAAI,MAAA,GAAS,SAAA;AAAA,UAC7B;AAAA,SACD,CAAA;AAAA,MACH;AAAA,IACF;AAAA,EACF,CAAC,CAAA,CACA,EAAA,CAAG,OAAA,EAAS,CAAA,KAAA,KAAS;AACpB,IAAA,IAAI,CAAC,SAAA,EAAW;AACd,MAAA,SAAA,GAAY,IAAA;AAEZ,MAAAA,kBAAA,CAAc;AAAA,QACZ,QAAA,EAAU,eAAA;AAAA,QACV,OAAA,EAAS,CAAA,4BAAA,EAA+B,KAAA,CAAM,OAAO,CAAA,CAAA,CAAA;AAAA,QACrD,KAAA,EAAO,OAAA;AAAA,QACP;AAAA,OACD,CAAA;AAAA,IACH;AAAA,EACF,CAAC,CAAA;AACL;AAEA,SAAS,yBAAA,CAA0B,QAAgB,OAAA,EAAwB;AACzE,EAAA,IAAI,QAAA;AAEJ,EAAA,MAAA,CACG,EAAA,CAAG,UAAU,MAAM;AAClB,IAAA,QAAA,GAAW,MAAA,CAAO,QAAA;AAAA,EACpB,CAAC,CAAA,CACA,EAAA,CAAG,OAAA,EAAS,CAAA,KAAA,KAAS;AACpB,IAAA,IAAI,OAAA,CAAQ,wBAAwB,KAAA,EAAO;AACzC,MAAAC,qBAAA,CAAiB,KAAA,EAAO;AAAA,QACtB,SAAA,EAAW,EAAE,IAAA,EAAM,kCAAA,EAAoC,OAAA,EAAS,KAAA,EAAO,IAAA,EAAM,EAAE,QAAA,EAAU,MAAA,CAAO,QAAQ,CAAA,EAAE;AAAE,OAC7G,CAAA;AAAA,IACH,CAAA,MAAO;AACL,MAAAD,kBAAA,CAAc;AAAA,QACZ,QAAA,EAAU,eAAA;AAAA,QACV,OAAA,EAAS,CAAA,4BAAA,EAA+B,KAAA,CAAM,OAAO,CAAA,CAAA,CAAA;AAAA,QACrD,KAAA,EAAO,OAAA;AAAA,QACP,IAAA,EAAM,EAAE,QAAA;AAAS,OAClB,CAAA;AAAA,IACH;AAAA,EACF,CAAC,CAAA;AACL;;;;"}
+{"version":3,"file":"childProcess.js","sources":["../../../src/integrations/childProcess.ts"],"sourcesContent":["import type { ChildProcess } from 'node:child_process';\nimport * as diagnosticsChannel from 'node:diagnostics_channel';\nimport { addBreadcrumb, defineIntegration, isObjectLike } from '@sentry/core';\n\ninterface Options {\n  /**\n   * Whether to include child process arguments in breadcrumbs data.\n   *\n   * @default false\n   */\n  includeChildProcessArgs?: boolean;\n}\n\nconst INTEGRATION_NAME = 'ChildProcess' as const;\n\n/**\n * Capture breadcrumbs and events for child processes.\n * For worker thread events, use `workerThreadsIntegration()` instead.\n */\nexport const childProcessIntegration = defineIntegration((options: Options = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    setup() {\n      diagnosticsChannel.channel('child_process').subscribe((event: unknown) => {\n        if (isObjectLike(event) && 'process' in event) {\n          captureChildProcessEvents(event.process as ChildProcess, options);\n        }\n      });\n    },\n  };\n});\n\nfunction captureChildProcessEvents(child: ChildProcess, options: Options): void {\n  let hasExited = false;\n  let data: Record<string, unknown> | undefined;\n\n  child\n    .on('spawn', () => {\n      // This is Sentry getting macOS OS context\n      if (child.spawnfile === '/usr/bin/sw_vers') {\n        hasExited = true;\n        return;\n      }\n\n      data = { spawnfile: child.spawnfile };\n      if (options.includeChildProcessArgs) {\n        data.spawnargs = child.spawnargs;\n      }\n    })\n    .on('exit', code => {\n      if (!hasExited) {\n        hasExited = true;\n\n        // Only log for non-zero exit codes\n        if (code !== null && code !== 0) {\n          addBreadcrumb({\n            category: 'child_process',\n            message: `Child process exited with code '${code}'`,\n            level: code === 0 ? 'info' : 'warning',\n            data,\n          });\n        }\n      }\n    })\n    .on('error', error => {\n      if (!hasExited) {\n        hasExited = true;\n\n        addBreadcrumb({\n          category: 'child_process',\n          message: `Child process errored with '${error.message}'`,\n          level: 'error',\n          data,\n        });\n      }\n    });\n}\n"],"names":["defineIntegration","isObjectLike","addBreadcrumb"],"mappings":";;;;;AAaA,MAAM,gBAAA,GAAmB,cAAA;AAMlB,MAAM,uBAAA,GAA0BA,sBAAA,CAAkB,CAAC,OAAA,GAAmB,EAAC,KAAM;AAClF,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,KAAA,GAAQ;AACN,MAAA,kBAAA,CAAmB,OAAA,CAAQ,eAAe,CAAA,CAAE,SAAA,CAAU,CAAC,KAAA,KAAmB;AACxE,QAAA,IAAIC,iBAAA,CAAa,KAAK,CAAA,IAAK,SAAA,IAAa,KAAA,EAAO;AAC7C,UAAA,yBAAA,CAA0B,KAAA,CAAM,SAAyB,OAAO,CAAA;AAAA,QAClE;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAC;AAED,SAAS,yBAAA,CAA0B,OAAqB,OAAA,EAAwB;AAC9E,EAAA,IAAI,SAAA,GAAY,KAAA;AAChB,EAAA,IAAI,IAAA;AAEJ,EAAA,KAAA,CACG,EAAA,CAAG,SAAS,MAAM;AAEjB,IAAA,IAAI,KAAA,CAAM,cAAc,kBAAA,EAAoB;AAC1C,MAAA,SAAA,GAAY,IAAA;AACZ,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,GAAO,EAAE,SAAA,EAAW,KAAA,CAAM,SAAA,EAAU;AACpC,IAAA,IAAI,QAAQ,uBAAA,EAAyB;AACnC,MAAA,IAAA,CAAK,YAAY,KAAA,CAAM,SAAA;AAAA,IACzB;AAAA,EACF,CAAC,CAAA,CACA,EAAA,CAAG,MAAA,EAAQ,CAAA,IAAA,KAAQ;AAClB,IAAA,IAAI,CAAC,SAAA,EAAW;AACd,MAAA,SAAA,GAAY,IAAA;AAGZ,MAAA,IAAI,IAAA,KAAS,IAAA,IAAQ,IAAA,KAAS,CAAA,EAAG;AAC/B,QAAAC,kBAAA,CAAc;AAAA,UACZ,QAAA,EAAU,eAAA;AAAA,UACV,OAAA,EAAS,mCAAmC,IAAI,CAAA,CAAA,CAAA;AAAA,UAChD,KAAA,EAAO,IAAA,KAAS,CAAA,GAAI,MAAA,GAAS,SAAA;AAAA,UAC7B;AAAA,SACD,CAAA;AAAA,MACH;AAAA,IACF;AAAA,EACF,CAAC,CAAA,CACA,EAAA,CAAG,OAAA,EAAS,CAAA,KAAA,KAAS;AACpB,IAAA,IAAI,CAAC,SAAA,EAAW;AACd,MAAA,SAAA,GAAY,IAAA;AAEZ,MAAAA,kBAAA,CAAc;AAAA,QACZ,QAAA,EAAU,eAAA;AAAA,QACV,OAAA,EAAS,CAAA,4BAAA,EAA+B,KAAA,CAAM,OAAO,CAAA,CAAA,CAAA;AAAA,QACrD,KAAA,EAAO,OAAA;AAAA,QACP;AAAA,OACD,CAAA;AAAA,IACH;AAAA,EACF,CAAC,CAAA;AACL;;;;"}

package/build/cjs/integrations/fs/vendored/instrumentation.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const attributes = require('@sentry/conventions/attributes');
 const core = require('@sentry/core');
 const fs = require('fs');
 const util = require('util');
@@ -222,7 +223,7 @@ function enableFsInstrumentation(config = {}) {
 function recordError(span, error, config) {
   span.setStatus({ code: core.SPAN_STATUS_ERROR, message: "internal_error" });
   if (config.recordErrorMessagesAsSpanAttributes && error instanceof Error) {
-    span.setAttribute("fs_error", error.message);
+    span.setAttribute(attributes.ERROR_TYPE, error.code ?? error.name);
   }
 }