@sentry/profiling-node 8.30.0 → 8.31.0-beta.0

package/bindings/cpu_profiler.cc

@@ -73,7 +73,7 @@ enum class ProfileStatus {
 
 class MeasurementsTicker {
 private:
-  uv_timer_t timer;
+  uv_timer_t *timer;
   uint64_t period_ms;
   std::unordered_map<std::string,
                      const std::function<bool(uint64_t, v8::HeapStatistics &)>>
@@ -87,9 +87,10 @@ private:
 public:
   MeasurementsTicker(uv_loop_t *loop)
       : period_ms(100), isolate(v8::Isolate::GetCurrent()) {
-    uv_timer_init(loop, &timer);
-    uv_handle_set_data(reinterpret_cast<uv_handle_t *>(&timer), this);
-    uv_unref(reinterpret_cast<uv_handle_t *>(&timer));
+    timer = new uv_timer_t;
+    uv_timer_init(loop, timer);
+    uv_handle_set_data((uv_handle_t *)timer, this);
+    uv_ref((uv_handle_t *)timer);
   }
 
   static void ticker(uv_timer_t *);
@@ -112,13 +113,13 @@ public:
   size_t listener_count();
 
   ~MeasurementsTicker() {
-    uv_timer_stop(&timer);
+    uv_handle_t *handle = (uv_handle_t *)timer;
 
-    auto handle = reinterpret_cast<uv_handle_t *>(&timer);
+    uv_timer_stop(timer);
+    uv_unref(handle);
 
-    // Calling uv_close on an inactive handle will cause a segfault.
-    if (uv_is_active(handle)) {
-      uv_close(handle, nullptr);
+    if (!uv_is_closing(handle)) {
+      uv_close(handle, [](uv_handle_t *handle) { delete handle; });
     }
   }
 };
@@ -143,8 +144,8 @@ void MeasurementsTicker::add_heap_listener(
   heap_listeners.emplace(profile_id, cb);
 
   if (listener_count() == 1) {
-    uv_timer_set_repeat(&timer, period_ms);
-    uv_timer_start(&timer, ticker, 0, period_ms);
+    uv_timer_set_repeat(timer, period_ms);
+    uv_timer_start(timer, ticker, 0, period_ms);
   }
 }
 
@@ -154,7 +155,7 @@ void MeasurementsTicker::remove_heap_listener(
   heap_listeners.erase(profile_id);
 
   if (listener_count() == 0) {
-    uv_timer_stop(&timer);
+    uv_timer_stop(timer);
   }
 };
 
@@ -223,8 +224,8 @@ void MeasurementsTicker::add_cpu_listener(
   cpu_listeners.emplace(profile_id, cb);
 
   if (listener_count() == 1) {
-    uv_timer_set_repeat(&timer, period_ms);
-    uv_timer_start(&timer, ticker, 0, period_ms);
+    uv_timer_set_repeat(timer, period_ms);
+    uv_timer_start(timer, ticker, 0, period_ms);
   }
 }
 
@@ -233,7 +234,7 @@ void MeasurementsTicker::remove_cpu_listener(
   cpu_listeners.erase(profile_id);
 
   if (listener_count() == 0) {
-    uv_timer_stop(&timer);
+    uv_timer_stop(timer);
   }
 };
 

package/lib/cjs/index.js

@@ -904,10 +904,10 @@ function setupAutomatedSpanProfiling(client) {
   });
 }
 
