feat: Capture logs for Electron integrations (#1199)

Author: timfish

src/main/integrations/child-process.ts

@@ -1,5 +1,12 @@
-import { addBreadcrumb, captureMessage, defineIntegration, SeverityLevel } from '@sentry/core';
-import { childProcessIntegration as nodeChildProcessIntegration, NodeClient } from '@sentry/node';
+import {
+  addBreadcrumb,
+  captureMessage,
+  defineIntegration,
+  Log,
+  ParameterizedString,
+  SeverityLevel,
+} from '@sentry/core';
+import { childProcessIntegration as nodeChildProcessIntegration, logger, NodeClient } from '@sentry/node';
 import { app } from 'electron';
 import { EXIT_REASONS, ExitReason } from '../electron-normalize';
 import { ElectronMainOptions } from '../sdk';
@@ -22,21 +29,27 @@ const DEFAULT_OPTIONS: ChildProcessOptions = {
   events: ['abnormal-exit', 'launch-failed', 'integrity-failure'],
 };
 
+type LogFn = (msg: ParameterizedString, attributes: Log['attributes']) => void;
+
 /** Gets message and severity */
-function getMessageAndSeverity(reason: ExitReason, proc?: string): { message: string; level: SeverityLevel } {
-  const message = `'${proc}' process exited with '${reason}'`;
+function getMessageAndSeverity(
+  reason: ExitReason,
+  process: string,
+): { message: string; messageFmt: ParameterizedString; level: SeverityLevel; log: LogFn } {
+  const message = `'${process}' process exited with '${reason}'`;
+  const messageFmt = logger.fmt`'${process}' process exited with '${reason}'`;
 
   switch (reason) {
     case 'abnormal-exit':
     case 'killed':
-      return { message, level: 'warning' };
+      return { message, level: 'warning', log: logger.warn, messageFmt };
     case 'crashed':
     case 'oom':
     case 'launch-failed':
     case 'integrity-failure':
-      return { message, level: 'fatal' };
+      return { message, level: 'fatal', log: logger.error, messageFmt };
     default:
-      return { message, level: 'debug' };
+      return { message, level: 'debug', log: logger.info, messageFmt };
   }
 }
 
@@ -70,10 +83,10 @@ export const childProcessIntegration = defineIntegration((userOptions: Partial<O
 
         app.on('child-process-gone', (_, details) => {
           const { reason } = details;
+          const { message, level, log, messageFmt } = getMessageAndSeverity(details.reason, details.type);
 
           // Capture message first
           if (events.includes(reason)) {
-            const { message, level } = getMessageAndSeverity(details.reason, details.type);
             captureMessage(message, { level, tags: { 'event.process': details.type } });
           }
 
@@ -82,19 +95,26 @@ export const childProcessIntegration = defineIntegration((userOptions: Partial<O
             addBreadcrumb({
               type: 'process',
               category: 'child-process',
-              ...getMessageAndSeverity(details.reason, details.type),
+              message,
+              level,
               data: details,
             });
+
+            log(messageFmt, {
+              exitCode: details.exitCode,
+              name: details.name,
+              serviceName: details.serviceName,
+            });
           }
         });
 
         app.on('render-process-gone', (_, contents, details) => {
           const { reason } = details;
           const name = clientOptions?.getRendererName?.(contents) || 'renderer';
+          const { message, level, log, messageFmt } = getMessageAndSeverity(details.reason, name);
 
           // Capture message first
           if (events.includes(reason)) {
-            const { message, level } = getMessageAndSeverity(details.reason, name);
             captureMessage(message, level);
           }
 
@@ -103,9 +123,14 @@ export const childProcessIntegration = defineIntegration((userOptions: Partial<O
             addBreadcrumb({
               type: 'process',
               category: 'child-process',
-              ...getMessageAndSeverity(details.reason, name),
+              message,
+              level,
               data: details,
             });
+
+            log(messageFmt, {
+              exitCode: details.exitCode,
+            });
           }
         });
       }

src/main/integrations/electron-breadcrumbs.ts

@@ -1,5 +1,5 @@
 import { addBreadcrumb, Breadcrumb, defineIntegration } from '@sentry/core';
-import { NodeClient } from '@sentry/node';
+import { logger, NodeClient } from '@sentry/node';
 import { app, autoUpdater, BrowserWindow, powerMonitor, screen, WebContents } from 'electron';
 import { getRendererProperties, trackRendererProperties } from '../renderers';
 import { ElectronMainOptions } from '../sdk';
@@ -137,6 +137,18 @@ export const electronBreadcrumbsIntegration = defineIntegration(
           }
 
           addBreadcrumb(breadcrumb);
+
+          const attributes: Record<string, unknown> = {};
+
+          if (breadcrumb.data?.id) {
+            attributes.id = breadcrumb.data.id;
+          }
+
+          if (breadcrumb.data?.url) {
+            attributes.url = breadcrumb.data.url;
+          }
+
+          logger.info(logger.fmt`electron.${category}.${event}`, attributes);
         }
 
         return emit(event, ...args);

src/main/integrations/net-breadcrumbs.ts

@@ -14,6 +14,7 @@ import {
   stringMatchesSomePattern,
   TracePropagationTargets,
 } from '@sentry/core';
+import { logger } from '@sentry/node';
 import { ClientRequest, ClientRequestConstructorOptions, IncomingMessage, net as electronNet } from 'electron';
 import * as urlModule from 'url';
 
@@ -200,6 +201,7 @@ function addRequestBreadcrumb(
   req: ClientRequest,
   res?: IncomingMessage,
 ): void {
+  const level = getBreadcrumbLogLevelFromHttpStatusCode(res?.statusCode);
   addBreadcrumb(
     {
       type: 'http',
@@ -209,14 +211,27 @@ function addRequestBreadcrumb(
         method: method,
         status_code: res?.statusCode,
       },
-      level: getBreadcrumbLogLevelFromHttpStatusCode(res?.statusCode),
+      level,
     },
     {
       event,
       request: req,
       response: res,
     },
   );
+
+  const attributes = { statusCode: res?.statusCode };
+
+  switch (level) {
+    case 'error':
+      logger.error(logger.fmt`Electron.net request failed: ${method} ${url}`, attributes);
+      break;
+    case 'warning':
+      logger.warn(logger.fmt`Electron.net request warning: ${method} ${url}`, attributes);
+      break;
+    default:
+      logger.info(logger.fmt`Electron.net request succeeded: ${method} ${url}`, attributes);
+  }
 }
 
 /**

test/e2e/test-apps/other/renderer-error/src/index.html

@@ -12,11 +12,11 @@
         _experiments: { enableLogs: true },
       });
 
-        logger.trace('User clicked submit button', {
-          buttonId: 'submit-form',
-          formId: 'user-profile',
-          timestamp: Date.now()
-        });
+      logger.trace('User clicked submit button', {
+        buttonId: 'submit-form',
+        formId: 'user-profile',
+        timestamp: Date.now()
+      });
 
       // setTimeout(() => {
       //   throw new Error('Some renderer error');

test/e2e/test-apps/other/renderer-error/test.ts

@@ -11,11 +11,27 @@ electronTestRunner(__dirname, async (ctx) => {
           [
             {
               type: 'log',
-              item_count: 2,
+              item_count: expect.any(Number),
               content_type: 'application/vnd.sentry.items.log+json',
             },
             {
-              items: [
+              items: expect.arrayContaining([
+                {
+                  timestamp: expect.any(Number),
+                  level: 'info',
+                  body: 'electron.app.ready',
+                  trace_id: UUID_MATCHER,
+                  severity_number: 9,
+                  attributes: {
+                    'sentry.release': { value: 'javascript-logs@1.0.0', type: 'string' },
+                    'sentry.environment': { value: 'development', type: 'string' },
+                    'sentry.sdk.name': { value: 'sentry.javascript.electron', type: 'string' },
+                    'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
+                    'sentry.message.template': { value: 'electron.%s.%s', type: 'string' },
+                    'sentry.message.parameter.0': { value: 'app', type: 'string' },
+                    'sentry.message.parameter.1': { value: 'ready', type: 'string' },
+                  },
+                },
                 {
                   timestamp: expect.any(Number),
                   level: 'info',
@@ -47,7 +63,7 @@ electronTestRunner(__dirname, async (ctx) => {
                     'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
                   },
                 },
-              ],
+              ]),
             },
           ],
         ],