Scope attributes sync (without native)

Author: alwx

packages/core/src/js/NativeRNSentry.ts

@@ -32,6 +32,8 @@ export interface Spec extends TurboModule {
   setContext(key: string, value: UnsafeObject | null): void;
   setExtra(key: string, value: string): void;
   setTag(key: string, value: string): void;
+  setAttribute(key: string, value: string): void;
+  setAttributes(attributes: UnsafeObject): void;
   enableNativeFramesTracking(): void;
   fetchModules(): Promise<string | undefined | null>;
   fetchViewHierarchy(): Promise<number[] | undefined | null>;

packages/core/src/js/scopeSync.ts

@@ -79,4 +79,28 @@ export function enableSyncToNative(scope: Scope): void {
     NATIVE.setContext(key, context);
     return original.call(scope, key, context);
   });
+
+  fillTyped(scope, 'setAttribute', original => (key: string, value: unknown): Scope => {
+    // Only sync primitive types
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+      NATIVE.setAttribute(key, value);
+    }
+    return original.call(scope, key, value);
+  });
+
+  fillTyped(scope, 'setAttributes', original => (attributes: Record<string, unknown>): Scope => {
+    // Filter to only primitive types
+    const primitiveAttrs: Record<string, string | number | boolean> = {};
+    Object.keys(attributes).forEach(key => {
+      const value = attributes[key];
+      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        primitiveAttrs[key] = value;
+      }
+    });
+
+    if (Object.keys(primitiveAttrs).length > 0) {
+      NATIVE.setAttributes(primitiveAttrs);
+    }
+    return original.call(scope, attributes);
+  });
 }

packages/core/src/js/wrapper.ts

@@ -100,6 +100,8 @@ interface SentryNativeWrapper {
   setExtra(key: string, extra: unknown): void;
   setUser(user: User | null): void;
   setTag(key: string, value?: string): void;
+  setAttribute(key: string, value: string | number | boolean): void;
+  setAttributes(attributes: Record<string, string | number | boolean>): void;
 
   nativeCrash(): void;
 
@@ -551,6 +553,43 @@ export const NATIVE: SentryNativeWrapper = {
     }
   },
 
+  /**
+   * Sets an attribute on the native scope.
+   * @param key string
+   * @param value primitive value (string, number, or boolean)
+   */
+  setAttribute(key: string, value: string | number | boolean): void {
+    if (!this.enableNative) {
+      return;
+    }
+    if (!this._isModuleLoaded(RNSentry)) {
+      throw this._NativeClientError;
+    }
+
+    const stringifiedValue = this.primitiveProcessor(value);
+    RNSentry.setAttribute(key, stringifiedValue);
+  },
+
+  /**
+   * Sets multiple attributes on the native scope.
+   * @param attributes key-value map of attributes (only string, number, and boolean values)
+   */
+  setAttributes(attributes: Record<string, string | number | boolean>): void {
+    if (!this.enableNative) {
+      return;
+    }
+    if (!this._isModuleLoaded(RNSentry)) {
+      throw this._NativeClientError;
+    }
+
+    const serializedAttributes: Record<string, string> = {};
+    Object.keys(attributes).forEach(key => {
+      serializedAttributes[key] = this.primitiveProcessor(attributes[key]);
+    });
+
+    RNSentry.setAttributes(serializedAttributes);
+  },
+
   /**
    * Closes the Native Layer SDK
    */

packages/core/test/mockWrapper.ts

