@sentry/profiling-node 8.39.0-dev.0 → 8.41.0-beta.0

package/bindings/cpu_profiler.cc

@@ -333,9 +333,8 @@ void SentryProfile::Start(Profiler *profiler) {
 
   // Initialize the CPU Profiler
   profiler->cpu_profiler->StartProfiling(
-      profile_title,
-      {v8::CpuProfilingMode::kCallerLineNumbers,
-       v8::CpuProfilingOptions::kNoSampleLimit, kSamplingInterval});
+      profile_title, v8::CpuProfilingMode::kCallerLineNumbers, true,
+      v8::CpuProfilingOptions::kNoSampleLimit);
 
   // listen for memory sample ticks
   profiler->measurements_ticker.add_cpu_listener(id, cpu_sampler_cb);
@@ -1169,6 +1168,7 @@ napi_value Init(napi_env env, napi_value exports) {
   }
 
   Profiler *profiler = new Profiler(env, isolate);
+  profiler->cpu_profiler->SetSamplingInterval(kSamplingInterval);
 
   if (napi_set_instance_data(env, profiler, FreeAddonData, NULL) != napi_ok) {
     napi_throw_error(env, nullptr, "Failed to set instance data for profiler.");

package/lib/cjs/index.js

@@ -2,12 +2,11 @@ var {
   _nullishCoalesce,
   _optionalChain,
   _optionalChainDelete
-} = require('@sentry/utils');
+} = require('@sentry/core');
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const core = require('@sentry/core');
-const utils = require('@sentry/utils');
 const node_os = require('node:os');
 const node_path = require('node:path');
 const node_process = require('node:process');
@@ -171,7 +170,7 @@ const PrivateCpuProfilerBindings = importCppBindingsModule();
 class Bindings  {
    startProfiling(name) {
     if (!PrivateCpuProfilerBindings) {
-      DEBUG_BUILD && utils.logger.log('[Profiling] Bindings not loaded, ignoring call to startProfiling.');
+      DEBUG_BUILD && core.logger.log('[Profiling] Bindings not loaded, ignoring call to startProfiling.');
       return;
     }
 
@@ -184,7 +183,7 @@ class Bindings  {
   ) {
     if (!PrivateCpuProfilerBindings) {
       DEBUG_BUILD &&
-        utils.logger.log('[Profiling] Bindings not loaded or profile was never started, ignoring call to stopProfiling.');
+        core.logger.log('[Profiling] Bindings not loaded or profile was never started, ignoring call to stopProfiling.');
       return null;
     }
 
@@ -192,14 +191,14 @@ class Bindings  {
       name,
       format ,
       node_worker_threads.threadId,
-      !!utils.GLOBAL_OBJ._sentryDebugIds,
+      !!core.GLOBAL_OBJ._sentryDebugIds,
     );
   }
 }
 
 const CpuProfilerBindings = new Bindings();
 
-const NODE_VERSION = utils.parseSemver(process.versions.node) ;
+const NODE_VERSION = core.parseSemver(process.versions.node) ;
 const NODE_MAJOR = NODE_VERSION.major;
 
 function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }function _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/* eslint-disable max-lines */
