Merge pull request #5549 from ag-grid/ag-16239/nx-tooling-improvements

alantreadway · web-flow · commit 8b177353581a · 2025-11-07T15:34:31.000Z
AG-16239: Improve Nx batch executor progress reporting and timeout handling
diff --git a/external/ag-shared/scripts/plugin-utils/executors-utils.ts b/external/ag-shared/scripts/plugin-utils/executors-utils.ts
@@ -7,6 +7,14 @@ import * as os from 'os';
 import * as path from 'path';
 import * as ts from 'typescript';
 
+import {
+    createProgressState,
+    displayProgress,
+    finishProgress,
+    setInProgressTasks,
+    updateProgress,
+} from './progress-tracker';
+
 export type TaskResult = {
     success: boolean;
     terminalOutput: string;
@@ -132,7 +140,11 @@ export function batchExecutor<ExecutorOptions>(
     };
 }
 
-export function batchWorkerExecutor<ExecutorOptions>(workerModule: string, extraMsgContent?: () => object) {
+export function batchWorkerExecutor<ExecutorOptions>(
+    workerModule: string,
+    extraMsgContent?: () => object,
+    timeout?: number // Optional timeout (includes queue time + execution time)
+) {
     return async function* (
         taskGraph: TaskGraph,
         inputs: Record<string, ExecutorOptions>,
@@ -161,7 +173,26 @@ export function batchWorkerExecutor<ExecutorOptions>(workerModule: string, extra
 
         const tasks = Object.keys(inputs);
 
-        console.info(`Batched execution of ${tasks.length} tasks, using ${pool.threads.length} threads...`);
+        const timeoutMsg = timeout != null ? ` (${timeout}ms timeout per task)` : '';
+        console.info(`Batched execution of ${tasks.length} tasks, using ${threadCount} threads${timeoutMsg}...`);
+        const inProgressTasks = new Set<string>(tasks.slice(0, threadCount));
+        const progressState = createProgressState(tasks.length);
+        const progressOptions = {
+            isTTY: process.stdout.isTTY,
+            maxInProgressToShow: threadCount,
+        };
+        let nextTaskIndex = threadCount;
+        const finished = (result: BatchExecutorTaskResult) => {
+            inProgressTasks.delete(result.task);
+            if (tasks[nextTaskIndex]) {
+                // FIFO queue, so next sequential task is always the next in the list
+                inProgressTasks.add(tasks[nextTaskIndex++]);
+            }
+            updateProgress(progressState, result.result.success, [...inProgressTasks]);
+            displayProgress(progressState, progressOptions, false, result.result.success);
+            return result;
+        };
+
         const start = performance.now();
         const contents = extraMsgContent?.() ?? {};
         for (let taskIndex = 0; taskIndex < tasks.length; taskIndex++) {
@@ -177,17 +208,31 @@ export function batchWorkerExecutor<ExecutorOptions>(workerModule: string, extra
                     configurationName: task.target.configuration,
                 },
                 taskName,
+                ...(timeout != null ? { timeout } : {}), // Only pass timeout to worker if defined
                 ...contents,
             };
-            results.set(taskName, pool.run(opts));
+
+            results.set(
+                taskName,
+                pool
+                    .run(opts)
+                    .then((r) => finished(r))
+                    .catch((e) => finished({ task: taskName, result: { success: false, terminalOutput: `${e}` } }))
+            );
         }
 
-        // Run yield loop after dispatch to avoid serializing execution.
+        // Initial progress display
+        setInProgressTasks(progressState, [...inProgressTasks]);
+        displayProgress(progressState, progressOptions, true, true);
+
         for (let taskIndex = 0; taskIndex < tasks.length; taskIndex++) {
             const taskName = tasks[taskIndex];
             yield results.get(taskName)!;
         }
 
+        // Finish progress display
+        finishProgress(progressOptions);
+
         await Promise.allSettled(results.values());
 
         const duration = performance.now() - start;
diff --git a/external/ag-shared/scripts/plugin-utils/progress-tracker.ts b/external/ag-shared/scripts/plugin-utils/progress-tracker.ts
@@ -0,0 +1,109 @@
+export interface ProgressState {
+    completed: number;
+    failed: number;
+    total: number;
+    inProgressTasks: string[];
+    lastLoggedPercentage: number;
+}
+
+export interface ProgressTrackerOptions {
+    isTTY: boolean;
+    maxInProgressToShow: number;
+}
+
+export function shortenTaskName(taskName: string): string {
+    // Extract meaningful parts from task name
+    // Common patterns:
+    // - ag-charts-website-<section>_<page>_<example>_main.ts:generate-example
+    // - ag-documentation-<project>-<parts>:<target>
+
+    // Try to extract last 2-3 meaningful segments before file extension or target
+    const withoutTarget = taskName.split(':')[0]; // Remove :target suffix
+    const parts = withoutTarget.split(/[-_]/); // Split on - or _
+
+    // Take last 2-3 parts before file extension
+    const meaningfulParts = parts.filter((p) => p !== 'main' && !p.match(/\.(ts|js)$/)).slice(-3);
+
+    const shortened = meaningfulParts.join('_');
+
+    // Truncate if still too long
+    return shortened.length > 30 ? shortened.substring(0, 27) + '...' : shortened;
+}
+
+export function createProgressState(total: number): ProgressState {
+    return {
+        completed: 0,
+        failed: 0,
+        total,
+        inProgressTasks: [],
+        lastLoggedPercentage: 0,
+    };
+}
+
+export function updateProgress(state: ProgressState, success: boolean, inProgressTasks: string[]): void {
+    state.completed++;
+    if (!success) {
+        state.failed++;
+    }
+    state.inProgressTasks = inProgressTasks;
+}
+
+export function setInProgressTasks(state: ProgressState, inProgressTasks: string[]): void {
+    state.inProgressTasks = inProgressTasks;
+}
+
+export function displayProgress(
+    state: ProgressState,
+    options: ProgressTrackerOptions,
+    isFirstTask: boolean,
+    lastTaskSuccess: boolean
+): void {
+    const percentage = Math.round((state.completed / state.total) * 100);
+    const failedMsg = state.failed > 0 ? ` - ${state.failed} failed` : '';
+    const queued = state.total - state.completed;
+    const progressMsg = `Progress: ${state.completed}/${state.total} (${percentage}%)${failedMsg} | Queued: ${queued}`;
+
+    const inProgressMsg =
+        state.inProgressTasks.length > 0
+            ? `In progress: [${state.inProgressTasks.map(shortenTaskName).slice(0, options.maxInProgressToShow).join(', ')}]`
+            : '';
+
+    if (options.isTTY) {
+        // Clear previous lines (progress + in-progress)
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        if (!isFirstTask) {
+            // Move up and clear the previous in-progress line
+            process.stdout.moveCursor(0, -1);
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+        }
+
+        // Write progress line
+        process.stdout.write(progressMsg + '\n');
+
+        // Write in-progress tasks line (truncate if needed)
+        if (inProgressMsg) {
+            const maxWidth = (process.stdout.columns || 80) - 10;
+            const truncated =
+                inProgressMsg.length > maxWidth ? inProgressMsg.substring(0, maxWidth - 3) + '...' : inProgressMsg;
+            process.stdout.write(truncated);
+        }
+    } else {
+        // Non-TTY: Log every 10% or on failure to avoid spam
+        const shouldLog =
+            percentage >= state.lastLoggedPercentage + 10 || !lastTaskSuccess || state.completed === state.total;
+
+        if (shouldLog) {
+            console.info(progressMsg);
+            if (inProgressMsg) console.info(inProgressMsg);
+            state.lastLoggedPercentage = percentage;
+        }
+    }
+}
+
+export function finishProgress(options: ProgressTrackerOptions): void {
+    if (options.isTTY) {
+        process.stdout.write('\n');
+    }
+}
diff --git a/plugins/ag-charts-generate-chart-thumbnail/src/executors/generate/batch-instance.ts b/plugins/ag-charts-generate-chart-thumbnail/src/executors/generate/batch-instance.ts
@@ -7,17 +7,49 @@ export type Message = {
     taskName: string;
     options: ExecutorOptions;
     context: Pick<ExecutorContext, 'projectName' | 'targetName' | 'configurationName'>;
+    timeout?: number; // Timeout in milliseconds (optional, defaults to 60000)
 };
 
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number, taskName: string): Promise<T> {
+    let timeoutHandle: NodeJS.Timeout;
+
+    const timeoutPromise = new Promise<T>((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+            if (process.env.DEBUG_TIMEOUT) {
+                console.log(`[Worker] Timeout fired for ${taskName} after ${timeoutMs}ms`);
+            }
+            reject(new Error(`Task '${taskName}' timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+
+    return Promise.race([
+        promise.finally(() => {
+            // Clear timeout if promise completes first
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }),
+        timeoutPromise,
+    ]);
+}
+
 export default async function processor(msg: Message) {
-    const { options, context, taskName } = msg;
+    const { options, context, taskName, timeout = 60000 } = msg;
 
     let result: BatchExecutorTaskResult;
     try {
-        await generateFiles(options, context);
+        await withTimeout(generateFiles(options, context), timeout, taskName);
         result = { task: taskName, result: { success: true, terminalOutput: '' } };
     } catch (e) {
-        result = { task: taskName, result: { success: false, terminalOutput: `${e}` } };
+        const isTimeout = e instanceof Error && e.message.includes('timeout');
+        if (isTimeout) {
+            console.error(`[Worker] Task ${taskName} timed out`);
+            // Exit the worker process to prevent it from picking up another task
+            // while the timed-out task is still running
+            process.exit(1);
+        }
+        const terminalOutput = isTimeout ? e.message : `${e}`;
+        result = { task: taskName, result: { success: false, terminalOutput } };
     }
 
     return result;
diff --git a/plugins/ag-charts-generate-example-files/src/executors/generate/batch-instance.ts b/plugins/ag-charts-generate-example-files/src/executors/generate/batch-instance.ts
@@ -5,18 +5,61 @@ import { type ExecutorOptions, generateFiles } from './executor';
 export type Message = {
     taskName: string;
     options: ExecutorOptions;
+    timeout?: number; // Timeout in milliseconds (optional, defaults to 60000)
 };
 
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number, taskName: string): Promise<T> {
+    let timeoutHandle: NodeJS.Timeout;
+
+    const timeoutPromise = new Promise<T>((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+            if (process.env.DEBUG_TIMEOUT) {
+                console.log(`[Worker] Timeout fired for ${taskName} after ${timeoutMs}ms`);
+            }
+            reject(new Error(`Task '${taskName}' timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+
+    return Promise.race([
+        promise.finally(() => {
+            // Clear timeout if promise completes first
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }),
+        timeoutPromise,
+    ]);
+}
+
 export default async function processor(msg: Message) {
-    const { options, taskName } = msg;
+    const { options, taskName, timeout = 60000 } = msg;
+
+    // Debug: Log timeout value
+    if (process.env.DEBUG_TIMEOUT) {
+        console.log(`[Worker] Task ${taskName} starting with ${timeout}ms timeout`);
+    }
 
     let result: BatchExecutorTaskResult;
+    const startTime = Date.now();
     try {
-        await generateFiles(options);
+        await withTimeout(generateFiles(options), timeout, taskName);
+        const duration = Date.now() - startTime;
+        if (process.env.DEBUG_TIMEOUT) {
+            console.log(`[Worker] Task ${taskName} completed in ${duration}ms`);
+        }
         result = { task: taskName, result: { success: true, terminalOutput: '' } };
     } catch (e) {
+        const duration = Date.now() - startTime;
+        const isTimeout = e instanceof Error && e.message.includes('timeout');
+        if (isTimeout) {
+            console.error(`[Worker] Task ${taskName} timed out after ${duration}ms (limit: ${timeout}ms)`);
+            // Exit the worker process to prevent it from picking up another task
+            // while the timed-out task is still running
+            process.exit(1);
+        }
         console.error(e);
-        result = { task: taskName, result: { success: false, terminalOutput: `${e.stack}` } };
+        const terminalOutput = isTimeout ? e.message : `${e.stack}`;
+        result = { task: taskName, result: { success: false, terminalOutput } };
     }
 
     return result;
