[Telemetry] Implement Phase 4: Integration Tests & Cleanup

Author: ergunsh

tests/telemetry/clearcut-logger.test.ts

@@ -10,22 +10,23 @@ import {describe, it, afterEach, beforeEach} from 'node:test';
 import sinon from 'sinon';
 
 import {ClearcutLogger} from '../../src/telemetry/clearcut-logger.js';
-import {ClearcutSender} from '../../src/telemetry/clearcut-sender.js';
+import {WatchdogClient} from '../../src/telemetry/watchdog-client.js';
 import type {Persistence} from '../../src/telemetry/persistence.js';
 import {FilePersistence} from '../../src/telemetry/persistence.js';
+import {IpcMessageType} from '../../src/telemetry/types.js';
 
 describe('ClearcutLogger', () => {
   let mockPersistence: sinon.SinonStubbedInstance<Persistence>;
-  let mockSender: sinon.SinonStubbedInstance<ClearcutSender>;
+  let sendStub: sinon.SinonStub;
 
   beforeEach(() => {
     mockPersistence = sinon.createStubInstance(FilePersistence, {
       loadState: Promise.resolve({
         lastActive: '',
       }),
     });
-    mockSender = sinon.createStubInstance(ClearcutSender);
-    mockSender.send.resolves();
+    // Stub the prototype of WatchdogClient so newly created instances use it
+    sendStub = sinon.stub(WatchdogClient.prototype, 'send');
   });
 
   afterEach(() => {
@@ -36,40 +37,38 @@ describe('ClearcutLogger', () => {
     it('sends correct payload', async () => {
       const logger = new ClearcutLogger({
         persistence: mockPersistence,
-        sender: mockSender,
+        appVersion: '1.0.0',
       });
       await logger.logToolInvocation({
         toolName: 'test_tool',
         success: true,
         latencyMs: 123,
       });
 
-      assert(mockSender.send.calledOnce);
-      const extension = mockSender.send.firstCall.args[0];
-      assert.strictEqual(extension.tool_invocation?.tool_name, 'test_tool');
-      assert.strictEqual(extension.tool_invocation?.success, true);
-      assert.strictEqual(extension.tool_invocation?.latency_ms, 123);
+      assert(sendStub.calledOnce);
+      const msg = sendStub.firstCall.args[0];
+      assert.strictEqual(msg.type, IpcMessageType.EVENT);
+      assert.strictEqual(msg.payload.tool_invocation?.tool_name, 'test_tool');
+      assert.strictEqual(msg.payload.tool_invocation?.success, true);
+      assert.strictEqual(msg.payload.tool_invocation?.latency_ms, 123);
     });
   });
 
   describe('logServerStart', () => {
     it('logs flag usage', async () => {
       const logger = new ClearcutLogger({
         persistence: mockPersistence,
-        sender: mockSender,
+        appVersion: '1.0.0',
       });
 
       await logger.logServerStart({headless: true});
 
       // Should have logged server start
-      const calls = mockSender.send.getCalls();
-      const serverStartCall = calls.find(call => {
-        return !!call.args[0].server_start;
-      });
-
-      assert(serverStartCall);
+      assert(sendStub.calledOnce);
+      const msg = sendStub.firstCall.args[0];
+      assert.strictEqual(msg.type, IpcMessageType.EVENT);
       assert.strictEqual(
-        serverStartCall.args[0].server_start?.flag_usage?.headless,
+        msg.payload.server_start?.flag_usage?.headless,
         true,
       );
     });
@@ -86,17 +85,16 @@ describe('ClearcutLogger', () => {
 
       const logger = new ClearcutLogger({
         persistence: mockPersistence,
-        sender: mockSender,
+        appVersion: '1.0.0',
       });
 
       await logger.logDailyActiveIfNeeded();
 
-      const calls = mockSender.send.getCalls();
-      const dailyActiveCall = calls.find(call => {
-        return !!call.args[0].daily_active;
-      });
-
-      assert(dailyActiveCall, 'Should have logged daily active');
+      assert(sendStub.calledOnce);
+      const msg = sendStub.firstCall.args[0];
+      assert.strictEqual(msg.type, IpcMessageType.EVENT);
+      assert.ok(msg.payload.daily_active);
+      
       assert(mockPersistence.saveState.called);
     });
 
@@ -107,17 +105,12 @@ describe('ClearcutLogger', () => {
 
       const logger = new ClearcutLogger({
         persistence: mockPersistence,
-        sender: mockSender,
+        appVersion: '1.0.0',
       });
 
       await logger.logDailyActiveIfNeeded();
 
-      const calls = mockSender.send.getCalls();
-      const dailyActiveCall = calls.find(call => {
-        return !!call.args[0].daily_active;
-      });
-
-      assert(!dailyActiveCall, 'Should NOT have logged daily active');
+      assert(sendStub.notCalled);
       assert(mockPersistence.saveState.notCalled);
     });
 
@@ -128,19 +121,16 @@ describe('ClearcutLogger', () => {
 
       const logger = new ClearcutLogger({
         persistence: mockPersistence,
-        sender: mockSender,
+        appVersion: '1.0.0',
       });
 
       await logger.logDailyActiveIfNeeded();
 
-      const calls = mockSender.send.getCalls();
-      const dailyActiveCall = calls.find(call => {
-        return !!call.args[0].daily_active;
-      });
-
-      assert(dailyActiveCall, 'Should have logged daily active');
+      assert(sendStub.calledOnce);
+      const msg = sendStub.firstCall.args[0];
+      assert.strictEqual(msg.type, IpcMessageType.EVENT);
       assert.strictEqual(
-        dailyActiveCall.args[0].daily_active?.days_since_last_active,
+        msg.payload.daily_active?.days_since_last_active,
         -1,
       );
       assert(mockPersistence.saveState.called);

tests/telemetry/watchdog-client.test.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {describe, it, afterEach, beforeEach} from 'node:test';
+import assert from 'node:assert';
+import sinon from 'sinon';
+import {spawn, type ChildProcess} from 'node:child_process';
+import EventEmitter from 'node:events';
+import {Writable} from 'node:stream';
+
+import {WatchdogClient} from '../../src/telemetry/watchdog-client.js';
+import {OsType, IpcMessageType} from '../../src/telemetry/types.js';
+
+describe('WatchdogClient', () => {
+  let spawnStub: sinon.SinonStub;
+  let mockChildProcess: ChildProcess & {stdin: Writable; kill: sinon.SinonStub};
+
+  beforeEach(() => {
+    // Mock child process
+    const eventEmitter = new EventEmitter();
+    const stdin = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        }
+    });
+    // Use stub instead of spy to allow throws()
+    sinon.stub(stdin, 'write');
+
+    mockChildProcess = Object.assign(eventEmitter, {
+      pid: 12345,
+      stdin,
+      stdout: null,
+      stderr: null,
+      kill: sinon.stub(),
+      unref: sinon.stub(),
+      destroyed: false,
+    } as unknown as ChildProcess) as ChildProcess & {stdin: Writable; kill: sinon.SinonStub};
+
+    spawnStub = sinon.stub().returns(mockChildProcess);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('spawns watchdog process with correct arguments', () => {
+     new WatchdogClient({
+      parentPid: 100,
+      appVersion: '1.2.3',
+      osType: OsType.OS_TYPE_MACOS,
+    }, {spawn: spawnStub as unknown as typeof spawn});
+
+    assert.strictEqual(spawnStub.calledOnce, true);
+    const args = spawnStub.firstCall.args;
+    // args[0] is process.execPath
+    // args[1] is arguments array
+    const cmdArgs = args[1];
+    
+    // Check main arg structure - we expect path to main.js as first arg
+    assert.match(cmdArgs[0], /watchdog\/main\.js$/);
+    assert.strictEqual(cmdArgs.includes('--parent-pid=100'), true);
+    assert.strictEqual(cmdArgs.includes('--app-version=1.2.3'), true);
+    assert.strictEqual(cmdArgs.includes('--os-type=2'), true);
+  });
+
+  it('passes log-file argument if provided', () => {
+     new WatchdogClient({
+      parentPid: 100,
+      appVersion: '1.0.0',
+      osType: OsType.OS_TYPE_LINUX,
+      logFile: '/tmp/test.log',
+    }, {spawn: spawnStub as unknown as typeof spawn});
+
+    const cmdArgs = spawnStub.firstCall.args[1];
+    assert.strictEqual(cmdArgs.includes('--log-file=/tmp/test.log'), true);
+  });
+
+  it('sends IPC messages via stdin', () => {
+    const client = new WatchdogClient({
+      parentPid: 100,
+      appVersion: '1.0.0',
+      osType: OsType.OS_TYPE_LINUX,
+    }, {spawn: spawnStub as unknown as typeof spawn});
+
+    const msg = {type: IpcMessageType.EVENT, payload: {}};
+    client.send(msg);
+
+    const writeSpy = mockChildProcess.stdin.write as sinon.SinonSpy;
+    assert.strictEqual(writeSpy.calledOnce, true);
+    
+    const writtenData = writeSpy.firstCall.args[0];
+    assert.strictEqual(writtenData.trim(), JSON.stringify(msg));
+  });
+
+  it('handles write errors gracefully', () => {
+    const client = new WatchdogClient({
+        parentPid: 100,
+        appVersion: '1.0.0',
+        osType: OsType.OS_TYPE_LINUX,
+      }, {spawn: spawnStub as unknown as typeof spawn});
+
+    const writeStub = mockChildProcess.stdin.write as unknown as sinon.SinonStub;
+    writeStub.throws(new Error('EPIPE'));
+
+    // Should not throw
+    assert.doesNotThrow(() => {
+        client.send({type: IpcMessageType.EVENT, payload: {}});
+    });
+  });
+});