feat(cache): Fallback to older decorator results on error

docs/usage/self-hosted-experimental.md

@@ -14,6 +14,10 @@ We do not follow Semantic Versioning for any experimental variables.
 These variables may be removed or have their behavior changed in **any** version.
 We will try to keep breakage to a minimum, but make no guarantees that an experimental variable will keep working.
 
+## `RENOVATE_CACHE_DECORATOR_MINUTES`
+
+If set to any integer, Renovate will use this integer instead of the time explicitly defined via `ttlMinutes` in decorators.
+
 ## `RENOVATE_CACHE_NPM_MINUTES`
 
 If set to any integer, Renovate will use this integer instead of the default npm cache time (15 minutes) for the npm datasource.

lib/util/cache/package/decorator.spec.ts

@@ -10,7 +10,7 @@ jest.mock('./file');
 describe('util/cache/package/decorator', () => {
   const spy = jest.fn(() => Promise.resolve());
 
-  beforeAll(async () => {
+  beforeEach(async () => {
     memCache.init();
     await packageCache.init({ cacheDir: os.tmpdir() });
   });
@@ -120,4 +120,70 @@ describe('util/cache/package/decorator', () => {
 
     expect(await getNumber.value?.()).toBeNumber();
   });
+
+  describe('Fallback', () => {
+    const inc = jest.fn();
+
+    class MyClass {
+      @cache({
+        namespace: (x: number) => x.toString(),
+        key: () => 'key',
+        ttlMinutes: 1,
+      })
+      public incNumber(x: number): Promise<number> {
+        return inc(x);
+      }
+    }
+
+    beforeEach(() => {
+      jest.useFakeTimers({ advanceTimers: false });
+      inc.mockImplementation((x: number) => Promise.resolve(x + 1));
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+      inc.mockClear();
+      delete process.env.RENOVATE_CACHE_DECORATOR_MINUTES;
+    });
+
+    it('updates cached result', async () => {
+      const myInst = new MyClass();
+
+      expect(await myInst.incNumber(99)).toBe(100);
+
+      jest.advanceTimersByTime(60 * 1000 - 1);
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(1);
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(2);
+    });
+
+    it('cache TTL can be overriden with RENOVATE_CACHE_DECORATOR_MINUTES', async () => {
+      process.env.RENOVATE_CACHE_DECORATOR_MINUTES = '3';
+      const myInst = new MyClass();
+
+      expect(await myInst.incNumber(99)).toBe(100);
+
+      jest.advanceTimersByTime(3 * 60 * 1000 - 1);
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(1);
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(2);
+    });
+
+    it('returns obsolete result on error', async () => {
+      const myInst = new MyClass();
+
+      expect(await myInst.incNumber(99)).toBe(100);
+
+      jest.advanceTimersByTime(60 * 1000);
+      inc.mockRejectedValueOnce(new Error('test'));
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(2);
+    });
+  });
 });

lib/util/cache/package/decorator.ts

@@ -1,5 +1,9 @@
 import is from '@sindresorhus/is';
+import { DateTime } from 'luxon';
+import { GlobalConfig } from '../../../config/global';
+import { logger } from '../../../logger';
 import { Decorator, decorate } from '../../decorator';
+import type { DecoratorCachedRecord } from './types';
 import * as packageCache from '.';
 
 type HashFunction<T extends any[] = any[]> = (...args: T) => string;
@@ -66,21 +70,51 @@ export function cache<T>({
       return callback();
     }
 
-    const cachedResult = await packageCache.get<unknown>(
+    finalKey = `cache-decorator:${finalKey}`;
+    const oldRecord = await packageCache.get<DecoratorCachedRecord>(
       finalNamespace,
       finalKey
     );
 
-    if (cachedResult !== undefined) {
-      return cachedResult;
+    const softTTL = process.env.RENOVATE_CACHE_DECORATOR_MINUTES
+      ? parseInt(process.env.RENOVATE_CACHE_DECORATOR_MINUTES, 10)
+      : ttlMinutes;
+
+    let oldData: unknown;
+    if (oldRecord) {
+      const now = DateTime.local();
+      const cachedAt = DateTime.fromISO(oldRecord.cachedAt);
+      const deadline = cachedAt.plus({ minutes: softTTL });
+      if (now < deadline) {
+        return oldRecord.data;
+      }
+      oldData = oldRecord.data;
     }
 
-    const result = await callback();
+    let newData: unknown;
+    if (oldData) {
+      try {
+        newData = (await callback()) as T | undefined;
+      } catch (err) {
+        logger.debug(
+          { err },
+          'Package cache decorator: callback error, returning old data'
+        );
+        return oldData;
+      }
+    } else {
+      newData = (await callback()) as T | undefined;
+    }
 
-    // only cache if we got a valid result
-    if (result !== undefined) {
-      await packageCache.set(finalNamespace, finalKey, result, ttlMinutes);
+    if (!is.undefined(newData)) {
+      const newRecord: DecoratorCachedRecord = {
+        cachedAt: DateTime.local().toISO(),
+        data: newData,
+      };
+      const hardTTL = GlobalConfig.get().cacheHardTtlMinutes ?? softTTL;
+      await packageCache.set(finalNamespace, finalKey, newRecord, hardTTL);
     }
-    return result;
+
+    return newData;
   });
 }

lib/util/cache/package/types.ts

@@ -8,3 +8,8 @@ export interface PackageCache {
     ttlMinutes?: number
   ): Promise<void>;
 }
+
+export interface DecoratorCachedRecord {
+  data: unknown;
+  cachedAt: string;
+}