@@ -41,6 +41,8 @@ const NATIVE: MockInterface<NativeType> = {
   setExtra: jest.fn(),
   setUser: jest.fn(),
   setTag: jest.fn(),
+  setAttribute: jest.fn(),
+  setAttributes: jest.fn(),
 
   nativeCrash: jest.fn(),
 
@@ -92,6 +94,7 @@ NATIVE.crashedLastRun.mockResolvedValue(false);
 NATIVE.popTimeToDisplayFor.mockResolvedValue(null);
 NATIVE.getNewScreenTimeToDisplay.mockResolvedValue(null);
 NATIVE.primitiveProcessor.mockReturnValue('');
+NATIVE.fetchNativeLogAttributes = jest.fn().mockResolvedValue({});
 export const getRNSentryModule = jest.fn();
 
 export { NATIVE };

packages/core/test/scopeSync.test.ts

@@ -116,6 +116,8 @@ describe('ScopeSync', () => {
     let setExtrasScopeSpy: jest.SpyInstance;
     let addBreadcrumbScopeSpy: jest.SpyInstance;
     let setContextScopeSpy: jest.SpyInstance;
+    let setAttributeScopeSpy: jest.SpyInstance;
+    let setAttributesScopeSpy: jest.SpyInstance;
 
     beforeAll(() => {
       const testScope = SentryCore.getIsolationScope();
@@ -126,6 +128,8 @@ describe('ScopeSync', () => {
       setExtrasScopeSpy = jest.spyOn(testScope, 'setExtras');
       addBreadcrumbScopeSpy = jest.spyOn(testScope, 'addBreadcrumb');
       setContextScopeSpy = jest.spyOn(testScope, 'setContext');
+      setAttributeScopeSpy = jest.spyOn(testScope, 'setAttribute');
+      setAttributesScopeSpy = jest.spyOn(testScope, 'setAttributes');
     });
 
     beforeEach(() => {
@@ -214,5 +218,70 @@ describe('ScopeSync', () => {
       expect(NATIVE.setContext).toHaveBeenCalledExactlyOnceWith('key', { key: 'value' });
       expect(setContextScopeSpy).toHaveBeenCalledExactlyOnceWith('key', { key: 'value' });
     });
+
+    it('setAttribute', () => {
+      expect(SentryCore.getIsolationScope().setAttribute).not.toBe(setAttributeScopeSpy);
+
+      SentryCore.getIsolationScope().setAttribute('session_id', 'abc123');
+      expect(NATIVE.setAttribute).toHaveBeenCalledExactlyOnceWith('session_id', 'abc123');
+      expect(setAttributeScopeSpy).toHaveBeenCalledExactlyOnceWith('session_id', 'abc123');
+    });
+
+    it('setAttribute with number', () => {
+      SentryCore.getIsolationScope().setAttribute('request_count', 42);
+      expect(NATIVE.setAttribute).toHaveBeenCalledExactlyOnceWith('request_count', 42);
+    });
+
+    it('setAttribute with boolean', () => {
+      SentryCore.getIsolationScope().setAttribute('is_admin', true);
+      expect(NATIVE.setAttribute).toHaveBeenCalledExactlyOnceWith('is_admin', true);
+    });
+
+    it('setAttribute with non-primitive does not sync to native', () => {
+      SentryCore.getIsolationScope().setAttribute('complex', { nested: 'object' });
+      expect(NATIVE.setAttribute).not.toHaveBeenCalled();
+    });
+
+    it('setAttributes', () => {
+      expect(SentryCore.getIsolationScope().setAttributes).not.toBe(setAttributesScopeSpy);
+
+      SentryCore.getIsolationScope().setAttributes({
+        session_type: 'test',
+        request_count: 42,
+        is_admin: true,
+      });
+      expect(NATIVE.setAttributes).toHaveBeenCalledExactlyOnceWith({
+        session_type: 'test',
+        request_count: 42,
+        is_admin: true,
+      });
+      expect(setAttributesScopeSpy).toHaveBeenCalledExactlyOnceWith({
+        session_type: 'test',
+        request_count: 42,
+        is_admin: true,
+      });
+    });
+
+    it('setAttributes filters non-primitive values', () => {
+      SentryCore.getIsolationScope().setAttributes({
+        session_type: 'test',
+        request_count: 42,
+        complex: { nested: 'object' },
+        is_admin: true,
+      });
+      expect(NATIVE.setAttributes).toHaveBeenCalledExactlyOnceWith({
+        session_type: 'test',
+        request_count: 42,
+        is_admin: true,
+      });
+    });
+
+    it('setAttributes does not sync to native if all values are non-primitive', () => {
+      SentryCore.getIsolationScope().setAttributes({
+        complex1: { nested: 'object' },
+        complex2: ['array'],
+      });
+      expect(NATIVE.setAttributes).not.toHaveBeenCalled();
+    });
   });
 });