@sentry/profiling-node 9.7.0 → 9.9.0

package/lib/cjs/index.js

@@ -375,6 +375,7 @@ function createEventEnvelopeHeaders(
  * Creates a standalone profile_chunk envelope.
  */
 function makeProfileChunkEnvelope(
+  platform,
   chunk,
   sdkInfo,
   tunnel,
@@ -382,6 +383,7 @@ function makeProfileChunkEnvelope(
 ) {
   const profileChunkHeader = {
     type: 'profile_chunk',
+    platform,
   };
 
   return core.createEnvelope(createEventEnvelopeHeaders(sdkInfo, tunnel, dsn), [
@@ -404,6 +406,8 @@ function applyDebugMetadata(client, resource_paths) {
   return core.getDebugImagesForResources(options.stackParser, resource_paths);
 }
 
+/* eslint-disable deprecation/deprecation */
+
 const MAX_PROFILE_DURATION_MS = 30 * 1000;
 
 /**
@@ -540,174 +544,361 @@ function takeFromProfileQueue(profile_id) {
   return profile;
 }
 
-/**
- * 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 !== core.getRootSpan(span)) {
-      return;
-    }
-
-    const profile_id = maybeProfileSpan(client, span);
+class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.call(this);ContinuousProfiler.prototype.__init2.call(this);ContinuousProfiler.prototype.__init3.call(this);ContinuousProfiler.prototype.__init4.call(this);ContinuousProfiler.prototype.__init5.call(this);ContinuousProfiler.prototype.__init6.call(this);ContinuousProfiler.prototype.__init7.call(this); }
 
-    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?.maxProfileDurationMs || MAX_PROFILE_DURATION_MS;
+   __init() {this._client = undefined;}
+   __init2() {this._chunkData = undefined;}
+   __init3() {this._mode = undefined;}
+   __init4() {this._legacyProfilerMode = undefined;}
+   __init5() {this._profileLifecycle = undefined;}
+   __init6() {this._sampled = undefined;}
+   __init7() {this._sessionSamplingRate = 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;
+    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.logger.log(`[Profiling] Profiling mode is ${this._legacyProfilerMode}.`);
+
+        switch (this._legacyProfilerMode) {
+          case 'span': {
+            this._setupAutomaticSpanProfiling();
+            break;
+          }
+          case 'continuous': {
+            // Continous mode requires manual calls to profiler.start() and profiler.stop()
+            break;
+          }
+          default: {
+            DEBUG_BUILD &&
+              core.logger.warn(
+                `[Profiling] Unknown profiler mode: ${this._legacyProfilerMode}, profiler was not initialized`,
+              );
+            break;
+          }
+        }
+        break;
+      }
 
-      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];
+      case 'current': {
+        this._setupSpanChunkInstrumentation();
+
+        DEBUG_BUILD && core.logger.log(`[Profiling] Profiling mode is ${this._profileLifecycle}.`);
+
+        switch (this._profileLifecycle) {
+          case 'trace': {
+            this._startTraceLifecycleProfiling();
+            break;
+          }
+          case 'manual': {
+            // Manual mode requires manual calls to profiler.startProfiler() and profiler.stopProfiler()
+            break;
+          }
+          default: {
+            DEBUG_BUILD &&
+              core.logger.warn(`[Profiling] Unknown profiler mode: ${this._profileLifecycle}, profiler was not initialized`);
+            break;
+          }
+        }
+        break;
       }
+      default: {
+        DEBUG_BUILD && core.logger.warn(`[Profiling] Unknown profiler mode: ${this._mode}, profiler was not initialized`);
+        break;
+      }
+    }
+
+    // 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));
+  }
 
-      // Enqueue a timeout to prevent profiles from running over max duration.
-      const timeout = global.setTimeout(() => {
-        DEBUG_BUILD &&
-          core.logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', core.spanToJSON(span).description);
+  /**
+   * Initializes a new profilerId session and schedules chunk profiling.
+   * @returns void
+   */
+   start() {
+    if (this._mode === 'current') {
+      this._startProfiler();
+      return;
+    }
 
-        const profile = stopSpanProfile(span, profile_id);
-        if (profile) {
-          addToProfileQueue(profile_id, profile);
-        }
-      }, maxProfileDurationMs);
+    if (!this._client) {
+      DEBUG_BUILD && core.logger.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
+      return;
+    }
 
-      // Unref timeout so it doesn't keep the process alive.
-      timeout.unref();
+    if (this._mode !== 'legacy') {
+      DEBUG_BUILD && core.logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
+      return;
+    }
 
-      core.getIsolationScope().setContext('profile', { profile_id });
-      spanToProfileIdMap.set(span, profile_id);
+    if (this._legacyProfilerMode === 'span') {
+      DEBUG_BUILD && core.logger.log('[Profiling] Calls to profiler.start() are not supported in span profiling mode.');
+      return;
     }
-  });
 
-  client.on('spanEnd', span => {
-    const profile_id = spanToProfileIdMap.get(span);
+    // Flush any existing chunks before starting a new one.
 
-    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);
+    this._stopChunkProfiling();
 
-      if (profile) {
-        addToProfileQueue(profile_id, profile);
-      }
+    // Restart the profiler session
+    this._setupSpanChunkInstrumentation();
+    this._restartChunkProfiling();
+  }
+
+  /**
+   * Stops the current chunk and flushes the profile to Sentry.
+   * @returns void
+   */
+   stop() {
+    if (this._mode === 'current') {
+      this._stopProfiler();
+      return;
     }
-  });
 
-  client.on('beforeEnvelope', (envelope) => {
-    // if not profiles are in queue, there is nothing to add to the envelope.
-    if (!PROFILE_MAP.size) {
+    if (!this._client) {
+      DEBUG_BUILD && core.logger.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
       return;
     }
 
-    const profiledTransactionEvents = findProfiledTransactionsFromEnvelope(envelope);
-    if (!profiledTransactionEvents.length) {
+    if (this._mode !== 'legacy') {
+      DEBUG_BUILD && core.logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
       return;
     }
 
-    const profilesToAddToEnvelope = [];
+    if (this._legacyProfilerMode === 'span') {
+      DEBUG_BUILD && core.logger.log('[Profiling] Calls to profiler.stop() are not supported in span profiling mode.');
+      return;
+    }
 
-    for (const profiledTransaction of profiledTransactionEvents) {
-      const profileContext = profiledTransaction.contexts?.profile;
-      const profile_id = profileContext?.profile_id;
+    this._stopChunkProfiling();
+    this._teardownSpanChunkInstrumentation();
+  }
 
-      if (!profile_id) {
-        throw new TypeError('[Profiling] cannot find profile for a transaction without a profile context');
-      }
+   _startProfiler() {
+    if (this._mode !== 'current') {
+      DEBUG_BUILD && core.logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
+      return;
+    }
 
-      // Remove the profile from the transaction context before sending, relay will take care of the rest.
-      if (profileContext) {
-        delete profiledTransaction.contexts?.profile;
-      }
+    if (this._chunkData !== undefined) {
+      DEBUG_BUILD && core.logger.log('[Profiling] Profile session already running, no-op.');
+      return;
+    }
 
-      const cpuProfile = takeFromProfileQueue(profile_id);
-      if (!cpuProfile) {
-        DEBUG_BUILD && core.logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
-        continue;
+    if (this._mode === 'current') {
+      if (!this._sampled) {
+        DEBUG_BUILD && core.logger.log('[Profiling] Profile session not sampled, no-op.');
+        return;
       }
+    }
 
-      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,
-      });
-
-      // @ts-expect-error profile does not inherit from Event
-      client.emit('postprocessEvent', profile, {
-        event_id: profiledTransaction.event_id,
-      });
+    if (this._profileLifecycle === 'trace') {
+      DEBUG_BUILD &&
+        core.logger.log(
+          '[Profiling] You are using the trace profile lifecycle, manual calls to profiler.startProfiler() and profiler.stopProfiler() will be ignored.',
+        );
+      return;
     }
 
-    addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
-  });
-}
+    this._startChunkProfiling();
+  }
 
-class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.call(this);ContinuousProfiler.prototype.__init2.call(this); }
+   _stopProfiler() {
+    if (this._mode !== 'current') {
+      DEBUG_BUILD && core.logger.log('[Profiling] Continuous profiling is not supported in the current mode.');
+      return;
+    }
 
-   __init() {this._client = undefined;}
-   __init2() {this._chunkData = undefined;}
+    if (this._profileLifecycle === 'trace') {
+      DEBUG_BUILD &&
+        core.logger.log(
+          '[Profiling] You are using the trace profile lifecycle, manual calls to profiler.startProfiler() and profiler.stopProfiler() will be ignored.',
+        );
+      return;
+    }
 
-  /**
-   * 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;
+    if (!this._chunkData) {
+      DEBUG_BUILD && core.logger.log('[Profiling] No profile session running, no-op.');
+      return;
+    }
 
-    // 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));
+    this._stopChunkProfiling();
   }
 
   /**
-   * Initializes a new profilerId session and schedules chunk profiling.
-   * @returns void
+   * Starts trace lifecycle profiling. Profiling will remain active as long as there is an active span.
    */
-   start() {
+   _startTraceLifecycleProfiling() {
     if (!this._client) {
-      DEBUG_BUILD && core.logger.log('[Profiling] Failed to start, sentry client was never attached to the profiler.');
+      DEBUG_BUILD &&
+        core.logger.log(
+          '[Profiling] Failed to start trace lifecycle profiling, sentry client was never attached to the profiler.',
+        );
       return;
     }
 
-    // Flush any existing chunks before starting a new one.
-    this._chunkStop();
+    let activeSpanCounter = 0;
+    this._client.on('spanStart', _span => {
+      if (activeSpanCounter === 0) {
+        this._startChunkProfiling();
+      }
+      activeSpanCounter++;
+    });
 
-    // Restart the profiler session
-    this._setupSpanChunkInstrumentation();
-    this._chunkStart();
+    this._client.on('spanEnd', _span => {
+      if (activeSpanCounter === 1) {
+        this._stopChunkProfiling();
+      }
+      activeSpanCounter--;
+    });
   }
 
-  /**
-   * Stops the current chunk and flushes the profile to Sentry.
-   * @returns void
-   */
-   stop() {
+   _setupAutomaticSpanProfiling() {
     if (!this._client) {
-      DEBUG_BUILD && core.logger.log('[Profiling] Failed to stop, sentry client was never attached to the profiler.');
+      DEBUG_BUILD &&
+        core.logger.log(
+          '[Profiling] Failed to setup automatic span profiling, sentry client was never attached to the profiler.',
+        );
       return;
     }
-    this._chunkStop();
-    this._teardownSpanChunkInstrumentation();
+
+    const spanToProfileIdMap = new WeakMap();
+
+    this._client.on('spanStart', span => {
+      if (span !== core.getRootSpan(span)) {
+        return;
+      }
+
+      const profile_id = maybeProfileSpan(this._client, span);
+
+      if (profile_id) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const options = this._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?.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 &&
+            core.logger.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);
+
+        // Unref timeout so it doesn't keep the process alive.
+        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]);
+          // 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);
+        }
+      }
+    });
+
+    this._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 = 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');
+        }
+
+        // Remove the profile from the transaction context before sending, relay will take care of the rest.
+        if (profileContext) {
+          delete profiledTransaction.contexts?.profile;
+        }
+
+        const cpuProfile = takeFromProfileQueue(profile_id);
+        if (!cpuProfile) {
+          DEBUG_BUILD && core.logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
+          continue;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const profile = createProfilingEvent(this._client, cpuProfile, profiledTransaction);
+        if (!profile) return;
+
+        profilesToAddToEnvelope.push(profile);
+
+        // @ts-expect-error profile does not inherit from Event
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._client.emit('preprocessEvent', profile, {
+          event_id: profiledTransaction.event_id,
+        });
+
+        // @ts-expect-error profile does not inherit from Event
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._client.emit('postprocessEvent', profile, {
+          event_id: profiledTransaction.event_id,
+        });
+      }
+
+      addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
+    });
   }
 
   /**
    * Stop profiler and initializes profiling of the next chunk
    */
