normalize depth

Author: s1gr1d

dev-packages/node-integration-tests/suites/consola/subject-object-context.ts

@@ -25,12 +25,24 @@ async function run(): Promise<void> {
   // Mixed primitives and objects
   consola.error('Error occurred', 'in payment module', { errorCode: 'E001', retryable: true });
 
-  // Aarrays (should be stored as context attributes)
+  // Arrays (should be stored as context attributes)
   consola.debug('Processing items', [1, 2, 3, 4, 5]);
 
   // Nested objects
   consola.info('Complex data', { user: { id: 789, name: 'Jane' }, metadata: { source: 'api' } });
 
+  // Deep nesting to test normalizeDepth (should be normalized at depth 3 - default)
+  consola.info('Deep object', {
+    level1: {
+      level2: {
+        level3: {
+          level4: { level5: 'should be normalized' },
+        },
+      },
+    },
+    simpleKey: 'simple value',
+  });
+
   await Sentry.flush();
 }
 

dev-packages/node-integration-tests/suites/consola/test.ts

@@ -593,6 +593,26 @@ describe('consola integration', () => {
                 metadata: { value: '{"source":"api"}', type: 'string' },
               },
             },
+            {
+              timestamp: expect.any(Number),
+              level: 'info',
+              body: 'Deep object',
+              severity_number: expect.any(Number),
+              trace_id: expect.any(String),
+              attributes: {
+                'sentry.origin': { value: 'auto.log.consola', type: 'string' },
+                'sentry.release': { value: '1.0.0', type: 'string' },
+                'sentry.environment': { value: 'test', type: 'string' },
+                'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
+                'sentry.sdk.version': { value: expect.any(String), type: 'string' },
+                'server.address': { value: expect.any(String), type: 'string' },
+                'consola.type': { value: 'info', type: 'string' },
+                'consola.level': { value: 3, type: 'integer' },
+                // Nested objects are extracted and normalized respecting normalizeDepth setting
+                level1: { value: '{"level2":{"level3":{"level4":"[Object]"}}}', type: 'string' },
+                simpleKey: { value: 'simple value', type: 'string' },
+              },
+            },
           ],
         },
       })

packages/core/src/integrations/consola.ts

@@ -4,6 +4,7 @@ import { _INTERNAL_captureLog } from '../logs/internal';
 import { formatConsoleArgs } from '../logs/utils';
 import type { LogSeverityLevel } from '../types-hoist/log';
 import { isPrimitive } from '../utils/is';
+import { normalize } from '../utils/normalize';
 
 /**
  * Options for the Sentry Consola reporter.
@@ -239,7 +240,12 @@ export function createConsolaReporter(options: ConsolaReporterOptions = {}): Con
                 for (const key in arg) {
                   // Only add if not conflicting with existing or consola-prefixed attributes
                   if (!(key in attributes) && !(`consola.${key}` in attributes)) {
-                    attributes[key] = (arg as Record<string, unknown>)[key];
+                    // Normalize the value to respect normalizeDepth
+                    attributes[key] = normalize(
+                      (arg as Record<string, unknown>)[key],
+                      normalizeDepth,
+                      normalizeMaxBreadth,
+                    );
                   }
                 }
               } catch {

packages/core/test/lib/integrations/consola.test.ts

@@ -213,7 +213,7 @@ describe('createConsolaReporter', () => {
         attributes: {
           'sentry.origin': 'auto.log.consola',
           'consola.type': 'info',
-          self: circular,
+          self: { self: '[Circular ~]' },
         },
       });
     });
@@ -318,6 +318,34 @@ describe('createConsolaReporter', () => {
       expect(captureCall.attributes.timestamp).toEqual(expect.any(Number));
     });
 
+    it('should respect normalizeDepth when extracting object properties', () => {
+      const logObj = {
+        type: 'info',
+        args: [
+          'Deep object',
+          {
+            level1: {
+              level2: {
+                level3: {
+                  level4: { level5: 'should be normalized' }, // beause of normalizeDepth=3
+                },
+              },
+            },
+            simpleKey: 'simple value',
+          },
+        ],
+      };
+
+      sentryReporter.log(logObj);
+
+      const captureCall = vi.mocked(_INTERNAL_captureLog).mock.calls[0][0];
+      expect(captureCall.level).toBe('info');
+      expect(captureCall.message).toBe('Deep object');
+      expect(captureCall.attributes['sentry.origin']).toBe('auto.log.consola');
+      expect(captureCall.attributes.level1).toEqual({ level2: { level3: { level4: '[Object]' } } });
+      expect(captureCall.attributes.simpleKey).toBe('simple value');
+    });
+
     it('should map consola levels to sentry levels when type is not provided', () => {
       const logObj = {
         level: 0, // Fatal level