fix it better??

Author: mydea

packages/browser-utils/src/metrics/utils.ts

@@ -108,6 +108,9 @@ export function startStandaloneWebVitalSpan(options: StandaloneWebVitalSpanOptio
     // For example: Chrome vs. Chrome Mobile
     'user_agent.original': WINDOW.navigator?.userAgent,
 
+    // This tells Sentry to infer the IP address from the request
+    'client.address': '{{auto}}',
+
     ...passedAttributes,
   };
 

packages/browser/src/client.ts

@@ -8,6 +8,7 @@ import type {
   ParameterizedString,
   Scope,
   SeverityLevel,
+  User,
 } from '@sentry/core';
 import { Client, applySdkMetadata, getSDKSource } from '@sentry/core';
 import { eventFromException, eventFromMessage } from './eventbuilder';
@@ -82,6 +83,23 @@ export class BrowserClient extends Client<BrowserClientOptions> {
         }
       });
     }
+
+    this.on('postprocessEvent', event => {
+      addAutoIpAddressToUser(event);
+    });
+
+    this.on('beforeSendSession', session => {
+      if ('aggregates' in session) {
+        if (session.attrs?.['ip_address'] === undefined) {
+          session.attrs = {
+            ...session.attrs,
+            ip_address: '{{auto}}',
+          };
+        }
+      } else {
+        addAutoIpAddressToUser(session);
+      }
+    });
   }
 
   /**
@@ -113,22 +131,18 @@ export class BrowserClient extends Client<BrowserClientOptions> {
   ): PromiseLike<Event | null> {
     event.platform = event.platform || 'javascript';
 
-    return super._prepareEvent(event, hint, currentScope, isolationScope).then(prepared => {
-      if (!prepared) {
-        return prepared;
-      }
-
-      // By default, we want to infer the IP address, unless this is explicitly set to `null`
-      // We do this after all other processing is done
-      // If `ip_address` is explicitly set to `null` or a value, we leave it as is
-      if (prepared.user?.ip_address === undefined) {
-        prepared.user = {
-          ...prepared.user,
-          ip_address: '{{auto}}',
-        };
-      }
+    return super._prepareEvent(event, hint, currentScope, isolationScope);
+  }
+}
 
-      return prepared;
-    });
+// By default, we want to infer the IP address, unless this is explicitly set to `null`
+// We do this after all other processing is done
+// If `ip_address` is explicitly set to `null` or a value, we leave it as is
+function addAutoIpAddressToUser(objWithMaybeUser: { user?: User | null }): void {
+  if (objWithMaybeUser.user?.ip_address === undefined) {
+    objWithMaybeUser.user = {
+      ...objWithMaybeUser.user,
+      ip_address: '{{auto}}',
+    };
   }
 }

packages/core/src/client.ts

@@ -411,6 +411,7 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
       }
       sessionAttrs.release = sessionAttrs.release || clientReleaseOption;
       sessionAttrs.environment = sessionAttrs.environment || clientEnvironmentOption;
+      session.attrs = sessionAttrs;
     } else {
       if (!session.release && !clientReleaseOption) {
         DEBUG_BUILD && logger.warn(MISSING_RELEASE_FOR_SESSION_ERROR);
@@ -420,6 +421,8 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
       session.environment = session.environment || clientEnvironmentOption;
     }
 
+    this.emit('beforeSendSession', session);
+
     const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
 
     // sendEnvelope should not throw
@@ -503,6 +506,13 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public on(hook: 'beforeSendEvent', callback: (event: Event, hint?: EventHint | undefined) => void): () => void;
 
+  /**
+   * Register a callback for before sending a session or session aggregrates..
+   * Receives the session/aggregate as second argument.
+   * @returns {() => void} A function that, when executed, removes the registered callback.
+   */
+  public on(hook: 'beforeSendSession', callback: (session: Session | SessionAggregates) => void): () => void;
+
   /**
    * Register a callback for preprocessing an event,
    * before it is passed to (global) event processors.
@@ -511,6 +521,14 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public on(hook: 'preprocessEvent', callback: (event: Event, hint?: EventHint | undefined) => void): () => void;
 
+  /**
+   * Register a callback for postprocessing an event,
+   * after it was passed to (global) event processors, before it is being sent.
+   * Receives an Event & EventHint as arguments.
+   * @returns {() => void} A function that, when executed, removes the registered callback.
+   */
+  public on(hook: 'postprocessEvent', callback: (event: Event, hint?: EventHint | undefined) => void): () => void;
+
   /**
    * Register a callback for when an event has been sent.
    * @returns {() => void} A function that, when executed, removes the registered callback.
@@ -636,12 +654,24 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public emit(hook: 'beforeSendEvent', event: Event, hint?: EventHint): void;
 
+  /**
+   * Fire a hook event before sending a session/aggregates.
+   * Expects to be given the prepared session/aggregates as second argument.
+   */
+  public emit(hook: 'beforeSendSession', session: Session | SessionAggregates): void;
+
   /**
    * Fire a hook event to process events before they are passed to (global) event processors.
    * Expects to be given an Event & EventHint as the second/third argument.
    */
   public emit(hook: 'preprocessEvent', event: Event, hint?: EventHint): void;
 
