@sentry/profiling-node 8.9.2 → 8.11.0

package/bindings/cpu_profiler.cc

@@ -546,7 +546,8 @@ CreateFrameNode(const napi_env &env, const v8::CpuProfileNode &node,
 };
 
 napi_value CreateSample(const napi_env &env, const enum ProfileFormat format,
-                        const uint32_t stack_id, const int64_t sample_timestamp,
+                        const uint32_t stack_id,
+                        const int64_t sample_timestamp_ns,
                         const double chunk_timestamp,
                         const uint32_t thread_id) {
   napi_value js_node;
@@ -564,7 +565,7 @@ napi_value CreateSample(const napi_env &env, const enum ProfileFormat format,
   switch (format) {
   case ProfileFormat::kFormatThread: {
     napi_value timestamp;
-    napi_create_int64(env, sample_timestamp, &timestamp);
+    napi_create_int64(env, sample_timestamp_ns, &timestamp);
     napi_set_named_property(env, js_node, "elapsed_since_start_ns", timestamp);
   } break;
   case ProfileFormat::kFormatChunk: {
@@ -643,7 +644,8 @@ static void GetSamples(const napi_env &env, const v8::CpuProfile *profile,
     uint64_t sample_offset_from_profile_start_ms =
         (sample_timestamp_us - profile_start_time_us) * 1e-3;
     double seconds_since_start =
-        profile_start_timestamp_ms + sample_offset_from_profile_start_ms;
+        (profile_start_timestamp_ms + sample_offset_from_profile_start_ms) *
+        1e-3;
 
     napi_value sample = nullptr;
     sample = CreateSample(env, format, stack_index, sample_timestamp_ns,
@@ -759,7 +761,7 @@ static napi_value TranslateMeasurementsDouble(
     } else if (format == ProfileFormat::kFormatChunk) {
       napi_value ts;
       napi_create_double(
-          env, profile_start_timestamp_ms + (timestamps_ns[i] * 1e-6), &ts);
+          env, profile_start_timestamp_ms + (timestamps_ns[i] * 1e-9), &ts);
       napi_set_named_property(env, entry, "timestamp", ts);
     }
 
@@ -818,7 +820,7 @@ TranslateMeasurements(const napi_env &env, const enum ProfileFormat format,
     case ProfileFormat::kFormatChunk: {
       napi_value ts;
       napi_create_double(
-          env, profile_start_timestamp_ms + (timestamps_ns[i] * 1e-6), &ts);
+          env, profile_start_timestamp_ms + (timestamps_ns[i] * 1e-9), &ts);
       napi_set_named_property(env, entry, "timestamp", ts);
     } break;
     default:

package/lib/cjs/index.js

@@ -202,12 +202,12 @@ const CpuProfilerBindings = new Bindings();
 const NODE_VERSION = utils.parseSemver(process.versions.node) ;
 const NODE_MAJOR = NODE_VERSION.major;
 
-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 */
+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 */
 
 // We require the file because if we import it, it will be included in the bundle.
 // I guess tsc does not check file contents when it's imported.
-const THREAD_ID_STRING = String(worker_threads.threadId);
-const THREAD_NAME = worker_threads.isMainThread ? 'main' : 'worker';
+const PROFILER_THREAD_ID_STRING = String(worker_threads.threadId);
+const PROFILER_THREAD_NAME = worker_threads.isMainThread ? 'main' : 'worker';
 const FORMAT_VERSION = '1';
 const CONTINUOUS_FORMAT_VERSION = '2';
 
@@ -253,8 +253,8 @@ function enrichWithThreadInformation(
     frames: profile.frames,
     stacks: profile.stacks,
     thread_metadata: {
-      [THREAD_ID_STRING]: {
-        name: THREAD_NAME,
+      [PROFILER_THREAD_ID_STRING]: {
+        name: PROFILER_THREAD_NAME,
       },
     },
   } ;
@@ -272,12 +272,12 @@ function createProfilingEvent(client, profile, event) {
   }
 
   return createProfilePayload(client, profile, {
-    release: _nullishCoalesce(event.release, () => ( '')),
-    environment: _nullishCoalesce(event.environment, () => ( '')),
-    event_id: _nullishCoalesce(event.event_id, () => ( '')),
-    transaction: _nullishCoalesce(event.transaction, () => ( '')),
+    release: _nullishCoalesce$1(event.release, () => ( '')),
+    environment: _nullishCoalesce$1(event.environment, () => ( '')),
+    event_id: _nullishCoalesce$1(event.event_id, () => ( '')),
+    transaction: _nullishCoalesce$1(event.transaction, () => ( '')),
     start_timestamp: event.start_timestamp ? event.start_timestamp * 1000 : Date.now(),
-    trace_id: _nullishCoalesce(_optionalChain$1([event, 'access', _ => _.contexts, 'optionalAccess', _2 => _2['trace'], 'optionalAccess', _3 => _3['trace_id']]), () => ( '')),
+    trace_id: _nullishCoalesce$1(_optionalChain$1([event, 'access', _ => _.contexts, 'optionalAccess', _2 => _2['trace'], 'optionalAccess', _3 => _3['trace_id']]), () => ( '')),
     profile_id: profile.profile_id,
   });
 }
@@ -344,7 +344,7 @@ function createProfilePayload(
       name: transaction,
       id: event_id,
       trace_id: trace_id || '',
-      active_thread_id: THREAD_ID_STRING,
+      active_thread_id: PROFILER_THREAD_ID_STRING,
     },
   };
 
@@ -363,7 +363,6 @@ function createProfileChunkPayload(
   {
     release,
     environment,
-    start_timestamp,
     trace_id,
     profiler_id,
     chunk_id,
@@ -383,7 +382,6 @@ function createProfileChunkPayload(
   const profile = {
     chunk_id: chunk_id,
     profiler_id: profiler_id,
-    timestamp: new Date(start_timestamp).toISOString(),
     platform: 'node',
     version: CONTINUOUS_FORMAT_VERSION,
     release: release,
@@ -402,7 +400,6 @@ function createProfileChunkPayload(
  * Creates a profiling chunk envelope item, if the profile does not pass validation, returns null.
  */
 function createProfilingChunkEvent(
-  start_timestamp,
   client,
   options,
   profile,
@@ -413,10 +410,9 @@ function createProfilingChunkEvent(
   }
 
   return createProfileChunkPayload(client, profile, {
-    release: _nullishCoalesce(options.release, () => ( '')),
-    environment: _nullishCoalesce(options.environment, () => ( '')),
-    start_timestamp: start_timestamp,
-    trace_id: _nullishCoalesce(identifiers.trace_id, () => ( '')),
+    release: _nullishCoalesce$1(options.release, () => ( '')),
+    environment: _nullishCoalesce$1(options.environment, () => ( '')),
+    trace_id: _nullishCoalesce$1(identifiers.trace_id, () => ( '')),
     chunk_id: identifiers.chunk_id,
     profiler_id: identifiers.profiler_id,
   });
@@ -753,7 +749,6 @@ 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}`);
 
   // In case of an overlapping span, stopProfiling may return null and silently ignore the overlapping profile.
@@ -962,8 +957,10 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
         utils.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 || !this._chunkData.startTimestampMS) {
+
+    const profile = this._stopChunkProfiling(this._chunkData);
+
+    if (!profile) {
       DEBUG_BUILD && utils.logger.log(`[Profiling] _chunkiledStartTraceID to collect profile for: ${this._chunkData.id}`);
       return;
     }
@@ -972,17 +969,11 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     }
 
     DEBUG_BUILD && utils.logger.log(`[Profiling] Profile chunk ${this._chunkData.id} sent to Sentry.`);
-    const chunk = createProfilingChunkEvent(
-      this._chunkData.startTimestampMS,
-      this._client,
-      this._client.getOptions(),
-      profile,
-      {
-        chunk_id: this._chunkData.id,
-        trace_id: this._chunkData.startTraceID,
-        profiler_id: this._profilerId,
-      },
-    );
+    const chunk = createProfilingChunkEvent(this._client, this._client.getOptions(), profile, {
+      chunk_id: this._chunkData.id,
+      trace_id: this._chunkData.startTraceID,
+      profiler_id: this._profilerId,
+    });
 
     if (!chunk) {
       DEBUG_BUILD && utils.logger.log(`[Profiling] Failed to create profile chunk for: ${this._chunkData.id}`);
@@ -1025,11 +1016,21 @@ 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();
     CpuProfilerBindings.startProfiling(chunk.id);
     DEBUG_BUILD && utils.logger.log(`[Profiling] starting profiling chunk: ${chunk.id}`);
 
@@ -1044,6 +1045,32 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     chunk.timer.unref();
   }
 
+  /**
+   * Attaches profiling information to spans that were started
+   * during a profiling session.
+   */
+   _setupSpanChunkInstrumentation() {
+    if (!this._client) {
+      DEBUG_BUILD &&
+        utils.logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+      return;
+    }
+
+    core.getGlobalScope().setContext('profile', {
+      profiler_id: this._profilerId,
+    });
+
+    this._client.on('beforeSendEvent', e => this._assignThreadIdContext(e));
+  }
+
+  /**
+   * Clear profiling information from global context when a profile is not running.
+   */
+   _teardownSpanChunkInstrumentation() {
+    const globalScope = core.getGlobalScope();
+    globalScope.setContext('profile', {});
+  }
+
   /**
    * Initializes new profile chunk metadata
    */
@@ -1051,11 +1078,34 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     this._chunkData = {
       id: utils.uuid4(),
       startTraceID: traceId,
-      startTimestampMS: utils.timestampInSeconds(),
       timer: undefined,
     };
   }
 
+  /**
+   * Assigns thread_id and thread name context to a profiled event.
+   */
+   _assignThreadIdContext(event) {
+    if (!_optionalChain([event, 'optionalAccess', _13 => _13['contexts'], 'optionalAccess', _14 => _14['profile']])) {
+      return;
+    }
+
+    if (!event.contexts) {
+      return;
+    }
+
+    // @ts-expect-error the trace fallback value is wrong, though it should never happen
+    // and in case it does, we dont want to override whatever was passed initially.
+    event.contexts['trace'] = {
+      ...(_nullishCoalesce(_optionalChain([event, 'access', _15 => _15.contexts, 'optionalAccess', _16 => _16['trace']]), () => ( {}))),
+      data: {
+        ...(_nullishCoalesce(_optionalChain([event, 'access', _17 => _17.contexts, 'optionalAccess', _18 => _18['trace'], 'optionalAccess', _19 => _19['data']]), () => ( {}))),
+        ['thread.id']: PROFILER_THREAD_ID_STRING,
+        ['thread.name']: PROFILER_THREAD_NAME,
+      },
+    };
+  }
+
   /**
    * Resets the current chunk state.
    */