sailfork / t3code-github / apps/ desktop/ src/ telemetry/ DesktopRendererHistory.ts

import type * as Electron from "electron";
import * as Cause from "effect/Cause";
import * as Clock from "effect/Clock";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Queue from "effect/Queue";

import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
import { makeRotatingLogFileWriter } from "../app/DesktopObservability.ts";

export interface RendererIdentity {
  readonly surface: "main" | "preview" | "splash" | "picture-in-picture" | "devtools";
  readonly tabId?: string;
}

export class DesktopRendererHistory extends Context.Service<
  DesktopRendererHistory,
  {
    readonly register: (
      webContents: Electron.WebContents,
      identity: RendererIdentity,
    ) => Effect.Effect<void>;
    readonly recordMetrics: (metrics: ReadonlyArray<Electron.ProcessMetric>) => Effect.Effect<void>;
    readonly shutdown: Effect.Effect<void>;
  }
>()("@t3tools/desktop/telemetry/DesktopRendererHistory") {}

interface RendererMemory {
  readonly sampledAtUnixMs: number;
  // Electron reports process-wide working sets in KiB, not JavaScript heaps.
  readonly kind: "electron-process-working-set";
  readonly workingSetBytes: number;
  readonly peakWorkingSetBytes: number;
}

interface RendererRecord {
  readonly version: 1;
  readonly mainPid: number;
  readonly mainSessionStartedAtUnixMs: number;
  readonly timestampUnixMs: number;
  readonly event:
    | "created"
    | "identified"
    | "dom-ready"
    | "sample"
    | "render-process-gone"
    | "destroyed";
  readonly webContentsId: number;
  readonly surface: RendererIdentity["surface"];
  readonly tabId?: string;
  readonly rendererPid: number | null;
  readonly rendererPidSource: "current" | "last-known" | "unavailable";
  readonly rendererCreationTimeMs: number | null;
  readonly memory: RendererMemory | null;
  readonly reason?: Electron.RenderProcessGoneDetails["reason"];
  readonly exitCode?: number;
}

interface TrackedRenderer {
  readonly webContents: Electron.WebContents;
  identity: RendererIdentity;
  pid: number | null;
  creationTimeMs: number | null;
  memory: RendererMemory | null;
  gone: boolean;
  readonly removeListeners: () => void;
}

const nonnegative = (value: number): number | null =>
  Number.isFinite(value) && value >= 0 ? Math.round(value) : null;

