Electron Logging and Crash Reporting: A Production Guide to Capturing What Your App Did Wrong

TL;DR: In an Electron app, console.log disappears the moment you package it. Production debugging needs three separate trails — structured logs in the main process, a controlled IPC bridge from renderers, and a native crash reporter — plus a way to redact secrets and ship a bundle to support. This guide gives you a setup that works on Windows, macOS, and Linux without leaking user data.

When a user says "your app froze at 4pm and showed a white screen," what do you actually know? Without logging, the answer is "nothing." Browser-side devtools are gone in production, the main process stdout is captured by nobody, and a native crash leaves a .dmp file sitting on a machine you will never touch.

This is the setup we wish we had on day one.

Table of Contents

• Why console.log is not enough
• Layer 1: Structured main-process logs
• Layer 2: Getting renderer logs to disk
• Layer 3: Catching native and renderer crashes
• Privacy: redact before you write
• One-click "send me the logs"
• Common pitfalls
• Production checklist

Why console.log is not enough

The fix is to treat logging as infrastructure: a single, rotating, on-disk trail the main process owns, plus a crash reporter that writes or uploads dumps.

Layer 1: Structured main-process logs

Use electron-log (the de-facto standard) rather than rolling your own. It handles transports, rotation, and file paths per-platform out of the box.

// main/log.js
const { app } = require('electron');
const log = require('electron-log');

log.transports.file.resolvePathFn = () =>
  `${app.getPath('userData')}/logs/main.log`;

// Keep the file small; rotate automatically.
log.transports.file.maxSize = 2 * 1024 * 1024; // 2 MB before rotation
log.transports.file.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] {text}';

// In production, silence console noise; keep file.
log.transports.console.level = process.env.NODE_ENV === 'development' ? 'debug' : 'warn';
log.transports.file.level = 'info';

module.exports = log;

Why this shape:

• userData/logs/ is the correct location. It is per-user, writable, and survives updates. Never write to the app bundle directory — on macOS it is read-only inside the .app, and on Windows Program Files needs admin rights.
• Rotation matters. A log that grows forever becomes a support ticket of its own. Two megabytes is plenty; electron-log keeps a main.old.log alongside it.
• JSON or text? Text is fine for humans; switch to json format when you ship logs into a central store.

Layer 2: Getting renderer logs to disk

The renderer cannot write files safely. It must send its logs over IPC to the main process, which is the only writer.

// preload.js — expose a safe, minimal API, not ipcRenderer itself
const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('appLogger', {
  info: (msg, meta) => ipcRenderer.send('log', { level: 'info', msg, meta }),
  warn: (msg, meta) => ipcRenderer.send('log', { level: 'warn', msg, meta }),
  error: (msg, meta) => ipcRenderer.send('log', { level: 'error', msg, meta }),
});

// main/index.js
const log = require('./log');
const { ipcMain } = require('electron');

ipcMain.on('log', (event, entry) => {
  // Validate shape before writing — never trust renderer input.
  if (!entry || typeof entry.msg !== 'string') return;
  const meta = entry.meta ? JSON.stringify(entry.meta) : '';
  log[entry.level]?.(`[renderer] ${entry.msg} ${meta}`);
});

Two rules that prevent this channel from becoming a security hole:

1. Validate and whitelist. A renderer can be compromised by malicious content; treat everything on log as untrusted data, not instructions.
2. Don't expose ipcRenderer. contextBridge gives the renderer exactly three functions and nothing else. This is the same least-privilege boundary you should already be applying to every IPC channel.

You can also wire renderer-level global errors in one place:

window.addEventListener('error', (e) => {
  window.appLogger.error('uncaught error', { message: e.message, stack: e.error?.stack });
});
window.addEventListener('unhandledrejection', (e) => {
  window.appLogger.error('unhandled rejection', { reason: String(e.reason) });
});

Layer 3: Catching native and renderer crashes