+  /**
+   * Fire a hook event to process a user on an event before it is sent to Sentry, after all other processors have run.
+   * Expects to be given an Event & EventHint as the second/third argument.
+   */
+  public emit(hook: 'postprocessEvent', event: Event, hint?: EventHint): void;
+
   /*
    * Fire a hook event after sending an event. Expects to be given an Event as the
    * second argument.
@@ -831,6 +861,8 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
         return evt;
       }
 
+      this.emit('postprocessEvent', evt, hint);
+
       evt.contexts = {
         trace: getTraceContextFromScope(currentScope),
         ...evt.contexts,

packages/core/src/types-hoist/session.ts

@@ -37,6 +37,7 @@ export interface SessionAggregates {
   attrs?: {
     environment?: string;
     release?: string;
+    ip_address?: string | null;
   };
   aggregates: Array<AggregationCounts>;
 }

packages/profiling-node/src/integration.ts

@@ -147,6 +147,11 @@ function setupAutomatedSpanProfiling(client: NodeClient): void {
       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,
+      });
     }
 
     addProfilesToEnvelope(envelope, profilesToAddToEnvelope);

packages/replay-internal/src/util/prepareReplayEvent.ts

@@ -40,6 +40,8 @@ export async function prepareReplayEvent({
     return null;
   }
 
+  client.emit('postprocessEvent', preparedEvent, eventHint);
+
   // This normally happens in browser client "_prepareEvent"
   // but since we do not use this private method from the client, but rather the plain import
   // we need to do this manually.
@@ -55,15 +57,5 @@ export async function prepareReplayEvent({
     version: version || '0.0.0',
   };
 
-  // By default, we want to infer the IP address, unless this is explicitly set to `null`
-  // We do this after all other processing is done
-  // If `ip_address` is explicitly set to `null` or a value, we leave it as is
-  if (preparedEvent.user?.ip_address === undefined) {
-    preparedEvent.user = {
-      ...preparedEvent.user,
-      ip_address: '{{auto}}',
-    };
-  }
-
   return preparedEvent;
 }

packages/replay-internal/test/unit/util/prepareReplayEvent.test.ts

@@ -77,21 +77,20 @@ describe('Unit | util | prepareReplayEvent', () => {
         name: 'sentry.javascript.testSdk',
         version: '1.0.0',
       },
-      user: {
-        ip_address: '{{auto}}',
-      },
       sdkProcessingMetadata: expect.any(Object),
       breadcrumbs: undefined,
     });
   });
 
-  it('sets user', async () => {
+  it('emits hooks', async () => {
     const client = getClient()!;
     const scope = getCurrentScope().clone();
 
-    scope.setUser({ id: 'user-id' });
+    const preprocessEvent = vi.fn();
+    const postprocessEvent = vi.fn();
 
-    expect(client).toBeDefined();
+    const removeHook1 = client.on('preprocessEvent', preprocessEvent);
+    const removeHook2 = client.on('postprocessEvent', postprocessEvent);
 
     const replayId = 'replay-ID';
     const event: ReplayEvent = {
@@ -111,11 +110,7 @@ describe('Unit | util | prepareReplayEvent', () => {
       },
     };
 
-    const replayEvent = await prepareReplayEvent({ scope, client, replayId, event });
-
-    expect(client.getSdkMetadata).toHaveBeenCalledTimes(1);
-
-    expect(replayEvent).toEqual({
+    const processedEvent = {
       type: 'replay_event',
       timestamp: 1670837008.634,
       error_ids: ['error-ID'],
@@ -137,73 +132,25 @@ describe('Unit | util | prepareReplayEvent', () => {
         name: 'sentry.javascript.testSdk',
         version: '1.0.0',
       },
-      user: {
-        id: 'user-id',
-        ip_address: '{{auto}}',
-      },
       sdkProcessingMetadata: expect.any(Object),
       breadcrumbs: undefined,
-    });
-  });
-
-  it('allows to set user.ip_address=null', async () => {
-    const client = getClient()!;
-    const scope = getCurrentScope().clone();
-
-    scope.setUser({ id: 'user-id', ip_address: null });
-
-    expect(client).toBeDefined();
-
-    const replayId = 'replay-ID';
-    const event: ReplayEvent = {
-      type: REPLAY_EVENT_NAME,
-      timestamp: 1670837008.634,
-      error_ids: ['error-ID'],
-      trace_ids: ['trace-ID'],
-      urls: ['https://sentry.io/'],
-      replay_id: replayId,
-      replay_type: 'session',
-      segment_id: 3,
-      contexts: {
-        replay: {
-          error_sample_rate: 1.0,
-          session_sample_rate: 0.1,
-        },
-      },
     };
 
-    const replayEvent = await prepareReplayEvent({ scope, client, replayId, event });
+    await prepareReplayEvent({ scope, client, replayId, event });
 
-    expect(client.getSdkMetadata).toHaveBeenCalledTimes(1);
+    expect(preprocessEvent).toHaveBeenCalledTimes(1);
+    expect(preprocessEvent).toHaveBeenCalledWith(event, {
+      event_id: 'replay-ID',
+      integrations: [],
+    });
 
-    expect(replayEvent).toEqual({
-      type: 'replay_event',
-      timestamp: 1670837008.634,
-      error_ids: ['error-ID'],
-      trace_ids: ['trace-ID'],
-      urls: ['https://sentry.io/'],
-      replay_id: 'replay-ID',
-      replay_type: 'session',
-      segment_id: 3,
-      platform: 'javascript',
+    expect(postprocessEvent).toHaveBeenCalledTimes(1);
+    expect(postprocessEvent).toHaveBeenCalledWith(processedEvent, {
       event_id: 'replay-ID',
-      environment: 'production',
-      contexts: {
-        replay: {
-          error_sample_rate: 1.0,
-          session_sample_rate: 0.1,
-        },
-      },
-      sdk: {
-        name: 'sentry.javascript.testSdk',
-        version: '1.0.0',
-      },
-      user: {
-        id: 'user-id',
-        ip_address: null,
-      },
-      sdkProcessingMetadata: expect.any(Object),
-      breadcrumbs: undefined,
+      integrations: [],
     });
+
+    removeHook1();
+    removeHook2();
   });
 });