@sentry/profiling-node 8.8.0 → 8.9.1

package/lib/esm/index.js

@@ -1,13 +1,15 @@
 import { _nullishCoalesce, _optionalChain, _optionalChainDelete } from '@sentry/utils';
-import { spanIsSampled, spanToJSON, defineIntegration, getRootSpan, getCurrentScope } from '@sentry/core';
-import { parseSemver, logger, GLOBAL_OBJ, forEachEnvelopeItem, uuid4 } from '@sentry/utils';
-import * as os from 'node:os';
+import { spanIsSampled, spanToJSON, defineIntegration, getRootSpan, getCurrentScope, getIsolationScope } from '@sentry/core';
+import { logger, GLOBAL_OBJ, parseSemver, forEachEnvelopeItem, createEnvelope, uuid4, dsnToString, LRUMap, timestampInSeconds } from '@sentry/utils';
 import { platform as platform$1, arch as arch$1 } from 'node:os';
 import { resolve, join } from 'node:path';
 import { versions, env } from 'node:process';
-import { threadId, isMainThread } from 'node:worker_threads';
+import { threadId } from 'node:worker_threads';
 import { familySync } from 'detect-libc';
 import { getAbi } from 'node-abi';
+import * as os from 'os';
+import { versions as versions$1, env as env$1 } from 'process';
+import { threadId as threadId$1, isMainThread } from 'worker_threads';
 
 
 // -- Shims --
@@ -24,9 +26,6 @@ const require = cjsModule.createRequire(import.meta.url);
  */
 const DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
 
-const NODE_VERSION = parseSemver(process.versions.node) ;
-const NODE_MAJOR = NODE_VERSION.major;
-
 const stdlib = familySync();
 const platform = process.env['BUILD_PLATFORM'] || platform$1();
 const arch = process.env['BUILD_ARCH'] || arch$1();
@@ -169,31 +168,49 @@ function importCppBindingsModule() {
 }
 
 const PrivateCpuProfilerBindings = importCppBindingsModule();
-const CpuProfilerBindings = {
-  startProfiling(name) {
+
+class Bindings  {
+   startProfiling(name) {
     if (!PrivateCpuProfilerBindings) {
       DEBUG_BUILD && logger.log('[Profiling] Bindings not loaded, ignoring call to startProfiling.');
       return;
     }
 
     return PrivateCpuProfilerBindings.startProfiling(name);
-  },
-  stopProfiling(name) {
+  }
+
+   stopProfiling(
+    name,
+    format,
+  ) {
     if (!PrivateCpuProfilerBindings) {
       DEBUG_BUILD &&
         logger.log('[Profiling] Bindings not loaded or profile was never started, ignoring call to stopProfiling.');
       return null;
     }
-    return PrivateCpuProfilerBindings.stopProfiling(name, threadId, !!GLOBAL_OBJ._sentryDebugIds);
-  },
-};
 
-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; }
+    return PrivateCpuProfilerBindings.stopProfiling(
+      name,
+      format ,
+      threadId,
+      !!GLOBAL_OBJ._sentryDebugIds,
+    );
+  }
+}
+
+const CpuProfilerBindings = new Bindings();
+
+const NODE_VERSION = 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 */
+
 // 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(threadId);
+const THREAD_ID_STRING = String(threadId$1);
 const THREAD_NAME = isMainThread ? 'main' : 'worker';
 const FORMAT_VERSION = '1';
+const CONTINUOUS_FORMAT_VERSION = '2';
 
 // Os machine was backported to 16.18, but this was not reflected in the types
 // @ts-expect-error ignore missing
@@ -212,7 +229,9 @@ const ARCH = os.arch();
  * @param {ThreadCpuProfile | RawThreadCpuProfile} profile
  * @returns {boolean}
  */