-   _chunkStart() {
+   _restartChunkProfiling() {
     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
@@ -715,12 +906,13 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
       DEBUG_BUILD && core.logger.log('[Profiling] Profiler was never attached to the client.');
       return;
     }
+
     if (this._chunkData) {
       DEBUG_BUILD &&
         core.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._chunkStop();
+      this._stopChunkProfiling();
     }
 
     this._startChunkProfiling();
@@ -729,32 +921,44 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
   /**
    * Stops profiling of the current chunks and flushes the profile to Sentry
    */
-   _chunkStop() {
+   _stopChunkProfiling() {
+    if (!this._chunkData) {
+      DEBUG_BUILD && core.logger.log('[Profiling] No chunk data found, no-op.');
+      return;
+    }
+
     if (this._chunkData?.timer) {
       global.clearTimeout(this._chunkData.timer);
       this._chunkData.timer = undefined;
       DEBUG_BUILD && core.logger.log(`[Profiling] Stopping profiling chunk: ${this._chunkData.id}`);
     }
+
     if (!this._client) {
       DEBUG_BUILD &&
         core.logger.log('[Profiling] Failed to collect profile, sentry client was never attached to the profiler.');
+      this._resetChunkData();
       return;
     }
+
     if (!this._chunkData?.id) {
       DEBUG_BUILD &&
         core.logger.log(`[Profiling] Failed to collect profile for: ${this._chunkData?.id}, the chunk_id is missing.`);
+      this._resetChunkData();
       return;
     }
 
     const profile = nodeCpuProfiler.CpuProfilerBindings.stopProfiling(this._chunkData.id, nodeCpuProfiler.ProfileFormat.CHUNK);
 
     if (!profile) {
-      DEBUG_BUILD && core.logger.log(`[Profiling] _chunkiledStartTraceID to collect profile for: ${this._chunkData.id}`);
+      DEBUG_BUILD && core.logger.log(`[Profiling] Failed to collect profile for: ${this._chunkData.id}`);
+      this._resetChunkData();
       return;
     }
+
     if (!this._profilerId) {
       DEBUG_BUILD &&
         core.logger.log('[Profiling] Profile chunk does not contain a valid profiler_id, this is a bug in the SDK');
+      this._resetChunkData();
       return;
     }
     if (profile) {
@@ -809,7 +1013,7 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
     const metadata = this._client.getSdkMetadata();
     const tunnel = this._client.getOptions().tunnel;
 
-    const envelope = makeProfileChunkEnvelope(chunk, metadata?.sdk, tunnel, dsn);
+    const envelope = makeProfileChunkEnvelope('node', chunk, metadata?.sdk, tunnel, dsn);
     transport.send(envelope).then(null, reason => {
       DEBUG_BUILD && core.logger.error('Error while sending profile chunk envelope:', reason);
     });
@@ -820,6 +1024,11 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
    * @param chunk
    */
    _startChunkProfiling() {
+    if (this._chunkData) {
+      DEBUG_BUILD && core.logger.log('[Profiling] Chunk is already running, no-op.');
+      return;
+    }
+
     const traceId =
       core.getCurrentScope().getPropagationContext().traceId || core.getIsolationScope().getPropagationContext().traceId;
     const chunk = this._initializeChunk(traceId);
@@ -829,9 +1038,9 @@ class ContinuousProfiler {constructor() { ContinuousProfiler.prototype.__init.ca
 
     chunk.timer = global.setTimeout(() => {
       DEBUG_BUILD && core.logger.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
-      this._chunkStop();
+      this._stopChunkProfiling();
       DEBUG_BUILD && core.logger.log('[Profiling] Starting new profiling chunk.');
-      setImmediate(this._chunkStart.bind(this));
+      setImmediate(this._restartChunkProfiling.bind(this));
     }, CHUNK_INTERVAL_MS);
 
     // Unref timeout so it doesn't keep the process alive.
@@ -937,36 +1146,31 @@ const _nodeProfilingIntegration = (() => {
     _profiler: new ContinuousProfiler(),
     setup(client) {
       DEBUG_BUILD && core.logger.log('[Profiling] Profiling integration setup.');
-      const options = client.getOptions();
-
-      const mode =
-        (options.profilesSampleRate === undefined ||
-          options.profilesSampleRate === null ||
-          options.profilesSampleRate === 0) &&
-        !options.profilesSampler
-          ? 'continuous'
-          : 'span';
-      switch (mode) {
-        case 'continuous': {
-          DEBUG_BUILD && core.logger.log('[Profiling] Continuous profiler mode enabled.');
-          this._profiler.initialize(client);
-          break;
-        }
-        // Default to span profiling when no mode profiler mode is set
-        case 'span':
-        case undefined: {
-          DEBUG_BUILD && core.logger.log('[Profiling] Span profiler mode enabled.');
-          setupAutomatedSpanProfiling(client);
-          break;
-        }
-        default: {
-          DEBUG_BUILD && core.logger.warn(`[Profiling] Unknown profiler mode: ${mode}, profiler was not initialized`);
-        }
-      }
+      this._profiler.initialize(client);
+      return;
     },
   };
 }) ;
 
+/**
+ * Determines the profiling mode based on the options.
+ * @param options
+ * @returns 'legacy' if the options are using the legacy profiling API, 'current' if the options are using the current profiling API
+ */
+function getProfilingMode(options) {
+  // Legacy mode takes precedence over current mode
+  if ('profilesSampleRate' in options || 'profilesSampler' in options) {
+    return 'legacy';
+  }
+
+  if ('profileSessionSampleRate' in options || 'profileLifecycle' in options) {
+    return 'current';
+  }
+
+  // If neither are set, we are in the legacy continuous profiling mode
+  return 'legacy';
+}
+
 /**
  * We need this integration in order to send data to Sentry. We hook into the event processor
  * and inspect each event to see if it is a transaction event and if that transaction event