fix(node): Pino child loggers

dev-packages/node-integration-tests/suites/pino/scenario-track.mjs

@@ -17,7 +17,18 @@ Sentry.withIsolationScope(() => {
 setTimeout(() => {
   Sentry.withIsolationScope(() => {
     Sentry.startSpan({ name: 'later' }, () => {
-      logger.error(new Error('oh no'));
+      // This child should be captured as we marked the parent logger to be tracked
+      const child = logger.child({ module: 'authentication' });
+      child.error(new Error('oh no'));
+
+      // This child should be ignored
+      const child2 = logger.child({ module: 'authentication.v2' });
+      Sentry.pinoIntegration.ignoreLogger(child2);
+      child2.error(new Error('oh no v2'));
+
+      // This should also be ignored as the parent is ignored
+      const child3 = child2.child({ module: 'authentication.v3' });
+      child3.error(new Error('oh no v3'));
     });
   });
 }, 1000);

dev-packages/node-integration-tests/suites/pino/scenario.mjs

@@ -4,7 +4,7 @@ import pino from 'pino';
 const logger = pino({ name: 'myapp' });
 
 const ignoredLogger = pino({ name: 'ignored' });
-Sentry.pinoIntegration.untrackLogger(ignoredLogger);
+Sentry.pinoIntegration.ignoreLogger(ignoredLogger);
 
 ignoredLogger.info('this will not be tracked');
 
@@ -17,7 +17,8 @@ Sentry.withIsolationScope(() => {
 setTimeout(() => {
   Sentry.withIsolationScope(() => {
     Sentry.startSpan({ name: 'later' }, () => {
-      logger.error(new Error('oh no'));
+      const child = logger.child({ module: 'authentication' });
+      child.error(new Error('oh no'));
     });
   });
 }, 1000);

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

@@ -45,7 +45,6 @@ conditionalTest({ min: 20 })('Pino integration', () => {
                       function: '?',
                       in_app: true,
                       module: 'scenario',
-                      context_line: "      logger.error(new Error('oh no'));",
                     }),
                   ]),
                 },
@@ -63,8 +62,8 @@ conditionalTest({ min: 20 })('Pino integration', () => {
               body: 'hello world',
               trace_id: expect.any(String),
               severity_number: 9,
-              attributes: expect.objectContaining({
-                'pino.logger.name': { value: 'myapp', type: 'string' },
+              attributes: {
+                name: { value: 'myapp', type: 'string' },
                 'pino.logger.level': { value: 30, type: 'integer' },
                 user: { value: 'user-id', type: 'string' },
                 something: {
@@ -74,22 +73,22 @@ conditionalTest({ min: 20 })('Pino integration', () => {
                 'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
                 'sentry.release': { value: '1.0', type: 'string' },
                 'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
-              }),
+              },
             },
             {
               timestamp: expect.any(Number),
               level: 'error',
               body: 'oh no',
               trace_id: expect.any(String),
               severity_number: 17,
-              attributes: expect.objectContaining({
-                'pino.logger.name': { value: 'myapp', type: 'string' },
+              attributes: {
+                name: { value: 'myapp', type: 'string' },
+                module: { value: 'authentication', type: 'string' },
                 'pino.logger.level': { value: 50, type: 'integer' },
-                err: { value: '{}', type: 'string' },
                 'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
                 'sentry.release': { value: '1.0', type: 'string' },
                 'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
-              }),
+              },
             },
           ],
         },
@@ -139,8 +138,8 @@ conditionalTest({ min: 20 })('Pino integration', () => {
               body: 'hello world',
               trace_id: expect.any(String),
               severity_number: 9,
-              attributes: expect.objectContaining({
-                'pino.logger.name': { value: 'myapp', type: 'string' },
+              attributes: {
+                name: { value: 'myapp', type: 'string' },
                 'pino.logger.level': { value: 30, type: 'integer' },
                 user: { value: 'user-id', type: 'string' },
                 something: {
@@ -150,22 +149,73 @@ conditionalTest({ min: 20 })('Pino integration', () => {
                 'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
                 'sentry.release': { value: '1.0', type: 'string' },
                 'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
-              }),
+              },
             },
             {
               timestamp: expect.any(Number),
               level: 'error',
               body: 'oh no',
               trace_id: expect.any(String),
               severity_number: 17,
-              attributes: expect.objectContaining({
-                'pino.logger.name': { value: 'myapp', type: 'string' },
+              attributes: {
+                name: { value: 'myapp', type: 'string' },
                 'pino.logger.level': { value: 50, type: 'integer' },
-                err: { value: '{}', type: 'string' },
                 'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
                 'sentry.release': { value: '1.0', type: 'string' },
                 'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
-              }),
+              },
+            },
+          ],
+        },
+      })
+      .start()
+      .completed();
+  });
+
+  test('captures logs when autoInstrument is false and logger is tracked', async () => {
+    const instrumentPath = join(__dirname, 'instrument-auto-off.mjs');
+
+    await createRunner(__dirname, 'scenario-track.mjs')
+      .withMockSentryServer()
+      .withInstrument(instrumentPath)
+      .expect({
+        log: {
+          items: [
+            {
+              timestamp: expect.any(Number),
+              level: 'info',
+              body: 'hello world',
+              trace_id: expect.any(String),
+              severity_number: 9,
+              attributes: {
+                name: { value: 'myapp', type: 'string' },
+                'pino.logger.level': { value: 30, type: 'integer' },
+                user: { value: 'user-id', type: 'string' },
+                something: {
+                  type: 'string',
+                  value: '{"more":3,"complex":"nope"}',
+                },
+                msg: { value: 'hello world', type: 'string' },
+                'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
+                'sentry.release': { value: '1.0', type: 'string' },
+                'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
+              },
+            },
+            {
+              timestamp: expect.any(Number),
+              level: 'error',
+              body: 'oh no',
+              trace_id: expect.any(String),
+              severity_number: 17,
+              attributes: {
+                name: { value: 'myapp', type: 'string' },
+                module: { value: 'authentication', type: 'string' },
+                msg: { value: 'oh no', type: 'string' },
+                'pino.logger.level': { value: 50, type: 'integer' },
+                'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
+                'sentry.release': { value: '1.0', type: 'string' },
+                'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
+              },
             },
           ],
         },

packages/angular/README.md

@@ -16,7 +16,7 @@
 
 ## Angular Version Compatibility
 
-This SDK officially supports Angular 14 to 20.
+This SDK officially supports Angular 14 to 19.
 
 If you're using an older Angular version please check the
 [compatibility table in the docs](https://docs.sentry.io/platforms/javascript/guides/angular/#angular-version-compatibility).

packages/node-core/src/integrations/pino.ts

@@ -81,9 +81,23 @@ type DeepPartial<T> = {
   [P in keyof T]?: T[P] extends object ? Partial<T[P]> : T[P];
 };
 
+type PinoResult = {
+  level?: string;
+  time?: string;
+  pid?: number;
+  hostname?: string;
+  err?: Error;
+} & Record<string, unknown>;
+
+function stripIgnoredFields(result: PinoResult): PinoResult {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { level, time, pid, hostname, err, ...rest } = result;
+  return rest;
+}
+
 const _pinoIntegration = defineIntegration((userOptions: DeepPartial<PinoOptions> = {}) => {
   const options: PinoOptions = {
-    autoInstrument: userOptions.autoInstrument === false ? userOptions.autoInstrument : DEFAULT_OPTIONS.autoInstrument,
+    autoInstrument: userOptions.autoInstrument !== false,
     error: { ...DEFAULT_OPTIONS.error, ...userOptions.error },
     log: { ...DEFAULT_OPTIONS.log, ...userOptions.log },
   };
@@ -112,27 +126,23 @@ const _pinoIntegration = defineIntegration((userOptions: DeepPartial<PinoOptions
       const injectedChannel = tracingChannel('orchestrion:pino:pino-log');
       const integratedChannel = tracingChannel('pino_asJson');
 
-      function onPinoStart(self: Pino, args: PinoHookArgs, result: string): void {
+      function onPinoStart(self: Pino, args: PinoHookArgs, result: PinoResult): void {
         if (!shouldTrackLogger(self)) {
           return;
         }
 
-        const [obj, message, levelNumber] = args;
+        const resultObj = stripIgnoredFields(result);
+
+        const [captureObj, message, levelNumber] = args;
         const level = self?.levels?.labels?.[levelNumber] || 'info';
 
         if (enableLogs && options.log.levels.includes(level)) {
           const attributes: Record<string, unknown> = {
-            ...obj,
+            ...resultObj,
             'sentry.origin': 'auto.logging.pino',
             'pino.logger.level': levelNumber,
           };
 
-          const parsedResult = JSON.parse(result) as { name?: string };
-
-          if (parsedResult.name) {
-            attributes['pino.logger.name'] = parsedResult.name;
-          }
-
           _INTERNAL_captureLog({ level, message, attributes });
         }
 
@@ -153,8 +163,8 @@ const _pinoIntegration = defineIntegration((userOptions: DeepPartial<PinoOptions
               return event;
             });
 
-            if (obj.err) {
-              captureException(obj.err, captureContext);
+            if (captureObj.err) {
+              captureException(captureObj.err, captureContext);
               return;
             }
 
@@ -165,7 +175,7 @@ const _pinoIntegration = defineIntegration((userOptions: DeepPartial<PinoOptions
 
       injectedChannel.end.subscribe(data => {
         const { self, arguments: args, result } = data as { self: Pino; arguments: PinoHookArgs; result: string };
-        onPinoStart(self, args, result);
+        onPinoStart(self, args, JSON.parse(result));
       });
 
       integratedChannel.end.subscribe(data => {
@@ -174,7 +184,7 @@ const _pinoIntegration = defineIntegration((userOptions: DeepPartial<PinoOptions
           arguments: args,
           result,
         } = data as { instance: Pino; arguments: PinoHookArgs; result: string };
-        onPinoStart(instance, args, result);
+        onPinoStart(instance, args, JSON.parse(result));
       });
     },
   };
@@ -193,14 +203,14 @@ interface PinoIntegrationFunction {
    *
    * @param logger A Pino logger instance.
    */
-  untrackLogger(logger: unknown): void;
+  ignoreLogger(logger: unknown): void;
 }
 
 /**
  * Integration for Pino logging library.
  * Captures Pino logs as Sentry logs and optionally captures some log levels as events.
  *
- * By default, all Pino loggers will be captured. To ignore a specific logger, use `pinoIntegration.untrackLogger(logger)`.
+ * By default, all Pino loggers will be captured. To ignore a specific logger, use `pinoIntegration.ignoreLogger(logger)`.
  *
  * If you disable automatic instrumentation with `autoInstrument: false`, you can mark specific loggers to be tracked with `pinoIntegration.trackLogger(logger)`.
  *
@@ -212,7 +222,7 @@ export const pinoIntegration = Object.assign(_pinoIntegration, {
       (logger as Pino)[SENTRY_TRACK_SYMBOL] = 'track';
     }
   },
-  untrackLogger(logger: unknown): void {
+  ignoreLogger(logger: unknown): void {
     if (logger && typeof logger === 'object' && 'levels' in logger) {
       (logger as Pino)[SENTRY_TRACK_SYMBOL] = 'ignore';
     }