feat: Abandoned packages logging (renovatebot#36090)

Co-authored-by: Rhys Arkins <rhys@arkins.net>
Co-authored-by: HonkingGoose <34918129+HonkingGoose@users.noreply.github.com>

Author: 3 people

lib/modules/manager/types.ts

@@ -170,6 +170,9 @@ export interface PackageDependency<T = Record<string, any>>
    * override data source's default strategy.
    */
   registryStrategy?: RegistryStrategy;
+
+  mostRecentTimestamp?: Timestamp;
+  isAbandoned?: boolean;
 }
 
 export interface Upgrade<T = Record<string, any>> extends PackageDependency<T> {

lib/util/stats.spec.ts

@@ -1,5 +1,6 @@
 import * as memCache from './cache/memory';
 import {
+  AbandonedPackageStats,
   DatasourceCacheStats,
   HttpCacheStats,
   HttpStats,
@@ -574,4 +575,95 @@ describe('util/stats', () => {
       });
     });
   });
+
+  describe('AbandonmentStats', () => {
+    beforeEach(() => {
+      memCache.init();
+    });
+
+    it('returns empty report', () => {
+      const res = AbandonedPackageStats.getReport();
+      expect(res).toEqual({});
+    });
+
+    it('writes data points', () => {
+      AbandonedPackageStats.write(
+        'npm',
+        'package1',
+        '2023-01-01T00:00:00.000Z',
+      );
+      AbandonedPackageStats.write(
+        'npm',
+        'package2',
+        '2023-02-01T00:00:00.000Z',
+      );
+      AbandonedPackageStats.write(
+        'docker',
+        'image1',
+        '2023-03-01T00:00:00.000Z',
+      );
+
+      const data = AbandonedPackageStats.getData();
+      expect(data).toEqual([
+        {
+          datasource: 'npm',
+          packageName: 'package1',
+          mostRecentTimestamp: '2023-01-01T00:00:00.000Z',
+        },
+        {
+          datasource: 'npm',
+          packageName: 'package2',
+          mostRecentTimestamp: '2023-02-01T00:00:00.000Z',
+        },
+        {
+          datasource: 'docker',
+          packageName: 'image1',
+          mostRecentTimestamp: '2023-03-01T00:00:00.000Z',
+        },
+      ]);
+
+      const report = AbandonedPackageStats.getReport();
+      expect(report).toEqual({
+        npm: {
+          package1: '2023-01-01T00:00:00.000Z',
+          package2: '2023-02-01T00:00:00.000Z',
+        },
+        docker: {
+          image1: '2023-03-01T00:00:00.000Z',
+        },
+      });
+    });
+
+    it('logs report', () => {
+      AbandonedPackageStats.write(
+        'npm',
+        'package1',
+        '2023-01-01T00:00:00.000Z',
+      );
+      AbandonedPackageStats.write(
+        'docker',
+        'image1',
+        '2023-03-01T00:00:00.000Z',
+      );
+
+      AbandonedPackageStats.report();
+
+      expect(logger.logger.debug).toHaveBeenCalledTimes(1);
+      const [data, msg] = logger.logger.debug.mock.calls[0];
+      expect(msg).toBe('Abandoned package statistics');
+      expect(data).toEqual({
+        npm: {
+          package1: '2023-01-01T00:00:00.000Z',
+        },
+        docker: {
+          image1: '2023-03-01T00:00:00.000Z',
+        },
+      });
+    });
+
+    it('does not log report when no data', () => {
+      AbandonedPackageStats.report();
+      expect(logger.logger.debug).not.toHaveBeenCalled();
+    });
+  });
 });

lib/util/stats.ts

@@ -520,3 +520,58 @@ export class ObsoleteCacheHitLogger {
   }
 }
 /* v8 ignore stop: temporary code */
