@sentry/profiling-node 9.38.0 → 9.39.0

package/build/esm/index.js

@@ -1,4 +1,4 @@
-import { parseSemver, forEachEnvelopeItem, createEnvelope, logger, dsnToString, uuid4, getDebugImagesForResources, spanIsSampled, spanToJSON, LRUMap, defineIntegration, consoleSandbox, getRootSpan, getIsolationScope, getCurrentScope, getGlobalScope } from '@sentry/core';
+import { parseSemver, forEachEnvelopeItem, createEnvelope, debug, dsnToString, uuid4, getDebugImagesForResources, spanIsSampled, spanToJSON, LRUMap, defineIntegration, consoleSandbox, getRootSpan, getIsolationScope, getCurrentScope, getGlobalScope } from '@sentry/core';
 import { CpuProfilerBindings, ProfileFormat } from '@sentry-internal/node-cpu-profiler';
 import * as os from 'os';
 import { env, versions } from 'process';
@@ -113,7 +113,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?.length !== 32) {
-    DEBUG_BUILD && logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
+    DEBUG_BUILD && debug.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
   }
 
   const enrichedThreadProfile = enrichWithThreadInformation(cpuProfile);
@@ -181,7 +181,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?.length !== 32) {
-    DEBUG_BUILD && logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
+    DEBUG_BUILD && debug.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
   }
 
   const enrichedThreadProfile = enrichWithThreadInformation(cpuProfile);
