feat(core): Support homogeneous primitive arrays as span attributes

Relay's wire contract (AttributeType enum in relay-event-schema) defines
exactly five `type:` tags: boolean, integer, double, string, array.
The SDK's AttributeTypeMap previously declared typed array variants
(`string[]`, `integer[]`, etc.) that Relay does not recognize - these
were never actually emitted because the runtime serializer only handled
primitives, so array-valued attributes silently dropped.

This change:
- Collapses the four `x[]` variants in AttributeTypeMap into a single
  `array` variant whose value is `Array<string> | Array<number> | Array<boolean>`.
- Extends getTypedAttributeValue to auto-detect homogeneous primitive
  arrays and emit `{type: 'array', value: [...]}`.
- Adds an isHomogeneousPrimitiveArray guard so mixed-type and nested
  arrays remain unsupported (dropped by default, stringified under
  the fallback path).
- Updates tests to cover the new typed-array path (including empty
  arrays, unit preservation, and mixed-type drop/stringify).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: nicohrubec

packages/core/src/attributes.ts

@@ -15,10 +15,7 @@ type AttributeTypeMap = {
   integer: number;
   double: number;
   boolean: boolean;
-  'string[]': Array<string>;
-  'integer[]': Array<number>;
-  'double[]': Array<number>;
-  'boolean[]': Array<boolean>;
+  array: Array<string> | Array<number> | Array<boolean>;
 };
 
 /* Generates a type from the AttributeTypeMap like:
@@ -66,9 +63,9 @@ export function isAttributeObject(maybeObj: unknown): maybeObj is AttributeObjec
 /**
  * Converts an attribute value to a typed attribute value.
  *
- * For now, we intentionally only support primitive values and attribute objects with primitive values.
- * If @param useFallback is true, we stringify non-primitive values to a string attribute value. Otherwise
- * we return `undefined` for unsupported values.
+ * For now, we support primitive values and homogeneous arrays of primitives, either raw or
+ * inside attribute objects. If @param useFallback is true, we stringify other non-primitive values
+ * to a string attribute value. Otherwise we return `undefined` for unsupported values.
  *
  * @param value - The value of the passed attribute.
  * @param useFallback - If true, unsupported values will be stringified to a string attribute value.
@@ -170,17 +167,18 @@ function estimatePrimitiveSizeInBytes(value: Primitive): number {
 }
 
 /**
- * NOTE: We intentionally do not return anything for non-primitive values:
- *  - array support will come in the future but if we stringify arrays now,
- *    sending arrays (unstringified) later will be a subtle breaking change.
+ * NOTE: We return typed attributes for primitives and homogeneous arrays of primitives:
+ *  - Homogeneous primitive arrays ship with `type: 'array'` (Relay's wire tag for arrays).
+ *  - Mixed-type and nested arrays are not supported and return undefined.
  *  - Objects are not supported yet and product support is still TBD.
  *  - We still keep the type signature for TypedAttributeValue wider to avoid a
- *    breaking change once we add support for non-primitive values.
- *  - Once we go back to supporting arrays and stringifying all other values,
- *    we already implemented the serialization logic here:
- *    https://github.com/getsentry/sentry-javascript/pull/18165
+ *    breaking change once we add support for other non-primitive values.
  */
 function getTypedAttributeValue(value: unknown): TypedAttributeValue | void {
+  if (Array.isArray(value) && isHomogeneousPrimitiveArray(value)) {
+    return { value, type: 'array' };
+  }
+
   const primitiveType =
     typeof value === 'string'
       ? 'string'
@@ -201,3 +199,10 @@ function getTypedAttributeValue(value: unknown): TypedAttributeValue | void {
     return { value, type: primitiveType };
   }
 }
+
+function isHomogeneousPrimitiveArray(arr: unknown[]): boolean {
+  if (arr.length === 0) return true;
+  const t = typeof arr[0];
+  if (t !== 'string' && t !== 'number' && t !== 'boolean') return false;
+  return arr.every(v => typeof v === t);
+}

packages/core/test/lib/attributes.test.ts

@@ -76,33 +76,38 @@ describe('attributeValueToTypedAttributeValue', () => {
       );
     });
 
