feat(plugin-eslint): log runner steps (lint results stats, artifacts usage)

Author: matejchalk

packages/plugin-eslint/src/lib/runner/index.ts

@@ -5,9 +5,15 @@ import type {
   PluginArtifactOptions,
   RunnerFunction,
 } from '@code-pushup/models';
-import { asyncSequential, logger } from '@code-pushup/utils';
+import {
+  asyncSequential,
+  logger,
+  pluralizeToken,
+  roundDecimals,
+} from '@code-pushup/utils';
 import type { ESLintPluginRunnerConfig, ESLintTarget } from '../config.js';
 import { lint } from './lint.js';
+import { aggregateLintResultsStats } from './stats.js';
 import { lintResultsToAudits, mergeLinterOutputs } from './transform.js';
 import { loadArtifacts } from './utils.js';
 
@@ -23,14 +29,32 @@ export function createRunnerFunction(options: {
   };
 
   return async (): Promise<AuditOutputs> => {
-    logger.info(`ESLint plugin executing ${targets.length} lint targets`);
+    logger.info(
+      `ESLint plugin executing ${pluralizeToken('lint target', targets.length)}`,
+    );
 
     const linterOutputs = artifacts
       ? await loadArtifacts(artifacts)
       : await asyncSequential(targets, lint);
+
     const lintResults = mergeLinterOutputs(linterOutputs);
     const failedAudits = lintResultsToAudits(lintResults);
 
+    const stats = aggregateLintResultsStats(lintResults.results);
+    logger.info(
+      stats.problemsCount === 0
+        ? 'ESLint did not find any problems'
+        : `ESLint found ${pluralizeToken('problem', stats.problemsCount)} from ${pluralizeToken('rule', stats.failedRulesCount)} across ${pluralizeToken('file', stats.failedFilesCount)}`,
+    );
+
+    const totalCount = config.slugs.length;
+    const failedCount = failedAudits.length;
+    const passedCount = totalCount - failedCount;
+    const percentage = roundDecimals((passedCount / totalCount) * 100, 2);
+    logger.info(
+      `${pluralizeToken('audit', passedCount)} passed, ${pluralizeToken('audit', failedCount)} failed (${percentage}% success)`,
+    );
+
     return config.slugs.map(
       (slug): AuditOutput =>
         failedAudits.find(audit => audit.slug === slug) ?? {

packages/plugin-eslint/src/lib/runner/stats.ts

@@ -0,0 +1,23 @@
+import type { ESLint } from 'eslint';
+
+export type LintResultsStats = {
+  problemsCount: number;
+  failedFilesCount: number;
+  failedRulesCount: number;
+};
+
+export function aggregateLintResultsStats(
+  results: ESLint.LintResult[],
+): LintResultsStats {
+  const problemsCount = results.reduce(
+    (acc, result) => acc + result.messages.length,
+    0,
+  );
+  const failedFilesCount = results.length;
+  const failedRulesCount = new Set(
+    results.flatMap(({ messages }) =>
+      messages.map(({ ruleId }) => ruleId).filter(Boolean),
+    ),
+  ).size;
+  return { problemsCount, failedFilesCount, failedRulesCount };
+}

packages/plugin-eslint/src/lib/runner/stats.unit.test.ts

@@ -0,0 +1,72 @@
+import type { ESLint } from 'eslint';
+import { type LintResultsStats, aggregateLintResultsStats } from './stats.js';
+
+describe('aggregateLintResultsStats', () => {
+  it('should sum all errors and warning across all files', () => {
+    expect(
+      aggregateLintResultsStats([
+        {
+          filePath: 'src/main.js',
+          messages: [{ severity: 2 }],
+        },
+        {
+          filePath: 'src/lib/index.js',
+          messages: [{ severity: 2 }, { severity: 1 }],
+        },
+        {
+          filePath: 'src/lib/utils.js',
+          messages: [
+            { severity: 1 },
+            { severity: 1 },
+            { severity: 2 },
+            { severity: 1 },
+          ],
+        },
+      ] as ESLint.LintResult[]),
+    ).toEqual(
+      expect.objectContaining<Partial<LintResultsStats>>({
+        problemsCount: 7,
+      }),
+    );
+  });
+
+  it('should count files with problems', () => {
+    expect(
+      aggregateLintResultsStats([
+        { filePath: 'src/main.js', messages: [{}] },
+        { filePath: 'src/lib/index.js', messages: [{}, {}] },
+        { filePath: 'src/lib/utils.js', messages: [{}, {}, {}] },
+      ] as ESLint.LintResult[]),
+    ).toEqual(
+      expect.objectContaining<Partial<LintResultsStats>>({
+        failedFilesCount: 3,
+      }),
+    );
+  });
+
+  it('should count unique rules with reported problems', () => {
+    expect(
+      aggregateLintResultsStats([
+        { filePath: 'src/lib/main.js', messages: [{}] }, // empty ruleId ignored
+        {
+          filePath: 'src/lib/index.js',
+          messages: [{ ruleId: 'max-lines' }, { ruleId: 'no-unused-vars' }],
+        },
+        {
+          filePath: 'src/lib/utils.js',
+          messages: [
+            { ruleId: 'no-unused-vars' },
+            { ruleId: 'eqeqeq' },
+            { ruleId: 'no-unused-vars' },
+            { ruleId: 'yoda' },
+            { ruleId: 'eqeqeq' },
+          ],
+        },
+      ] as ESLint.LintResult[]),
+    ).toEqual(
+      expect.objectContaining<Partial<LintResultsStats>>({
+        failedRulesCount: 4, // no-unused-vars (3), eqeqeq (2), max-lines (1), yoda (1)
+      }),
+    );
+  });
+});

packages/plugin-eslint/src/lib/runner/utils.ts

@@ -1,7 +1,14 @@
 import type { ESLint } from 'eslint';
 import { glob } from 'glob';
 import type { PluginArtifactOptions } from '@code-pushup/models';
-import { executeProcess, readJsonFile } from '@code-pushup/utils';
+import {
+  executeProcess,
+  logger,
+  pluralize,
+  pluralizeToken,
+  readJsonFile,
+  toArray,
+} from '@code-pushup/utils';
 import type { LinterOutput } from './types.js';
 
 export async function loadArtifacts(
@@ -20,13 +27,11 @@ export async function loadArtifacts(
     });
   }
 
-  const initialArtifactPaths = Array.isArray(artifacts.artifactsPaths)
-    ? artifacts.artifactsPaths
-    : [artifacts.artifactsPaths];
+  const artifactPatterns = toArray(artifacts.artifactsPaths);
 
-  const artifactPaths = await glob(initialArtifactPaths);
+  const artifactPaths = await glob(artifactPatterns);
 
-  return await Promise.all(
+  const outputs = await Promise.all(
     artifactPaths.map(async artifactPath => {
       // ESLint CLI outputs raw ESLint.LintResult[], but we need LinterOutput format
       const results = await readJsonFile<ESLint.LintResult[]>(artifactPath);
@@ -36,4 +41,10 @@ export async function loadArtifacts(
       };
     }),
   );
+
+  logger.info(
+    `Loaded lint outputs from ${pluralizeToken('artifact', artifactPaths.length)} matching ${pluralize('pattern', artifactPatterns.length)}: ${artifactPatterns.join(' ')}`,
+  );
+
+  return outputs;
 }