@@ -240,7 +240,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 &&
-      logger.warn(
+      debug.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)}.`,
@@ -255,7 +255,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 && logger.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
+    DEBUG_BUILD && debug.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
     return false;
   }
   return true;
@@ -272,7 +272,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.
-      logger.log('[Profiling] Discarding profile because it contains less than 2 samples');
+      debug.log('[Profiling] Discarding profile because it contains less than 2 samples');
     return false;
   }
 
@@ -294,7 +294,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.
-      logger.log('[Profiling] Discarding profile chunk because it contains less than 2 samples');
+      debug.log('[Profiling] Discarding profile chunk because it contains less than 2 samples');
     return false;
   }
 
@@ -424,13 +424,13 @@ function maybeProfileSpan(
 
   // Client and options are required for profiling
   if (!client) {
-    DEBUG_BUILD && logger.log('[Profiling] Profiling disabled, no client found.');
+    DEBUG_BUILD && debug.log('[Profiling] Profiling disabled, no client found.');
     return;
   }
 
   const options = client.getOptions();
   if (!options) {
-    DEBUG_BUILD && logger.log('[Profiling] Profiling disabled, no options found.');
+    DEBUG_BUILD && debug.log('[Profiling] Profiling disabled, no options found.');
     return;
   }
 
@@ -454,14 +454,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 && logger.warn('[Profiling] Discarding profile because of invalid sample rate.');
+    DEBUG_BUILD && debug.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 &&
-      logger.log(
+      debug.log(
         `[Profiling] Discarding profile because ${
           typeof profilesSampler === 'function'
             ? 'profileSampler returned 0 or false'
@@ -477,7 +477,7 @@ function maybeProfileSpan(
   // Check if we should sample this profile
   if (!sampled) {
     DEBUG_BUILD &&
-      logger.log(
+      debug.log(
         `[Profiling] Discarding profile because it's not included in the random sample (sampling rate = ${Number(
           profilesSampleRate,
         )})`,
@@ -487,7 +487,7 @@ function maybeProfileSpan(
 
   const profile_id = uuid4();
   CpuProfilerBindings.startProfiling(profile_id);
-  DEBUG_BUILD && logger.log(`[Profiling] started profiling transaction: ${spanToJSON(span).description}`);
+  DEBUG_BUILD && debug.log(`[Profiling] started profiling transaction: ${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
@@ -507,12 +507,12 @@ function stopSpanProfile(span, profile_id) {
   }
 
   const profile = CpuProfilerBindings.stopProfiling(profile_id, 0);
-  DEBUG_BUILD && logger.log(`[Profiling] stopped profiling of transaction: ${spanToJSON(span).description}`);
+  DEBUG_BUILD && debug.log(`[Profiling] stopped profiling of transaction: ${spanToJSON(span).description}`);
 
   // In case of an overlapping span, stopProfiling may return null and silently ignore the overlapping profile.
   if (!profile) {
     DEBUG_BUILD &&
-      logger.log(
+      debug.log(
         `[Profiling] profiler returned null profile for: ${spanToJSON(span).description}`,
         'this may indicate an overlapping span or a call to stopProfiling with a profile title that was never started',
       );
@@ -566,7 +566,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
         this._legacyProfilerMode =
           'profilesSampleRate' in options || 'profilesSampler' in options ? 'span' : 'continuous';
 
-        DEBUG_BUILD && logger.log(`[Profiling] Profiling mode is ${this._legacyProfilerMode}.`);
+        DEBUG_BUILD && debug.log(`[Profiling] Profiling mode is ${this._legacyProfilerMode}.`);
 
         switch (this._legacyProfilerMode) {
           case 'span': {
@@ -579,7 +579,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
           }
           default: {
             DEBUG_BUILD &&
-              logger.warn(
+              debug.warn(
                 `[Profiling] Unknown profiler mode: ${this._legacyProfilerMode}, profiler was not initialized`,
               );
             break;
@@ -591,7 +591,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
       case 'current': {
         this._setupSpanChunkInstrumentation();
 
-        DEBUG_BUILD && logger.log(`[Profiling] Profiling mode is ${this._profileLifecycle}.`);
+        DEBUG_BUILD && debug.log(`[Profiling] Profiling mode is ${this._profileLifecycle}.`);
 
         switch (this._profileLifecycle) {
           case 'trace': {
@@ -604,14 +604,14 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
           }
           default: {
             DEBUG_BUILD &&
-              logger.warn(`[Profiling] Unknown profiler mode: ${this._profileLifecycle}, profiler was not initialized`);
+              debug.warn(`[Profiling] Unknown profiler mode: ${this._profileLifecycle}, profiler was not initialized`);
             break;
           }
         }
         break;
       }
       default: {
-        DEBUG_BUILD && logger.warn(`[Profiling] Unknown profiler mode: ${this._mode}, profiler was not initialized`);
+        DEBUG_BUILD && debug.warn(`[Profiling] Unknown profiler mode: ${this._mode}, profiler was not initialized`);
         break;
       }
     }
@@ -633,17 +633,17 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     }
 
     if (!this._client) {
-      DEBUG_BUILD && logger.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
+      DEBUG_BUILD && debug.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
       return;
     }
 
     if (this._mode !== 'legacy') {
-      DEBUG_BUILD && logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
+      DEBUG_BUILD && debug.log('[Profiling] Continuous profiling is not supported in the current mode.');
       return;
     }
 
     if (this._legacyProfilerMode === 'span') {
-      DEBUG_BUILD && logger.log('[Profiling] Calls to profiler.start() are not supported in span profiling mode.');
+      DEBUG_BUILD && debug.log('[Profiling] Calls to profiler.start() are not supported in span profiling mode.');
       return;
     }
 
@@ -667,17 +667,17 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     }
 
     if (!this._client) {
-      DEBUG_BUILD && logger.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
+      DEBUG_BUILD && debug.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
       return;
     }
 
     if (this._mode !== 'legacy') {
-      DEBUG_BUILD && logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
+      DEBUG_BUILD && debug.log('[Profiling] Continuous profiling is not supported in the current mode.');
       return;
     }
 
     if (this._legacyProfilerMode === 'span') {
-      DEBUG_BUILD && logger.log('[Profiling] Calls to profiler.stop() are not supported in span profiling mode.');
+      DEBUG_BUILD && debug.log('[Profiling] Calls to profiler.stop() are not supported in span profiling mode.');
       return;
     }
 
@@ -687,25 +687,25 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 
    _startProfiler() {
     if (this._mode !== 'current') {
-      DEBUG_BUILD && logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
+      DEBUG_BUILD && debug.log('[Profiling] Continuous profiling is not supported in the current mode.');
       return;
     }
 
     if (this._chunkData !== undefined) {
-      DEBUG_BUILD && logger.log('[Profiling] Profile session already running, no-op.');
+      DEBUG_BUILD && debug.log('[Profiling] Profile session already running, no-op.');
       return;
     }
 
     if (this._mode === 'current') {
       if (!this._sampled) {
-        DEBUG_BUILD && logger.log('[Profiling] Profile session not sampled, no-op.');
+        DEBUG_BUILD && debug.log('[Profiling] Profile session not sampled, no-op.');
         return;
       }
     }
 
     if (this._profileLifecycle === 'trace') {
       DEBUG_BUILD &&
-        logger.log(
+        debug.log(
           '[Profiling] You are using the trace profile lifecycle, manual calls to profiler.startProfiler() and profiler.stopProfiler() will be ignored.',
         );
       return;
@@ -716,20 +716,20 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 
    _stopProfiler() {
     if (this._mode !== 'current') {
-      DEBUG_BUILD && logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
+      DEBUG_BUILD && debug.log('[Profiling] Continuous profiling is not supported in the current mode.');
       return;
     }
 
     if (this._profileLifecycle === 'trace') {
       DEBUG_BUILD &&
-        logger.log(
+        debug.log(
           '[Profiling] You are using the trace profile lifecycle, manual calls to profiler.startProfiler() and profiler.stopProfiler() will be ignored.',
         );
       return;
     }
 
     if (!this._chunkData) {
-      DEBUG_BUILD && logger.log('[Profiling] No profile session running, no-op.');
+      DEBUG_BUILD && debug.log('[Profiling] No profile session running, no-op.');
       return;
     }
 
@@ -742,7 +742,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _startTraceLifecycleProfiling() {
     if (!this._client) {
       DEBUG_BUILD &&
-        logger.log(
+        debug.log(
           '[Profiling] Failed to start trace lifecycle profiling, sentry client was never attached to the profiler.',
         );
       return;
@@ -767,7 +767,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _setupAutomaticSpanProfiling() {
     if (!this._client) {
       DEBUG_BUILD &&
-        logger.log(
+        debug.log(
           '[Profiling] Failed to setup automatic span profiling, sentry client was never attached to the profiler.',
         );
       return;
@@ -798,7 +798,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
         // Enqueue a timeout to prevent profiles from running over max duration.
         const timeout = global.setTimeout(() => {
           DEBUG_BUILD &&
-            logger.log(
+            debug.log(
               '[Profiling] max profile duration elapsed, stopping profiling for:',
               spanToJSON(span).description,
             );
@@ -862,7 +862,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 
         const cpuProfile = takeFromProfileQueue(profile_id);
         if (!cpuProfile) {
-          DEBUG_BUILD && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
+          DEBUG_BUILD && debug.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
           continue;
         }
 
@@ -897,13 +897,13 @@ 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 && logger.log('[Profiling] Profiler was never attached to the client.');
+      DEBUG_BUILD && debug.log('[Profiling] Profiler was never attached to the client.');
       return;
     }
 
     if (this._chunkData) {
       DEBUG_BUILD &&
-        logger.log(
+        debug.log(
           `[Profiling] Chunk with chunk_id ${this._chunkData.id} is still running, current chunk will be stopped a new chunk will be started.`,
         );
       this._stopChunkProfiling();
@@ -917,26 +917,26 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    */
    _stopChunkProfiling() {
     if (!this._chunkData) {
-      DEBUG_BUILD && logger.log('[Profiling] No chunk data found, no-op.');
+      DEBUG_BUILD && debug.log('[Profiling] No chunk data found, no-op.');
       return;
     }
 
     if (this._chunkData?.timer) {
       global.clearTimeout(this._chunkData.timer);
       this._chunkData.timer = undefined;
-      DEBUG_BUILD && logger.log(`[Profiling] Stopping profiling chunk: ${this._chunkData.id}`);
+      DEBUG_BUILD && debug.log(`[Profiling] Stopping profiling chunk: ${this._chunkData.id}`);
     }
 
     if (!this._client) {
       DEBUG_BUILD &&
-        logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+        debug.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
       this._resetChunkData();
       return;
     }
 
     if (!this._chunkData?.id) {
       DEBUG_BUILD &&
-        logger.log(`[Profiling] Failed to collect profile for: ${this._chunkData?.id}, the chunk_id is missing.`);
+        debug.log(`[Profiling] Failed to collect profile for: ${this._chunkData?.id}, the chunk_id is missing.`);
       this._resetChunkData();
       return;
     }
@@ -944,22 +944,22 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     const profile = CpuProfilerBindings.stopProfiling(this._chunkData.id, ProfileFormat.CHUNK);
 
     if (!profile) {
-      DEBUG_BUILD && logger.log(`[Profiling] Failed to collect profile for: ${this._chunkData.id}`);
+      DEBUG_BUILD && debug.log(`[Profiling] Failed to collect profile for: ${this._chunkData.id}`);
       this._resetChunkData();
       return;
     }
 
     if (!this._profilerId) {
       DEBUG_BUILD &&
-        logger.log('[Profiling] Profile chunk does not contain a valid profiler_id, this is a bug in the SDK');
+        debug.log('[Profiling] Profile chunk does not contain a valid profiler_id, this is a bug in the SDK');
       this._resetChunkData();
       return;
     }
     if (profile) {
-      DEBUG_BUILD && logger.log(`[Profiling] Sending profile chunk ${this._chunkData.id}.`);
+      DEBUG_BUILD && debug.log(`[Profiling] Sending profile chunk ${this._chunkData.id}.`);
     }
 
-    DEBUG_BUILD && logger.log(`[Profiling] Profile chunk ${this._chunkData.id} sent to Sentry.`);
+    DEBUG_BUILD && debug.log(`[Profiling] Profile chunk ${this._chunkData.id} sent to Sentry.`);
     const chunk = createProfilingChunkEvent(
       this._client,
       this._client.getOptions(),
@@ -973,7 +973,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     );
 
     if (!chunk) {
-      DEBUG_BUILD && logger.log(`[Profiling] Failed to create profile chunk for: ${this._chunkData.id}`);
+      DEBUG_BUILD && debug.log(`[Profiling] Failed to create profile chunk for: ${this._chunkData.id}`);
       this._resetChunkData();
       return;
     }
@@ -993,13 +993,13 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _flush(chunk) {
     if (!this._client) {
       DEBUG_BUILD &&
-        logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+        debug.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
       return;
     }
 
     const transport = this._client.getTransport();
     if (!transport) {
-      DEBUG_BUILD && logger.log('[Profiling] No transport available to send profile chunk.');
+      DEBUG_BUILD && debug.log('[Profiling] No transport available to send profile chunk.');
       return;
     }
 
@@ -1009,7 +1009,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 
     const envelope = makeProfileChunkEnvelope('node', chunk, metadata?.sdk, tunnel, dsn);
     transport.send(envelope).then(null, reason => {
-      DEBUG_BUILD && logger.error('Error while sending profile chunk envelope:', reason);
+      DEBUG_BUILD && debug.error('Error while sending profile chunk envelope:', reason);
     });
   }
 
@@ -1019,7 +1019,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    */
    _startChunkProfiling() {
     if (this._chunkData) {
-      DEBUG_BUILD && logger.log('[Profiling] Chunk is already running, no-op.');
+      DEBUG_BUILD && debug.log('[Profiling] Chunk is already running, no-op.');
       return;
     }
 
@@ -1028,12 +1028,12 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     const chunk = this._initializeChunk(traceId);
 
     CpuProfilerBindings.startProfiling(chunk.id);
-    DEBUG_BUILD && logger.log(`[Profiling] starting profiling chunk: ${chunk.id}`);
+    DEBUG_BUILD && debug.log(`[Profiling] starting profiling chunk: ${chunk.id}`);
 
     chunk.timer = global.setTimeout(() => {
-      DEBUG_BUILD && logger.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
+      DEBUG_BUILD && debug.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
       this._stopChunkProfiling();
-      DEBUG_BUILD && logger.log('[Profiling] Starting new profiling chunk.');
+      DEBUG_BUILD && debug.log('[Profiling] Starting new profiling chunk.');
       setImmediate(this._restartChunkProfiling.bind(this));
     }, CHUNK_INTERVAL_MS);
 
@@ -1048,9 +1048,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _setupSpanChunkInstrumentation() {
     if (!this._client) {
       DEBUG_BUILD &&
-        logger.log(
-          '[Profiling] Failed to initialize span profiling, sentry client was never attached to the profiler.',
-        );
+        debug.log('[Profiling] Failed to initialize span profiling, sentry client was never attached to the profiler.');
       return;
     }
 
@@ -1139,7 +1137,7 @@ const _nodeProfilingIntegration = (() => {
     name: 'ProfilingIntegration',
     _profiler: new ContinuousProfiler(),
     setup(client) {
-      DEBUG_BUILD && logger.log('[Profiling] Profiling integration setup.');
+      DEBUG_BUILD && debug.log('[Profiling] Profiling integration setup.');
       this._profiler.initialize(client);
       return;
     },