@sentry/profiling-node 11.0.0-alpha.0 → 11.0.0-alpha.1

package/README.md

@@ -32,13 +32,13 @@ Sentry.init({
   dsn: 'https://7fa19397baaf433f919fbe02228d5470@o1137848.ingest.sentry.io/6625302',
   debug: true,
   tracesSampleRate: 1,
-  profilesSampleRate: 1, // Set profiling sampling rate.
+  profileSessionSampleRate: 1,
+  profileLifecycle: 'trace',
   integrations: [nodeProfilingIntegration()],
 });
 ```
 
-Sentry SDK will now automatically profile all root spans, even the ones which may be started as a result of using an
-automatic instrumentation integration.
+The Sentry SDK will now collect profile chunks while spans are active, including spans started by automatic instrumentation.
 
 ```javascript
 Sentry.startSpan({ name: 'some workflow' }, () => {
@@ -46,6 +46,8 @@ Sentry.startSpan({ name: 'some workflow' }, () => {
 });
 ```
 
+With `profileLifecycle: 'manual'` (the default), you can start and stop the profiler by calling `Sentry.profiler.startProfiler()` and `Sentry.profiler.stopProfiler()`.
+
 ### Building the package from source
 
 Profiling uses native modules to interop with the v8 javascript engine which means that you may be required to build it

package/build/cjs/index.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const core = require('@sentry/core');
 const nodeCpuProfiler = require('@sentry/node-cpu-profiler');
 const worker_threads = require('worker_threads');
-const os = require('os');
-const process$1 = require('process');
 
 const DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
 
@@ -13,14 +11,7 @@ const NODE_MAJOR = NODE_VERSION.major;
 
 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";
-const PLATFORM = os.platform();
-const RELEASE = os.release();
-const VERSION = os.version();
-const TYPE = os.type();
-const MODEL = os.machine();
-const ARCH = os.arch();
 function isRawThreadCpuProfile(profile) {
   return !("thread_metadata" in profile);
 }
@@ -39,70 +30,6 @@ function enrichWithThreadInformation(profile) {
     }
   };
 }
-function createProfilingEvent(client, profile, event) {
-  if (!isValidProfile(profile)) {
-    return null;
-  }
-  return createProfilePayload(client, profile, {
-    release: event.release ?? "",
-    environment: event.environment ?? "",
-    event_id: event.event_id ?? "",
-    transaction: event.transaction ?? "",
-    start_timestamp: event.start_timestamp ? event.start_timestamp * 1e3 : Date.now(),
-    trace_id: event.contexts?.trace?.trace_id ?? "",
-    profile_id: profile.profile_id
-  });
-}
-function createProfilePayload(client, cpuProfile, {
-  release,
-  environment,
-  event_id,
-  transaction,
-  start_timestamp,
-  trace_id,
-  profile_id
-}) {
-  if (trace_id?.length !== 32) {
-    DEBUG_BUILD && core.debug.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
-  }
-  const enrichedThreadProfile = enrichWithThreadInformation(cpuProfile);
-  const profile = {
-    event_id: profile_id,
-    timestamp: new Date(start_timestamp).toISOString(),
-    platform: "node",
-    version: FORMAT_VERSION,
-    release,
-    environment,
-    measurements: cpuProfile.measurements,
-    runtime: {
-      name: "node",
-      version: process$1.versions.node || ""
-    },
-    os: {
-      name: PLATFORM,
-      version: RELEASE,
-      build_number: VERSION
-    },
-    device: {
-      locale: process$1.env["LC_ALL"] || process$1.env["LC_MESSAGES"] || process$1.env["LANG"] || process$1.env["LANGUAGE"] || "",
-      model: MODEL,
-      manufacturer: TYPE,
-      architecture: ARCH,
-      is_emulator: false
-    },
-    debug_meta: {
-      images: applyDebugMetadata(client, cpuProfile.resources)
-    },
-    profile: enrichedThreadProfile,
-    transaction: {
-      name: transaction,
-      id: event_id,
-      trace_id: trace_id || "",
-      active_thread_id: PROFILER_THREAD_ID_STRING
-    }
-  };
-  return profile;
-}
 function createProfileChunkPayload(client, cpuProfile, {
   release,
   environment,
@@ -147,37 +74,6 @@ function createProfilingChunkEvent(client, options, profile, sdk, identifiers) {
     sdk
   });
 }
-function isValidSampleRate(rate) {
-  if (typeof rate !== "number" && typeof rate !== "boolean" || typeof rate === "number" && isNaN(rate)) {
-    DEBUG_BUILD && core.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)}.`
-    );
-    return false;
-  }
-  if (rate === true || rate === false) {
-    return true;
-  }
-  if (rate < 0 || rate > 1) {
-    DEBUG_BUILD && core.debug.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
-    return false;
-  }
-  return true;
-}
-function isValidProfile(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.
-    core.debug.log("[Profiling] Discarding profile because it contains less than 2 samples");
-    return false;
-  }
-  if (!profile.profile_id) {
-    return false;
-  }
-  return true;
-}
 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
