chore: Add CLI args for config & increase e2e test timeout

ergunsh · OrKoN · commit 3c34e0b74d26 · 2026-01-27T15:02:42.000+01:00
diff --git a/src/cli.ts b/src/cli.ts
@@ -211,6 +211,21 @@ export const cliOptions = {
     hidden: true,
     describe: 'Set to false to opt-out of usage statistics collection.',
   },
+  clearcutEndpoint: {
+    type: 'string',
+    hidden: true,
+    describe: 'Endpoint for Clearcut telemetry.',
+  },
+  clearcutForceFlushIntervalMs: {
+    type: 'number',
+    hidden: true,
+    describe: 'Force flush interval in milliseconds (for testing).',
+  },
+  clearcutIncludePidHeader: {
+    type: 'boolean',
+    hidden: true,
+    describe: 'Include watchdog PID in Clearcut request headers (for testing).',
+  },
 } satisfies Record<string, YargsOptions>;
 
 export function parseArguments(version: string, argv = process.argv) {
diff --git a/src/main.ts b/src/main.ts
@@ -42,6 +42,9 @@ if (args.usageStatistics) {
   clearcutLogger = new ClearcutLogger({
     logFile: args.logFile,
     appVersion: VERSION,
+    clearcutEndpoint: args.clearcutEndpoint,
+    clearcutForceFlushIntervalMs: args.clearcutForceFlushIntervalMs,
+    clearcutIncludePidHeader: args.clearcutIncludePidHeader,
   });
 }
 
diff --git a/src/telemetry/clearcut-logger.ts b/src/telemetry/clearcut-logger.ts
@@ -37,6 +37,9 @@ export class ClearcutLogger {
     logFile?: string;
     persistence?: Persistence;
     watchdogClient?: WatchdogClient;
+    clearcutEndpoint?: string;
+    clearcutForceFlushIntervalMs?: number;
+    clearcutIncludePidHeader?: boolean;
   }) {
     this.#persistence = options.persistence ?? new FilePersistence();
     this.#watchdog =
@@ -46,6 +49,9 @@ export class ClearcutLogger {
         appVersion: options.appVersion,
         osType: detectOsType(),
         logFile: options.logFile,
+        clearcutEndpoint: options.clearcutEndpoint,
+        clearcutForceFlushIntervalMs: options.clearcutForceFlushIntervalMs,
+        clearcutIncludePidHeader: options.clearcutIncludePidHeader,
       });
   }
 