-class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.call(this);ContinuousProfiler.prototype.__init2.call(this);ContinuousProfiler.prototype.__init3.call(this); }
-   __init() {this._profilerId = utils.uuid4();}
-   __init2() {this._client = undefined;}
-   __init3() {this._chunkData = undefined;}
+class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.call(this);ContinuousProfiler.prototype.__init2.call(this); }
+
+   __init() {this._client = undefined;}
+   __init2() {this._chunkData = undefined;}
 
   /**
    * Called when the profiler is attached to the client (continuous mode is enabled). If of the profiler
@@ -916,15 +916,48 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    */
    initialize(client) {
     this._client = client;
+
+    // Attaches a listener to beforeSend which will add the threadId data to the event being sent.
+    // This adds a constant overhead to all events being sent which could be improved to only attach
+    // and detach the listener during a profiler session
+    this._client.on('beforeSendEvent', this._onBeforeSendThreadContextAssignment.bind(this));
   }
 
   /**
-   * Recursively schedules chunk profiling to start and stop at a set interval.
-   * Once the user calls stop(), the current chunk will be stopped and flushed to Sentry and no new chunks will
-   * will be started. To restart continuous mode after calling stop(), the user must call start() again.
+   * Initializes a new profilerId session and schedules chunk profiling.
    * @returns void
    */
    start() {
+    if (!this._client) {
+      DEBUG_BUILD && utils.logger.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
+      return;
+    }
+
+    // Flush any existing chunks before starting a new one.
+    this._chunkStop();
+
+    // Restart the profiler session
+    this._setupSpanChunkInstrumentation();
+    this._chunkStart();
+  }
+
+  /**
+   * Stops the current chunk and flushes the profile to Sentry.
+   * @returns void
+   */
+   stop() {
+    if (!this._client) {
+      DEBUG_BUILD && utils.logger.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
+      return;
+    }
+    this._chunkStop();
+    this._teardownSpanChunkInstrumentation();
+  }
+
+  /**
+   * Stop profiler and initializes profiling of the next chunk
+   */
+   _chunkStart() {
     if (!this._client) {
       // 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
@@ -937,20 +970,16 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
         utils.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.stop();
+      this._chunkStop();
     }
 
-    const traceId =
-      core.getCurrentScope().getPropagationContext().traceId || core.getIsolationScope().getPropagationContext().traceId;
-    this._initializeChunk(traceId);
-    this._startChunkProfiling(this._chunkData);
+    this._startChunkProfiling();
   }
 
   /**
-   * Stops the current chunk and flushes the profile to Sentry.
-   * @returns void
+   * Stops profiling of the current chunks and flushes the profile to Sentry
    */
-   stop() {
+   _chunkStop() {
     if (_optionalChain([this, 'access', _6 => _6._chunkData, 'optionalAccess', _7 => _7.timer])) {
       global.clearTimeout(this._chunkData.timer);
       this._chunkData.timer = undefined;
@@ -967,12 +996,17 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
       return;
     }
 
-    const profile = this._stopChunkProfiling(this._chunkData);
+    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}`);
       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');
+      return;
+    }
     if (profile) {
       DEBUG_BUILD && utils.logger.log(`[Profiling] Sending profile chunk ${this._chunkData.id}.`);
     }
@@ -992,7 +1026,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}`);
-      this._reset();
+      this._resetChunkData();
       return;
     }
 
@@ -1001,7 +1035,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     // the format may negatively impact the performance of the application. To avoid
     // blocking for too long, enqueue the next chunk start inside the next macrotask.
     // clear current chunk
-    this._reset();
+    this._resetChunkData();
   }
 
   /**
@@ -1031,29 +1065,23 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     });
   }
 
-  /**
-   * Stops the profile and clears chunk instrumentation from global scope
-   * @returns void
-   */
-   _stopChunkProfiling(chunk) {
-    this._teardownSpanChunkInstrumentation();
-    return CpuProfilerBindings.stopProfiling(chunk.id, ProfileFormat.CHUNK);
-  }
-
   /**
    * Starts the profiler and registers the flush timer for a given chunk.
    * @param chunk
    */
-   _startChunkProfiling(chunk) {
-    this._setupSpanChunkInstrumentation();
+   _startChunkProfiling() {
+    const traceId =
+      core.getCurrentScope().getPropagationContext().traceId || core.getIsolationScope().getPropagationContext().traceId;
+    const chunk = this._initializeChunk(traceId);
+
     CpuProfilerBindings.startProfiling(chunk.id);
     DEBUG_BUILD && utils.logger.log(`[Profiling] starting profiling chunk: ${chunk.id}`);
 
     chunk.timer = global.setTimeout(() => {
       DEBUG_BUILD && utils.logger.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
-      this.stop();
+      this._chunkStop();
       DEBUG_BUILD && utils.logger.log('[Profiling] Starting new profiling chunk.');
-      setImmediate(this.start.bind(this));
+      setImmediate(this._chunkStart.bind(this));
     }, CHUNK_INTERVAL_MS);
 
     // Unref timeout so it doesn't keep the process alive.
@@ -1067,21 +1095,31 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _setupSpanChunkInstrumentation() {
     if (!this._client) {
       DEBUG_BUILD &&
-        utils.logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+        utils.logger.log(
+          '[Profiling] Failed to initialize span profiling, sentry client was never attached to the profiler.',
+        );
       return;
     }
 
+    this._profilerId = utils.uuid4();
     core.getGlobalScope().setContext('profile', {
       profiler_id: this._profilerId,
     });
+  }
 
-    this._client.on('beforeSendEvent', e => this._assignThreadIdContext(e));
+  /**
+   * Assigns thread_id and thread name context to a profiled event if there is an active profiler session
+   */
+   _onBeforeSendThreadContextAssignment(event) {
+    if (!this._client || !this._profilerId) return;
+    this._assignThreadIdContext(event);
   }
 
   /**
    * Clear profiling information from global context when a profile is not running.
    */
    _teardownSpanChunkInstrumentation() {
+    this._profilerId = undefined;
     const globalScope = core.getGlobalScope();
     globalScope.setContext('profile', {});
   }
@@ -1095,6 +1133,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
       startTraceID: traceId,
       timer: undefined,
     };
+    return this._chunkData;
   }
 
   /**
@@ -1124,7 +1163,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
   /**
    * Resets the current chunk state.
    */