-    describe('invalid values (non-primitives)', () => {
-      it.each([
-        ['foo', 'bar'],
-        [1, 2, 3],
-        [true, false, true],
-        [1, 'foo', true],
-        { foo: 'bar' },
-        () => 'test',
-        Symbol('test'),
-      ])('returns undefined for non-primitive raw values (%s)', value => {
-        const result = attributeValueToTypedAttributeValue(value);
-        expect(result).toBeUndefined();
-      });
+    describe('homogeneous primitive arrays', () => {
+      it.each([[['foo', 'bar']], [[1, 2, 3]], [[true, false, true]], [[] as unknown[]]])(
+        'emits a typed array attribute for raw value %j',
+        value => {
+          const result = attributeValueToTypedAttributeValue(value);
+          expect(result).toStrictEqual({ value, type: 'array' });
+        },
+      );
 
-      it.each([
-        ['foo', 'bar'],
-        [1, 2, 3],
-        [true, false, true],
-        [1, 'foo', true],
-        { foo: 'bar' },
-        () => 'test',
-        Symbol('test'),
-      ])('returns undefined for non-primitive attribute object values (%s)', value => {
-        const result = attributeValueToTypedAttributeValue({ value });
-        expect(result).toBeUndefined();
+      it('emits a typed array attribute for attribute object values', () => {
+        const result = attributeValueToTypedAttributeValue({ value: ['foo', 'bar'] });
+        expect(result).toStrictEqual({ value: ['foo', 'bar'], type: 'array' });
       });
     });
+
+    describe('invalid values (non-primitives)', () => {
+      it.each([[[1, 'foo', true]], [{ foo: 'bar' }], [() => 'test'], [Symbol('test')]])(
+        'returns undefined for non-primitive raw values (%s)',
+        value => {
+          const result = attributeValueToTypedAttributeValue(value);
+          expect(result).toBeUndefined();
+        },
+      );
+
+      it.each([[[1, 'foo', true]], [{ foo: 'bar' }], [() => 'test'], [Symbol('test')]])(
+        'returns undefined for non-primitive attribute object values (%s)',
+        value => {
+          const result = attributeValueToTypedAttributeValue({ value });
+          expect(result).toBeUndefined();
+        },
+      );
+    });
   });
 
   describe('with fallback=true', () => {
@@ -189,26 +194,10 @@ describe('attributeValueToTypedAttributeValue', () => {
     });
 
     describe('invalid values (non-primitives) - stringified fallback', () => {
-      it('stringifies string arrays', () => {
-        const result = attributeValueToTypedAttributeValue(['foo', 'bar'], true);
+      it('stringifies mixed-type arrays (not homogeneous)', () => {
+        const result = attributeValueToTypedAttributeValue(['foo', 1, true], true);
         expect(result).toStrictEqual({
-          value: '["foo","bar"]',
-          type: 'string',
-        });
-      });
-
-      it('stringifies number arrays', () => {
-        const result = attributeValueToTypedAttributeValue([1, 2, 3], true);
-        expect(result).toStrictEqual({
-          value: '[1,2,3]',
-          type: 'string',
-        });
-      });
-
-      it('stringifies boolean arrays', () => {
-        const result = attributeValueToTypedAttributeValue([true, false, true], true);
-        expect(result).toStrictEqual({
-          value: '[true,false,true]',
+          value: '["foo",1,true]',
           type: 'string',
         });
       });
@@ -425,15 +414,17 @@ describe('serializeAttributes', () => {
   describe('invalid (non-primitive) values', () => {
     it("doesn't fall back to stringification by default", () => {
       const result = serializeAttributes({ foo: { some: 'object' }, bar: [1, 2, 3], baz: () => {} });
-      expect(result).toStrictEqual({});
+      expect(result).toStrictEqual({
+        bar: { type: 'array', value: [1, 2, 3] },
+      });
     });
 
     it('falls back to stringification of unsupported non-primitive values if fallback is true', () => {
       const result = serializeAttributes({ foo: { some: 'object' }, bar: [1, 2, 3], baz: () => {} }, true);
       expect(result).toStrictEqual({
         bar: {
-          type: 'string',
-          value: '[1,2,3]',
+          type: 'array',
+          value: [1, 2, 3],
         },
         baz: {
           type: 'string',
@@ -445,5 +436,12 @@ describe('serializeAttributes', () => {
         },
       });
     });
+
+    it('drops mixed-type arrays by default and stringifies them with fallback', () => {
+      expect(serializeAttributes({ mixed: ['a', 1] })).toStrictEqual({});
+      expect(serializeAttributes({ mixed: ['a', 1] }, true)).toStrictEqual({
+        mixed: { type: 'string', value: '["a",1]' },
+      });
+    });
   });
 });

packages/core/test/lib/logs/internal.test.ts

@@ -191,7 +191,6 @@ describe('_INTERNAL_captureLog', () => {
       scope.setAttribute('scope_2', { value: 38, unit: 'gigabyte' });
       scope.setAttributes({
         scope_3: true,
-        // these are invalid since for now we don't support arrays
         scope_4: [1, 2, 3],
         scope_5: { value: [true, false, true], unit: 'second' },
       });
@@ -229,6 +228,15 @@ describe('_INTERNAL_captureLog', () => {
           type: 'boolean',
           value: true,
         },
+        scope_4: {
+          type: 'array',
+          value: [1, 2, 3],
+        },
+        scope_5: {
+          type: 'array',
+          value: [true, false, true],
+          unit: 'second',
+        },
         'sentry.timestamp.sequence': { value: expect.any(Number), type: 'integer' },
       });
     });

packages/core/test/lib/tracing/spans/estimateSize.test.ts

@@ -130,9 +130,9 @@ describe('estimateSerializedSpanSizeInBytes', () => {
       status: 'ok',
       is_segment: false,
       attributes: {
-        'item.ids': { type: 'string[]', value: ['id-001', 'id-002', 'id-003', 'id-004', 'id-005'] },
-        scores: { type: 'double[]', value: [1.1, 2.2, 3.3, 4.4] },
-        flags: { type: 'boolean[]', value: [true, false, true] },
+        'item.ids': { type: 'array', value: ['id-001', 'id-002', 'id-003', 'id-004', 'id-005'] },
+        scores: { type: 'array', value: [1.1, 2.2, 3.3, 4.4] },
+        flags: { type: 'array', value: [true, false, true] },
       },
     };
 

packages/core/test/lib/utils/spanUtils.test.ts

@@ -622,11 +622,9 @@ describe('spanToJSON', () => {
           attr1: { type: 'string', value: 'value1' },
           attr2: { type: 'integer', value: 2 },
           attr3: { type: 'boolean', value: true },
+          attr4: { type: 'array', value: [1, 2, 3] },
           [SEMANTIC_ATTRIBUTE_SENTRY_OP]: { type: 'string', value: 'test op' },
           [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: { type: 'string', value: 'auto' },
-          // notice the absence of `attr4`!
-          // for now, we don't yet serialize array attributes. This test will fail
-          // once we allow serializing them.
         },
         links: [
           {