sailfork / t3code-github / apps/ desktop/ src/ telemetry/ DesktopTelemetryPublisher.test.ts

import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Context from "effect/Context";
import * as Option from "effect/Option";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";

import type * as Electron from "electron";
import * as NodeEvents from "node:events";

import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
import * as ElectronApp from "../electron/ElectronApp.ts";
import * as ElectronPowerMonitor from "../electron/ElectronPowerMonitor.ts";
import * as DesktopTelemetryPublisher from "./DesktopTelemetryPublisher.ts";
import * as DesktopRendererHistory from "./DesktopRendererHistory.ts";
import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";

const layerHistory = Layer.succeed(DesktopRendererHistory.DesktopRendererHistory, {
  register: () => Effect.void,
  recordMetrics: () => Effect.void,
  shutdown: Effect.void,
});

function layerElectronApp(
  metrics: ReadonlyArray<Electron.ProcessMetric>,
  onMetricsRead: () => void = () => undefined,
) {
  return Layer.succeed(ElectronApp.ElectronApp, {
    metadata: Effect.die("unexpected metadata read"),
    name: Effect.succeed("T3 Code"),
    systemLocale: Effect.succeed("en-US"),
    whenReady: Effect.void,
    requestSingleInstanceLock: Effect.succeed(true),
    quit: Effect.void,
    exit: () => Effect.void,
    relaunch: () => Effect.void,
    setPath: () => Effect.void,
    setName: () => Effect.void,
    setAboutPanelOptions: () => Effect.void,
    setAppUserModelId: () => Effect.void,
    getAppMetrics: Effect.sync(() => {
      onMetricsRead();
      return metrics;
    }),
    setAsDefaultProtocolClient: () => Effect.succeed(true),
    setDesktopName: () => Effect.void,
    setDockIcon: () => Effect.void,
    appendCommandLineSwitch: () => Effect.void,
    removeCommandLineSwitch: () => Effect.void,
    onBeforeQuitForUpdate: () => Effect.void,
    on: () => Effect.void,
  } satisfies ElectronApp.ElectronApp["Service"]);
}

describe("DesktopTelemetryPublisher", () => {
  it.effect(
    "forwards shell discovery while a telemetry sample is pending and stops on scope close",
    () =>
      Effect.gen(function* () {
        const pollStarted = yield* Deferred.make<void>();
        const blockPoll = yield* Deferred.make<void>();
        const layerPower = Layer.succeed(
          ElectronPowerMonitor.ElectronPowerMonitor,
          ElectronPowerMonitor.ElectronPowerMonitor.of({
            isOnBatteryPower: Effect.succeed(false),
            getSystemIdleTime: Deferred.succeed(pollStarted, undefined).pipe(
              Effect.andThen(Deferred.await(blockPoll)),
              Effect.as(0),
            ),
            getSystemIdleState: () => Effect.succeed("active"),
            getCurrentThermalState: Effect.succeed("nominal"),
            onSimpleEvent: () => Effect.void,
            onThermalStateChange: () => Effect.void,
            onSpeedLimitChange: () => Effect.void,
          }),
        );
        const layer = DesktopTelemetryPublisher.layer.pipe(
          Layer.provide(
            Layer.mergeAll(
              layerElectronApp([]),
              layerPower,
              layerHistory,
              Layer.succeed(DesktopShellEnvironment.DesktopShellEnvironment, {
                installIntoProcess: Effect.succeed(true),
                awaitDiscovery: Effect.succeed(true),
                updates: Stream.make({
                  version: 1,
                  type: "shellEnvironment",
                  discovered: true,
                  platform: "darwin",
                  environment: { PATH: "/discovered/bin" },
                }),
              }),
            ),
          ),
        );
        const scope = yield* Scope.make();

        const context = yield* Layer.buildWithScope(layer, scope);
        const publisher = Context.get(context, DesktopTelemetryPublisher.DesktopTelemetryPublisher);
        const update = yield* publisher.encoded.pipe(
          Stream.filter((bytes) => new TextDecoder().decode(bytes).includes("shellEnvironment")),
          Stream.runHead,
        );
        assert.isTrue(Option.isSome(update));
        if (Option.isSome(update))
          assert.include(new TextDecoder().decode(update.value), "/discovered/bin");
        yield* Deferred.await(pollStarted);

        const closeFiber = yield* Scope.close(scope, Exit.void).pipe(Effect.forkDetach);
        yield* Effect.yieldNow;
        yield* Effect.yieldNow;

        assert.isDefined(closeFiber.pollUnsafe());
      }),
  );
});