const make = Effect.fn("DesktopRendererHistory.make")(function* () {
  const environment = yield* DesktopEnvironment.DesktopEnvironment;
  const path = yield* Path.Path;
  const clock = yield* Clock.Clock;
  const context = yield* Effect.context<never>();
  const runFork = Effect.runForkWith(context);
  const mainSessionStartedAtUnixMs = clock.currentTimeMillisUnsafe();
  const records = yield* Queue.sliding<RendererRecord>(256);
  const active = new Map<number, TrackedRenderer>();
  let accepting = true;
  const writer = yield* makeRotatingLogFileWriter({
    filePath: path.join(environment.logDir, "renderer-history.ndjson"),
    maxBytes: 256 * 1024,
    maxFiles: 2,
  }).pipe(
    Effect.catch(() =>
      Effect.logWarning("Renderer incident history could not be opened.").pipe(
        Effect.as({ writeText: (_chunk: string) => Effect.void }),
      ),
    ),
  );

  const writeRecord = (record: RendererRecord) =>
    writer.writeText(`${JSON.stringify(record)}\n`).pipe(Effect.ignore);
  const writerFiber = yield* Effect.forever(
    Effect.uninterruptibleMask((restore) =>
      restore(Queue.take(records)).pipe(Effect.flatMap(writeRecord)),
    ).pipe(
      Effect.catchCauseIf(
        (cause) => !Cause.hasInterrupts(cause),
        () => Effect.void,
      ),
    ),
  ).pipe(
    Effect.ensuring(
      Effect.gen(function* () {
        while (Queue.sizeUnsafe(records) > 0) {
          const pending = yield* Queue.takeAll(records);
          yield* Effect.forEach(pending, writeRecord, { discard: true });
        }
      }),
    ),
    Effect.forkScoped,
  );

  const readPid = (renderer: TrackedRenderer): RendererRecord["rendererPidSource"] => {
    try {
      if (!renderer.gone && !renderer.webContents.isDestroyed()) {
        const pid = renderer.webContents.getOSProcessId();
        if (Number.isInteger(pid) && pid > 0) {
          if (pid !== renderer.pid) {
            renderer.pid = pid;
            renderer.creationTimeMs = null;
            renderer.memory = null;
          }
          return "current";
        }
      }
    } catch {
      // Electron can remove a guest before its destruction callback runs.
    }
    return renderer.pid === null ? "unavailable" : "last-known";
  };
  const record = (
    renderer: TrackedRenderer,
    event: RendererRecord["event"],
    details?: Electron.RenderProcessGoneDetails,
  ): void => {
    const rendererPidSource = readPid(renderer);
    Queue.offerUnsafe(records, {
      version: 1,
      mainPid: process.pid,
      mainSessionStartedAtUnixMs,
      timestampUnixMs: clock.currentTimeMillisUnsafe(),
      event,
      webContentsId: renderer.webContents.id,
      ...renderer.identity,
      rendererPid: renderer.pid,
      rendererPidSource,
      rendererCreationTimeMs: renderer.creationTimeMs,
      memory: renderer.memory,
      ...(details === undefined
        ? {}
        : {
            reason: details.reason,
            ...(Number.isFinite(details.exitCode)
              ? { exitCode: Math.round(details.exitCode) }
              : {}),
          }),
    });
  };

  const register = (webContents: Electron.WebContents, identity: RendererIdentity) =>
    Effect.sync(() => {
      if (!accepting || webContents.isDestroyed()) return;
      const boundedIdentity: RendererIdentity = {
        surface: identity.surface,
        ...(identity.tabId === undefined ? {} : { tabId: identity.tabId.slice(0, 128) }),
      };
      const existing = active.get(webContents.id);
      if (existing !== undefined) {
        if (
          existing.identity.surface !== boundedIdentity.surface ||
          existing.identity.tabId !== boundedIdentity.tabId
        ) {
          existing.identity = boundedIdentity;
          record(existing, "identified");
        }
        return;
      }
      const onDomReady = () => {
        if (renderer.gone) {
          renderer.pid = null;
          renderer.creationTimeMs = null;
          renderer.memory = null;
          renderer.gone = false;
        }
        record(renderer, "dom-ready");
      };
      const onDevToolsOpened = () => {
        const tools = webContents.devToolsWebContents;
        if (tools)
          runFork(
            register(tools, {
              surface: "devtools",
              ...(renderer.identity.tabId === undefined ? {} : { tabId: renderer.identity.tabId }),
            }),
          );
      };
      const onGone = (_event: Electron.Event, details: Electron.RenderProcessGoneDetails) => {
        readPid(renderer);
        renderer.gone = true;
        record(renderer, "render-process-gone", details);
      };
      const onDestroyed = () => {
        record(renderer, "destroyed");
        active.delete(webContents.id);
        renderer.removeListeners();
      };
      const renderer: TrackedRenderer = {
        webContents,
        identity: boundedIdentity,
        pid: null,
        creationTimeMs: null,
        memory: null,
        gone: false,
        removeListeners: () => {
          webContents.removeListener("dom-ready", onDomReady);
          webContents.removeListener("devtools-opened", onDevToolsOpened);
          webContents.removeListener("render-process-gone", onGone);
          webContents.removeListener("destroyed", onDestroyed);
        },
      };
      active.set(webContents.id, renderer);
      webContents.on("dom-ready", onDomReady);
      webContents.on("devtools-opened", onDevToolsOpened);
      webContents.on("render-process-gone", onGone);
      webContents.once("destroyed", onDestroyed);
      record(renderer, "created");
    }).pipe(
      Effect.catchCauseIf(
        (cause) => !Cause.hasInterrupts(cause),
        () => Effect.void,
      ),
    );

  let lastSampledAtUnixMs = -Infinity;
  const recordMetrics = (metrics: ReadonlyArray<Electron.ProcessMetric>) =>
    Effect.sync(() => {
      if (!accepting) return;
      const sampledAtUnixMs = clock.currentTimeMillisUnsafe();
      if (sampledAtUnixMs - lastSampledAtUnixMs < 30_000) return;
      lastSampledAtUnixMs = sampledAtUnixMs;
      const byPid = new Map(metrics.map((metric) => [metric.pid, metric]));
      for (const renderer of active.values()) {
        const pidSource = readPid(renderer);
        // A last-known PID may already have been reused by another process.
        const metric =
          pidSource !== "current" || renderer.pid === null ? undefined : byPid.get(renderer.pid);
        if (metric !== undefined) {
          renderer.creationTimeMs = nonnegative(metric.creationTime);
          renderer.memory = {
            sampledAtUnixMs,
            kind: "electron-process-working-set",
            workingSetBytes: nonnegative(metric.memory.workingSetSize * 1024) ?? 0,
            peakWorkingSetBytes: nonnegative(metric.memory.peakWorkingSetSize * 1024) ?? 0,
          };
        }
        // A process can host multiple contents; these rows must not be summed.
        record(renderer, "sample");
      }
    }).pipe(
      Effect.catchCauseIf(
        (cause) => !Cause.hasInterrupts(cause),
        () => Effect.void,
      ),
    );
  const shutdown = Effect.sync(() => {
    accepting = false;
    for (const renderer of active.values()) renderer.removeListeners();
    active.clear();
  }).pipe(
    Effect.andThen(Fiber.interrupt(writerFiber)),
    Effect.asVoid,
    Effect.withSpan("desktop.rendererHistory.shutdown"),
  );
  yield* Effect.addFinalizer(() => shutdown);

  return DesktopRendererHistory.of({ register, recordMetrics, shutdown });
});

export const layer = Layer.effect(DesktopRendererHistory, make());