fix(browser): Ensure IP address is only inferred by Relay if sendDefaultPii is true

Lms24 · Lms24 · commit b41f05158465 · 2025-08-08T17:00:19.000+02:00
diff --git a/dev-packages/browser-integration-tests/suites/feedback/attachTo/test.ts b/dev-packages/browser-integration-tests/suites/feedback/attachTo/test.ts
@@ -61,6 +61,9 @@ sentryTest('should capture feedback with custom button', async ({ getLocalTestUr
       version: expect.any(String),
       name: 'sentry.javascript.browser',
       packages: expect.anything(),
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
diff --git a/dev-packages/browser-integration-tests/suites/feedback/captureFeedback/test.ts b/dev-packages/browser-integration-tests/suites/feedback/captureFeedback/test.ts
@@ -61,6 +61,9 @@ sentryTest('should capture feedback', async ({ getLocalTestUrl, page }) => {
       version: expect.any(String),
       name: 'sentry.javascript.browser',
       packages: expect.anything(),
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
diff --git a/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/test.ts b/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackAndReplay/hasSampling/test.ts
@@ -95,6 +95,9 @@ sentryTest('should capture feedback', async ({ forceFlushReplay, getLocalTestUrl
       version: expect.any(String),
       name: 'sentry.javascript.browser',
       packages: expect.anything(),
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
diff --git a/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackCsp/test.ts b/dev-packages/browser-integration-tests/suites/feedback/captureFeedbackCsp/test.ts
@@ -61,6 +61,9 @@ sentryTest('should capture feedback', async ({ getLocalTestUrl, page }) => {
       version: expect.any(String),
       name: 'sentry.javascript.browser',
       packages: expect.anything(),
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
diff --git a/dev-packages/browser-integration-tests/suites/manual-client/browser-context/test.ts b/dev-packages/browser-integration-tests/suites/manual-client/browser-context/test.ts
@@ -41,6 +41,9 @@ sentryTest('allows to setup a client manually & capture exceptions', async ({ ge
       name: 'sentry.javascript.browser',
       version: expect.any(String),
       packages: [{ name: expect.any(String), version: expect.any(String) }],
+      settings: {
+        infer_ip: 'never',
+      },
     },
     contexts: {
       trace: { trace_id: expect.stringMatching(/[a-f0-9]{32}/), span_id: expect.stringMatching(/[a-f0-9]{16}/) },
diff --git a/dev-packages/browser-integration-tests/suites/public-api/captureException/simpleError/test.ts b/dev-packages/browser-integration-tests/suites/public-api/captureException/simpleError/test.ts
@@ -39,5 +39,8 @@ sentryTest('should capture correct SDK metadata', async ({ getLocalTestUrl, page
         version: SDK_VERSION,
       },
     ],
+    settings: {
+      infer_ip: 'never',
+    },
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/errors/test.ts b/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/errors/test.ts
@@ -1,10 +1,12 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest } from '../../../../utils/helpers';
+import { envelopeRequestParser, waitForErrorRequestOnUrl } from '../../../../utils/helpers';
 
-sentryTest('should default user to {{auto}} on errors when sendDefaultPii: true', async ({ getLocalTestUrl, page }) => {
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  expect(eventData.user?.ip_address).toBe('{{auto}}');
-});
+sentryTest(
+  'sets sdk.settings.infer_ip to "auto" on errors when sendDefaultPii: true',
+  async ({ getLocalTestUrl, page }) => {
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const eventData = await envelopeRequestParser(await waitForErrorRequestOnUrl(page, url));
+    expect(eventData.sdk?.settings?.infer_ip).toBe('auto');
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/performance/test.ts b/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/performance/test.ts
@@ -7,7 +7,7 @@ import {
 } from '../../../../utils/helpers';
 
 sentryTest(
-  'should default user to {{auto}} on transactions when sendDefaultPii: true',
+  'sets user.ip_address to "auto" on transactions when sendDefaultPii: true',
   async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
@@ -16,6 +16,6 @@ sentryTest(
     const url = await getLocalTestUrl({ testDir: __dirname });
     const req = await waitForTransactionRequestOnUrl(page, url);
     const transaction = envelopeRequestParser(req);
-    expect(transaction.user?.ip_address).toBe('{{auto}}');
+    expect(transaction.sdk?.settings?.infer_ip).toBe('auto');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/replay/test.ts b/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/replay/test.ts
@@ -3,7 +3,7 @@ import { sentryTest } from '../../../../utils/fixtures';
 import { getReplayEvent, shouldSkipReplayTest, waitForReplayRequest } from '../../../../utils/replayHelpers';
 
 sentryTest(
-  'replay recording should contain default performance spans',
+  'sets sdk.settings.infer_ip to "auto" on replay events when sendDefaultPii: true',
   async ({ getLocalTestUrl, page, browserName }) => {
     // We only test this against the NPM package and replay bundles
     // and only on chromium as most performance entries are only available in chromium
@@ -18,6 +18,6 @@ sentryTest(
     await page.goto(url);
     const replayEvent = getReplayEvent(await reqPromise0);
 
-    expect(replayEvent.user?.ip_address).toBe('{{auto}}');
+    expect(replayEvent.sdk?.settings?.infer_ip).toBe('auto');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/sessions/test.ts b/dev-packages/browser-integration-tests/suites/public-api/sendDefaultPii/sessions/test.ts
@@ -3,7 +3,7 @@ import { sentryTest } from '../../../../utils/fixtures';
 import { getFirstSentryEnvelopeRequest } from '../../../../utils/helpers';
 
 sentryTest(
-  'should default user to {{auto}} on sessions when sendDefaultPii: true',
+  'sets attrs.ip_address user to {{auto}} on sessions when sendDefaultPii: true',
   async ({ getLocalTestUrl, page }) => {
     const url = await getLocalTestUrl({ testDir: __dirname });
     const session = await getFirstSentryEnvelopeRequest(page, url);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/setUser/unset_user/test.ts b/dev-packages/browser-integration-tests/suites/public-api/setUser/unset_user/test.ts
@@ -11,7 +11,7 @@ sentryTest('should unset user', async ({ getLocalTestUrl, page }) => {
   expect(eventData[0].message).toBe('no_user');
 
   // because sendDefaultPii: true
-  expect(eventData[0].user).toEqual({ ip_address: '{{auto}}' });
+  expect(eventData[0].sdk?.settings?.infer_ip).toBe('auto');
 
   expect(eventData[1].message).toBe('user');
   expect(eventData[1].user).toEqual({
@@ -23,7 +23,5 @@ sentryTest('should unset user', async ({ getLocalTestUrl, page }) => {
   expect(eventData[2].message).toBe('unset_user');
 
   // because sendDefaultPii: true
-  expect(eventData[2].user).toEqual({
-    ip_address: '{{auto}}',
-  });
+  expect(eventData[2].sdk?.settings?.infer_ip).toBe('auto');
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/setUser/update_user/test.ts b/dev-packages/browser-integration-tests/suites/public-api/setUser/update_user/test.ts
@@ -13,10 +13,11 @@ sentryTest('should update user', async ({ getLocalTestUrl, page }) => {
     id: 'foo',
     ip_address: 'bar',
   });
+  expect(eventData[0].sdk?.settings?.infer_ip).toBe('auto');
 
   expect(eventData[1].message).toBe('second_user');
   expect(eventData[1].user).toEqual({
     id: 'baz',
-    ip_address: '{{auto}}',
   });
+  expect(eventData[1].sdk?.settings?.infer_ip).toBe('auto');
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/withScope/nested_scopes/test.ts b/dev-packages/browser-integration-tests/suites/public-api/withScope/nested_scopes/test.ts
@@ -11,34 +11,28 @@ sentryTest('should allow nested scoping', async ({ getLocalTestUrl, page }) => {
   expect(eventData[0].message).toBe('root_before');
   expect(eventData[0].user).toEqual({
     id: 'qux',
-    ip_address: '{{auto}}', // because sendDefaultPii: true
   });
   expect(eventData[0].tags).toBeUndefined();
 
   expect(eventData[1].message).toBe('outer_before');
   expect(eventData[1].user).toEqual({
     id: 'qux',
-    ip_address: '{{auto}}', // because sendDefaultPii: true
   });
   expect(eventData[1].tags).toMatchObject({ foo: false });
 
   expect(eventData[2].message).toBe('inner');
-  expect(eventData[2].user).toEqual({
-    ip_address: '{{auto}}', // because sendDefaultPii: true
-  });
+  expect(eventData[2].user).toEqual({});
   expect(eventData[2].tags).toMatchObject({ foo: false, bar: 10 });
 
   expect(eventData[3].message).toBe('outer_after');
   expect(eventData[3].user).toEqual({
     id: 'baz',
-    ip_address: '{{auto}}', // because sendDefaultPii: true
   });
   expect(eventData[3].tags).toMatchObject({ foo: false });
 
   expect(eventData[4].message).toBe('root_after');
   expect(eventData[4].user).toEqual({
     id: 'qux',
-    ip_address: '{{auto}}', // because sendDefaultPii: true
   });
   expect(eventData[4].tags).toBeUndefined();
 });
diff --git a/dev-packages/browser-integration-tests/suites/replay/captureReplay/test.ts b/dev-packages/browser-integration-tests/suites/replay/captureReplay/test.ts
@@ -47,6 +47,9 @@ sentryTest('should capture replays (@sentry/browser export)', async ({ getLocalT
       ]),
       version: SDK_VERSION,
       name: 'sentry.javascript.browser',
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
@@ -85,6 +88,9 @@ sentryTest('should capture replays (@sentry/browser export)', async ({ getLocalT
       ]),
       version: SDK_VERSION,
       name: 'sentry.javascript.browser',
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
diff --git a/dev-packages/browser-integration-tests/suites/replay/captureReplayFromReplayPackage/test.ts b/dev-packages/browser-integration-tests/suites/replay/captureReplayFromReplayPackage/test.ts
@@ -47,6 +47,9 @@ sentryTest('should capture replays (@sentry-internal/replay export)', async ({ g
       ]),
       version: SDK_VERSION,
       name: 'sentry.javascript.browser',
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
@@ -85,6 +88,9 @@ sentryTest('should capture replays (@sentry-internal/replay export)', async ({ g
       ]),
       version: SDK_VERSION,
       name: 'sentry.javascript.browser',
+      settings: {
+        infer_ip: 'never',
+      },
     },
     request: {
       url: `${TEST_HOST}/index.html`,
diff --git a/dev-packages/browser-integration-tests/utils/replayEventTemplates.ts b/dev-packages/browser-integration-tests/utils/replayEventTemplates.ts
@@ -30,6 +30,9 @@ const DEFAULT_REPLAY_EVENT = {
     ]),
     version: SDK_VERSION,
     name: 'sentry.javascript.browser',
+    settings: {
+      infer_ip: 'never',
+    },
   },
   request: {
     url: expect.stringContaining('/index.html'),
diff --git a/packages/browser/src/client.ts b/packages/browser/src/client.ts
@@ -83,6 +83,15 @@ export class BrowserClient extends Client<BrowserClientOptions> {
     const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();
     applySdkMetadata(opts, 'browser', ['browser'], sdkSource);
 
+    // Only allow IP inferral by Relay if sendDefaultPii is true
+    if (opts._metadata?.sdk) {
+      opts._metadata.sdk.settings = {
+        infer_ip: opts.sendDefaultPii ? 'auto' : 'never',
+        // purposefully allowing already passed settings to override the default
+        ...opts._metadata.sdk.settings,
+      };
+    }
+
     super(opts);
 
     const { sendDefaultPii, sendClientReports, enableLogs } = this._options;
@@ -117,7 +126,6 @@ export class BrowserClient extends Client<BrowserClientOptions> {
     }
 
     if (sendDefaultPii) {
-      this.on('postprocessEvent', addAutoIpAddressToUser);
       this.on('beforeSendSession', addAutoIpAddressToSession);
     }
   }
diff --git a/packages/browser/test/client.test.ts b/packages/browser/test/client.test.ts
@@ -184,3 +184,93 @@ describe('applyDefaultOptions', () => {
     WINDOW.SENTRY_RELEASE = releaseBefore;
   });
 });
+
+describe('SDK metadata', () => {
+  describe('sdk.settings', () => {
+    it('sets infer_ipto "never" by default', () => {
+      const options = getDefaultBrowserClientOptions({});
+      const client = new BrowserClient(options);
+
+      expect(client.getOptions()._metadata?.sdk?.settings?.infer_ip).toBe('never');
+    });
+
+    it('sets infer_ip to "never" if sendDefaultPii is false', () => {
+      const options = getDefaultBrowserClientOptions({
+        sendDefaultPii: false,
+      });
+      const client = new BrowserClient(options);
+
+      expect(client.getOptions()._metadata?.sdk?.settings?.infer_ip).toBe('never');
+    });
+
+    it('sets infer_ip to "auto" if sendDefaultPii is true', () => {
+      const options = getDefaultBrowserClientOptions({
+        sendDefaultPii: true,
+      });
+      const client = new BrowserClient(options);
+
+      expect(client.getOptions()._metadata?.sdk?.settings?.infer_ip).toBe('auto');
+    });
+
+    it("doesn't override already set sdk metadata settings", () => {
+      const options = getDefaultBrowserClientOptions({
+        sendDefaultPii: true,
+        _metadata: {
+          sdk: {
+            settings: {
+              infer_ip: 'never',
+              // @ts-expect-error -- not typed but let's test anyway
+              other_random_setting: 'some value',
+            },
+          },
+        },
+      });
+      const client = new BrowserClient(options);
+
+      expect(client.getOptions()._metadata?.sdk?.settings).toEqual({
+        infer_ip: 'never',
+        other_random_setting: 'some value',
+      });
+    });
+
+    it('still sets infer_ip if other SDK metadata was already passed in', () => {
+      const options = getDefaultBrowserClientOptions({
+        _metadata: {
+          sdk: {
+            name: 'sentry.javascript.angular',
+          },
+        },
+      });
+      const client = new BrowserClient(options);
+
+      expect(client.getOptions()._metadata?.sdk).toEqual({
+        name: 'sentry.javascript.angular',
+        settings: {
+          infer_ip: 'never',
+        },
+      });
+    });
+  });
+
+  describe('sdk data', () => {
+    it('sets sdk.name to "sentry.javascript.browser" by default', () => {
+      const options = getDefaultBrowserClientOptions({});
+      const client = new BrowserClient(options);
+
+      expect(client.getOptions()._metadata?.sdk?.name).toBe('sentry.javascript.browser');
+    });
+
+    it("doesn't override already set sdk metadata", () => {
+      const options = getDefaultBrowserClientOptions({
+        _metadata: {
+          sdk: {
+            name: 'sentry.javascript.angular',
+          },
+        },
+      });
+      const client = new BrowserClient(options);
+
+      expect(client.getOptions()._metadata?.sdk?.name).toBe('sentry.javascript.angular');
+    });
+  });
+});
diff --git a/packages/core/src/envelope.ts b/packages/core/src/envelope.ts
@@ -37,11 +37,18 @@ function enhanceEventWithSdkInfo(event: Event, sdkInfo?: SdkInfo): Event {
   if (!sdkInfo) {
     return event;
   }
-  event.sdk = event.sdk || {};
-  event.sdk.name = event.sdk.name || sdkInfo.name;
-  event.sdk.version = event.sdk.version || sdkInfo.version;
-  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];
-  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];
+
+  event.sdk = {
+    ...event.sdk,
+    ...sdkInfo,
+    integrations: [...(event.sdk?.integrations || []), ...(sdkInfo.integrations || [])],
+    packages: [...(event.sdk?.packages || []), ...(sdkInfo.packages || [])],
+    settings: {
+      ...event.sdk?.settings,
+      ...sdkInfo.settings,
+    },
+  };
+
   return event;
 }
 
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -63,7 +63,10 @@ export { hasSpansEnabled } from './utils/hasSpansEnabled';
 export { isSentryRequestUrl } from './utils/isSentryRequestUrl';
 export { handleCallbackErrors } from './utils/handleCallbackErrors';
 export { parameterize, fmt } from './utils/parameterize';
-export { addAutoIpAddressToSession, addAutoIpAddressToUser } from './utils/ipAddress';
+
+export { addAutoIpAddressToSession } from './utils/ipAddress';
+// eslint-disable-next-line deprecation/deprecation
+export { addAutoIpAddressToUser } from './utils/ipAddress';
 export {
   convertSpanLinksForEnvelope,
   spanToTraceHeader,
diff --git a/packages/core/src/types-hoist/sdkinfo.ts b/packages/core/src/types-hoist/sdkinfo.ts
diff --git a/packages/core/src/utils/ipAddress.ts b/packages/core/src/utils/ipAddress.ts
diff --git a/packages/core/src/utils/sdkMetadata.ts b/packages/core/src/utils/sdkMetadata.ts
diff --git a/packages/replay-internal/src/util/prepareReplayEvent.ts b/packages/replay-internal/src/util/prepareReplayEvent.ts
