feat(plugin-lighthouse): log initializer steps (audit/group counts, expanded, skipped)

Author: matejchalk

packages/plugin-lighthouse/src/lib/constants.ts

@@ -6,6 +6,8 @@ import { DEFAULT_PERSIST_OUTPUT_DIR } from '@code-pushup/models';
 export const DEFAULT_CHROME_FLAGS = [...DEFAULT_FLAGS, '--headless'];
 
 export const LIGHTHOUSE_PLUGIN_SLUG = 'lighthouse';
+export const LIGHTHOUSE_PLUGIN_TITLE = 'Lighthouse';
+
 export const LIGHTHOUSE_OUTPUT_PATH = path.join(
   DEFAULT_PERSIST_OUTPUT_DIR,
   LIGHTHOUSE_PLUGIN_SLUG,

packages/plugin-lighthouse/src/lib/format.ts

@@ -0,0 +1,4 @@
+import { pluginMetaLogFormatter } from '@code-pushup/utils';
+import { LIGHTHOUSE_PLUGIN_TITLE } from './constants.js';
+
+export const formatMetaLog = pluginMetaLogFormatter(LIGHTHOUSE_PLUGIN_TITLE);

packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts

@@ -1,7 +1,10 @@
 import { createRequire } from 'node:module';
 import type { PluginConfig, PluginUrls } from '@code-pushup/models';
 import { normalizeUrlInput } from '@code-pushup/utils';
-import { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';
+import {
+  LIGHTHOUSE_PLUGIN_SLUG,
+  LIGHTHOUSE_PLUGIN_TITLE,
+} from './constants.js';
 import { normalizeFlags } from './normalize-flags.js';
 import { processAuditsAndGroups } from './processing.js';
 import { createRunnerFunction } from './runner/runner.js';
@@ -33,10 +36,10 @@ export function lighthousePlugin(
 
   return {
     slug: LIGHTHOUSE_PLUGIN_SLUG,
+    title: LIGHTHOUSE_PLUGIN_TITLE,
+    icon: 'lighthouse',
     packageName: packageJson.name,
     version: packageJson.version,
-    title: 'Lighthouse',
-    icon: 'lighthouse',
     audits,
     groups,
     runner: createRunnerFunction(normalizedUrls, {

packages/plugin-lighthouse/src/lib/processing.ts

@@ -1,9 +1,15 @@
+import type { Audit, Group } from '@code-pushup/models';
 import {
   addIndex,
   expandAuditsForUrls,
   expandGroupsForUrls,
+  logger,
+  objectFromEntries,
+  objectToEntries,
+  pluralizeToken,
   shouldExpandForUrls,
 } from '@code-pushup/utils';
+import { formatMetaLog } from './format.js';
 import {
   LIGHTHOUSE_GROUPS,
   LIGHTHOUSE_NAVIGATION_AUDITS,
@@ -14,35 +20,82 @@ export function expandOptionsForUrls(
   options: FilterOptions,
   urlCount: number,
 ): FilterOptions {
-  return Object.fromEntries(
-    Object.entries(options).map(([key, value]) => [
+  return objectFromEntries(
+    objectToEntries(options).map(([key, value = []]) => [
       key,
-      Array.isArray(value)
-        ? value.flatMap(slug =>
-            Array.from({ length: urlCount }, (_, i) => addIndex(slug, i)),
-          )
-        : value,
+      value.flatMap(slug =>
+        Array.from({ length: urlCount }, (_, i) => addIndex(slug, i)),
+      ),
     ]),
   );
 }
 
 export function processAuditsAndGroups(urls: string[], options: FilterOptions) {
+  logTotal();
   if (!shouldExpandForUrls(urls.length)) {
-    return markSkippedAuditsAndGroups(
+    const marked = markSkippedAuditsAndGroups(
       LIGHTHOUSE_NAVIGATION_AUDITS,
       LIGHTHOUSE_GROUPS,
       options,
     );
+    logSkipped(marked);
+    return marked;
   }
   const expandedAudits = expandAuditsForUrls(
     LIGHTHOUSE_NAVIGATION_AUDITS,
     urls,
   );
   const expandedGroups = expandGroupsForUrls(LIGHTHOUSE_GROUPS, urls);
   const expandedOptions = expandOptionsForUrls(options, urls.length);
-  return markSkippedAuditsAndGroups(
+  logExpanded(expandedAudits, expandedGroups, urls);
+  const marked = markSkippedAuditsAndGroups(
     expandedAudits,
     expandedGroups,
     expandedOptions,
   );
+  logSkipped(marked);
+  return marked;
+}
+
+function logTotal(): void {
+  logger.info(
+    formatMetaLog(
+      `Created ${pluralizeToken('group', LIGHTHOUSE_GROUPS.length)} and ${pluralizeToken('audit', LIGHTHOUSE_NAVIGATION_AUDITS.length)} from Lighthouse's categories and navigation audits`,
+    ),
+  );
+}
+
+function logExpanded(
+  expandedAudits: Audit[],
+  expandedGroups: Group[],
+  urls: string[],
+): void {
+  logger.info(
+    formatMetaLog(
+      `Expanded audits (${LIGHTHOUSE_NAVIGATION_AUDITS.length} → ${expandedAudits.length}) and groups (${LIGHTHOUSE_GROUPS.length} → ${expandedGroups.length}) for ${pluralizeToken('URL', urls.length)}`,
+    ),
+  );
+}
+
+function logSkipped(marked: { audits: Audit[]; groups: Group[] }): void {
+  const { audits, groups } = marked;
+
+  const formattedCounts = [
+    { name: 'audit', items: audits },
+    { name: 'group', items: groups },
+  ]
+    .map(({ name, items }) => {
+      const skipped = items.filter(({ isSkipped }) => isSkipped);
+      if (skipped.length === 0) {
+        return '';
+      }
+      return `${skipped.length} out of ${pluralizeToken(name, items.length)}`;
+    })
+    .filter(Boolean)
+    .join(' and ');
+
+  if (!formattedCounts) {
+    return;
+  }
+  logger.info(formatMetaLog(`Skipping ${formattedCounts}`));
 }

packages/plugin-lighthouse/src/lib/utils.ts

@@ -25,9 +25,10 @@ export function lighthouseAuditRef(auditSlug: string, weight = 1): CategoryRef {
   };
 }
 
-export class AuditsNotImplementedError extends Error {
-  constructor(auditSlugs: string[]) {
-    super(`audits: "${auditSlugs.join(', ')}" not implemented`);
+export class NotImplementedError extends Error {
+  constructor(plural: string, slugs: string[]) {
+    const formattedSlugs = slugs.map(slug => `"${slug}"`).join(', ');
+    super(`${plural} not implemented: ${formattedSlugs}`);
   }
 }
 
@@ -36,17 +37,11 @@ export function validateAudits(audits: Audit[], onlyAudits: string[]): boolean {
     slug => !audits.some(audit => audit.slug === slug),
   );
   if (missingAudtis.length > 0) {
-    throw new AuditsNotImplementedError(missingAudtis);
+    throw new NotImplementedError('Audits', missingAudtis);
   }
   return true;
 }
 
-export class CategoriesNotImplementedError extends Error {
-  constructor(categorySlugs: string[]) {
-    super(`categories: "${categorySlugs.join(', ')}" not implemented`);
-  }
-}
-
 export function validateOnlyCategories(
   groups: Group[],
   onlyCategories: string | string[],
@@ -55,7 +50,7 @@ export function validateOnlyCategories(
     groups.every(group => group.slug !== slug),
   );
   if (missingCategories.length > 0) {
-    throw new CategoriesNotImplementedError(missingCategories);
+    throw new NotImplementedError('Categories', missingCategories);
   }
   return true;
 }

packages/plugin-lighthouse/src/lib/utils.unit.test.ts

@@ -7,8 +7,6 @@ import {
   pluginConfigSchema,
 } from '@code-pushup/models';
 import {
-  AuditsNotImplementedError,
-  CategoriesNotImplementedError,
   lighthouseAuditRef,
   lighthouseGroupRef,
   markSkippedAuditsAndGroups,
@@ -70,7 +68,7 @@ describe('validateAudits', () => {
         ],
         ['missing-audit'],
       ),
-    ).toThrow(new AuditsNotImplementedError(['missing-audit']));
+    ).toThrow('Audits not implemented: "missing-audit"');
   });
 });
 
@@ -107,7 +105,7 @@ describe('validateOnlyCategories', () => {
         ],
         'missing-category',
       ),
-    ).toThrow(new CategoriesNotImplementedError(['missing-category']));
+    ).toThrow('Categories not implemented: "missing-category"');
   });
 });
 
@@ -209,7 +207,7 @@ describe('markSkippedAuditsAndGroups to be used in plugin config', () => {
         ] as Group[],
         { skipAudits: ['missing-audit'] },
       ),
-    ).toThrow(new AuditsNotImplementedError(['missing-audit']));
+    ).toThrow('Audits not implemented: "missing-audit"');
   });
 
   it('should mark audits as not skipped when onlyAudits is set', () => {
@@ -258,7 +256,7 @@ describe('markSkippedAuditsAndGroups to be used in plugin config', () => {
         ] as Group[],
         { onlyAudits: ['missing-audit'] },
       ),
-    ).toThrow(new AuditsNotImplementedError(['missing-audit']));
+    ).toThrow('Audits not implemented: "missing-audit"');
   });
 
   it('should mark skipped audits and groups when onlyGroups is set', () => {
@@ -396,10 +394,10 @@ describe('markSkippedAuditsAndGroups to be used in plugin config', () => {
           onlyAudits: ['missing-audit'],
         },
       ),
-    ).toThrow(new AuditsNotImplementedError(['missing-audit']));
+    ).toThrow('Audits not implemented: "missing-audit"');
   });
 
-  it('should throw if onlyGroups is set with a group slug that is not implemented', () => {
+  it('should throw if onlyCategories is set with a group slug that is not implemented', () => {
     expect(() =>
       markSkippedAuditsAndGroups(
         [{ slug: 'speed-index' }] as Audit[],
@@ -413,6 +411,6 @@ describe('markSkippedAuditsAndGroups to be used in plugin config', () => {
           onlyCategories: ['missing-group'],
         },
       ),
-    ).toThrow(new CategoriesNotImplementedError(['missing-group']));
+    ).toThrow('Categories not implemented: "missing-group"');
   });
 });