[Telemetry] Comprehensive E2E test coverage for process termination (signals, crash, exit)

Author: ergunsh

tests/e2e/fixtures/server-fixture.ts

@@ -0,0 +1,55 @@
+
+import {hideBin} from 'yargs/helpers';
+import yargs from 'yargs';
+import process from 'node:process';
+import {ClearcutLogger} from '../../../src/telemetry/clearcut-logger.js';
+import {saveLogsToFile} from '../../../src/logger.js';
+
+async function main() {
+  const argv = await yargs(hideBin(process.argv))
+    .option('action', {
+      type: 'string',
+      choices: ['exit-0', 'exit-1', 'crash', 'stay-alive'],
+      demandOption: true,
+    })
+    .option('log-file', {
+      type: 'string',
+      demandOption: true,
+    })
+    .parse();
+
+  if (argv.logFile) {
+    saveLogsToFile(argv.logFile);
+  }
+
+  // Initialize Watchdog (mimicking main.ts)
+  new ClearcutLogger({
+    logFile: argv.logFile,
+    appVersion: '1.0.0-test',
+  });
+
+  console.log(`Server fixture started with PID ${process.pid}`);
+
+  // Give watchdog time to start
+  setTimeout(() => {
+    switch (argv.action) {
+      case 'exit-0':
+        console.log('Exiting with 0');
+        process.exit(0);
+        break;
+      case 'exit-1':
+        console.log('Exiting with 1');
+        process.exit(1);
+        break;
+      case 'crash':
+        console.log('Crashing');
+        throw new Error('Planned crash');
+      case 'stay-alive':
+        console.log('Staying alive');
+        setInterval(() => {}, 1000); // Keep alive
+        break;
+    }
+  }, 1000);
+}
+
+main();

tests/e2e/telemetry.test.ts

