remove verbose telemetry comments

Author: charlesvien

apps/code/src/main/index.ts

@@ -75,9 +75,6 @@ function isCrashLoop(): boolean {
   return recentCrashTimestamps.length >= CRASH_LOOP_THRESHOLD;
 }
 
-// Shared diagnostics attached to every crash event: uptime, the native chromium
-// log tail, and flattened memory. A hard OOM kills the renderer before it can
-// log, so the memory snapshot is often the only signal of what happened.
 function crashDiagnostics() {
   return {
     appUptimeSeconds: Math.round(process.uptime()),
@@ -100,8 +97,6 @@ app.on("render-process-gone", (_event, webContents, details) => {
   log.error("Renderer process gone", props);
   captureException(new Error(`Renderer process gone: ${details.reason}`), {
     ...props,
-    // Stack is always this handler, so default grouping collapses every
-    // renderer death into one issue. Split by reason instead.
     $exception_fingerprint: ["render-process-gone", details.reason],
   });
   getPostHogClient()

apps/code/src/main/services/posthog-analytics.ts

@@ -23,9 +23,6 @@ export function initializePostHog() {
     enableExceptionAutocapture: true,
   });
 
-  // Mint the main-owned session id now, before the first window, so crash
-  // handlers can stamp $session_id even when the renderer crashes during
-  // startup (before it fetches the id to bootstrap posthog-js).
   getOrCreateSessionId();
 
   return posthogClient;
@@ -39,18 +36,6 @@ export function getCurrentUserId() {
   return currentUserId;
 }
 
-/**
- * The PostHog session id is OWNED BY MAIN. Main mints one UUIDv7 and every
- * renderer window bootstraps posthog-js with it (`bootstrap.sessionID`).
- * Because main outlives the renderer, the id stays stable across a renderer
- * crash + reload, so the replay is one continuous session spanning the crash
- * and main-captured crash events (the renderer can't report its own OOM)
- * always carry the right `$session_id` with no race or hand-off.
- *
- * Minted lazily on first request (a window asks at boot, before posthog-js
- * init) so its UUIDv7 timestamp precedes the session's first event, as
- * posthog-js requires.
- */
 export function getOrCreateSessionId(): string {
   if (!sessionId) {
     sessionId = uuidv7();
@@ -123,8 +108,6 @@ export function captureException(
   posthogClient.captureException(error, distinctId, {
     team: "posthog-code",
     ...additionalProperties,
-    // System-owned fields last so callers can't overwrite them: main owns the
-    // session id used for crash->replay linking.
     ...(sessionId ? { $session_id: sessionId } : {}),
     app_version: getAppVersion(),
   });

apps/code/src/main/trpc/routers/analytics.ts

@@ -30,11 +30,6 @@ export const analyticsRouter = router({
       }
     }),
 
-  /**
-   * Return the main-owned session id for a window to bootstrap posthog-js with
-   * (`bootstrap.sessionID`). Main owns it so crash events captured from main
-   * link to the right replay, and the id survives renderer crash+reload.
-   */
   getSessionId: publicProcedure
     .output(z.object({ sessionId: z.string() }))
     .query(() => ({ sessionId: getOrCreateSessionId() })),

apps/code/src/main/utils/crash-diagnostics.ts

@@ -5,21 +5,6 @@ export interface MemorySnapshot {
   byType: Record<string, number>;
 }
 
-/**
- * Summarize per-process memory (from `app.getAppMetrics()`, passed in by the
- * caller so this stays free of a direct `electron` import) for crash
- * diagnostics. Working-set sizes are in KB. Attached to renderer/child crash
- * events so PostHog Error Tracking can show whether the app was under memory
- * pressure: a hard OOM kills the renderer before it can log anything, so the
- * chromium log usually goes silent and this is the only reliable signal.
- *
- * Defensive on purpose: a throw here would run before the crash handler's
- * auto-recovery reload, so failures return `undefined` instead.
- *
- * Caveat: at `render-process-gone` time the dead renderer is already gone from
- * the metrics, so the `Tab` total understates the renderer's real peak. The
- * `unresponsive` sample (renderer still alive) is the more telling one.
- */
 export function collectMemorySnapshot(
   getMetrics: () => Electron.ProcessMetric[],
 ): MemorySnapshot | undefined {
@@ -48,11 +33,6 @@ export function collectMemorySnapshot(
   }
 }
 
-/**
- * Flatten a snapshot into scalar event properties for PostHog (which doesn't
- * accept nested objects, so `byType` is serialized). Returns `{}` when no
- * snapshot was collected, so it spreads cleanly into a crash event's props.
- */
 export function flattenMemorySnapshot(
   memory: MemorySnapshot | undefined,
 ): Record<string, number | string> {

apps/code/src/main/utils/uuidv7.test.ts

@@ -16,7 +16,6 @@ describe("uuidv7", () => {
     const id = uuidv7();
     const after = Date.now();
 
-    // First 48 bits (first 12 hex chars, minus the dash) are the unix-ms stamp.
     const stampMs = Number.parseInt(id.slice(0, 8) + id.slice(9, 13), 16);
     expect(stampMs).toBeGreaterThanOrEqual(before);
     expect(stampMs).toBeLessThanOrEqual(after);
@@ -31,7 +30,6 @@ describe("uuidv7", () => {
     vi.spyOn(Date, "now").mockReturnValue(0x0123456789ab);
     try {
       const id = uuidv7();
-      // bytes 0-5 of 0x0123456789ab -> "01234567" then "89ab"
       expect(id.slice(0, 8)).toBe("01234567");
       expect(id.slice(9, 13)).toBe("89ab");
     } finally {

apps/code/src/main/utils/uuidv7.ts

@@ -1,15 +1,5 @@
 import { randomBytes } from "node:crypto";
 
-/**
- * Generate a UUIDv7 (time-ordered, RFC 9562). posthog-js requires this exact
- * format for `bootstrap.sessionID`: a valid v7 whose 48-bit timestamp precedes
- * the session's first event. Main mints it before any window starts posthog-js,
- * so the ordering holds.
- *
- * Layout: 48-bit big-endian unix-ms timestamp, 4-bit version (7), 2-bit variant
- * (10), 74 random bits. Hand-rolled to avoid a phantom dependency on `uuid`
- * (transitive only, and several major versions resolve in the tree).
- */
 export function uuidv7(): string {
   const bytes = randomBytes(16);
   const timestamp = Date.now();

apps/code/src/main/window.ts

@@ -116,8 +116,6 @@ function setupCrashLogging(window: BrowserWindow): void {
     });
   });
 
-  // Unresponsive often precedes an OOM kill, and here the renderer is still
-  // alive, so this memory sample reflects its real (bloated) footprint.
   window.on("unresponsive", () => {
     log.warn("Window unresponsive", {
       url: window.webContents.getURL(),

apps/code/src/renderer/App.tsx

@@ -52,10 +52,6 @@ function App() {
 
   // Initialize PostHog analytics and register the app version super property.
   useEffect(() => {
-    // Fetch the main-owned session id BEFORE initializing posthog-js so the
-    // recording shares the id main stamps on crash events. Init is gated on it
-    // so the id is set before the first event (posthog-js requires the
-    // bootstrap id's timestamp to precede the session's first event).
     void (async () => {
       let sessionId: string | undefined;
       try {

apps/code/src/renderer/utils/analytics.ts

@@ -36,16 +36,8 @@ type PendingFlagListener = {
 // Subscribers added before initializePostHog runs.
 const pendingFlagListeners = new Set<PendingFlagListener>();
 
-// 10 h, the posthog-js maximum. The app sits idle for hours during background
-// tasks; a shorter timeout would rotate the session id and break the
-// main-owned crash->replay link.
 const SESSION_IDLE_TIMEOUT_SECONDS = 36_000;
 
-/**
- * @param sessionId Main-owned session id (UUIDv7) to bootstrap posthog-js with,
- *   so the recording shares the id main stamps on crash events. Main owns it so
- *   it survives a renderer crash+reload as one continuous session.
- */
 export function initializePostHog(sessionId?: string) {
   const apiKey = import.meta.env.VITE_POSTHOG_API_KEY;
   const apiHost =
@@ -61,8 +53,6 @@ export function initializePostHog(sessionId?: string) {
     api_host: apiHost,
     ui_host: uiHost,
     disable_session_recording: false,
-    // Hold the session open through long idle so posthog-js's own rotation
-    // doesn't replace main's bootstrapped id mid-run.
     session_idle_timeout_seconds: SESSION_IDLE_TIMEOUT_SECONDS,
     ...(sessionId ? { bootstrap: { sessionID: sessionId } } : {}),
     capture_exceptions: import.meta.env.DEV