diff --git a/src/telemetry/watchdog-client.ts b/src/telemetry/watchdog-client.ts
@@ -20,6 +20,9 @@ export class WatchdogClient {
       appVersion: string;
       osType: OsType;
       logFile?: string;
+      clearcutEndpoint?: string;
+      clearcutForceFlushIntervalMs?: number;
+      clearcutIncludePidHeader?: boolean;
     },
     options?: {spawn?: typeof spawn},
   ) {
@@ -37,6 +40,17 @@ export class WatchdogClient {
     if (config.logFile) {
       args.push(`--log-file=${config.logFile}`);
     }
+    if (config.clearcutEndpoint) {
+      args.push(`--clearcut-endpoint=${config.clearcutEndpoint}`);
+    }
+    if (config.clearcutForceFlushIntervalMs) {
+      args.push(
+        `--clearcut-force-flush-interval-ms=${config.clearcutForceFlushIntervalMs}`,
+      );
+    }
+    if (config.clearcutIncludePidHeader) {
+      args.push('--clearcut-include-pid-header');
+    }
 
     const spawner = options?.spawn ?? spawn;
     this.#childProcess = spawner(process.execPath, args, {
diff --git a/src/telemetry/watchdog/clearcut-sender.ts b/src/telemetry/watchdog/clearcut-sender.ts
@@ -14,13 +14,18 @@ import type {
   OsType,
 } from '../types.js';
 
-const INCLUDE_PID_HEADER = process.env.INCLUDE_PID_HEADER === 'true';
-const MAX_BUFFER_SIZE = parseInt(process.env.MAX_BUFFER_SIZE ?? '', 10) || 1000;
-const FLUSH_INTERVAL_MS =
-  parseInt(process.env.FORCE_FLUSH_INTERVAL ?? '', 10) || 15 * 60 * 1000;
-const CLEARCUT_ENDPOINT =
-  process.env.CLEARCUT_ENDPOINT ??
+export interface ClearcutSenderConfig {
+  appVersion: string;
+  osType: OsType;
+  clearcutEndpoint?: string;
+  forceFlushIntervalMs?: number;
+  includePidHeader?: boolean;
+}
+
+const MAX_BUFFER_SIZE = 1000;
+const DEFAULT_CLEARCUT_ENDPOINT =
   'https://play.googleapis.com/log?format=json_proto';
+const DEFAULT_FLUSH_INTERVAL_MS = 15 * 60 * 1000;
 
 const LOG_SOURCE = 2839;
 const CLIENT_TYPE = 47;
@@ -37,16 +42,24 @@ interface BufferedEvent {
 export class ClearcutSender {
   #appVersion: string;
   #osType: OsType;
+  #clearcutEndpoint: string;
+  #flushIntervalMs: number;
+  #includePidHeader: boolean;
   #sessionId: string;
   #sessionCreated: number;
   #buffer: BufferedEvent[] = [];
   #flushTimer: ReturnType<typeof setTimeout> | null = null;
   #isFlushing = false;
   #timerStarted = false;
 
-  constructor(appVersion: string, osType: OsType) {
-    this.#appVersion = appVersion;
-    this.#osType = osType;
+  constructor(config: ClearcutSenderConfig) {
+    this.#appVersion = config.appVersion;
+    this.#osType = config.osType;
+    this.#clearcutEndpoint =
+      config.clearcutEndpoint ?? DEFAULT_CLEARCUT_ENDPOINT;
+    this.#flushIntervalMs =
+      config.forceFlushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.#includePidHeader = config.includePidHeader ?? false;
     this.#sessionId = crypto.randomUUID();
     this.#sessionCreated = Date.now();
   }
@@ -66,7 +79,7 @@ export class ClearcutSender {
 
     if (!this.#timerStarted) {
       this.#timerStarted = true;
-      this.#scheduleFlush(FLUSH_INTERVAL_MS);
+      this.#scheduleFlush(this.#flushIntervalMs);
     }
   }
 
@@ -97,12 +110,12 @@ export class ClearcutSender {
     }
 
     if (this.#buffer.length === 0) {
-      this.#scheduleFlush(FLUSH_INTERVAL_MS);
+      this.#scheduleFlush(this.#flushIntervalMs);
       return;
     }
 
     this.#isFlushing = true;
-    let nextDelayMs = FLUSH_INTERVAL_MS;
+    let nextDelayMs = this.#flushIntervalMs;
 
     // Optimistically remove events from buffer before sending.
     // This prevents race conditions where a simultaneous #finalFlush would include these same events.
@@ -182,12 +195,12 @@ export class ClearcutSender {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
     try {
-      const response = await fetch(CLEARCUT_ENDPOINT, {
+      const response = await fetch(this.#clearcutEndpoint, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
           // Used in E2E tests to confirm that the watchdog process is killed
-          ...(INCLUDE_PID_HEADER ? {'X-Watchdog-Pid': process.pid.toString()} : {}),
+          ...(this.#includePidHeader ? {'X-Watchdog-Pid': process.pid.toString()} : {}),
         },
         body: JSON.stringify(requestBody),
         signal: controller.signal,
diff --git a/src/telemetry/watchdog/main.ts b/src/telemetry/watchdog/main.ts
@@ -15,21 +15,76 @@ import {WatchdogMessageType} from '../types.js';
 
 import {ClearcutSender} from './clearcut-sender.js';
 
-function main() {
-  const {values} = parseArgs({
+interface WatchdogArgs {
+  // Required arguments
+  parentPid: number;
+  appVersion: string;
+  osType: OsType;
+  // Optional arguments
+  logFile?: string;
+  clearcutEndpoint?: string;
+  clearcutForceFlushIntervalMs?: number;
+  clearcutIncludePidHeader?: boolean;
+}
+
+function parseWatchdogArgs(): WatchdogArgs {
+    const {values} = parseArgs({
     options: {
       'parent-pid': {type: 'string'},
       'app-version': {type: 'string'},
       'os-type': {type: 'string'},
       'log-file': {type: 'string'},
+      'clearcut-endpoint': {type: 'string'},
+      'clearcut-force-flush-interval-ms': {type: 'string'},
+      'clearcut-include-pid-header': {type: 'boolean'},
     },
     strict: true,
   });
-
+  // Verify required arguments
   const parentPid = parseInt(values['parent-pid'] ?? '', 10);
   const appVersion = values['app-version'];
   const osType = parseInt(values['os-type'] ?? '', 10);
+  if (isNaN(parentPid) || !appVersion || isNaN(osType)) {
+    console.error(
+      'Invalid arguments provided for watchdog process: ', 
+      JSON.stringify({parentPid, appVersion, osType})
+    );
+    process.exit(1);
+  }
+
+  // Parse Optional Arguments
   const logFile = values['log-file'];
+  const clearcutEndpoint = values['clearcut-endpoint'];
+  const clearcutIncludePidHeader = values['clearcut-include-pid-header'];
+  let clearcutForceFlushIntervalMs: number|undefined;
+  if (values['clearcut-force-flush-interval-ms']) {
+    const parsed = parseInt(values['clearcut-force-flush-interval-ms'], 10);
+    if (!isNaN(parsed)) {
+      clearcutForceFlushIntervalMs = parsed;
+    }
+  }
+
+  return {
+    parentPid,
+    appVersion,
+    osType,
+    logFile,
+    clearcutEndpoint,
+    clearcutForceFlushIntervalMs,
+    clearcutIncludePidHeader,
+  };
+}
+
+function main() {
+  const {
+    parentPid,
+    appVersion,
+    osType,
+    logFile,
+    clearcutEndpoint,
+    clearcutForceFlushIntervalMs,
+    clearcutIncludePidHeader,
+  } = parseWatchdogArgs();
   let logStream: WriteStream | undefined;
   if (logFile) {
     logStream = saveLogsToFile(logFile);
@@ -45,15 +100,6 @@ function main() {
     });
   };
 
-  if (isNaN(parentPid) || !appVersion || isNaN(osType)) {
-    logger(
-      'Invalid arguments provided for watchdog process: ',
-      JSON.stringify({parentPid, appVersion, osType}),
-    );
-    exit(1);
-    return;
-  }
-
   logger(
     'Watchdog started',
     JSON.stringify(
@@ -68,7 +114,13 @@ function main() {
     ),
   );
 
-  const sender = new ClearcutSender(appVersion, osType as OsType);
+  const sender = new ClearcutSender({
+    appVersion,
+    osType: osType,
+    clearcutEndpoint,
+    forceFlushIntervalMs: clearcutForceFlushIntervalMs,
+    includePidHeader: clearcutIncludePidHeader,
+  });
 
   let isShuttingDown = false;
   function onParentDeath(reason: string) {
diff --git a/tests/e2e/telemetry.test.ts b/tests/e2e/telemetry.test.ts
@@ -166,23 +166,22 @@ describe('Telemetry E2E', () => {
           SERVER_PATH,
           '--usage-statistics',
           '--headless',
+          `--clearcutEndpoint=http://127.0.0.1:${mockContext.port}`,
+          '--clearcutForceFlushIntervalMs=10',
+          '--clearcutIncludePidHeader',
         ],
         {
           stdio: ['pipe', 'pipe', 'pipe'],
           env: {
             ...process.env,
-            CLEARCUT_ENDPOINT: `http://127.0.0.1:${mockContext.port}`,
-            FORCE_FLUSH_INTERVAL: '10',
-            MAX_BUFFER_SIZE: '100',
-            INCLUDE_PID_HEADER: 'true',
           },
           ...spawnOptions,
         },
       );
 
       const startEvent = await Promise.race([
         mockContext.waitForEvent(e => e.server_start !== undefined),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout waiting for server_start')), 5000))
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout waiting for server_start')), 10000))
       ]);
       assert.ok(startEvent, 'server_start event not received');
 
@@ -199,7 +198,7 @@ describe('Telemetry E2E', () => {
       // Verify shutdown event
       const shutdownEvent = await Promise.race([
         mockContext.waitForEvent(e => e.server_shutdown !== undefined),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout waiting for server_shutdown')), 5000))
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout waiting for server_shutdown')), 10000))
       ]);
       assert.ok(shutdownEvent, 'server_shutdown event not received');
 
diff --git a/tests/telemetry/watchdog/clearcut-sender.test.ts b/tests/telemetry/watchdog/clearcut-sender.test.ts

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,9 @@ if (args.usageStatistics) {`
`42`	`42`	`clearcutLogger = new ClearcutLogger({`
`43`	`43`	`logFile: args.logFile,`
`44`	`44`	`appVersion: VERSION,`
	`45`	`+ clearcutEndpoint: args.clearcutEndpoint,`
	`46`	`+ clearcutForceFlushIntervalMs: args.clearcutForceFlushIntervalMs,`
	`47`	`+ clearcutIncludePidHeader: args.clearcutIncludePidHeader,`
`45`	`48`	`});`
`46`	`49`	`}`
`47`	`50`