feat: logsOrigin implementation

CHANGELOG.md

@@ -8,6 +8,13 @@
 
 ## Unreleased
 
+### Features
+
+- added `logsOrigin` to Sentry Options ([#5354](https://github.com/getsentry/sentry-react-native/pull/5354))
+  Now you can choose which logs will be captured: 'native' for only Logs that comes from the Native code, 'js' for logs that only comes from the JavaScript layer, or 'all' for both layers. This will only have any impact if `enableLogs` is set to `true`.
+  By default it is set to `all` so it behaves the same before this change.
+
+
 ### Fixes
 
 - Android SDK not being disabled when `options.enabled` is set to `false`  ([#5334](https://github.com/getsentry/sentry-react-native/pull/5334))

packages/core/src/js/client.ts

@@ -64,6 +64,13 @@ export class ReactNativeClient extends Client<ReactNativeClientOptions> {
     // We default this to true, as it is the safer scenario
     options.parentSpanIsAlwaysRootSpan =
       options.parentSpanIsAlwaysRootSpan === undefined ? true : options.parentSpanIsAlwaysRootSpan;
+
+    const originalEnableLogs = options.enableLogs;
+    if (options.enableLogs && options.logsOrigin === 'native') {
+      debug.log('disabling Sentry logs on JavaScript due to rule set by logsOrigin');
+      options.enableLogs = false;
+    }
+
     super(options);
 
     this._outcomesBuffer = [];
@@ -87,6 +94,9 @@ export class ReactNativeClient extends Client<ReactNativeClientOptions> {
         }, DEFAULT_FLUSH_INTERVAL);
       });
     }
+
+    // Restore original settings for enabling Native options.
+    options.enableLogs = originalEnableLogs;
   }
 
   /**

packages/core/src/js/integrations/default.ts

@@ -85,7 +85,7 @@ export function getDefaultIntegrations(options: ReactNativeClientOptions): Integ
   if (options.enableNative) {
     integrations.push(deviceContextIntegration());
     integrations.push(modulesLoaderIntegration());
-    if (options.enableLogs) {
+    if (options.enableLogs && options.logsOrigin !== 'native') {
       integrations.push(logEnricherIntegration());
       integrations.push(consoleLoggingIntegration());
     }

packages/core/src/js/options.ts

@@ -316,6 +316,16 @@ export interface BaseReactNativeOptions {
    * @default false
    */
   propagateTraceparent?: boolean;
+
+  /**
+   * Controls which log origin is captured when `enableLogs` is set to true.
+   * 'all' will log all origins.
+   * 'js' will capture only JavaScript logs.
+   * 'native' will capture only native logs.
+   *
+   * @default 'all'
+   */
+  logsOrigin?: 'all' | 'js' | 'native';
 }
 
 export type SentryReplayQuality = 'low' | 'medium' | 'high';

packages/core/src/js/wrapper.ts

@@ -228,6 +228,10 @@ export const NATIVE: SentryNativeWrapper = {
       enableNative: true,
       autoInitializeNativeSdk: true,
       ...originalOptions,
+      // Keeps original behavior of enableLogs by not setting it when not defined.
+      ...(originalOptions.enableLogs !== undefined
+        ? { enableLogs: originalOptions.enableLogs && originalOptions.logsOrigin !== 'js' }
+        : {}),
     };
 
     if (!options.enableNative) {
@@ -273,8 +277,15 @@ export const NATIVE: SentryNativeWrapper = {
 
     // filter out all the options that would crash native.
     /* eslint-disable @typescript-eslint/unbound-method,@typescript-eslint/no-unused-vars */
-    const { beforeSend, beforeBreadcrumb, beforeSendTransaction, integrations, ignoreErrors, ...filteredOptions } =
-      options;
+    const {
+      beforeSend,
+      beforeBreadcrumb,
+      beforeSendTransaction,
+      integrations,
+      ignoreErrors,
+      logsOrigin,
+      ...filteredOptions
+    } = options;
     /* eslint-enable @typescript-eslint/unbound-method,@typescript-eslint/no-unused-vars */
     const nativeIsReady = await RNSentry.initNativeSdk(filteredOptions);
 

packages/core/test/client.test.ts

@@ -7,6 +7,7 @@ import type {
   Transport,
   TransportMakeRequestResponse,
 } from '@sentry/core';
+import * as SentryCore from '@sentry/core';
 import {
   addAutoIpAddressToSession,
   addAutoIpAddressToUser,
@@ -852,6 +853,50 @@ describe('Tests ReactNativeClient', () => {
       );
     });
   });