@@ -12,17 +12,17 @@ import path from 'node:path';
 import os from 'node:os';
 
 describe('Telemetry E2E', () => {
-  it('spawns server, logs events, and shuts down watchdog cleanly on termination', async () => {
+  async function runTelemetryTest(signal: NodeJS.Signals) {
     // Setup
-    const logFile = path.join(os.tmpdir(), `test-mcp-telemetry-${Date.now()}.log`);
+    const logFile = path.join(os.tmpdir(), `test-mcp-telemetry-${signal}-${Date.now()}.log`);
     const serverPath = path.resolve('build/src/main.js');
 
     if (!fs.existsSync(serverPath)) {
         throw new Error(`Server build not found at ${serverPath}. Run 'npm run build' first.`);
     }
 
     // Spawn Server
-    console.log(`Spawning server at ${serverPath} with log file ${logFile}`);
+    console.log(`[${signal}] Spawning server at ${serverPath} with log file ${logFile}`);
     const server = spawn(process.execPath, [
       serverPath,
       `--log-file=${logFile}`,
@@ -33,7 +33,7 @@ describe('Telemetry E2E', () => {
       stdio: ['pipe', 'pipe', 'pipe'],
     });
 
-    server.stderr.on('data', (d) => console.log(`Stderr: ${d}`));
+    server.stderr.on('data', (d) => console.log(`[${signal}] Stderr: ${d}`));
 
     // Wait for Watchdog start
     let watchdogPid: number | undefined;
@@ -63,15 +63,15 @@ describe('Telemetry E2E', () => {
 
     await waitForWatchdogStart;
     assert.ok(watchdogPid, 'Watchdog PID not found');
-    console.log(`Watchdog started with PID ${watchdogPid}`);
+    console.log(`[${signal}] Watchdog started with PID ${watchdogPid}`);
 
     // Verify start event logged
     const contentBeforeKill = fs.readFileSync(logFile, 'utf8');
     assert.match(contentBeforeKill, /server_start/);
 
-    // Kill Server with SIGKILL
-    console.log(`Killing server process ${server.pid} with SIGKILL`);
-    server.kill('SIGKILL');
+    // Kill Server
+    console.log(`[${signal}] Killing server process ${server.pid} with ${signal}`);
+    server.kill(signal);
 
     // Wait for Watchdog exit
     const waitForWatchdogExit = new Promise<void>((resolve, reject) => {
@@ -93,15 +93,108 @@ describe('Telemetry E2E', () => {
     });
 
     await waitForWatchdogExit;
-    console.log('Watchdog process is gone');
+    console.log(`[${signal}] Watchdog process is gone`);
 
     // Verify shutdown logged
     const contentAfter = fs.readFileSync(logFile, 'utf8');
     assert.match(contentAfter, /Parent death detected/);
     assert.match(contentAfter, /server_shutdown/);
-    console.log('Shutdown events verified');
+    console.log(`[${signal}] Shutdown events verified`);
 
     // Cleanup
     if (fs.existsSync(logFile)) fs.unlinkSync(logFile);
-  });
+  }
+
+  async function runFixtureTest(action: 'exit-0' | 'exit-1' | 'crash') {
+    // Setup
+    const logFile = path.join(os.tmpdir(), `test-mcp-telemetry-fixture-${action}-${Date.now()}.log`);
+    const fixturePath = path.resolve('build/tests/e2e/fixtures/server-fixture.js');
+
+    if (!fs.existsSync(fixturePath)) {
+        throw new Error(`Fixture build not found at ${fixturePath}. Run 'npm run build' first.`);
+    }
+
+    // Spawn Fixture
+    console.log(`[${action}] Spawning fixture at ${fixturePath}`);
+    const server = spawn(process.execPath, [
+      fixturePath,
+      `--log-file=${logFile}`,
+      `--action=${action}`
+    ], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    server.stderr.on('data', (d) => console.log(`[${action}] Stderr: ${d}`));
+
+    // Wait for Watchdog start (same logic)
+    let watchdogPid: number | undefined;
+    const waitForWatchdogStart = new Promise<void>((resolve, reject) => {
+      const checkInterval = setInterval(() => {
+        // Note: Fixture might exit cleanly for exit-0/1, so we don't reject on exitCode immediately
+        // unless it exited BEFORE watchdog started?
+        
+        if (fs.existsSync(logFile)) {
+          const content = fs.readFileSync(logFile, 'utf8');
+          const match = content.match(/Watchdog started[\s\S]*?"pid":\s*(\d+)/);
+          if (match) {
+            watchdogPid = parseInt(match[1]);
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }
+        
+        if (server.exitCode !== null && !watchdogPid) {
+           // If server exited and we haven't seen watchdog yet... might be too fast or failed?
+           // But fixture waits 1s.
+           // We'll keep checking logFile for a moment? No, if server gone, it won't write more.
+           // reject(new Error(`Server exited early with code ${server.exitCode} before watchdog start`));
+        }
+      }, 100);
+      setTimeout(() => {
+        clearInterval(checkInterval);
+        reject(new Error('Timeout waiting for Watchdog start'));
+      }, 5000);
+    });
+
+    await waitForWatchdogStart;
+    assert.ok(watchdogPid, 'Watchdog PID not found');
+    console.log(`[${action}] Watchdog started with PID ${watchdogPid}`);
+
+    // Wait for Watchdog exit
+    const waitForWatchdogExit = new Promise<void>((resolve, reject) => {
+      const checkInterval = setInterval(() => {
+        try {
+          process.kill(watchdogPid!, 0); 
+        } catch (e) {
+          clearInterval(checkInterval);
+          resolve();
+          return;
+        }
+      }, 100);
+      
+      setTimeout(() => {
+        clearInterval(checkInterval);
+        try { process.kill(watchdogPid!, 'SIGKILL'); } catch {}
+        reject(new Error('Timeout waiting for Watchdog exit'));
+      }, 5000);
+    });
+
+    await waitForWatchdogExit;
+    console.log(`[${action}] Watchdog process is gone`);
+
+    const contentAfter = fs.readFileSync(logFile, 'utf8');
+    assert.match(contentAfter, /Parent death detected/);
+    assert.match(contentAfter, /server_shutdown/);
+    console.log(`[${action}] Shutdown events verified`);
+
+    if (fs.existsSync(logFile)) fs.unlinkSync(logFile);
+  }
+
+  it('handles clean exit (process.exit(0))', () => runFixtureTest('exit-0'));
+  it('handles error exit (process.exit(1))', () => runFixtureTest('exit-1'));
+  it('handles uncaught exception', () => runFixtureTest('crash'));
+
+  it('handles SIGKILL', () => runTelemetryTest('SIGKILL'));
+  it('handles SIGTERM', () => runTelemetryTest('SIGTERM'));
+  it('handles SIGINT', () => runTelemetryTest('SIGINT'));
 });