+
+interface AbandonedPackage {
+  datasource: string;
+  packageName: string;
+  mostRecentTimestamp: string;
+}
+
+type AbandonedPackageReport = Record<string, Record<string, string>>;
+
+export class AbandonedPackageStats {
+  static getData(): AbandonedPackage[] {
+    return memCache.get<AbandonedPackage[]>('abandonment-stats') ?? [];
+  }
+
+  private static setData(data: AbandonedPackage[]): void {
+    memCache.set('abandonment-stats', data);
+  }
+
+  static write(
+    datasource: string,
+    packageName: string,
+    mostRecentTimestamp: string,
+  ): void {
+    const data = this.getData();
+    data.push({ datasource, packageName, mostRecentTimestamp });
+    this.setData(data);
+  }
+
+  static getReport(): AbandonedPackageReport {
+    const data = this.getData();
+    const result: AbandonedPackageReport = {};
+
+    for (const { datasource, packageName, mostRecentTimestamp } of data) {
+      result[datasource] ??= {};
+      result[datasource][packageName] = mostRecentTimestamp;
+    }
+
+    const sortedResult: AbandonedPackageReport = {};
+    for (const datasource of Object.keys(result).sort()) {
+      sortedResult[datasource] = {};
+      for (const packageName of Object.keys(result[datasource]).sort()) {
+        sortedResult[datasource][packageName] = result[datasource][packageName];
+      }
+    }
+
+    return sortedResult;
+  }
+
+  static report(): void {
+    const report = this.getReport();
+    if (Object.keys(report).length > 0) {
+      logger.debug(report, 'Abandoned package statistics');
+    }
+  }
+}

lib/workers/repository/index.ts

@@ -20,6 +20,7 @@ import * as queue from '../../util/http/queue';
 import * as throttle from '../../util/http/throttle';
 import { addSplit, getSplits, splitInit } from '../../util/split';
 import {
+  AbandonedPackageStats,
   DatasourceCacheStats,
   HttpCacheStats,
   HttpStats,
@@ -149,6 +150,7 @@ export async function renovateRepository(
   HttpCacheStats.report();
   LookupStats.report();
   ObsoleteCacheHitLogger.report();
+  AbandonedPackageStats.report();
   const cloned = isCloned();
   logger.info({ cloned, durationMs: splits.total }, 'Repository finished');
   resetRepositoryLogLevelRemaps();

lib/workers/repository/process/lookup/abandonment.ts

@@ -2,6 +2,7 @@ import { DateTime } from 'luxon';
 import { logger } from '../../../../logger';
 import type { ReleaseResult } from '../../../../modules/datasource/types';
 import { toMs } from '../../../../util/pretty-time';
+import { AbandonedPackageStats } from '../../../../util/stats';
 import type { LookupUpdateConfig } from './types';
 
 export function calculateAbandonment(
@@ -63,5 +64,10 @@ export function calculateAbandonment(
     'Calculated abandonment status',
   );
 
+  if (isAbandoned) {
+    const { datasource, packageName } = config;
+    AbandonedPackageStats.write(datasource, packageName, mostRecentTimestamp);
+  }
+
   return releaseResult;
 }

lib/workers/repository/process/lookup/index.ts

@@ -203,6 +203,8 @@ export async function lookupUpdates(
         'dependencyUrl',
         'lookupName',
         'packageScope',
+        'mostRecentTimestamp',
+        'isAbandoned',
       ]);
 
       const latestVersion = dependency.tags?.latest;

lib/workers/repository/process/lookup/types.ts

@@ -8,6 +8,7 @@ import type {
 } from '../../../../modules/manager/types';
 import type { SkipReason } from '../../../../types';
 import type { MergeConfidence } from '../../../../util/merge-confidence/types';
+import type { Timestamp } from '../../../../util/timestamp';
 
 export interface FilterConfig {
   allowedVersions?: string;
@@ -75,4 +76,6 @@ export interface UpdateResult {
   currentVersionTimestamp?: string;
   vulnerabilityFixVersion?: string;
   vulnerabilityFixStrategy?: string;
+  mostRecentTimestamp?: Timestamp | null;
+  isAbandoned?: boolean;
 }