@@ -188,34 +84,6 @@ function isValidProfileChunk(profile) {
   }
   return true;
 }
-function addProfilesToEnvelope(envelope, profiles) {
-  if (!profiles.length) {
-    return envelope;
-  }
-  for (const profile of profiles) {
-    envelope[1].push([{ type: "profile" }, profile]);
-  }
-  return envelope;
-}
-function findProfiledTransactionsFromEnvelope(envelope) {
-  const events = [];
-  core.forEachEnvelopeItem(envelope, (item, type) => {
-    if (type !== "transaction") {
-      return;
-    }
-    for (let j = 1; j < item.length; j++) {
-      const event = item[j];
-      if (!event) {
-        continue;
-      }
-      const profile_id = event.contexts?.profile?.profile_id;
-      if (event && profile_id) {
-        events.push(event);
-      }
-    }
-  });
-  return events;
-}
 function createEventEnvelopeHeaders(sdkInfo, tunnel, dsn) {
   return {
     event_id: core.uuid4(),
@@ -241,94 +109,11 @@ function applyDebugMetadata(client, resource_paths) {
   return core.getDebugImagesForResources(options.stackParser, resource_paths);
 }
 
-const MAX_PROFILE_DURATION_MS = 30 * 1e3;
-function maybeProfileSpan(client, span, customSamplingContext) {
-  if (!worker_threads.isMainThread) {
-    DEBUG_BUILD && core.debug.log("[Profiling] Skipping span profiling in worker thread.");
-    return;
-  }
-  if (!core.spanIsSampled(span)) {
-    return;
-  }
-  if (!client) {
-    DEBUG_BUILD && core.debug.log("[Profiling] Profiling disabled, no client found.");
-    return;
-  }
-  const options = client.getOptions();
-  if (!options) {
-    DEBUG_BUILD && core.debug.log("[Profiling] Profiling disabled, no options found.");
-    return;
-  }
-  const profilesSampler = options.profilesSampler;
-  let profilesSampleRate = options.profilesSampleRate;
-  if (typeof profilesSampler === "function") {
-    const { description: spanName = "<unknown>", data } = core.spanToJSON(span);
-    const parentSampled = true;
-    profilesSampleRate = profilesSampler({
-      name: spanName,
-      attributes: data,
-      parentSampled,
-      ...customSamplingContext
-    });
-  }
-  if (!isValidSampleRate(profilesSampleRate)) {
-    DEBUG_BUILD && core.debug.warn("[Profiling] Discarding profile because of invalid sample rate.");
-    return;
-  }
-  if (!profilesSampleRate) {
-    DEBUG_BUILD && core.debug.log(
-      `[Profiling] Discarding profile because ${typeof profilesSampler === "function" ? "profileSampler returned 0 or false" : "a negative sampling decision was inherited or profileSampleRate is set to 0"}`
-    );
-    return;
-  }
-  const sampled = profilesSampleRate === true ? true : Math.random() < profilesSampleRate;
-  if (!sampled) {
-    DEBUG_BUILD && core.debug.log(
-      `[Profiling] Discarding profile because it's not included in the random sample (sampling rate = ${Number(
-        profilesSampleRate
-      )})`
-    );
-    return;
-  }
-  const profile_id = core.uuid4();
-  nodeCpuProfiler.CpuProfilerBindings.startProfiling(profile_id);
-  DEBUG_BUILD && core.debug.log(`[Profiling] started profiling transaction: ${core.spanToJSON(span).description}`);
-  return profile_id;
-}
-function stopSpanProfile(span, profile_id) {
-  if (!profile_id) {
-    return null;
-  }
-  const profile = nodeCpuProfiler.CpuProfilerBindings.stopProfiling(profile_id, 0);
-  DEBUG_BUILD && core.debug.log(`[Profiling] stopped profiling of transaction: ${core.spanToJSON(span).description}`);
-  if (!profile) {
-    DEBUG_BUILD && core.debug.log(
-      `[Profiling] profiler returned null profile for: ${core.spanToJSON(span).description}`,
-      "this may indicate an overlapping span or a call to stopProfiling with a profile title that was never started"
-    );
-    return null;
-  }
-  profile.profile_id = profile_id;
-  return profile;
-}
-
 const CHUNK_INTERVAL_MS = 1e3 * 60;
-const PROFILE_MAP = new core.LRUMap(50);
-const PROFILE_TIMEOUTS = {};
-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;
-}
 class ContinuousProfiler {
   constructor() {
     this._client = void 0;
     this._chunkData = void 0;
-    this._mode = void 0;
-    this._legacyProfilerMode = void 0;
     this._profileLifecycle = void 0;
     this._sampled = void 0;
     this._sessionSamplingRate = void 0;
@@ -347,51 +132,21 @@ class ContinuousProfiler {
     }
     this._client = client;
     const options = client.getOptions();
-    this._mode = getProfilingMode(options);
     this._sessionSamplingRate = Math.random();
     this._sampled = this._sessionSamplingRate < (options.profileSessionSampleRate ?? 0);
     this._profileLifecycle = options.profileLifecycle ?? "manual";
-    switch (this._mode) {
-      case "legacy": {
-        this._legacyProfilerMode = "profilesSampleRate" in options || "profilesSampler" in options ? "span" : "continuous";
-        DEBUG_BUILD && core.debug.log(`[Profiling] Profiling mode is ${this._legacyProfilerMode}.`);
-        switch (this._legacyProfilerMode) {
-          case "span": {
-            this._setupAutomaticSpanProfiling();
-            break;
-          }
-          case "continuous": {
-            break;
-          }
-          default: {
-            DEBUG_BUILD && core.debug.warn(
-              `[Profiling] Unknown profiler mode: ${this._legacyProfilerMode}, profiler was not initialized`
-            );
-            break;
-          }
-        }
+    this._setupSpanChunkInstrumentation();
+    DEBUG_BUILD && core.debug.log(`[Profiling] Profiling mode is ${this._profileLifecycle}.`);
+    switch (this._profileLifecycle) {
+      case "trace": {
+        this._startTraceLifecycleProfiling();
         break;
       }
-      case "current": {
-        this._setupSpanChunkInstrumentation();
-        DEBUG_BUILD && core.debug.log(`[Profiling] Profiling mode is ${this._profileLifecycle}.`);
-        switch (this._profileLifecycle) {
-          case "trace": {
-            this._startTraceLifecycleProfiling();
-            break;
-          }
-          case "manual": {
-            break;
-          }
-          default: {
-            DEBUG_BUILD && core.debug.warn(`[Profiling] Unknown profiler mode: ${this._profileLifecycle}, profiler was not initialized`);
-            break;
-          }
-        }
+      case "manual": {
         break;
       }
       default: {
-        DEBUG_BUILD && core.debug.warn(`[Profiling] Unknown profiler mode: ${this._mode}, profiler was not initialized`);
+        DEBUG_BUILD && core.debug.warn(`[Profiling] Unknown profiler mode: ${this._profileLifecycle}, profiler was not initialized`);
         break;
       }
     }
@@ -402,64 +157,26 @@ class ContinuousProfiler {
    * @returns void
    */
   start() {
-    if (this._mode === "current") {
-      this._startProfiler();
-      return;
-    }
     if (!this._client) {
-      DEBUG_BUILD && core.debug.log("[Profiling] Failed to start, sentry client was never attached to the profiler.");
-      return;
-    }
-    if (this._mode !== "legacy") {
-      DEBUG_BUILD && core.debug.log("[Profiling] Continuous profiling is not supported in the current mode.");
-      return;
-    }
-    if (this._legacyProfilerMode === "span") {
-      DEBUG_BUILD && core.debug.log("[Profiling] Calls to profiler.start() are not supported in span profiling mode.");
+      DEBUG_BUILD && core.debug.log("[Profiling] Failed to start, Sentry client was never attached to the profiler.");
       return;
     }
-    this._stopChunkProfiling();
-    this._setupSpanChunkInstrumentation();
-    this._restartChunkProfiling();
+    this._startProfiler();
   }
   /**
    * Stops the current chunk and flushes the profile to Sentry.
-   * @returns void
    */
   stop() {
-    if (this._mode === "current") {
-      this._stopProfiler();
-      return;
-    }
-    if (!this._client) {
-      DEBUG_BUILD && core.debug.log("[Profiling] Failed to stop, sentry client was never attached to the profiler.");
-      return;
-    }
-    if (this._mode !== "legacy") {
-      DEBUG_BUILD && core.debug.log("[Profiling] Continuous profiling is not supported in the current mode.");
-      return;
-    }
-    if (this._legacyProfilerMode === "span") {
-      DEBUG_BUILD && core.debug.log("[Profiling] Calls to profiler.stop() are not supported in span profiling mode.");
-      return;
-    }
-    this._stopChunkProfiling();
-    this._teardownSpanChunkInstrumentation();
+    this._stopProfiler();
   }
   _startProfiler() {
-    if (this._mode !== "current") {
-      DEBUG_BUILD && core.debug.log("[Profiling] Continuous profiling is not supported in the current mode.");
-      return;
-    }
     if (this._chunkData !== void 0) {
       DEBUG_BUILD && core.debug.log("[Profiling] Profile session already running, no-op.");
       return;
     }
-    if (this._mode === "current") {
-      if (!this._sampled) {
-        DEBUG_BUILD && core.debug.log("[Profiling] Profile session not sampled, no-op.");
-        return;
-      }
+    if (!this._sampled) {
+      DEBUG_BUILD && core.debug.log("[Profiling] Profile session not sampled, no-op.");
+      return;
     }
     if (this._profileLifecycle === "trace") {
       DEBUG_BUILD && core.debug.log(
@@ -470,10 +187,6 @@ class ContinuousProfiler {
     this._startChunkProfiling();
   }
   _stopProfiler() {
-    if (this._mode !== "current") {
-      DEBUG_BUILD && core.debug.log("[Profiling] Continuous profiling is not supported in the current mode.");
-      return;
-    }
     if (this._profileLifecycle === "trace") {
       DEBUG_BUILD && core.debug.log(
         "[Profiling] You are using the trace profile lifecycle, manual calls to profiler.startProfiler() and profiler.stopProfiler() will be ignored."
@@ -514,90 +227,6 @@ class ContinuousProfiler {
       activeSpanCounter--;
     });
   }
-  _setupAutomaticSpanProfiling() {
-    if (!this._client) {
-      DEBUG_BUILD && core.debug.log(
-        "[Profiling] Failed to setup automatic span profiling, sentry client was never attached to the profiler."
-      );
-      return;
-    }
-    const spanToProfileIdMap = /* @__PURE__ */ new WeakMap();
-    this._client.on("spanStart", (span) => {
-      if (span !== core.getRootSpan(span)) {
-        return;
-      }
-      const profile_id = maybeProfileSpan(this._client, span);
-      if (profile_id) {
-        const options = this._client.getOptions();
-        const maxProfileDurationMs = options._experiments?.maxProfileDurationMs || MAX_PROFILE_DURATION_MS;
-        if (PROFILE_TIMEOUTS[profile_id]) {
-          global.clearTimeout(PROFILE_TIMEOUTS[profile_id]);
-          delete PROFILE_TIMEOUTS[profile_id];
-        }
-        const timeout = global.setTimeout(() => {
-          DEBUG_BUILD && core.debug.log(
-            "[Profiling] max profile duration elapsed, stopping profiling for:",
-            core.spanToJSON(span).description
-          );
-          const profile = stopSpanProfile(span, profile_id);
-          if (profile) {
-            addToProfileQueue(profile_id, profile);
-          }
-        }, maxProfileDurationMs);
-        timeout.unref();
-        core.getIsolationScope().setContext("profile", { profile_id });
-        spanToProfileIdMap.set(span, profile_id);
-      }
-    });
-    this._client.on("spanEnd", (span) => {
-      const profile_id = spanToProfileIdMap.get(span);
-      if (profile_id) {
-        if (PROFILE_TIMEOUTS[profile_id]) {
-          global.clearTimeout(PROFILE_TIMEOUTS[profile_id]);
-          delete PROFILE_TIMEOUTS[profile_id];
-        }
-        const profile = stopSpanProfile(span, profile_id);
-        if (profile) {
-          addToProfileQueue(profile_id, profile);
-        }
-      }
-    });
-    this._client.on("beforeEnvelope", (envelope) => {
-      if (!PROFILE_MAP.size) {
-        return;
-      }
-      const profiledTransactionEvents = findProfiledTransactionsFromEnvelope(envelope);
-      if (!profiledTransactionEvents.length) {
-        return;
-      }
-      const profilesToAddToEnvelope = [];
-      for (const profiledTransaction of profiledTransactionEvents) {
-        const profileContext = profiledTransaction.contexts?.profile;
-        const profile_id = profileContext?.profile_id;
-        if (!profile_id) {
-          throw new TypeError("[Profiling] cannot find profile for a transaction without a profile context");
-        }
-        if (profileContext) {
-          delete profiledTransaction.contexts?.profile;
-        }
-        const cpuProfile = takeFromProfileQueue(profile_id);
-        if (!cpuProfile) {
-          DEBUG_BUILD && core.debug.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
-          continue;
-        }
-        const profile = createProfilingEvent(this._client, cpuProfile, profiledTransaction);
-        if (!profile) return;
-        profilesToAddToEnvelope.push(profile);
-        this._client.emit("preprocessEvent", profile, {
-          event_id: profiledTransaction.event_id
-        });
-        this._client.emit("postprocessEvent", profile, {
-          event_id: profiledTransaction.event_id
-        });
-      }
-      addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
-    });
-  }
   /**
    * Stop profiler and initializes profiling of the next chunk
    */
@@ -801,15 +430,6 @@ const _nodeProfilingIntegration = (() => {
     }
   };
 });
-function getProfilingMode(options) {
-  if ("profilesSampleRate" in options || "profilesSampler" in options) {
-    return "legacy";
-  }
-  if ("profileSessionSampleRate" in options || "profileLifecycle" in options) {
-    return "current";
-  }
-  return "legacy";
-}
 const nodeProfilingIntegration = core.defineIntegration(_nodeProfilingIntegration);
 
 exports.nodeProfilingIntegration = nodeProfilingIntegration;