@@ -307,7 +306,7 @@ function createProfilePayload(
   // All profiles and transactions are rejected if this is the case and we want to
   // warn users that this is happening if they enable debug flag
   if (trace_id && trace_id.length !== 32) {
-    DEBUG_BUILD && utils.logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
+    DEBUG_BUILD && core.logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
   }
 
   const enrichedThreadProfile = enrichWithThreadInformation(cpuProfile);
@@ -375,7 +374,7 @@ function createProfileChunkPayload(
   // All profiles and transactions are rejected if this is the case and we want to
   // warn users that this is happening if they enable debug flag
   if (trace_id && trace_id.length !== 32) {
-    DEBUG_BUILD && utils.logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
+    DEBUG_BUILD && core.logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
   }
 
   const enrichedThreadProfile = enrichWithThreadInformation(cpuProfile);
@@ -434,7 +433,7 @@ function isValidSampleRate(rate) {
   // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck
   if ((typeof rate !== 'number' && typeof rate !== 'boolean') || (typeof rate === 'number' && isNaN(rate))) {
     DEBUG_BUILD &&
-      utils.logger.warn(
+      core.logger.warn(
         `[Profiling] Invalid sample rate. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(
           rate,
         )} of type ${JSON.stringify(typeof rate)}.`,
@@ -449,7 +448,7 @@ function isValidSampleRate(rate) {
 
   // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false
   if (rate < 0 || rate > 1) {
-    DEBUG_BUILD && utils.logger.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
+    DEBUG_BUILD && core.logger.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
     return false;
   }
   return true;
@@ -466,7 +465,7 @@ function isValidProfile(profile) {
       // Log a warning if the profile has less than 2 samples so users can know why
       // they are not seeing any profiling data and we cant avoid the back and forth
       // of asking them to provide us with a dump of the profile data.
-      utils.logger.log('[Profiling] Discarding profile because it contains less than 2 samples');
+      core.logger.log('[Profiling] Discarding profile because it contains less than 2 samples');
     return false;
   }
 
@@ -488,7 +487,7 @@ function isValidProfileChunk(profile) {
       // Log a warning if the profile has less than 2 samples so users can know why
       // they are not seeing any profiling data and we cant avoid the back and forth
       // of asking them to provide us with a dump of the profile data.
-      utils.logger.log('[Profiling] Discarding profile chunk because it contains less than 2 samples');
+      core.logger.log('[Profiling] Discarding profile chunk because it contains less than 2 samples');
     return false;
   }
 
@@ -521,7 +520,7 @@ function addProfilesToEnvelope(envelope, profiles) {
 function findProfiledTransactionsFromEnvelope(envelope) {
   const events = [];
 
-  utils.forEachEnvelopeItem(envelope, (item, type) => {
+  core.forEachEnvelopeItem(envelope, (item, type) => {
     if (type !== 'transaction') {
       return;
     }
@@ -557,10 +556,10 @@ function createEventEnvelopeHeaders(
   dsn,
 ) {
   return {
-    event_id: utils.uuid4(),
+    event_id: core.uuid4(),
     sent_at: new Date().toISOString(),
     ...(sdkInfo && { sdk: sdkInfo }),
-    ...(!!tunnel && dsn && { dsn: utils.dsnToString(dsn) }),
+    ...(!!tunnel && dsn && { dsn: core.dsnToString(dsn) }),
   };
 }
 
@@ -577,7 +576,7 @@ function makeProfileChunkEnvelope(
     type: 'profile_chunk',
   };
 
-  return utils.createEnvelope(createEventEnvelopeHeaders(sdkInfo, tunnel, dsn), [
+  return core.createEnvelope(createEventEnvelopeHeaders(sdkInfo, tunnel, dsn), [
     [profileChunkHeader, chunk],
   ]);
 }
@@ -594,7 +593,7 @@ function applyDebugMetadata(client, resource_paths) {
     return [];
   }
 
-  return utils.getDebugImagesForResources(options.stackParser, resource_paths);
+  return core.getDebugImagesForResources(options.stackParser, resource_paths);
 }
 
 const MAX_PROFILE_DURATION_MS = 30 * 1000;
@@ -617,13 +616,13 @@ function maybeProfileSpan(
 
   // Client and options are required for profiling
   if (!client) {
-    DEBUG_BUILD && utils.logger.log('[Profiling] Profiling disabled, no client found.');
+    DEBUG_BUILD && core.logger.log('[Profiling] Profiling disabled, no client found.');
     return;
   }
 
   const options = client.getOptions();
   if (!options) {
-    DEBUG_BUILD && utils.logger.log('[Profiling] Profiling disabled, no options found.');
+    DEBUG_BUILD && core.logger.log('[Profiling] Profiling disabled, no options found.');
     return;
   }
 
@@ -651,14 +650,14 @@ function maybeProfileSpan(
   // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The
   // only valid values are booleans or numbers between 0 and 1.)
   if (!isValidSampleRate(profilesSampleRate)) {
-    DEBUG_BUILD && utils.logger.warn('[Profiling] Discarding profile because of invalid sample rate.');
+    DEBUG_BUILD && core.logger.warn('[Profiling] Discarding profile because of invalid sample rate.');
     return;
   }
 
   // if the function returned 0 (or false), or if `profileSampleRate` is 0, it's a sign the profile should be dropped
   if (!profilesSampleRate) {
     DEBUG_BUILD &&
-      utils.logger.log(
+      core.logger.log(
         `[Profiling] Discarding profile because ${
           typeof profilesSampler === 'function'
             ? 'profileSampler returned 0 or false'
@@ -674,7 +673,7 @@ function maybeProfileSpan(
   // Check if we should sample this profile
   if (!sampled) {
     DEBUG_BUILD &&
-      utils.logger.log(
+      core.logger.log(
         `[Profiling] Discarding profile because it's not included in the random sample (sampling rate = ${Number(
           profilesSampleRate,
         )})`,
@@ -682,9 +681,9 @@ function maybeProfileSpan(
     return;
   }
 
-  const profile_id = utils.uuid4();
+  const profile_id = core.uuid4();
   CpuProfilerBindings.startProfiling(profile_id);
-  DEBUG_BUILD && utils.logger.log(`[Profiling] started profiling transaction: ${core.spanToJSON(span).description}`);
+  DEBUG_BUILD && core.logger.log(`[Profiling] started profiling transaction: ${core.spanToJSON(span).description}`);
 
   // set transaction context - do this regardless if profiling fails down the line
   // so that we can still see the profile_id in the transaction context
@@ -704,12 +703,12 @@ function stopSpanProfile(span, profile_id) {
   }
 
   const profile = CpuProfilerBindings.stopProfiling(profile_id, 0);
-  DEBUG_BUILD && utils.logger.log(`[Profiling] stopped profiling of transaction: ${core.spanToJSON(span).description}`);
+  DEBUG_BUILD && core.logger.log(`[Profiling] stopped profiling of transaction: ${core.spanToJSON(span).description}`);
 
   // In case of an overlapping span, stopProfiling may return null and silently ignore the overlapping profile.
   if (!profile) {
     DEBUG_BUILD &&
-      utils.logger.log(
+      core.logger.log(
         `[Profiling] profiler returned null profile for: ${core.spanToJSON(span).description}`,
         'this may indicate an overlapping span or a call to stopProfiling with a profile title that was never started',
       );
@@ -729,7 +728,7 @@ var ProfileFormat;(function (ProfileFormat) {
 /* eslint-disable max-lines */
 
 const CHUNK_INTERVAL_MS = 5000;
-const PROFILE_MAP = new utils.LRUMap(50);
+const PROFILE_MAP = new core.LRUMap(50);
 const PROFILE_TIMEOUTS = {};
 
 function addToProfileQueue(profile_id, profile) {
@@ -772,7 +771,7 @@ function setupAutomatedSpanProfiling(client) {
       // Enqueue a timeout to prevent profiles from running over max duration.
       const timeout = global.setTimeout(() => {
         DEBUG_BUILD &&
-          utils.logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', core.spanToJSON(span).description);
+          core.logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', core.spanToJSON(span).description);
 
         const profile = stopSpanProfile(span, profile_id);
         if (profile) {
@@ -833,7 +832,7 @@ function setupAutomatedSpanProfiling(client) {
 
       const cpuProfile = takeFromProfileQueue(profile_id);
       if (!cpuProfile) {
-        DEBUG_BUILD && utils.logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
+        DEBUG_BUILD && core.logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
         continue;
       }
 
@@ -877,7 +876,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    */
    start() {
     if (!this._client) {
-      DEBUG_BUILD && utils.logger.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
+      DEBUG_BUILD && core.logger.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
       return;
     }
 
@@ -895,7 +894,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    */
    stop() {
     if (!this._client) {
-      DEBUG_BUILD && utils.logger.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
+      DEBUG_BUILD && core.logger.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
       return;
     }
     this._chunkStop();
@@ -910,12 +909,12 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
       // The client is not attached to the profiler if the user has not enabled continuous profiling.
       // In this case, calling start() and stop() is a noop action.The reason this exists is because
       // it makes the types easier to work with and avoids users having to do null checks.
-      DEBUG_BUILD && utils.logger.log('[Profiling] Profiler was never attached to the client.');
+      DEBUG_BUILD && core.logger.log('[Profiling] Profiler was never attached to the client.');
       return;
     }
     if (this._chunkData) {
       DEBUG_BUILD &&
-        utils.logger.log(
+        core.logger.log(
           `[Profiling] Chunk with chunk_id ${this._chunkData.id} is still running, current chunk will be stopped a new chunk will be started.`,
         );
       this._chunkStop();
@@ -931,35 +930,35 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     if (_optionalChain([this, 'access', _6 => _6._chunkData, 'optionalAccess', _7 => _7.timer])) {
       global.clearTimeout(this._chunkData.timer);
       this._chunkData.timer = undefined;
-      DEBUG_BUILD && utils.logger.log(`[Profiling] Stopping profiling chunk: ${this._chunkData.id}`);
+      DEBUG_BUILD && core.logger.log(`[Profiling] Stopping profiling chunk: ${this._chunkData.id}`);
     }
     if (!this._client) {
       DEBUG_BUILD &&
-        utils.logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+        core.logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
       return;
     }
     if (!_optionalChain([this, 'access', _8 => _8._chunkData, 'optionalAccess', _9 => _9.id])) {
       DEBUG_BUILD &&
-        utils.logger.log(`[Profiling] Failed to collect profile for: ${_optionalChain([this, 'access', _10 => _10._chunkData, 'optionalAccess', _11 => _11.id])}, the chunk_id is missing.`);
+        core.logger.log(`[Profiling] Failed to collect profile for: ${_optionalChain([this, 'access', _10 => _10._chunkData, 'optionalAccess', _11 => _11.id])}, the chunk_id is missing.`);
       return;
     }
 
     const profile = CpuProfilerBindings.stopProfiling(this._chunkData.id, ProfileFormat.CHUNK);
 
     if (!profile) {
-      DEBUG_BUILD && utils.logger.log(`[Profiling] _chunkiledStartTraceID to collect profile for: ${this._chunkData.id}`);
+      DEBUG_BUILD && core.logger.log(`[Profiling] _chunkiledStartTraceID to collect profile for: ${this._chunkData.id}`);
       return;
     }
     if (!this._profilerId) {
       DEBUG_BUILD &&
-        utils.logger.log('[Profiling] Profile chunk does not contain a valid profiler_id, this is a bug in the SDK');
+        core.logger.log('[Profiling] Profile chunk does not contain a valid profiler_id, this is a bug in the SDK');
       return;
     }
     if (profile) {
-      DEBUG_BUILD && utils.logger.log(`[Profiling] Sending profile chunk ${this._chunkData.id}.`);
+      DEBUG_BUILD && core.logger.log(`[Profiling] Sending profile chunk ${this._chunkData.id}.`);
     }
 
-    DEBUG_BUILD && utils.logger.log(`[Profiling] Profile chunk ${this._chunkData.id} sent to Sentry.`);
+    DEBUG_BUILD && core.logger.log(`[Profiling] Profile chunk ${this._chunkData.id} sent to Sentry.`);
     const chunk = createProfilingChunkEvent(
       this._client,
       this._client.getOptions(),
@@ -973,7 +972,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     );
 
     if (!chunk) {
-      DEBUG_BUILD && utils.logger.log(`[Profiling] Failed to create profile chunk for: ${this._chunkData.id}`);
+      DEBUG_BUILD && core.logger.log(`[Profiling] Failed to create profile chunk for: ${this._chunkData.id}`);
       this._resetChunkData();
       return;
     }
@@ -993,13 +992,13 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _flush(chunk) {
     if (!this._client) {
       DEBUG_BUILD &&
-        utils.logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+        core.logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
       return;
     }
 
     const transport = this._client.getTransport();
     if (!transport) {
-      DEBUG_BUILD && utils.logger.log('[Profiling] No transport available to send profile chunk.');
+      DEBUG_BUILD && core.logger.log('[Profiling] No transport available to send profile chunk.');
       return;
     }
 
@@ -1009,7 +1008,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 
     const envelope = makeProfileChunkEnvelope(chunk, _optionalChain([metadata, 'optionalAccess', _16 => _16.sdk]), tunnel, dsn);
     transport.send(envelope).then(null, reason => {
-      DEBUG_BUILD && utils.logger.error('Error while sending profile chunk envelope:', reason);
+      DEBUG_BUILD && core.logger.error('Error while sending profile chunk envelope:', reason);
     });
   }
 
@@ -1023,12 +1022,12 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     const chunk = this._initializeChunk(traceId);
 
     CpuProfilerBindings.startProfiling(chunk.id);
-    DEBUG_BUILD && utils.logger.log(`[Profiling] starting profiling chunk: ${chunk.id}`);
+    DEBUG_BUILD && core.logger.log(`[Profiling] starting profiling chunk: ${chunk.id}`);
 
     chunk.timer = global.setTimeout(() => {
-      DEBUG_BUILD && utils.logger.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
+      DEBUG_BUILD && core.logger.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
       this._chunkStop();
-      DEBUG_BUILD && utils.logger.log('[Profiling] Starting new profiling chunk.');
+      DEBUG_BUILD && core.logger.log('[Profiling] Starting new profiling chunk.');
       setImmediate(this._chunkStart.bind(this));
     }, CHUNK_INTERVAL_MS);
 
@@ -1043,13 +1042,13 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _setupSpanChunkInstrumentation() {
     if (!this._client) {
       DEBUG_BUILD &&
-        utils.logger.log(
+        core.logger.log(
           '[Profiling] Failed to initialize span profiling, sentry client was never attached to the profiler.',
         );
       return;
     }
 
-    this._profilerId = utils.uuid4();
+    this._profilerId = core.uuid4();
     core.getGlobalScope().setContext('profile', {
       profiler_id: this._profilerId,
     });
@@ -1077,7 +1076,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    */
    _initializeChunk(traceId) {
     this._chunkData = {
-      id: utils.uuid4(),
+      id: core.uuid4(),
       startTraceID: traceId,
       timer: undefined,
     };
@@ -1119,7 +1118,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 /** Exported only for tests. */
 const _nodeProfilingIntegration = (() => {
   if (![16, 18, 20, 22].includes(NODE_MAJOR)) {
-    utils.consoleSandbox(() => {
+    core.consoleSandbox(() => {
       // eslint-disable-next-line no-console
       console.warn(
         `[Sentry Profiling] You are using a Node.js version that does not have prebuilt binaries (${NODE_VERSION}).`,
@@ -1134,7 +1133,7 @@ const _nodeProfilingIntegration = (() => {
     name: 'ProfilingIntegration',
     _profiler: new ContinuousProfiler(),
     setup(client) {
-      DEBUG_BUILD && utils.logger.log('[Profiling] Profiling integration setup.');
+      DEBUG_BUILD && core.logger.log('[Profiling] Profiling integration setup.');
       const options = client.getOptions();
 
       const mode =
@@ -1146,19 +1145,19 @@ const _nodeProfilingIntegration = (() => {
           : 'span';
       switch (mode) {
         case 'continuous': {
-          DEBUG_BUILD && utils.logger.log('[Profiling] Continuous profiler mode enabled.');
+          DEBUG_BUILD && core.logger.log('[Profiling] Continuous profiler mode enabled.');
           this._profiler.initialize(client);
           break;
         }
         // Default to span profiling when no mode profiler mode is set
         case 'span':
         case undefined: {
-          DEBUG_BUILD && utils.logger.log('[Profiling] Span profiler mode enabled.');
+          DEBUG_BUILD && core.logger.log('[Profiling] Span profiler mode enabled.');
           setupAutomatedSpanProfiling(client);
           break;
         }
         default: {
-          DEBUG_BUILD && utils.logger.warn(`[Profiling] Unknown profiler mode: ${mode}, profiler was not initialized`);
+          DEBUG_BUILD && core.logger.warn(`[Profiling] Unknown profiler mode: ${mode}, profiler was not initialized`);
         }
       }
     },

package/lib/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/lib/esm/index.js

@@ -1,6 +1,5 @@
-import { _nullishCoalesce, _optionalChain, _optionalChainDelete } from '@sentry/utils';
-import { spanIsSampled, spanToJSON, defineIntegration, getRootSpan, getCurrentScope, getIsolationScope, getGlobalScope } from '@sentry/core';
-import { logger, GLOBAL_OBJ, parseSemver, forEachEnvelopeItem, createEnvelope, getDebugImagesForResources, uuid4, dsnToString, LRUMap, consoleSandbox } from '@sentry/utils';
+import { _nullishCoalesce, _optionalChain, _optionalChainDelete } from '@sentry/core';
+import { logger, GLOBAL_OBJ, parseSemver, forEachEnvelopeItem, createEnvelope, getDebugImagesForResources, uuid4, dsnToString, spanIsSampled, spanToJSON, LRUMap, defineIntegration, consoleSandbox, getRootSpan, getCurrentScope, getIsolationScope, getGlobalScope } from '@sentry/core';
 import { platform as platform$1, arch as arch$1 } from 'node:os';
 import cjsPath, { resolve, join } from 'node:path';
 import { versions, env } from 'node:process';

package/lib/esm/index.js.map

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

package/lib/esm/package.json

@@ -1 +1 @@
-{"type":"module","version":"8.39.0-dev.0","sideEffects":false}
+{"type":"module","version":"8.41.0-beta.0","sideEffects":false}

package/lib/types/spanProfileUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spanProfileUtils.d.ts","sourceRoot":"","sources":["../../src/spanProfileUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAKjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD,eAAO,MAAM,uBAAuB,QAAY,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,IAAI,EAAE,IAAI,EACV,qBAAqB,CAAC,EAAE,qBAAqB,GAC5C,MAAM,GAAG,SAAS,CAkFpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB,GAAG,IAAI,CAsBtG"}
+{"version":3,"file":"spanProfileUtils.d.ts","sourceRoot":"","sources":["../../src/spanProfileUtils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAIjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD,eAAO,MAAM,uBAAuB,QAAY,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,IAAI,EAAE,IAAI,EACV,qBAAqB,CAAC,EAAE,qBAAqB,GAC5C,MAAM,GAAG,SAAS,CAkFpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB,GAAG,IAAI,CAsBtG"}

package/lib/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,MAAM,EAEN,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,OAAO,EACP,YAAY,EACZ,oBAAoB,EAEpB,OAAO,EACP,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAcvB,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAIvE,eAAO,MAAM,yBAAyB,QAAmB,CAAC;AAC1D,eAAO,MAAM,oBAAoB,QAAmC,CAAC;AA2BrE;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,0BAA0B,GAAG,kBAAkB,GAChG,gBAAgB,GAAG,0BAA0B,CAe/C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI,CAc/G;AAoID;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,EACnD,OAAO,EAAE,kBAAkB,EAC3B,GAAG,EAAE,OAAO,GAAG,SAAS,EACxB,WAAW,EAAE;IAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACnF,YAAY,GAAG,IAAI,CAarB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAuBxD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,IAAI,mBAAmB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAepH;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,IAAI,kBAAkB,CAW9F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,QAAQ,CAUvF;AAED;;;;GAIG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,EAAE,CA2BhF;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,GAAG,CAAC,EAAE,aAAa,GAClB,oBAAoB,CAOtB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,GAAG,CAAC,EAAE,aAAa,GAClB,oBAAoB,CAQtB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,UAAU,EAAE,CAQtG"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,MAAM,EAEN,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,OAAO,EACP,YAAY,EACZ,oBAAoB,EAEpB,OAAO,EACP,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAMvB,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAIvE,eAAO,MAAM,yBAAyB,QAAmB,CAAC;AAC1D,eAAO,MAAM,oBAAoB,QAAmC,CAAC;AA2BrE;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,0BAA0B,GAAG,kBAAkB,GAChG,gBAAgB,GAAG,0BAA0B,CAe/C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI,CAc/G;AAoID;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,EACnD,OAAO,EAAE,kBAAkB,EAC3B,GAAG,EAAE,OAAO,GAAG,SAAS,EACxB,WAAW,EAAE;IAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACnF,YAAY,GAAG,IAAI,CAarB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAuBxD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,IAAI,mBAAmB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAepH;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,IAAI,kBAAkB,CAW9F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,QAAQ,CAUvF;AAED;;;;GAIG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,EAAE,CA2BhF;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,GAAG,CAAC,EAAE,aAAa,GAClB,oBAAoB,CAOtB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,GAAG,CAAC,EAAE,aAAa,GAClB,oBAAoB,CAQtB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,UAAU,EAAE,CAQtG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/profiling-node",
-  "version": "8.39.0-dev.0",
+  "version": "8.41.0-beta.0",
   "description": "Official Sentry SDK for Node.js Profiling",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/profiling-node",
@@ -75,10 +75,9 @@
     "test": "cross-env SENTRY_PROFILER_BINARY_DIR=lib jest --config jest.config.js"
   },
   "dependencies": {
-    "@sentry/core": "8.39.0-dev.0",
-    "@sentry/node": "8.39.0-dev.0",
-    "@sentry/types": "8.39.0-dev.0",
-    "@sentry/utils": "8.39.0-dev.0",
+    "@sentry/core": "8.41.0-beta.0",
+    "@sentry/node": "8.41.0-beta.0",
+    "@sentry/types": "8.41.0-beta.0",
     "detect-libc": "^2.0.2",
     "node-abi": "^3.61.0"
   },