+
+  describe('logger initialization', () => {
+    afterEach(() => {
+      jest.useRealTimers();
+      jest.restoreAllMocks();
+    });
+
+    test('does not flush logs when enableLogs is false', () => {
+      jest.useFakeTimers();
+      const flushLogsSpy = jest.spyOn(SentryCore, '_INTERNAL_flushLogsBuffer').mockImplementation(jest.fn());
+
+      const { client } = createClientWithSpy({ enableLogs: false });
+
+      client.emit('afterCaptureLog', { message: 'test', attributes: {} } as unknown);
+      jest.advanceTimersByTime(5000);
+
+      expect(flushLogsSpy).not.toHaveBeenCalled();
+    });
+
+    test('does not flush logs when logsOrigin is native', () => {
+      jest.useFakeTimers();
+      const flushLogsSpy = jest.spyOn(SentryCore, '_INTERNAL_flushLogsBuffer').mockImplementation(jest.fn());
+
+      const { client } = createClientWithSpy({ enableLogs: true, logsOrigin: 'native' });
+
+      client.emit('afterCaptureLog', { message: 'test', attributes: {} } as unknown);
+      jest.advanceTimersByTime(5000);
+
+      expect(flushLogsSpy).not.toHaveBeenCalled();
+    });
+
+    it.each([['all' as const], ['js' as const]])('flushes logs when logsOrigin is %s', logOrlogsOriginigin => {
+      jest.useFakeTimers();
+      const flushLogsSpy = jest.spyOn(SentryCore, '_INTERNAL_flushLogsBuffer').mockImplementation(jest.fn());
+
+      const { client } = createClientWithSpy({ enableLogs: true, logsOrigin: logOrlogsOriginigin });
+
+      client.emit('afterCaptureLog', { message: 'test', attributes: {} } as unknown);
+      jest.advanceTimersByTime(5000);
+
+      expect(flushLogsSpy).toHaveBeenCalledTimes(1);
+      expect(flushLogsSpy).toHaveBeenLastCalledWith(client);
+    });
+  });
 });
 
 function mockedOptions(options: Partial<ReactNativeClientOptions>): ReactNativeClientOptions {

packages/core/test/integrations/defaultLogs.test.ts

@@ -0,0 +1,78 @@
+import { consoleLoggingIntegration } from '@sentry/browser';
+import type { Integration } from '@sentry/core';
+import { getDefaultIntegrations } from '../../src/js/integrations/default';
+import { logEnricherIntegration } from '../../src/js/integrations/logEnricherIntegration';
+import type { ReactNativeClientOptions } from '../../src/js/options';
+import { notWeb } from '../../src/js/utils/environment';
+
+jest.mock('../../src/js/utils/environment', () => {
+  const actual = jest.requireActual('../../src/js/utils/environment');
+  return {
+    ...actual,
+    notWeb: jest.fn(() => true),
+  };
+});
+
+const logEnricherIntegrationName = logEnricherIntegration().name;
+const consoleLoggingIntegrationName = consoleLoggingIntegration().name;
+
+describe('getDefaultIntegrations - logging integrations', () => {
+  beforeEach(() => {
+    (notWeb as jest.Mock).mockReturnValue(true);
+  });
+
+  const createOptions = (overrides: Partial<ReactNativeClientOptions>): ReactNativeClientOptions => {
+    return {
+      dsn: 'https://example.com/1',
+      enableNative: true,
+      ...overrides,
+    } as ReactNativeClientOptions;
+  };
+
+  const getIntegrationNames = (options: ReactNativeClientOptions): string[] => {
+    const integrations = getDefaultIntegrations(options);
+    return integrations.map((integration: Integration) => integration.name);
+  };
+
+  it('does not add logging integrations when enableLogs is falsy', () => {
+    const names = getIntegrationNames(createOptions({ enableLogs: false }));
+
+    expect(names).not.toContain(logEnricherIntegrationName);
+    expect(names).not.toContain(consoleLoggingIntegrationName);
+  });
+
+  it('adds logging integrations when enableLogs is true and logsOrigin is not native', () => {
+    const names = getIntegrationNames(createOptions({ enableLogs: true }));
+
+    expect(names).toContain(logEnricherIntegrationName);
+    expect(names).toContain(consoleLoggingIntegrationName);
+  });
+
+  it('does not add logging integrations when logsOrigin is native', () => {
+    const names = getIntegrationNames(
+      createOptions({
+        enableLogs: true,
+        logsOrigin: 'native' as unknown as ReactNativeClientOptions['logsOrigin'],
+      }),
+    );
+
+    expect(names).not.toContain(logEnricherIntegrationName);
+    expect(names).not.toContain(consoleLoggingIntegrationName);
+  });
+
+  it.each([
+    ['all', true],
+    ['js', true],
+    ['native', false],
+  ])('handles logsOrigin %s correctly', (logsOrigin, shouldInclude) => {
+    const names = getIntegrationNames(
+      createOptions({
+        enableLogs: true,
+        logsOrigin: logsOrigin as unknown as ReactNativeClientOptions['logsOrigin'],
+      }),
+    );
+
+    expect(names.includes(logEnricherIntegrationName)).toBe(shouldInclude);
+    expect(names.includes(consoleLoggingIntegrationName)).toBe(shouldInclude);
+  });
+});

packages/core/test/wrapper.test.ts

@@ -312,6 +312,44 @@ describe('Tests Native Wrapper', () => {
       expect(initParameter.ignoreErrorsStr).toBeUndefined();
       expect(initParameter.ignoreErrorsRegex).toBeUndefined();
     });
+
+    test('does not set enableLogs when option is undefined', async () => {
+      await NATIVE.initNativeSdk({
+        dsn: 'test',
+        enableNative: true,
+        autoInitializeNativeSdk: true,
+        devServerUrl: undefined,
+        defaultSidecarUrl: undefined,
+        mobileReplayOptions: undefined,
+      });
+
+      expect(RNSentry.initNativeSdk).toHaveBeenCalled();
+      const initParameter = (RNSentry.initNativeSdk as jest.MockedFunction<any>).mock.calls[0][0];
+      expect(initParameter.enableLogs).toBeUndefined();
+    });
+
+    it.each([
+      ['without logsOrigin', undefined, true],
+      ['with logsOrigin set to Native', 'native' as const, true],
+      ['with logsOrigin set to all', 'all' as const, true],
+      ['with logsOrigin set to JS', 'js' as const, false],
+    ])('handles enableLogs %s', async (_description, logsOrigin, expectedEnableLogs) => {
+      await NATIVE.initNativeSdk({
+        dsn: 'test',
+        enableNative: true,
+        autoInitializeNativeSdk: true,
+        enableLogs: true,
+        ...(logsOrigin !== undefined ? { logsOrigin } : {}),
+        devServerUrl: undefined,
+        defaultSidecarUrl: undefined,
+        mobileReplayOptions: undefined,
+      });
+
+      expect(RNSentry.initNativeSdk).toHaveBeenCalled();
+      const initParameter = (RNSentry.initNativeSdk as jest.MockedFunction<any>).mock.calls[0][0];
+      expect(initParameter.enableLogs).toBe(expectedEnableLogs);
+      expect(initParameter.logsOrigin).toBeUndefined();
+    });
   });
 
   describe('sendEnvelope', () => {

samples/react-native/src/App.tsx

@@ -67,6 +67,7 @@ Sentry.init({
   _experiments: {
     enableUnhandledCPPExceptionsV2: true,
   },
+  logsOrigin: 'all',
   enableLogs: true,
   beforeSendLog: (log) => {
     return log;