Observability PII session context

src/main/app/startup.ts

@@ -0,0 +1,4 @@
+import { performance } from "node:perf_hooks";
+
+// Use the Node process start time rather than module evaluation time.
+export const appStartTimestamp = performance.timeOrigin;

src/main/controllers/index.ts

@@ -21,3 +21,8 @@ import "./loaded-profiles-controller";
 import "./tabs-controller";
 import "./handoff-controller";
 import "./sessions-controller";
+
+// Observability: wires up PostHog event tracking across all controllers.
+// Must be imported after all controllers are instantiated.
+import { initializeObservability } from "./posthog-controller/observability";
+initializeObservability();

src/main/controllers/loaded-profiles-controller/index.ts

@@ -1,5 +1,6 @@
 import { transformUserAgentHeader } from "@/modules/user-agent";
 import { ProfileData, profilesController } from "@/controllers/profiles-controller";
+import { posthogController } from "@/controllers/posthog-controller";
 import { sessionsController } from "@/controllers/sessions-controller";
 import { NEW_TAB_URL, tabsController } from "@/controllers/tabs-controller";
 import { windowsController } from "@/controllers/windows-controller";
@@ -256,9 +257,11 @@ class LoadedProfilesController extends TypedEventEmitter<LoadedProfilesControlle
       },
       afterInstall: async (details) => {
         await extensionsManager.addInstalledExtension("crx", details.id);
+        posthogController.captureEvent("extension-installed");
       },
       afterUninstall: async (details) => {
         await extensionsManager.removeInstalledExtension(details.id);
+        posthogController.captureEvent("extension-uninstalled");
       },
       customSetExtensionEnabled: async (_state, extensionId, enabled) => {
         await extensionsManager.setExtensionDisabled(extensionId, !enabled);

src/main/controllers/posthog-controller/exception-autocapture.ts

@@ -0,0 +1,144 @@
+import { BucketedRateLimiter, ErrorTracking as CoreErrorTracking, createLogger } from "@posthog/core";
+import { getSessionId } from "./session";
+import { PostHog } from "posthog-node";
+
+const SHUTDOWN_TIMEOUT_MS = 2000;
+
+const logger = createLogger("[PostHog exception autocapture]");
+
+type ErrorHandler = { _posthogErrorHandler: boolean } & ((error: Error) => void);
+
+const errorPropertiesBuilder = new CoreErrorTracking.ErrorPropertiesBuilder(
+  [
+    new CoreErrorTracking.EventCoercer(),
+    new CoreErrorTracking.ErrorCoercer(),
+    new CoreErrorTracking.ObjectCoercer(),
+    new CoreErrorTracking.StringCoercer(),
+    new CoreErrorTracking.PrimitiveCoercer()
+  ],
+  CoreErrorTracking.createStackParser("node:javascript", CoreErrorTracking.nodeStackLineParser)
+);
+
+const rateLimiter = new BucketedRateLimiter<string>({
+  refillRate: 1,
+  bucketSize: 10,
+  refillInterval: 10000,
+  _logger: logger
+});
+
+function isPreviouslyCapturedError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "__posthog_previously_captured_error" in error &&
+    error.__posthog_previously_captured_error === true
+  );
+}
+
+async function buildExceptionEventMessage(exception: unknown, hint: CoreErrorTracking.EventHint, distinctId: string) {
+  const exceptionProperties = errorPropertiesBuilder.buildFromUnknown(exception, hint);
+  exceptionProperties.$exception_list = await errorPropertiesBuilder.modifyFrames(exceptionProperties.$exception_list);
+
+  return {
+    event: "$exception",
+    distinctId,
+    properties: {
+      ...exceptionProperties,
+      $session_id: getSessionId()
+    },
+    _originatedFromCaptureException: true as const
+  };
+}
+
+async function captureAutocapturedException(
+  client: PostHog,
+  exception: unknown,
+  hint: CoreErrorTracking.EventHint,
+  distinctId: string
+): Promise<void> {
+  if (isPreviouslyCapturedError(exception)) {
+    return;
+  }
+
+  const eventMessage = await buildExceptionEventMessage(exception, hint, distinctId);
+
+  const exceptionType = eventMessage.properties?.$exception_list?.[0]?.type ?? "Exception";
+  const isRateLimited = rateLimiter.consumeRateLimit(exceptionType);
+  if (isRateLimited) {
+    logger.info("Skipping exception capture because of client rate limiting.", {
+      exception: exceptionType
+    });
+    return;
+  }
+
+  client.capture(eventMessage);
+}
+
+function makeUncaughtExceptionHandler(
+  captureFn: (exception: Error, hint: CoreErrorTracking.EventHint) => void,
+  onFatalFn: (exception: Error) => void
+): ErrorHandler {
+  let calledFatalError = false;
+
+  return Object.assign(
+    (error: Error): void => {
+      const userProvidedListenersCount = global.process.listeners("uncaughtException").filter((listener) => {
+        return (
+          listener.name !== "domainUncaughtExceptionClear" && (listener as ErrorHandler)._posthogErrorHandler !== true
+        );
+      }).length;
+
+      const processWouldExit = userProvidedListenersCount === 0;
+
+      captureFn(error, {
+        mechanism: {
+          type: "onuncaughtexception",
+          handled: false
+        }
+      });
+
+      if (!calledFatalError && processWouldExit) {
+        calledFatalError = true;
+        onFatalFn(error);
+      }
+    },
+    { _posthogErrorHandler: true }
+  );
+}
+
+function addUncaughtExceptionListener(
+  captureFn: (exception: Error, hint: CoreErrorTracking.EventHint) => void,
+  onFatalFn: (exception: Error) => void
+): void {
+  global.process.on("uncaughtException", makeUncaughtExceptionHandler(captureFn, onFatalFn));
+}
+
+function addUnhandledRejectionListener(
+  captureFn: (exception: unknown, hint: CoreErrorTracking.EventHint) => void
+): void {
+  global.process.on("unhandledRejection", (reason: unknown) => {
+    captureFn(reason, {
+      mechanism: {
+        type: "onunhandledrejection",
+        handled: false
+      }
+    });
+  });
+}
+
+export function enableExceptionAutocapture(client: PostHog, distinctId: string): void {
+  addUncaughtExceptionListener(
+    (exception, hint) => {
+      void captureAutocapturedException(client, exception, hint, distinctId);
+    },
+    async (error) => {
+      console.error(error);
+      await client.shutdown(SHUTDOWN_TIMEOUT_MS).catch(() => {});
+      process.exit(1);
+    }
+  );
+
+  addUnhandledRejectionListener((reason, hint) => {
+    void captureAutocapturedException(client, reason, hint, distinctId);
+  });
+}

