How One‑Line Code Turns Electron Apps into Fully Observable Desktop Agents

Electron applications have a monitoring blind spot because the main process (Node.js) and renderer processes (Chromium) run in separate runtimes, so traditional front‑end RUM SDKs cannot capture main‑process metrics, native crashes, or IPC interactions.

The problem consists of four layers: (1) dual‑process architecture, (2) native crashes that generate .dmp files requiring symbol services, (3) unreliable data reporting from renderer windows, and (4) lack of observability for IPC communication such as tRPC.

Design Overview

The @arms/rum-electron SDK adopts a single‑init design. Calling armsRum.init({ endpoint: '<your-endpoint>' }) in the main process automatically instruments both the main process and all renderer processes. Events from renderers are sent to an ElectronReporter in the main process, which aggregates and forwards them to the backend.

Key Capabilities

Zero‑Config Injection

The SDK listens to web-contents-created and dom-ready events. When a BrowserWindow is created and its DOM is ready, the Browser SDK script and an IPC bridge are injected automatically. No preload changes, import statements, or manual configuration are required in renderer code.

import armsRum from '@arms/rum-electron';
armsRum.init({ endpoint: '<your-endpoint>' });

Local Crash Parsing with Rust WASM

When a native crash occurs, Electron produces a binary .dmp file. The SDK bundles a Rust rust‑minidump library compiled to WebAssembly via wasm‑pack. The WASM module (≈1.5 MB, Base64‑encoded) runs in the client after restart, parses the dump locally, and extracts thread stacks, module lists, and system info without sending raw crash data to a server.

tRPC IPC Monitoring

For applications that use electron‑trpc, the SDK provides armsRum.instrumentTRPC(initTRPC.create()). This wraps every tRPC procedure with a monitoring middleware that emits OpenTelemetry‑compatible traces ( rpc.system='trpc') and forwards them through the same reporting pipeline. Existing middleware (e.g., auth) remains unaffected.

import { initTRPC } from '@trpc/server';
import armsRum from '@arms/rum-electron';
const t = armsRum.instrumentTRPC(initTRPC.create());
export const appRouter = t.router({
  greeting: t.procedure.query(...),
  chat: t.procedure.mutation(...),
});

Distributed Tracing

The SDK supports W3C Trace Context, B3, B3 Multi, Jaeger, and SkyWalking propagators. Tracing can be enabled and sampled per domain, e.g.:

armsRum.init({
  endpoint: '<your-endpoint>',
  tracing: {
    enable: true,
    sample: 10, // global 10% sampling
    propagatorTypes: ['tracecontext', 'b3'],
    allowedUrls: [
      { match: /^https:\/\/api\.example\.com/, sample: 100 }, // core API 100%
      /^https:\/\/cdn\.example\.com/, // CDN inherits global 10%
    ],
  },
});

Trace headers are injected into outbound fetch requests and tRPC calls, enabling end‑to‑end latency analysis across client and backend services.

Memory‑Leak Sentinel

A high‑frequency sampler calls app.getAppMetrics() every 10 seconds, accumulating memory usage in an O(1) counter (<0.1 % CPU). Every 30 minutes the SDK emits memory_max (peak) and memory_avg (average) events and flushes the snapshot on crash or exit, providing a low‑overhead view of memory trends and early leak detection.

10 s: sample app.getAppMetrics() 30 min: emit memory_max and memory_avg Crash/exit: immediate flush of current memory snapshot

Multi‑Layer Exception Protection

In the main process the SDK captures uncaughtException, unhandledRejection, and console.error. In renderer processes it auto‑captures front‑end errors, unhandled promises, and white‑screen events, routing all to the main process for reliable reporting even after a renderer crash.

Comparison with Existing Solutions

Sentry’s @sentry/electron provides a dedicated Electron SDK, session replay, and a large community, but it lacks built‑in tRPC monitoring, local crash parsing, and flexible tracing protocol support. Generic front‑end RUM SDKs only cover the renderer side, leaving the main process invisible. The @arms/rum-electron SDK offers full‑stack coverage, data sovereignty (crash data never leaves the device), and native tRPC integration.

Performance Impact

The SDK adds less than 0.1 % CPU overhead and negligible memory consumption. All monkey‑patches are reversible via a restore method, ensuring the SDK can be removed without leaving side effects.

Getting Started

Requirements: Electron ≥ 28 (fallback to session.setPreloads() on older versions). Install the package and add a single init call in the main entry. Optional tRPC instrumentation can be added as shown above.

npm install @arms/rum-electron

import armsRum from '@arms/rum-electron';
import { app, BrowserWindow } from 'electron';

armsRum.init({ endpoint: '<your-endpoint>', env: 'prod', version: '1.0.0' });
app.whenReady().then(() => {
  const win = new BrowserWindow({ webPreferences: {} });
  win.loadURL('https://your-app.com');
});