describe("DesktopRendererHistory", () => {
  it.effect(
    "persists surface identity and memory through renderer replacement and destruction",
    () =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const directory = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "t3-renderer-history-",
        });
        let previewPid = 7_002;
        let previewDestroyed = false;
        let urlReads = 0;
        const main = Object.assign(new NodeEvents.EventEmitter(), {
          id: 1,
          getOSProcessId: () => 7_001,
          isDestroyed: () => false,
          getURL: () => {
            urlReads += 1;
            return "https://private.invalid/main?secret=private";
          },
        });
        const preview = Object.assign(new NodeEvents.EventEmitter(), {
          id: 2,
          getOSProcessId: () => previewPid,
          isDestroyed: () => previewDestroyed,
          getURL: () => {
            urlReads += 1;
            return "https://private.invalid/preview?secret=private";
          },
        });
        const metrics = [7_001, 7_002].map(
          (pid) =>
            ({
              pid,
              type: "Tab",
              creationTime: pid * 100,
              memory: { workingSetSize: 2_048, peakWorkingSetSize: 4_096 },
              cpu: { percentCPUUsage: 0, cumulativeCPUUsage: 0, idleWakeupsPerSecond: 0 },
            }) satisfies Electron.ProcessMetric,
        );
        const recordSchema = Schema.fromJsonString(
          Schema.Struct({
            event: Schema.String,
            mainPid: Schema.Number,
            mainSessionStartedAtUnixMs: Schema.Number,
            timestampUnixMs: Schema.Number,
            webContentsId: Schema.Number,
            surface: Schema.String,
            tabId: Schema.optional(Schema.String),
            rendererPid: Schema.NullOr(Schema.Number),
            rendererPidSource: Schema.String,
            rendererCreationTimeMs: Schema.NullOr(Schema.Number),
            memory: Schema.NullOr(
              Schema.Struct({
                kind: Schema.String,
                sampledAtUnixMs: Schema.Number,
                workingSetBytes: Schema.Number,
                peakWorkingSetBytes: Schema.Number,
              }),
            ),
            reason: Schema.optional(Schema.String),
            exitCode: Schema.optional(Schema.Number),
          }),
        );
        const decodeRecord = Schema.decodeUnknownEffect(recordSchema);
        type Record = typeof recordSchema.Type;
        const persisted: Record[] = [];
        let milestone:
          | {
              readonly matches: (record: Record) => boolean;
              readonly written: Deferred.Deferred<Record>;
            }
          | undefined;
        const layerFile = Layer.succeed(FileSystem.FileSystem, {
          ...fileSystem,
          writeFile: (filePath, bytes, options) =>
            fileSystem.writeFile(filePath, bytes, options).pipe(
              Effect.tap(() =>
                decodeRecord(new TextDecoder().decode(bytes).trim()).pipe(
                  Effect.orDie,
                  Effect.flatMap((record) =>
                    Effect.sync(() => {
                      persisted.push(record);
                      if (milestone?.matches(record)) {
                        Deferred.doneUnsafe(milestone.written, Effect.succeed(record));
                      }
                    }),
                  ),
                ),
              ),
            ),
        });
        const layer = DesktopRendererHistory.layer.pipe(
          Layer.provide(
            Layer.mergeAll(
              Layer.succeed(
                DesktopEnvironment.DesktopEnvironment,
                DesktopEnvironment.DesktopEnvironment.of({
                  logDir: directory,
                } as DesktopEnvironment.DesktopEnvironment["Service"]),
              ),
              layerFile,
            ),
          ),
        );

        yield* Effect.gen(function* () {
          const history = yield* DesktopRendererHistory.DesktopRendererHistory;
          yield* history.register(main as unknown as Electron.WebContents, { surface: "main" });
          yield* history.register(preview as unknown as Electron.WebContents, {
            surface: "preview",
          });
          yield* history.register(preview as unknown as Electron.WebContents, {
            surface: "preview",
            tabId: "preview-tab",
          });
          const sampled = yield* Deferred.make<Record>();
          milestone = {
            matches: (row) => row.event === "sample" && row.webContentsId === 2,
            written: sampled,
          };
          yield* TestClock.adjust(Duration.seconds(30));
          yield* history.recordMetrics(metrics);
          const sample = yield* Deferred.await(sampled);
          assert.equal(sample.rendererPid, 7_002);
          assert.equal(sample.rendererCreationTimeMs, 700_200);
          assert.equal(sample.tabId, "preview-tab");
          assert.equal(sample.mainPid, process.pid);
          assert.equal(sample.memory?.kind, "electron-process-working-set");
          assert.equal(sample.memory?.workingSetBytes, 2_048 * 1_024);
          assert.equal(sample.memory?.peakWorkingSetBytes, 4_096 * 1_024);
          assert.equal(sample.memory?.sampledAtUnixMs, sample.timestampUnixMs);
          assert.isTrue(
            persisted.some(
              (row) =>
                row.event === "created" && row.surface === "main" && row.rendererPid === 7_001,
            ),
          );
          assert.isTrue(
            persisted.some((row) => row.event === "identified" && row.tabId === "preview-tab"),
          );

          const replaced = yield* Deferred.make<Record>();
          milestone = { matches: (row) => row.event === "dom-ready", written: replaced };
          previewPid = 7_003;
          preview.emit("dom-ready");
          const replacement = yield* Deferred.await(replaced);
          assert.equal(replacement.rendererPid, 7_003);
          assert.isNull(replacement.rendererCreationTimeMs);
          assert.isNull(replacement.memory);
          metrics[1] = { ...metrics[1]!, pid: 7_003, creationTime: 700_300 };
          const replacementSampled = yield* Deferred.make<Record>();
          milestone = {
            matches: (row) => row.event === "sample" && row.webContentsId === 2,
            written: replacementSampled,
          };
          yield* TestClock.adjust(Duration.seconds(30));
          yield* history.recordMetrics(metrics);
          assert.equal((yield* Deferred.await(replacementSampled)).rendererCreationTimeMs, 700_300);

          const crashed = yield* Deferred.make<Record>();
          milestone = { matches: (row) => row.event === "render-process-gone", written: crashed };
          previewPid = 0;
          preview.emit("render-process-gone", {}, { reason: "oom", exitCode: -7 });
          const crash = yield* Deferred.await(crashed);
          assert.equal(crash.rendererPid, 7_003);
          assert.equal(crash.rendererPidSource, "last-known");
          assert.equal(crash.reason, "oom");
          assert.equal(crash.exitCode, -7);
          const restarted = yield* Deferred.make<Record>();
          milestone = { matches: (row) => row.event === "dom-ready", written: restarted };
          previewPid = 7_003;
          preview.emit("dom-ready");
          const restart = yield* Deferred.await(restarted);
          assert.equal(restart.rendererPid, 7_003);
          assert.equal(restart.rendererPidSource, "current");
          assert.isNull(restart.rendererCreationTimeMs);
          assert.isNull(restart.memory);
          const destroyed = yield* Deferred.make<Record>();
          milestone = { matches: (row) => row.event === "destroyed", written: destroyed };
          previewDestroyed = true;
          preview.emit("destroyed");
          const destruction = yield* Deferred.await(destroyed);
          assert.equal(destruction.rendererPid, 7_003);
          assert.isNull(destruction.rendererCreationTimeMs);
          assert.equal(destruction.tabId, "preview-tab");
          assert.equal(preview.eventNames().length, 0);
          const afterDestroy = yield* Deferred.make<Record>();
          milestone = { matches: (row) => row.event === "sample", written: afterDestroy };
          const previousCount = persisted.length;
          yield* TestClock.adjust(Duration.seconds(30));
          yield* history.recordMetrics(metrics);
          assert.equal((yield* Deferred.await(afterDestroy)).webContentsId, 1);
          assert.isFalse(persisted.slice(previousCount).some((row) => row.webContentsId === 2));
          for (let index = 0; index < 12; index++) main.emit("dom-ready");
          yield* history.shutdown;
          assert.equal(
            persisted.filter((row) => row.webContentsId === 1 && row.event === "dom-ready").length,
            12,
          );
          const afterShutdown = persisted.length;
          yield* history.register(main as unknown as Electron.WebContents, { surface: "main" });
          yield* history.recordMetrics(metrics);
          assert.equal(persisted.length, afterShutdown);
          assert.equal(main.eventNames().length, 0);
          yield* history.shutdown;
        }).pipe(Effect.provide(layer));

        assert.equal(main.eventNames().length, 0);
        assert.equal(
          persisted.filter((row) => row.webContentsId === 1 && row.event === "dom-ready").length,
          12,
        );
        assert.equal(urlReads, 0);
        const contents = yield* fileSystem.readFileString(`${directory}/renderer-history.ndjson`);
        assert.isFalse(contents.includes("private.invalid"));
        assert.isFalse(contents.includes("secret"));
      }).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("rotates retained incident history within three 256 kib files", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const directory = yield* fileSystem.makeTempDirectoryScoped({
        prefix: "t3-renderer-rotation-",
      });
      const filePath = `${directory}/renderer-history.ndjson`;
      const maxBytes = 256 * 1_024;
      const encodeSeed = Schema.encodeEffect(
        Schema.fromJsonString(Schema.Struct({ seed: Schema.String })),
      );
      for (const [suffix, seed] of [
        ["", "current"],
        [".1", "previous"],
        [".2", "expired"],
        [".3", "overflow"],
      ] as const) {
        const encodedSeed = yield* encodeSeed({ seed });
        yield* fileSystem.writeFileString(
          `${filePath}${suffix}`,
          `${encodedSeed.padEnd(maxBytes - 1, " ")}\n`,
        );
      }
      const written = yield* Deferred.make<void>();
      const layerFile = Layer.succeed(FileSystem.FileSystem, {
        ...fileSystem,
        writeFile: (target, bytes, options) =>
          fileSystem
            .writeFile(target, bytes, options)
            .pipe(Effect.tap(() => Deferred.succeed(written, undefined))),
      });
      const layer = DesktopRendererHistory.layer.pipe(
        Layer.provide(
          Layer.mergeAll(
            Layer.succeed(
              DesktopEnvironment.DesktopEnvironment,
              DesktopEnvironment.DesktopEnvironment.of({
                logDir: directory,
              } as DesktopEnvironment.DesktopEnvironment["Service"]),
            ),
            layerFile,
          ),
        ),
      );
      const renderer = Object.assign(new NodeEvents.EventEmitter(), {
        id: 7,
        getOSProcessId: () => 9_001,
        isDestroyed: () => false,
      });
      yield* Effect.gen(function* () {
        const history = yield* DesktopRendererHistory.DesktopRendererHistory;
        yield* history.register(renderer as unknown as Electron.WebContents, {
          surface: "preview",
          tabId: "t".repeat(1_000),
        });
        yield* Deferred.await(written);
      }).pipe(Effect.provide(layer));
      assert.deepEqual((yield* fileSystem.readDirectory(directory)).sort(), [
        "renderer-history.ndjson",
        "renderer-history.ndjson.1",
        "renderer-history.ndjson.2",
      ]);
      let totalBytes = 0;
      for (const suffix of ["", ".1", ".2"]) {
        const size = Number((yield* fileSystem.stat(`${filePath}${suffix}`)).size);
        assert.isAtMost(size, maxBytes);
        totalBytes += size;
      }
      assert.isAtMost(totalBytes, 3 * maxBytes);
      assert.include(yield* fileSystem.readFileString(`${filePath}.1`), '"seed":"current"');
      assert.include(yield* fileSystem.readFileString(`${filePath}.2`), '"seed":"previous"');
      const current = yield* fileSystem.readFileString(filePath);
      assert.include(current, `"tabId":"${"t".repeat(128)}"`);
      assert.notInclude(current, "t".repeat(129));
    }).pipe(Effect.provide(NodeServices.layer)),
  );
});