-function isRawThreadCpuProfile(profile) {
+function isRawThreadCpuProfile(
+  profile,
+) {
   return !('thread_metadata' in profile);
 }
 
@@ -223,7 +242,9 @@ function isRawThreadCpuProfile(profile) {
  * @param {ThreadCpuProfile | RawThreadCpuProfile} profile
  * @returns {ThreadCpuProfile}
  */
-function enrichWithThreadInformation(profile) {
+function enrichWithThreadInformation(
+  profile,
+) {
   if (!isRawThreadCpuProfile(profile)) {
     return profile;
   }
@@ -237,7 +258,7 @@ function enrichWithThreadInformation(profile) {
         name: THREAD_NAME,
       },
     },
-  };
+  } ;
 }
 
 /**
@@ -268,7 +289,6 @@ function createProfilingEvent(client, profile, event) {
  * @param {options}
  * @returns {Profile}
  */
-
 function createProfilePayload(
   client,
   cpuProfile,
@@ -303,7 +323,7 @@ function createProfilePayload(
     measurements: cpuProfile.measurements,
     runtime: {
       name: 'node',
-      version: versions.node || '',
+      version: versions$1.node || '',
     },
     os: {
       name: PLATFORM,
@@ -311,7 +331,7 @@ function createProfilePayload(
       build_number: VERSION,
     },
     device: {
-      locale: env['LC_ALL'] || env['LC_MESSAGES'] || env['LANG'] || env['LANGUAGE'] || '',
+      locale: env$1['LC_ALL'] || env$1['LC_MESSAGES'] || env$1['LANG'] || env$1['LANGUAGE'] || '',
       model: MODEL,
       manufacturer: TYPE,
       architecture: ARCH,
@@ -320,7 +340,7 @@ function createProfilePayload(
     debug_meta: {
       images: applyDebugMetadata(client, cpuProfile.resources),
     },
-    profile: enrichedThreadProfile,
+    profile: enrichedThreadProfile ,
     transaction: {
       name: transaction,
       id: event_id,
@@ -332,6 +352,77 @@ function createProfilePayload(
   return profile;
 }
 
+/**
+ * Create a profile chunk from raw thread profile
+ * @param {RawThreadCpuProfile} cpuProfile
+ * @param {options}
+ * @returns {Profile}
+ */
+function createProfileChunkPayload(
+  client,
+  cpuProfile,
+  {
+    release,
+    environment,
+    start_timestamp,
+    trace_id,
+    profiler_id,
+    chunk_id,
+  }
+
+,
+) {
+  // Log a warning if the profile has an invalid traceId (should be uuidv4).
+  // 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 && logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
+  }
+
+  const enrichedThreadProfile = enrichWithThreadInformation(cpuProfile);
+
+  const profile = {
+    chunk_id: chunk_id,
+    profiler_id: profiler_id,
+    timestamp: new Date(start_timestamp).toISOString(),
+    platform: 'node',
+    version: CONTINUOUS_FORMAT_VERSION,
+    release: release,
+    environment: environment,
+    measurements: cpuProfile.measurements,
+    debug_meta: {
+      images: applyDebugMetadata(client, cpuProfile.resources),
+    },
+    profile: enrichedThreadProfile ,
+  };
+
+  return profile;
+}
+
+/**
+ * Creates a profiling chunk envelope item, if the profile does not pass validation, returns null.
+ */
+function createProfilingChunkEvent(
+  start_timestamp,
+  client,
+  options,
+  profile,
+  identifiers,
+) {
+  if (!isValidProfileChunk(profile)) {
+    return null;
+  }
+
+  return createProfileChunkPayload(client, profile, {
+    release: _nullishCoalesce(options.release, () => ( '')),
+    environment: _nullishCoalesce(options.environment, () => ( '')),
+    start_timestamp: start_timestamp,
+    trace_id: _nullishCoalesce(identifiers.trace_id, () => ( '')),
+    chunk_id: identifiers.chunk_id,
+    profiler_id: identifiers.profiler_id,
+  });
+}
+
 /**
  * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).
  * @param {unknown} rate
@@ -384,6 +475,24 @@ function isValidProfile(profile) {
   return true;
 }
 
+/**
+ * Checks if the profile chunk is valid and can be sent to Sentry.
+ * @param profile
+ * @returns
+ */
+function isValidProfileChunk(profile) {
+  if (profile.samples.length <= 1) {
+    DEBUG_BUILD &&
+      // 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');
+    return false;
+  }
+
+  return true;
+}
+
 /**
  * Adds items to envelope if they are not already present - mutates the envelope.
  * @param {Envelope} envelope
@@ -436,6 +545,41 @@ function findProfiledTransactionsFromEnvelope(envelope) {
   return events;
 }
 
+/**
+ * Creates event envelope headers for a profile chunk. This is separate from createEventEnvelopeHeaders util
+ * as the profile chunk does not conform to the sentry event type
+ */
+function createEventEnvelopeHeaders(
+  sdkInfo,
+  tunnel,
+  dsn,
+) {
+  return {
+    event_id: uuid4(),
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),
+  };
+}
+
+/**
+ * Creates a standalone profile_chunk envelope.
+ */
+function makeProfileChunkEnvelope(
+  chunk,
+  sdkInfo,
+  tunnel,
+  dsn,
+) {
+  const profileChunkHeader = {
+    type: 'profile_chunk',
+  };
+
+  return createEnvelope(createEventEnvelopeHeaders(sdkInfo, tunnel, dsn), [
+    [profileChunkHeader, chunk],
+  ]);
+}
+
 const debugIdStackParserCache = new WeakMap();
 
 /**
@@ -603,16 +747,13 @@ function maybeProfileSpan(
  * @param profile_id
  * @returns
  */
-function stopSpanProfile(
-  span,
-  profile_id,
-) {
+function stopSpanProfile(span, profile_id) {
   // Should not happen, but satisfy the type checker and be safe regardless.
   if (!profile_id) {
     return null;
   }
 
-  const profile = CpuProfilerBindings.stopProfiling(profile_id);
+  const profile = CpuProfilerBindings.stopProfiling(profile_id, 0);
 
   DEBUG_BUILD && logger.log(`[Profiling] stopped profiling of transaction: ${spanToJSON(span).description}`);
 
@@ -631,16 +772,296 @@ function stopSpanProfile(
   return profile;
 }
 
-const MAX_PROFILE_QUEUE_LENGTH = 50;
-const PROFILE_QUEUE = [];
+var ProfileFormat;(function (ProfileFormat) {
+  const THREAD = 0; ProfileFormat[ProfileFormat["THREAD"] = THREAD] = "THREAD";
+  const CHUNK = 1; ProfileFormat[ProfileFormat["CHUNK"] = CHUNK] = "CHUNK";
+})(ProfileFormat || (ProfileFormat = {}));
+
+const CHUNK_INTERVAL_MS = 5000;
+const PROFILE_MAP = new LRUMap(50);
 const PROFILE_TIMEOUTS = {};
 
-function addToProfileQueue(profile) {
-  PROFILE_QUEUE.push(profile);
+function addToProfileQueue(profile_id, profile) {
+  PROFILE_MAP.set(profile_id, profile);
+}
+
+function takeFromProfileQueue(profile_id) {
+  const profile = PROFILE_MAP.get(profile_id);
+  PROFILE_MAP.remove(profile_id);
+  return profile;
+}
 
-  // We only want to keep the last n profiles in the queue.
-  if (PROFILE_QUEUE.length > MAX_PROFILE_QUEUE_LENGTH) {
-    PROFILE_QUEUE.shift();
+/**
+ * Instruments the client to automatically invoke the profiler on span start and stop events.
+ * @param client
+ */
+function setupAutomatedSpanProfiling(client) {
+  const spanToProfileIdMap = new WeakMap();
+
+  client.on('spanStart', span => {
+    if (span !== getRootSpan(span)) {
+      return;
+    }
+
+    const profile_id = maybeProfileSpan(client, span);
+
+    if (profile_id) {
+      const options = client.getOptions();
+      // Not intended for external use, hence missing types, but we want to profile a couple of things at Sentry that
+      // currently exceed the default timeout set by the SDKs.
+      const maxProfileDurationMs =
+        (options._experiments && options._experiments['maxProfileDurationMs']) || MAX_PROFILE_DURATION_MS;
+
+      if (PROFILE_TIMEOUTS[profile_id]) {
+        global.clearTimeout(PROFILE_TIMEOUTS[profile_id]);
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete PROFILE_TIMEOUTS[profile_id];
+      }
+
+      // Enqueue a timeout to prevent profiles from running over max duration.
+      const timeout = global.setTimeout(() => {
+        DEBUG_BUILD &&
+          logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', spanToJSON(span).description);
+
+        const profile = stopSpanProfile(span, profile_id);
+        if (profile) {
+          addToProfileQueue(profile_id, profile);
+        }
+      }, maxProfileDurationMs);
+
+      // Unref timeout so it doesn't keep the process alive.
+      timeout.unref();
+
+      getCurrentScope().setContext('profile', { profile_id });
+      spanToProfileIdMap.set(span, profile_id);
+    }
+  });
+
+  client.on('spanEnd', span => {
+    const profile_id = spanToProfileIdMap.get(span);
+
+    if (profile_id) {
+      if (PROFILE_TIMEOUTS[profile_id]) {
+        global.clearTimeout(PROFILE_TIMEOUTS[profile_id]);
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete PROFILE_TIMEOUTS[profile_id];
+      }
+      const profile = stopSpanProfile(span, profile_id);
+
+      if (profile) {
+        addToProfileQueue(profile_id, profile);
+      }
+    }
+  });
+
+  client.on('beforeEnvelope', (envelope) => {
+    // if not profiles are in queue, there is nothing to add to the envelope.
+    if (!PROFILE_MAP.size) {
+      return;
+    }
+
+    const profiledTransactionEvents = findProfiledTransactionsFromEnvelope(envelope);
+    if (!profiledTransactionEvents.length) {
+      return;
+    }
+
+    const profilesToAddToEnvelope = [];
+
+    for (const profiledTransaction of profiledTransactionEvents) {
+      const profileContext = _optionalChain([profiledTransaction, 'access', _ => _.contexts, 'optionalAccess', _2 => _2['profile']]);
+      const profile_id = _optionalChain([profileContext, 'optionalAccess', _3 => _3['profile_id']]);
+
+      if (!profile_id) {
+        throw new TypeError('[Profiling] cannot find profile for a transaction without a profile context');
+      }
+
+      // Remove the profile from the transaction context before sending, relay will take care of the rest.
+      if (profileContext) {
+         _optionalChainDelete([profiledTransaction, 'access', _4 => _4.contexts, 'optionalAccess', _5 => delete _5['profile']]);
+      }
+
+      const cpuProfile = takeFromProfileQueue(profile_id);
+      if (!cpuProfile) {
+        DEBUG_BUILD && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
+        continue;
+      }
+
+      const profile = createProfilingEvent(client, cpuProfile, profiledTransaction);
+      if (!profile) return;
+
+      profilesToAddToEnvelope.push(profile);
+
+      // @ts-expect-error profile does not inherit from Event
+      client.emit('preprocessEvent', profile, {
+        event_id: profiledTransaction.event_id,
+      });
+    }
+
+    addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
+  });
+}
+
+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;}
+
+  /**
+   * Called when the profiler is attached to the client (continuous mode is enabled). If of the profiler
+   * methods called before the profiler is initialized will result in a noop action with debug logs.
+   * @param client
+   */
+   initialize(client) {
+    this._client = client;
+  }
+
+  /**
+   * 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.
+   * @returns void
+   */
+   start() {
+    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
+      // 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.');
+      return;
+    }
+    if (this._chunkData) {
+      DEBUG_BUILD &&
+        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();
+    }
+
+    const traceId =
+      getCurrentScope().getPropagationContext().traceId || getIsolationScope().getPropagationContext().traceId;
+    this._initializeChunk(traceId);
+    this._startChunkProfiling(this._chunkData);
+  }
+
+  /**
+   * Stops the current chunk and flushes the profile to Sentry.
+   * @returns void
+   */
+   stop() {
+    if (_optionalChain([this, 'access', _6 => _6._chunkData, 'optionalAccess', _7 => _7.timer])) {
+      global.clearTimeout(this._chunkData.timer);
+      this._chunkData.timer = undefined;
+      DEBUG_BUILD && logger.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.');
+      return;
+    }
+    if (!_optionalChain([this, 'access', _8 => _8._chunkData, 'optionalAccess', _9 => _9.id])) {
+      DEBUG_BUILD &&
+        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) {
+      DEBUG_BUILD && logger.log(`[Profiling] _chunkiledStartTraceID to collect profile for: ${this._chunkData.id}`);
+      return;
+    }
+    if (profile) {
+      DEBUG_BUILD && logger.log(`[Profiling] Sending profile chunk ${this._chunkData.id}.`);
+    }
+
+    DEBUG_BUILD && 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,
+      },
+    );
+
+    if (!chunk) {
+      DEBUG_BUILD && logger.log(`[Profiling] Failed to create profile chunk for: ${this._chunkData.id}`);
+      this._reset();
+      return;
+    }
+
+    this._flush(chunk);
+    // Depending on the profile and stack sizes, stopping the profile and converting
+    // 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();
+  }
+
+  /**
+   * Flushes the profile chunk to Sentry.
+   * @param chunk
+   */
+   _flush(chunk) {
+    if (!this._client) {
+      DEBUG_BUILD &&
+        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 && logger.log('[Profiling] No transport available to send profile chunk.');
+      return;
+    }
+
+    const dsn = this._client.getDsn();
+    const metadata = this._client.getSdkMetadata();
+    const tunnel = this._client.getOptions().tunnel;
+
+    const envelope = makeProfileChunkEnvelope(chunk, _optionalChain([metadata, 'optionalAccess', _12 => _12.sdk]), tunnel, dsn);
+    transport.send(envelope).then(null, reason => {
+      DEBUG_BUILD && logger.error('Error while sending profile chunk envelope:', reason);
+    });
+  }
+
+  /**
+   * Starts the profiler and registers the flush timer for a given chunk.
+   * @param chunk
+   */
+   _startChunkProfiling(chunk) {
+    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();
+      DEBUG_BUILD && logger.log('[Profiling] Starting new profiling chunk.');
+      setImmediate(this.start.bind(this));
+    }, CHUNK_INTERVAL_MS);
+
+    // Unref timeout so it doesn't keep the process alive.
+    chunk.timer.unref();
+  }
+
+  /**
+   * Initializes new profile chunk metadata
+   */
+   _initializeChunk(traceId) {
+    this._chunkData = {
+      id: uuid4(),
+      startTraceID: traceId,
+      startTimestampMS: timestampInSeconds(),
+      timer: undefined,
+    };
+  }
+
+  /**
+   * Resets the current chunk state.
+   */
+   _reset() {
+    this._chunkData = undefined;
   }
 }
 
@@ -657,129 +1078,32 @@ const _nodeProfilingIntegration = (() => {
 
   return {
     name: 'ProfilingIntegration',
+    _profiler: new ContinuousProfiler(),
     setup(client) {
-      const spanToProfileIdMap = new WeakMap();
-
-      client.on('spanStart', span => {
-        if (span !== getRootSpan(span)) {
-          return;
-        }
-
-        const profile_id = maybeProfileSpan(client, span, undefined);
-
-        if (profile_id) {
-          const options = client.getOptions();
-          // Not intended for external use, hence missing types, but we want to profile a couple of things at Sentry that
-          // currently exceed the default timeout set by the SDKs.
-          const maxProfileDurationMs =
-            (options._experiments && options._experiments['maxProfileDurationMs']) || MAX_PROFILE_DURATION_MS;
-
-          if (PROFILE_TIMEOUTS[profile_id]) {
-            global.clearTimeout(PROFILE_TIMEOUTS[profile_id]);
-            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-            delete PROFILE_TIMEOUTS[profile_id];
-          }
-
-          // Enqueue a timeout to prevent profiles from running over max duration.
-          PROFILE_TIMEOUTS[profile_id] = global.setTimeout(() => {
-            DEBUG_BUILD &&
-              logger.log(
-                '[Profiling] max profile duration elapsed, stopping profiling for:',
-                spanToJSON(span).description,
-              );
-
-            const profile = stopSpanProfile(span, profile_id);
-            if (profile) {
-              addToProfileQueue(profile);
-            }
-          }, maxProfileDurationMs);
-
-          getCurrentScope().setContext('profile', { profile_id });
-
-          spanToProfileIdMap.set(span, profile_id);
+      DEBUG_BUILD && logger.log('[Profiling] Profiling integration setup.');
+      const options = client.getOptions();
+
+      const mode =
+        (options.profilesSampleRate === undefined || options.profilesSampleRate === 0) && !options.profilesSampler
+          ? 'continuous'
+          : 'span';
+      switch (mode) {
+        case 'continuous': {
+          DEBUG_BUILD && logger.log('[Profiling] Continuous profiler mode enabled.');
+          this._profiler.initialize(client);
+          break;
         }
-      });
-
-      client.on('spanEnd', span => {
-        const profile_id = spanToProfileIdMap.get(span);
-
-        if (profile_id) {
-          if (PROFILE_TIMEOUTS[profile_id]) {
-            global.clearTimeout(PROFILE_TIMEOUTS[profile_id]);
-            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-            delete PROFILE_TIMEOUTS[profile_id];
-          }
-          const profile = stopSpanProfile(span, profile_id);
-
-          if (profile) {
-            addToProfileQueue(profile);
-          }
+        // Default to span profiling when no mode profiler mode is set
+        case 'span':
+        case undefined: {
+          DEBUG_BUILD && logger.log('[Profiling] Span profiler mode enabled.');
+          setupAutomatedSpanProfiling(client);
+          break;
         }
-      });
-
-      client.on('beforeEnvelope', (envelope) => {
-        // if not profiles are in queue, there is nothing to add to the envelope.
-        if (!PROFILE_QUEUE.length) {
-          return;
+        default: {
+          DEBUG_BUILD && logger.warn(`[Profiling] Unknown profiler mode: ${mode}, profiler was not initialized`);
         }
-
-        const profiledTransactionEvents = findProfiledTransactionsFromEnvelope(envelope);
-        if (!profiledTransactionEvents.length) {
-          return;
-        }
-
-        const profilesToAddToEnvelope = [];
-
-        for (const profiledTransaction of profiledTransactionEvents) {
-          const profileContext = _optionalChain([profiledTransaction, 'access', _ => _.contexts, 'optionalAccess', _2 => _2['profile']]);
-          const profile_id = _optionalChain([profileContext, 'optionalAccess', _3 => _3['profile_id']]);
-
-          if (!profile_id) {
-            throw new TypeError('[Profiling] cannot find profile for a transaction without a profile context');
-          }
-
-          // Remove the profile from the transaction context before sending, relay will take care of the rest.
-          if (profileContext) {
-             _optionalChainDelete([profiledTransaction, 'access', _4 => _4.contexts, 'optionalAccess', _5 => delete _5['profile']]);
-          }
-
-          // We need to find both a profile and a transaction event for the same profile_id.
-          const profileIndex = PROFILE_QUEUE.findIndex(p => p.profile_id === profile_id);
-          if (profileIndex === -1) {
-            DEBUG_BUILD && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
-            continue;
-          }
-
-          const cpuProfile = PROFILE_QUEUE[profileIndex];
-          if (!cpuProfile) {
-            DEBUG_BUILD && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
-            continue;
-          }
-
-          // Remove the profile from the queue.
-          PROFILE_QUEUE.splice(profileIndex, 1);
-          const profile = createProfilingEvent(client, cpuProfile, profiledTransaction);
-
-          if (client.emit && profile) {
-            const integrations =
-              client['_integrations'] && client['_integrations'] !== null && !Array.isArray(client['_integrations'])
-                ? Object.keys(client['_integrations'])
-                : undefined;
-
-            // @ts-expect-error bad overload due to unknown event
-            client.emit('preprocessEvent', profile, {
-              event_id: profiledTransaction.event_id,
-              integrations,
-            });
-          }
-
-          if (profile) {
-            profilesToAddToEnvelope.push(profile);
-          }
-        }
-
-        addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
-      });
+      }
     },
   };
 }) ;