@sentry/profiling-node 8.9.2 → 8.10.0

package/lib/cjs/index.js

@@ -18,6 +18,666 @@ const os = require('os');
 const process$1 = require('process');
 const worker_threads = require('worker_threads');
 
+/**
+ * Updates a session object with the properties passed in the context.
+ *
+ * Note that this function mutates the passed object and returns void.
+ * (Had to do this instead of returning a new and updated session because closing and sending a session
+ * makes an update to the session after it was passed to the sending logic.
+ * @see BaseClient.captureSession )
+ *
+ * @param session the `Session` to update
+ * @param context the `SessionContext` holding the properties that should be updated in @param session
+ */
+// eslint-disable-next-line complexity
+function updateSession(session, context = {}) {
+  if (context.user) {
+    if (!session.ipAddress && context.user.ip_address) {
+      session.ipAddress = context.user.ip_address;
+    }
+
+    if (!session.did && !context.did) {
+      session.did = context.user.id || context.user.email || context.user.username;
+    }
+  }
+
+  session.timestamp = context.timestamp || utils.timestampInSeconds();
+
+  if (context.abnormal_mechanism) {
+    session.abnormal_mechanism = context.abnormal_mechanism;
+  }
+
+  if (context.ignoreDuration) {
+    session.ignoreDuration = context.ignoreDuration;
+  }
+  if (context.sid) {
+    // Good enough uuid validation. — Kamil
+    session.sid = context.sid.length === 32 ? context.sid : utils.uuid4();
+  }
+  if (context.init !== undefined) {
+    session.init = context.init;
+  }
+  if (!session.did && context.did) {
+    session.did = `${context.did}`;
+  }
+  if (typeof context.started === 'number') {
+    session.started = context.started;
+  }
+  if (session.ignoreDuration) {
+    session.duration = undefined;
+  } else if (typeof context.duration === 'number') {
+    session.duration = context.duration;
+  } else {
+    const duration = session.timestamp - session.started;
+    session.duration = duration >= 0 ? duration : 0;
+  }
+  if (context.release) {
+    session.release = context.release;
+  }
+  if (context.environment) {
+    session.environment = context.environment;
+  }
+  if (!session.ipAddress && context.ipAddress) {
+    session.ipAddress = context.ipAddress;
+  }
+  if (!session.userAgent && context.userAgent) {
+    session.userAgent = context.userAgent;
+  }
+  if (typeof context.errors === 'number') {
+    session.errors = context.errors;
+  }
+  if (context.status) {
+    session.status = context.status;
+  }
+}
+
+const SCOPE_SPAN_FIELD = '_sentrySpan';
+
+/**
+ * Set the active span for a given scope.
+ * NOTE: This should NOT be used directly, but is only used internally by the trace methods.
+ */
+function _setSpanForScope(scope, span) {
+  if (span) {
+    utils.addNonEnumerableProperty(scope , SCOPE_SPAN_FIELD, span);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete (scope )[SCOPE_SPAN_FIELD];
+  }
+}
+
+/**
+ * Get the active span for a given scope.
+ * NOTE: This should NOT be used directly, but is only used internally by the trace methods.
+ */
+function _getSpanForScope(scope) {
+  return scope[SCOPE_SPAN_FIELD];
+}
+
+/**
+ * Default value for maximum number of breadcrumbs added to an event.
+ */
+const DEFAULT_MAX_BREADCRUMBS = 100;
+
+/**
+ * Holds additional event information.
+ */
+class ScopeClass  {
+  /** Flag if notifying is happening. */
+
+  /** Callback for client to receive scope changes. */
+
+  /** Callback list that will be called during event processing. */
+
+  /** Array of breadcrumbs. */
+
+  /** User */
+
+  /** Tags */
+
+  /** Extra */
+
+  /** Contexts */
+
+  /** Attachments */
+
+  /** Propagation Context for distributed tracing */
+
+  /**
+   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+   * sent to Sentry
+   */
+
+  /** Fingerprint */
+
+  /** Severity */
+
+  /**
+   * Transaction Name
+   *
+   * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
+   * It's purpose is to assign a transaction to the scope that's added to non-transaction events.
+   */
+
+  /** Session */
+
+  /** Request Mode Session Status */
+
+  /** The client on this scope */
+
+  /** Contains the last event id of a captured event.  */
+
+  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
+
+   constructor() {
+    this._notifyingListeners = false;
+    this._scopeListeners = [];
+    this._eventProcessors = [];
+    this._breadcrumbs = [];
+    this._attachments = [];
+    this._user = {};
+    this._tags = {};
+    this._extra = {};
+    this._contexts = {};
+    this._sdkProcessingMetadata = {};
+    this._propagationContext = utils.generatePropagationContext();
+  }
+
+  /**
+   * @inheritDoc
+   */
+   clone() {
+    const newScope = new ScopeClass();
+    newScope._breadcrumbs = [...this._breadcrumbs];
+    newScope._tags = { ...this._tags };
+    newScope._extra = { ...this._extra };
+    newScope._contexts = { ...this._contexts };
+    newScope._user = this._user;
+    newScope._level = this._level;
+    newScope._session = this._session;
+    newScope._transactionName = this._transactionName;
+    newScope._fingerprint = this._fingerprint;
+    newScope._eventProcessors = [...this._eventProcessors];
+    newScope._requestSession = this._requestSession;
+    newScope._attachments = [...this._attachments];
+    newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };
+    newScope._propagationContext = { ...this._propagationContext };
+    newScope._client = this._client;
+    newScope._lastEventId = this._lastEventId;
+
+    _setSpanForScope(newScope, _getSpanForScope(this));
+
+    return newScope;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setClient(client) {
+    this._client = client;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setLastEventId(lastEventId) {
+    this._lastEventId = lastEventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getClient() {
+    return this._client ;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   lastEventId() {
+    return this._lastEventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addScopeListener(callback) {
+    this._scopeListeners.push(callback);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addEventProcessor(callback) {
+    this._eventProcessors.push(callback);
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setUser(user) {
+    // If null is passed we want to unset everything, but still define keys,
+    // so that later down in the pipeline any existing values are cleared.
+    this._user = user || {
+      email: undefined,
+      id: undefined,
+      ip_address: undefined,
+      username: undefined,
+    };
+
+    if (this._session) {
+      updateSession(this._session, { user });
+    }
+
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getUser() {
+    return this._user;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getRequestSession() {
+    return this._requestSession;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setRequestSession(requestSession) {
+    this._requestSession = requestSession;
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTags(tags) {
+    this._tags = {
+      ...this._tags,
+      ...tags,
+    };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTag(key, value) {
+    this._tags = { ...this._tags, [key]: value };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setExtras(extras) {
+    this._extra = {
+      ...this._extra,
+      ...extras,
+    };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setExtra(key, extra) {
+    this._extra = { ...this._extra, [key]: extra };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setFingerprint(fingerprint) {
+    this._fingerprint = fingerprint;
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setLevel(level) {
+    this._level = level;
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTransactionName(name) {
+    this._transactionName = name;
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setContext(key, context) {
+    if (context === null) {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete this._contexts[key];
+    } else {
+      this._contexts[key] = context;
+    }
+
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setSession(session) {
+    if (!session) {
+      delete this._session;
+    } else {
+      this._session = session;
+    }
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getSession() {
+    return this._session;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   update(captureContext) {
+    if (!captureContext) {
+      return this;
+    }
+
+    const scopeToMerge = typeof captureContext === 'function' ? captureContext(this) : captureContext;
+
+    const [scopeInstance, requestSession] =
+      scopeToMerge instanceof Scope
+        ? [scopeToMerge.getScopeData(), scopeToMerge.getRequestSession()]
+        : utils.isPlainObject(scopeToMerge)
+          ? [captureContext , (captureContext ).requestSession]
+          : [];
+
+    const { tags, extra, user, contexts, level, fingerprint = [], propagationContext } = scopeInstance || {};
+
+    this._tags = { ...this._tags, ...tags };
+    this._extra = { ...this._extra, ...extra };
+    this._contexts = { ...this._contexts, ...contexts };
+
+    if (user && Object.keys(user).length) {
+      this._user = user;
+    }
+
+    if (level) {
+      this._level = level;
+    }
+
+    if (fingerprint.length) {
+      this._fingerprint = fingerprint;
+    }
+
+    if (propagationContext) {
+      this._propagationContext = propagationContext;
+    }
+
+    if (requestSession) {
+      this._requestSession = requestSession;
+    }
+
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   clear() {
+    // client is not cleared here on purpose!
+    this._breadcrumbs = [];
+    this._tags = {};
+    this._extra = {};
+    this._user = {};
+    this._contexts = {};
+    this._level = undefined;
+    this._transactionName = undefined;
+    this._fingerprint = undefined;
+    this._requestSession = undefined;
+    this._session = undefined;
+    _setSpanForScope(this, undefined);
+    this._attachments = [];
+    this._propagationContext = utils.generatePropagationContext();
+
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addBreadcrumb(breadcrumb, maxBreadcrumbs) {
+    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
+
+    // No data has been changed, so don't notify scope listeners
+    if (maxCrumbs <= 0) {
+      return this;
+    }
+
+    const mergedBreadcrumb = {
+      timestamp: utils.dateTimestampInSeconds(),
+      ...breadcrumb,
+    };
+
+    const breadcrumbs = this._breadcrumbs;
+    breadcrumbs.push(mergedBreadcrumb);
+    this._breadcrumbs = breadcrumbs.length > maxCrumbs ? breadcrumbs.slice(-maxCrumbs) : breadcrumbs;
+
+    this._notifyScopeListeners();
+
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getLastBreadcrumb() {
+    return this._breadcrumbs[this._breadcrumbs.length - 1];
+  }
+
+  /**
+   * @inheritDoc
+   */
+   clearBreadcrumbs() {
+    this._breadcrumbs = [];
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addAttachment(attachment) {
+    this._attachments.push(attachment);
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   clearAttachments() {
+    this._attachments = [];
+    return this;
+  }
+
+  /** @inheritDoc */
+   getScopeData() {
+    return {
+      breadcrumbs: this._breadcrumbs,
+      attachments: this._attachments,
+      contexts: this._contexts,
+      tags: this._tags,
+      extra: this._extra,
+      user: this._user,
+      level: this._level,
+      fingerprint: this._fingerprint || [],
+      eventProcessors: this._eventProcessors,
+      propagationContext: this._propagationContext,
+      sdkProcessingMetadata: this._sdkProcessingMetadata,
+      transactionName: this._transactionName,
+      span: _getSpanForScope(this),
+    };
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setSDKProcessingMetadata(newData) {
+    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };
+
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setPropagationContext(context) {
+    this._propagationContext = context;
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getPropagationContext() {
+    return this._propagationContext;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureException(exception, hint) {
+    const eventId = hint && hint.event_id ? hint.event_id : utils.uuid4();
+
+    if (!this._client) {
+      utils.logger.warn('No client configured on scope - will not capture exception!');
+      return eventId;
+    }
+
+    const syntheticException = new Error('Sentry syntheticException');
+
+    this._client.captureException(
+      exception,
+      {
+        originalException: exception,
+        syntheticException,
+        ...hint,
+        event_id: eventId,
+      },
+      this,
+    );
+
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureMessage(message, level, hint) {
+    const eventId = hint && hint.event_id ? hint.event_id : utils.uuid4();
+
+    if (!this._client) {
+      utils.logger.warn('No client configured on scope - will not capture message!');
+      return eventId;
+    }
+
+    const syntheticException = new Error(message);
+
+    this._client.captureMessage(
+      message,
+      level,
+      {
+        originalException: message,
+        syntheticException,
+        ...hint,
+        event_id: eventId,
+      },
+      this,
+    );
+
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureEvent(event, hint) {
+    const eventId = hint && hint.event_id ? hint.event_id : utils.uuid4();
+
+    if (!this._client) {
+      utils.logger.warn('No client configured on scope - will not capture event!');
+      return eventId;
+    }
+
+    this._client.captureEvent(event, { ...hint, event_id: eventId }, this);
+
+    return eventId;
+  }
+
+  /**
+   * This will be called on every set call.
+   */
+   _notifyScopeListeners() {
+    // We need this check for this._notifyingListeners to be able to work on scope during updates
+    // If this check is not here we'll produce endless recursion when something is done with the scope
+    // during the callback.
+    if (!this._notifyingListeners) {
+      this._notifyingListeners = true;
+      this._scopeListeners.forEach(callback => {
+        callback(this);
+      });
+      this._notifyingListeners = false;
+    }
+  }
+}
+
+// NOTE: By exporting this here as const & type, instead of doing `export class`,
+// We can get the correct class when importing from `@sentry/core`, but the original type (from `@sentry/types`)
+// This is helpful for interop, e.g. when doing `import type { Scope } from '@sentry/node';` (which re-exports this)
+
+/**
+ * Holds additional event information.
+ */
+const Scope = ScopeClass;
+
+/**
+ * Holds additional event information.
+ */
+
+/**
+ * Get the global scope.
+ * This scope is applied to _all_ events.
+ */
+function getGlobalScope() {
+  return utils.getGlobalSingleton('globalScope', () => new Scope());
+}
+
 /**
  * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
  *
@@ -202,12 +862,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 +913,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 +932,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 +1004,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 +1023,6 @@ function createProfileChunkPayload(
   {
     release,
     environment,
-    start_timestamp,
     trace_id,
     profiler_id,
     chunk_id,
@@ -383,7 +1042,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 +1060,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 +1070,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 +1409,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 +1617,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 +1629,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 +1676,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 +1705,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;
+    }
+
+    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 = getGlobalScope();
+    globalScope.setContext('profile', {});
+  }
+
   /**
    * Initializes new profile chunk metadata
    */
@@ -1051,11 +1738,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.
    */