-   _reset() {
+   _resetChunkData() {
     this._chunkData = undefined;
   }
 }

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

@@ -912,10 +912,10 @@ function setupAutomatedSpanProfiling(client) {
   });
 }
 
-class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.call(this);ContinuousProfiler.prototype.__init2.call(this);ContinuousProfiler.prototype.__init3.call(this); }
-   __init() {this._profilerId = uuid4();}
-   __init2() {this._client = undefined;}
-   __init3() {this._chunkData = undefined;}
+class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.call(this);ContinuousProfiler.prototype.__init2.call(this); }
+
+   __init() {this._client = undefined;}
+   __init2() {this._chunkData = undefined;}
 
   /**
    * Called when the profiler is attached to the client (continuous mode is enabled). If of the profiler
@@ -924,15 +924,48 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    */
    initialize(client) {
     this._client = client;
+
+    // Attaches a listener to beforeSend which will add the threadId data to the event being sent.
+    // This adds a constant overhead to all events being sent which could be improved to only attach
+    // and detach the listener during a profiler session
+    this._client.on('beforeSendEvent', this._onBeforeSendThreadContextAssignment.bind(this));
   }
 
   /**
-   * Recursively schedules chunk profiling to start and stop at a set interval.
-   * Once the user calls stop(), the current chunk will be stopped and flushed to Sentry and no new chunks will
-   * will be started. To restart continuous mode after calling stop(), the user must call start() again.
+   * Initializes a new profilerId session and schedules chunk profiling.
    * @returns void
    */
    start() {
+    if (!this._client) {
+      DEBUG_BUILD && logger.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
+      return;
+    }
+
+    // Flush any existing chunks before starting a new one.
+    this._chunkStop();
+
+    // Restart the profiler session
+    this._setupSpanChunkInstrumentation();
+    this._chunkStart();
+  }
+
+  /**
+   * Stops the current chunk and flushes the profile to Sentry.
+   * @returns void
+   */
+   stop() {
+    if (!this._client) {
+      DEBUG_BUILD && logger.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
+      return;
+    }
+    this._chunkStop();
+    this._teardownSpanChunkInstrumentation();
+  }
+
+  /**
+   * Stop profiler and initializes profiling of the next chunk
+   */
+   _chunkStart() {
     if (!this._client) {
       // 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
@@ -945,20 +978,16 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
         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.stop();
+      this._chunkStop();
     }
 
-    const traceId =
-      getCurrentScope().getPropagationContext().traceId || getIsolationScope().getPropagationContext().traceId;
-    this._initializeChunk(traceId);
-    this._startChunkProfiling(this._chunkData);
+    this._startChunkProfiling();
   }
 
   /**
-   * Stops the current chunk and flushes the profile to Sentry.
-   * @returns void
+   * Stops profiling of the current chunks and flushes the profile to Sentry
    */
