[Telemetry] Implement Phase 3: Main Process Integration

Author: ergunsh

src/main.ts

@@ -38,7 +38,10 @@ export const args = parseArguments(VERSION);
 const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 let clearcutLogger: ClearcutLogger | undefined;
 if (args.usageStatistics) {
-  clearcutLogger = new ClearcutLogger();
+  clearcutLogger = new ClearcutLogger({
+    logFile: args.logFile,
+    appVersion: VERSION,
+  });
 }
 
 process.on('unhandledRejection', (reason, promise) => {

src/telemetry/clearcut-logger.ts

@@ -4,42 +4,72 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import process from 'node:process';
+
 import {logger} from '../logger.js';
 
-import {ClearcutSender} from './clearcut-sender.js';
 import type {LocalState, Persistence} from './persistence.js';
 import {FilePersistence} from './persistence.js';
-import type {FlagUsage} from './types.js';
+import {type FlagUsage, IpcMessageType, OsType} from './types.js';
+import {WatchdogClient} from './watchdog-client.js';
 
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
 export class ClearcutLogger {
   #persistence: Persistence;
-  #sender: ClearcutSender;
+  #watchdog: WatchdogClient;
 
-  constructor(options?: {persistence?: Persistence; sender?: ClearcutSender}) {
-    this.#persistence = options?.persistence ?? new FilePersistence();
-    this.#sender = options?.sender ?? new ClearcutSender();
+  constructor(options: {
+    persistence?: Persistence;
+    logFile?: string;
+    appVersion: string;
+  }) {
+    this.#persistence = options.persistence ?? new FilePersistence();
+    this.#watchdog = new WatchdogClient({
+      parentPid: process.pid,
+      appVersion: options.appVersion,
+      osType: this.#detectOsType(),
+      logFile: options.logFile,
+    });
+  }
+
+  #detectOsType(): OsType {
+    switch (process.platform) {
+      case 'win32':
+        return OsType.OS_TYPE_WINDOWS;
+      case 'darwin':
+        return OsType.OS_TYPE_MACOS;
+      case 'linux':
+        return OsType.OS_TYPE_LINUX;
+      default:
+        return OsType.OS_TYPE_UNSPECIFIED;
+    }
   }
 
   async logToolInvocation(args: {
     toolName: string;
     success: boolean;
     latencyMs: number;
   }): Promise<void> {
-    await this.#sender.send({
-      tool_invocation: {
-        tool_name: args.toolName,
-        success: args.success,
-        latency_ms: args.latencyMs,
+    this.#watchdog.send({
+      type: IpcMessageType.EVENT,
+      payload: {
+        tool_invocation: {
+          tool_name: args.toolName,
+          success: args.success,
+          latency_ms: args.latencyMs,
+        },
       },
     });
   }
 
   async logServerStart(flagUsage: FlagUsage): Promise<void> {
-    await this.#sender.send({
-      server_start: {
-        flag_usage: flagUsage,
+    this.#watchdog.send({
+      type: IpcMessageType.EVENT,
+      payload: {
+        server_start: {
+          flag_usage: flagUsage,
+        },
       },
     });
   }
@@ -57,9 +87,12 @@ export class ClearcutLogger {
           daysSince = Math.ceil(diffTime / MS_PER_DAY);
         }
 
-        await this.#sender.send({
-          daily_active: {
-            days_since_last_active: daysSince,
+        this.#watchdog.send({
+          type: IpcMessageType.EVENT,
+          payload: {
+            daily_active: {
+              days_since_last_active: daysSince,
+            },
           },
         });
 

src/telemetry/types.ts

@@ -49,11 +49,11 @@ export interface LogRequest {
 
 // IPC Types
 export enum IpcMessageType {
-  DATA = 'data',
+  EVENT = 'event',
 }
 
-export interface TelemetryEvent {
-  type: IpcMessageType.DATA;
+export interface IpcMessage {
+  type: IpcMessageType.EVENT;
   payload: ChromeDevToolsMcpExtension;
 }
 

src/telemetry/watchdog-client.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {spawn, type ChildProcess} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+
+import {logger} from '../logger.js';
+
+import type {IpcMessage, OsType} from './types.js';
+
+export class WatchdogClient {
+  #childProcess: ChildProcess;
+
+  constructor(
+    config: {
+      parentPid: number;
+      appVersion: string;
+      osType: OsType;
+      logFile?: string;
+    },
+    options?: {spawn?: typeof spawn},
+  ) {
+    const watchdogPath = fileURLToPath(
+      new URL('./watchdog/main.js', import.meta.url),
+    );
+
+    const args = [
+      watchdogPath,
+      `--parent-pid=${config.parentPid}`,
+      `--app-version=${config.appVersion}`,
+      `--os-type=${config.osType}`,
+    ];
+
+    if (config.logFile) {
+      args.push(`--log-file=${config.logFile}`);
+    }
+
+    const spawner = options?.spawn ?? spawn;
+    this.#childProcess = spawner(process.execPath, args, {
+      stdio: ['pipe', 'ignore', 'ignore'],
+      detached: false, // Keep attached to parent lifecycle generally, but unref to not block exit
+    });
+
+    // Don't let the watchdog keep the main process alive
+    this.#childProcess.unref();
+
+    this.#childProcess.on('error', (err) => {
+      logger('Watchdog process error:', err);
+    });
+
+    this.#childProcess.on('exit', (code, signal) => {
+      logger(`Watchdog exited with code ${code} and signal ${signal}`);
+    });
+  }
+
+  send(message: IpcMessage): void {
+    if (
+      this.#childProcess.stdin &&
+      !this.#childProcess.stdin.destroyed &&
+      this.#childProcess.pid
+    ) {
+      try {
+        const line = JSON.stringify(message) + '\n';
+        this.#childProcess.stdin.write(line);
+      } catch (err) {
+        logger('Failed to write to watchdog stdin', err);
+      }
+    } else {
+      logger('Watchdog stdin not available, dropping message');
+    }
+  }
+}

src/telemetry/watchdog/main.ts

@@ -89,7 +89,7 @@ async function main() {
       if (!line.trim()) return;
 
       const msg = JSON.parse(line);
-      if (msg.type === IpcMessageType.DATA && msg.payload) {
+      if (msg.type === IpcMessageType.EVENT && msg.payload) {
         sender.send(msg.payload).catch((err) => {
           logger('Error sending event', err);
         });