fix(core): Ignore non-primitive values passed to setTag(s)

Author: Lms24

packages/core/src/scope.ts

@@ -17,7 +17,7 @@ import type { Span } from './types-hoist/span';
 import type { PropagationContext } from './types-hoist/tracing';
 import type { User } from './types-hoist/user';
 import { debug } from './utils/debug-logger';
-import { isPlainObject } from './utils/is';
+import { isPlainObject, isPrimitive } from './utils/is';
 import { merge } from './utils/merge';
 import { uuid4 } from './utils/misc';
 import { generateTraceId } from './utils/propagationContext';
@@ -279,10 +279,11 @@ export class Scope {
    * and will be sent as tags data with the event.
    */
   public setTags(tags: { [key: string]: Primitive }): this {
-    this._tags = {
-      ...this._tags,
-      ...tags,
-    };
+    for (const [key, value] of Object.entries(tags)) {
+      if (isPrimitive(value)) {
+        this._tags[key] = value;
+      }
+    }
     this._notifyScopeListeners();
     return this;
   }
@@ -291,9 +292,7 @@ export class Scope {
    * Set a single tag that will be sent as tags data with the event.
    */
   public setTag(key: string, value: Primitive): this {
-    this._tags = { ...this._tags, [key]: value };
-    this._notifyScopeListeners();
-    return this;
+    return this.setTags({ [key]: value });
   }
 
   /**

packages/core/test/lib/scope.test.ts

@@ -140,16 +140,61 @@ describe('Scope', () => {
       expect(scope['_extra']).toEqual({ a: undefined });
     });
 
-    test('setTag', () => {
-      const scope = new Scope();
-      scope.setTag('a', 'b');
-      expect(scope['_tags']).toEqual({ a: 'b' });
+    describe('setTag', () => {
+      it('sets a tag', () => {
+        const scope = new Scope();
+        scope.setTag('a', 'b');
+        expect(scope['_tags']).toEqual({ a: 'b' });
+      });
+
+      it('sets a tag with undefined', () => {
+        const scope = new Scope();
+        scope.setTag('a', 'b');
+        scope.setTag('a', undefined);
+        expect(scope['_tags']).toEqual({ a: undefined });
+      });
+
+      it('notifies scope listeners once per call', () => {
+        const scope = new Scope();
+        const listener = vi.fn();
+
+        scope.addScopeListener(listener);
+        scope.setTag('a', 'b');
+        scope.setTag('a', 'c');
+
+        expect(listener).toHaveBeenCalledTimes(2);
+      });
+
+      it('discards non-primitive values', () => {
+        const scope = new Scope();
+        // @ts-expect-error we want to test with a non-primitive value despite types not allowing it
+        scope.setTag('a', { b: 'c' });
+        expect(scope['_tags']).toEqual({});
+      });
     });
 
-    test('setTags', () => {
-      const scope = new Scope();
-      scope.setTags({ a: 'b' });
-      expect(scope['_tags']).toEqual({ a: 'b' });
+    describe('setTags', () => {
+      it('sets tags', () => {
+        const scope = new Scope();
+        scope.setTags({ a: 'b' });
+        expect(scope['_tags']).toEqual({ a: 'b' });
+      });
+
+      it('notifies scope listeners once per call', () => {
+        const scope = new Scope();
+        const listener = vi.fn();
+        scope.addScopeListener(listener);
+        scope.setTags({ a: 'b', c: 'd' });
+        scope.setTags({ a: 'e', f: 'g' });
+        expect(listener).toHaveBeenCalledTimes(2);
+      });
+
+      it('discards non-primitive values', () => {
+        const scope = new Scope();
+        // @ts-expect-error we want to test with a non-primitive value despite types not allowing it
+        scope.setTags({ a: { b: 'c' }, b: [1, 2, 3], c: new Map(), d: () => {} });
+        expect(scope['_tags']).toEqual({});
+      });
     });
 
     test('setUser', () => {