-   stop() {
+   _chunkStop() {
     if (_optionalChain([this, 'access', _6 => _6._chunkData, 'optionalAccess', _7 => _7.timer])) {
       global.clearTimeout(this._chunkData.timer);
       this._chunkData.timer = undefined;
@@ -975,12 +1004,17 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
       return;
     }
 
-    const profile = this._stopChunkProfiling(this._chunkData);
+    const profile = CpuProfilerBindings.stopProfiling(this._chunkData.id, ProfileFormat.CHUNK);
 
     if (!profile) {
       DEBUG_BUILD && logger.log(`[Profiling] _chunkiledStartTraceID to collect profile for: ${this._chunkData.id}`);
       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');
+      return;
+    }
     if (profile) {
       DEBUG_BUILD && logger.log(`[Profiling] Sending profile chunk ${this._chunkData.id}.`);
     }
@@ -1000,7 +1034,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 
     if (!chunk) {
       DEBUG_BUILD && logger.log(`[Profiling] Failed to create profile chunk for: ${this._chunkData.id}`);
-      this._reset();
+      this._resetChunkData();
       return;
     }
 
@@ -1009,7 +1043,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     // the format may negatively impact the performance of the application. To avoid
     // blocking for too long, enqueue the next chunk start inside the next macrotask.
     // clear current chunk
-    this._reset();
+    this._resetChunkData();
   }
 
   /**
@@ -1039,29 +1073,23 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     });
   }
 
-  /**
-   * Stops the profile and clears chunk instrumentation from global scope
-   * @returns void
-   */
-   _stopChunkProfiling(chunk) {
-    this._teardownSpanChunkInstrumentation();
-    return CpuProfilerBindings.stopProfiling(chunk.id, ProfileFormat.CHUNK);
-  }
-
   /**
    * Starts the profiler and registers the flush timer for a given chunk.
    * @param chunk
    */
-   _startChunkProfiling(chunk) {
-    this._setupSpanChunkInstrumentation();
+   _startChunkProfiling() {
+    const traceId =
+      getCurrentScope().getPropagationContext().traceId || getIsolationScope().getPropagationContext().traceId;
+    const chunk = this._initializeChunk(traceId);
+
     CpuProfilerBindings.startProfiling(chunk.id);
     DEBUG_BUILD && logger.log(`[Profiling] starting profiling chunk: ${chunk.id}`);
 
     chunk.timer = global.setTimeout(() => {
       DEBUG_BUILD && logger.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
-      this.stop();
+      this._chunkStop();
       DEBUG_BUILD && logger.log('[Profiling] Starting new profiling chunk.');
-      setImmediate(this.start.bind(this));
+      setImmediate(this._chunkStart.bind(this));
     }, CHUNK_INTERVAL_MS);
 
     // Unref timeout so it doesn't keep the process alive.
@@ -1075,21 +1103,31 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    _setupSpanChunkInstrumentation() {
     if (!this._client) {
       DEBUG_BUILD &&
-        logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+        logger.log(
+          '[Profiling] Failed to initialize span profiling, sentry client was never attached to the profiler.',
+        );
       return;
     }
 
+    this._profilerId = uuid4();
     getGlobalScope().setContext('profile', {
       profiler_id: this._profilerId,
     });
+  }
 
-    this._client.on('beforeSendEvent', e => this._assignThreadIdContext(e));
+  /**
+   * Assigns thread_id and thread name context to a profiled event if there is an active profiler session
+   */
+   _onBeforeSendThreadContextAssignment(event) {
+    if (!this._client || !this._profilerId) return;
+    this._assignThreadIdContext(event);
   }
 
   /**
    * Clear profiling information from global context when a profile is not running.
    */
    _teardownSpanChunkInstrumentation() {
+    this._profilerId = undefined;
     const globalScope = getGlobalScope();
     globalScope.setContext('profile', {});
   }
@@ -1103,6 +1141,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
       startTraceID: traceId,
       timer: undefined,
     };
+    return this._chunkData;
   }
 
   /**
@@ -1132,7 +1171,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
   /**
    * Resets the current chunk state.
    */
-   _reset() {
+   _resetChunkData() {
     this._chunkData = undefined;
   }
 }

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/types/integration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../src/integration.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAA+C,oBAAoB,EAAQ,MAAM,eAAe,CAAC;AAwX7G,+BAA+B;AAC/B,eAAO,MAAM,yBAAyB,QAAQ,qBAAqB,UAAU,CA2CnD,CAAC;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,2CAA+C,CAAC"}
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../src/integration.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAA+C,oBAAoB,EAAQ,MAAM,eAAe,CAAC;AA+Z7G,+BAA+B;AAC/B,eAAO,MAAM,yBAAyB,QAAQ,qBAAqB,UAAU,CA2CnD,CAAC;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,2CAA+C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/profiling-node",
-  "version": "8.30.0",
+  "version": "8.31.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,10 @@
     "test": "cross-env SENTRY_PROFILER_BINARY_DIR=lib jest --config jest.config.js"
   },
   "dependencies": {
-    "@sentry/core": "8.30.0",
-    "@sentry/node": "8.30.0",
-    "@sentry/types": "8.30.0",
-    "@sentry/utils": "8.30.0",
+    "@sentry/core": "8.31.0-beta.0",
+    "@sentry/node": "8.31.0-beta.0",
+    "@sentry/types": "8.31.0-beta.0",
+    "@sentry/utils": "8.31.0-beta.0",
     "detect-libc": "^2.0.2",
     "node-abi": "^3.61.0"
   },