Function onPinoStart

packages/node-core/src/integrations/pino.ts:132–196

(self: Pino, args: PinoHookArgs, result: PinoResult)

      const integratedChannel = diagnosticsChannel.tracingChannel('pino_asJson');

      function onPinoStart(self: Pino, args: PinoHookArgs, result: PinoResult): void {
        if (!shouldTrackLogger(self)) {
          return;
        }

        const resultObj = stripIgnoredFields(result);

        const [captureObj, message, levelNumber] = args;
        const level = self?.levels?.labels?.[levelNumber] || 'info';
        const messageKey = getPinoKey(self, 'pino.messageKey', 'msg');
        const logMessage = message || (resultObj?.[messageKey] as string | undefined) || '';

        if (enableLogs && options.log.levels.includes(level)) {
          const attributes: Record<string, unknown> = {
            ...resultObj,
            'sentry.origin': 'auto.log.pino',
            'pino.logger.level': levelNumber,
          };

          _INTERNAL_captureLog({ level, message: logMessage, attributes });
        }

        if (options.error.levels.includes(level)) {
          const errorKey = getPinoKey(self, 'pino.errorKey', 'err');

          // Attach the log message and remaining log fields (e.g. child logger
          // bindings, merge object fields) to the event. The serialized error is
          // excluded since it is captured as the event exception itself.
          const pinoContext: Record<string, unknown> = {};
          for (const [key, value] of Object.entries(resultObj)) {
            if (key !== errorKey && key !== messageKey) {
              pinoContext[key] = value;
            }
          }
          if (logMessage) {
            pinoContext[messageKey] = logMessage;
          }

          const captureContext = {
            level: severityLevelFromString(level),
            contexts: { pino: pinoContext },
          };

          withScope(scope => {
            scope.addEventProcessor(event => {
              event.logger = 'pino';

              addExceptionMechanism(event, {
                handled: options.error.handled,
                type: 'auto.log.pino',
              });

              return event;
            });

            const error = captureObj[errorKey];
            if (error) {
              captureException(error, captureContext);