Merge branch 'master' into overview-title-fix

Author: anders-nom

.nais/config.yml

@@ -18,19 +18,18 @@ spec:
   port: 3000
   liveness:
     path: /api/internal/isAlive
-    initialDelay: 5
+    initialDelay: 10
     timeout: 10
   readiness:
     path: /api/internal/isReady
-    initialDelay: 20
+    initialDelay: 10
     timeout: 10
   prometheus:
     enabled: true
     path: /internal/metrics
-  leaderElection: true
   redis:
     - instance: {{ redis.instance }}
-      access: admin
+      access: readwrite
   ingresses:
     {{#each ingresses as |url|}}
     - {{url}}

.nais/redis.yml

@@ -9,6 +9,9 @@ metadata:
 spec:
   plan: {{ redis.plan }}
   project: {{ redis.project }}
+  maintenanceWindowDow: saturday
+  userConfig:
+    redis_maxmemory_policy: allkeys-lru
 
 ---
 apiVersion: aiven.io/v1alpha1

package-lock.json

@@ -61,6 +61,7 @@
         "react-dom": "18.2.0",
         "react-movable": "3.0.4",
         "react-redux": "8.1.3",
+        "redis": "4.6.13",
         "rss": "1.2.2",
         "sharp": "0.33.2",
         "swr": "2.2.4",

package.json

@@ -22,8 +22,7 @@
         "express-prom-bundle": "7.0.0",
         "http-terminator": "3.2.0",
         "on-headers": "1.0.2",
-        "prom-client": "15.1.0",
-        "redis": "4.6.13"
+        "prom-client": "15.1.0"
     },
     "devDependencies": {
         "@types/cookie-parser": "1.4.6",

server/package.json

@@ -1,20 +1,17 @@
 import FileSystemCache from 'next/dist/server/lib/incremental-cache/file-system-cache';
 import { LRUCache } from 'lru-cache';
 import { CacheHandlerValue } from 'next/dist/server/lib/incremental-cache';
-import { RedisCache, RedisCacheDummy } from 'cache/redis';
-import { isLeaderPod } from 'leader-pod';
-
-const CACHE_TTL_24_HOURS_IN_MS = 3600 * 24 * 1000;
+import { RedisCache } from 'srcCommon/redis';
+import { CACHE_TTL_72_HOURS_IN_MS } from 'srcCommon/constants';
+import { pathToCacheKey } from 'srcCommon/cache-key';
 
 const TTL_RESOLUTION_MS = 60 * 1000;
 
-export const redisCache = !process.env.REDIS_URI_PAGECACHE
-    ? new RedisCacheDummy()
-    : new RedisCache({ ttl: CACHE_TTL_24_HOURS_IN_MS });
+export const redisCache = new RedisCache();
 
 const localCache = new LRUCache<string, CacheHandlerValue>({
     max: 2000,
-    ttl: CACHE_TTL_24_HOURS_IN_MS,
+    ttl: CACHE_TTL_72_HOURS_IN_MS,
     ttlResolution: TTL_RESOLUTION_MS,
 });
 
@@ -27,16 +24,16 @@ export default class PageCacheHandler {
             return fromLocalCache;
         }
 
-        const fromRedisCache = await redisCache.get(key);
+        const fromRedisCache = await redisCache.getRender(key);
         if (!fromRedisCache) {
             return null;
         }
 
         const ttlRemaining = fromRedisCache.lastModified
             ? fromRedisCache.lastModified +
-              CACHE_TTL_24_HOURS_IN_MS -
+              CACHE_TTL_72_HOURS_IN_MS -
               Date.now()
-            : CACHE_TTL_24_HOURS_IN_MS;
+            : CACHE_TTL_72_HOURS_IN_MS;
 
         if (ttlRemaining > TTL_RESOLUTION_MS) {
             localCache.set(key, fromRedisCache, {
@@ -56,23 +53,14 @@ export default class PageCacheHandler {
         };
 
         localCache.set(key, cacheItem);
-        redisCache.set(key, cacheItem);
+        redisCache.setRender(key, cacheItem);
     }
 
     public async clear() {
         localCache.clear();
-
-        if (await isLeaderPod()) {
-            return redisCache.clear();
-        }
     }
 
     public async delete(path: string) {
-        const pagePath = path === '/' ? '/index' : path;
-        localCache.delete(pagePath);
-
-        if (await isLeaderPod()) {
-            return redisCache.delete(pagePath);
-        }
+        localCache.delete(pathToCacheKey(path));
     }
 }

server/src/cache/page-cache-handler.ts

@@ -16,7 +16,7 @@ describe('Revalidator proxy heartbeat', () => {
 
         fetchMock.mockResponse('Hello!');
 
-        initRevalidatorProxyHeartbeat();
+        initRevalidatorProxyHeartbeat('dummy-build-id');
 
         expect(fetchMock.mock.calls.length).toEqual(1);
         expect(fetchMock.mock.calls[0][0]).toMatch(

server/src/cache/redis.ts

@@ -3,6 +3,11 @@
 // See: https://github.com/navikt/nav-enonicxp-frontend-revalidator-proxy
 import { networkInterfaces } from 'os';
 import { logger } from 'srcCommon/logger';
+import {
+    getRenderCacheKeyPrefix,
+    getResponseCacheKeyPrefix,
+} from 'srcCommon/redis';
+import { objectToQueryString } from 'srcCommon/fetch-utils';
 
 const {
     ENV,
@@ -11,7 +16,8 @@ const {
     REVALIDATOR_PROXY_ORIGIN,
     SERVICE_SECRET,
 } = process.env;
-const heartbeatPeriodMs = 5000;
+
+const HEARTBEAT_PERIOD_MS = 5000;
 
 const getPodAddress = () => {
     if (ENV === 'localhost') {
@@ -34,33 +40,46 @@ const getPodAddress = () => {
     return podAddress;
 };
 
-const getProxyLivenessUrl = () => {
+const getProxyLivenessUrl = (buildId: string) => {
     const podAddress = getPodAddress();
     return podAddress
-        ? `${REVALIDATOR_PROXY_ORIGIN}/liveness?address=${podAddress}`
+        ? `${REVALIDATOR_PROXY_ORIGIN}/liveness${objectToQueryString({
+              address: podAddress,
+              redisPrefixes: [
+                  getRenderCacheKeyPrefix(buildId),
+                  getResponseCacheKeyPrefix(),
+              ].join(','),
+          })}`
         : null;
 };
 
-export const initRevalidatorProxyHeartbeat = (() => {
+let didStart = false;
+
+export const initRevalidatorProxyHeartbeat = (buildId: string) => {
     if (NODE_ENV === 'development') {
-        return () => {};
+        return;
     }
 
-    let heartbeatInterval: NodeJS.Timer;
-    const url = getProxyLivenessUrl();
+    if (didStart) {
+        logger.warn('Proxy heartbeat loop already started!');
+        return;
+    }
+
+    const url = getProxyLivenessUrl(buildId);
+    if (!url) {
+        return;
+    }
 
-    return () => {
-        if (!heartbeatInterval && url) {
-            logger.info('Starting heartbeat loop');
-            const heartbeatFunc = () => {
-                fetch(url, {
-                    headers: { secret: SERVICE_SECRET },
-                }).catch((e) =>
-                    logger.error(`Failed to send heartbeat signal - ${e}`)
-                );
-            };
-            heartbeatFunc();
-            heartbeatInterval = setInterval(heartbeatFunc, heartbeatPeriodMs);
-        }
+    didStart = true;
+
+    logger.info('Starting heartbeat loop');
+
+    const heartbeatFunc = () => {
+        fetch(url, {
+            headers: { secret: SERVICE_SECRET },
+        }).catch((e) => logger.error(`Failed to send heartbeat signal - ${e}`));
     };
-})();
+
+    heartbeatFunc();
+    setInterval(heartbeatFunc, HEARTBEAT_PERIOD_MS);
+};