Native crashes (a segfault in a native module, a Chromium crash) need Electron's built-in crash reporter. It writes minidumps and can upload them.

const { crashReporter } = require('electron');

crashReporter.start({
  productName: app.getName(),
  companyName: 'YourCompany',
  submitURL: 'https://logs.example.com/crash', // or '' for local-only
  uploadToServer: false, // flip to true once you have an endpoint
  ignoreSystemCrashHandler: true,
});

While submitURL is empty, dumps land in userData/Crashpad/ and you can retrieve them on demand. Set uploadToServer: true only when you control the endpoint and have a privacy review (see next section).

On the main side, also catch the process-level failures that would otherwise vanish:

process.on('uncaughtException', (err) => {
  log.error('main uncaughtException', { error: err.stack });
  // Give the logger a tick to flush before exiting.
  setTimeout(() => app.exit(1), 500);
});
process.on('unhandledRejection', (reason) => {
  log.error('main unhandledRejection', { reason: String(reason) });
});

Privacy: redact before you write

Logs are a privacy surface. Users do not expect passwords, tokens, API keys, emails, or file paths from their documents to be uploaded to your server.

// redact.js — a small middleware applied to every logged object.
const SECRET = /(Bearer\s+[A-Za-z0-9\-._~+\/]+|eyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+|password|token|api[_-]?key)/gi;

function redact(input) {
  if (typeof input === 'string') return input.replace(SECRET, '[REDACTED]');
  if (typeof input !== 'object' || input === null) return input;
  const out = {};
  for (const [k, v] of Object.entries(input)) {
    out[k] = /password|token|secret|key|cookie/i.test(k) ? '[REDACTED]' : redact(v);
  }
  return out;
}

module.exports = { redact };

Apply it at the boundary — before the IPC handler writes, and before crashReporter uploads — not inside every call site. It is much easier to forget one call site than to forget one middleware.

One-click "send me the logs"

The highest ROI feature for a support team: a menu item that bundles the current logs and a few pieces of metadata into a zip, and lets the user attach it to a bug report.

// main/collect-logs.js
const { app, dialog } = require('electron');
const fs = require('fs');
const path = require('path');
const AdmZip = require('adm-zip');

async function collectLogs() {
  const dir = app.getPath('userData');
  const zip = new AdmZip();
  const logsDir = path.join(dir, 'logs');
  if (fs.existsSync(logsDir)) zip.addLocalFolder(logsDir, 'logs');

  const meta = {
    appVersion: app.getVersion(),
    electron: process.versions.electron,
    platform: process.platform,
    arch: process.arch,
    date: new Date().toISOString(),
  };
  zip.addFile('meta.json', Buffer.from(JSON.stringify(meta, null, 2)));

  const out = path.join(app.getPath('downloads'), `app-logs-${Date.now()}.zip`);
  zip.writeZip(out);

  await dialog.showMessageBox({
    type: 'info',
    message: 'Logs saved',
    detail: `Saved to:\n${out}\nPlease attach this to your bug report.`,
  });
}

This is intentionally user-initiated: the user chooses when to send what. That is both a privacy win and a support win — people trust the app more when logs are visible and opt-in.

Common pitfalls

Production checklist

• [ ] Main process writes rotating logs under userData/logs/ with a max size.
• [ ] Renderer logs go through a contextBridge IPC channel, never raw ipcRenderer.
• [ ] IPC handler validates message shape and redacts secrets before writing.
• [ ] crashReporter.start() runs early, with local dumps until you are ready to upload.
• [ ] Main process handles uncaughtException and unhandledRejection, with a flush before exit.
• [ ] A user-facing "send logs" action zips logs/ + meta.json to the Downloads folder.
• [ ] File logging level is info in production, debug in development.
• [ ] No secret, token, or email pattern appears in a sample log line you review before shipping.

Good logging is invisible until the day you need it. Build it on a quiet Tuesday, because on a Friday night at 9pm you will be very glad it is there.