src/main/controllers/posthog-controller/index.ts

@@ -1,99 +1,119 @@
-// This controller handles PostHog events and exceptions.
-
-import ErrorTracking from "./posthog-error-capture-sdk";
-import { app } from "electron";
+import { enableExceptionAutocapture } from "./exception-autocapture";
+import { sanitizeProperties } from "./sanitize-pii";
+import { getSessionId } from "./session";
+import { app, crashReporter } from "electron";
 import { PostHog } from "posthog-node";
 import { _getPosthogIdentifier } from "./identify";
 
+const IS_ENABLED = app.isPackaged;
+
 class PosthogController {
-  /**
-   * The PostHog client.
-   */
-  private client: PostHog;
+  private client: PostHog | null = null;
 
-  /**
-   * Whether the PostHog identifier is ready.
-   */
   public isIdentifierReady: boolean = false;
 
   constructor() {
-    const enableExceptionAutocapture = app.isPackaged;
+    if (!IS_ENABLED) return;
 
     this.client = new PostHog("phc_P8uPRRW5eJj8vMmgMlsgoOmmeNZ9NxBHN6COZQndvfZ", {
       host: "https://eu.i.posthog.com",
       disableGeoip: false,
-      enableExceptionAutocapture
+      enableExceptionAutocapture: false,
+      before_send: (event) => {
+        if (!event) return null;
+
+        return {
+          ...event,
+          properties: sanitizeProperties(event.properties ?? {})
+        };
+      }
     });
 
-    // Warm identifier cache
     const identifierPromise = this.getPosthogIdentifier();
     identifierPromise.then((identifier) => {
       this.isIdentifierReady = true;
 
-      // Identify user
-      this.client.identify({
-        distinctId: identifier,
-        properties: {
-          ...this.getAppInfoForPosthog()
-        }
-      });
+      this.client!.withContext({ distinctId: identifier, sessionId: getSessionId() }, () => {
+        this.client!.identify({
+          distinctId: identifier,
+          properties: {
+            ...this.getAppInfoForPosthog()
+          }
+        });
 
-      // Auto capture exceptions
-      new ErrorTracking(this.client, {
-        fallbackDistinctId: identifier,
-        enableExceptionAutocapture: true
+        enableExceptionAutocapture(this.client!, identifier);
       });
     });
 
-    // Capture app started
     this.captureEvent("app-started");
 
-    // Shutdown client on app quit
+    this.setupCrashReporter();
+
     app.on("before-quit", () => {
-      this.client.shutdown();
+      this.client!.shutdown();
     });
   }
 
-  /**
-   * Get the PostHog identifier.
-   * @returns The PostHog identifier.
-   */
   public async getPosthogIdentifier(): Promise<string> {
     return await _getPosthogIdentifier();
   }
 
   /**
-   * Capture an event.
-   * @param event - The event to capture.
-   * @param properties - The properties to capture.
+   * Capture an event. Properties are automatically sanitized to remove PII
+   * and enriched with session context.
    */
   public async captureEvent(event: string, properties?: Record<string, unknown>): Promise<void> {
+    if (!this.client) return;
     const identifier = await this.getPosthogIdentifier();
-    this.client.capture({
-      distinctId: identifier,
-      event,
-      properties: {
-        ...properties
-      }
+    this.client.withContext({ distinctId: identifier, sessionId: getSessionId() }, () => {
+      this.client!.capture({
+        distinctId: identifier,
+        event,
+        properties
+      });
     });
   }
 
   /**
-   * Capture an exception.
-   * @param error - The error to capture.
-   * @param properties - The properties to capture.
+   * Capture an exception. Properties are automatically sanitized to remove PII
+   * and enriched with session context.
    */
-  public async captureException(error: string, properties?: Record<string, unknown>): Promise<void> {
+  public async captureException(error: unknown, properties?: Record<string, unknown>): Promise<void> {
+    if (!this.client) return;
     const identifier = await this.getPosthogIdentifier();
-    this.client.captureException(error, identifier, {
-      ...properties
+    this.client.withContext({ distinctId: identifier, sessionId: getSessionId() }, () => {
+      this.client!.captureException(error, identifier, properties);
+    });
+  }
+
+  private setupCrashReporter(): void {
+    crashReporter.start({
+      submitURL: "",
+      uploadToServer: false,
+      extra: {
+        sessionId: getSessionId()
+      }
+    });
+
+    app.on("child-process-gone", (_event, details) => {
+      this.captureEvent("crash-child-process-gone", {
+        type: details.type,
+        reason: details.reason,
+        exitCode: details.exitCode,
+        serviceName: details.serviceName,
+        name: details.name
+      });
+    });
+
+    app.on("render-process-gone", (_event, webContents, details) => {
+      this.captureEvent("crash-render-process-gone", {
+        reason: details.reason,
+        exitCode: details.exitCode,
+        webContentsId: webContents.id
+      });
     });
   }
 
-  /**
-   * Get the app info for PostHog.
-   * @returns The app info for PostHog.
-   */
   private getAppInfoForPosthog() {
     return {
       version: app.getVersion(),