feat: dns caching manager (#1294)

* feat(dns): implement dns caching

* feat: simple implementation of dnscaching

* feat: dynamic ttl which is revalidated while using stale dns cache

This is done as tmdb ttl is very less like 40 seconds so to make sure
any issues wont be caused due to cached dns (previously we were caching
for 5 minutes no matter what ttl)

* feat(dns): improve DNS cache with multi-strategy fallback system

- multiple DNS resolution strategie
- graceful fallbacks between IPv6 and IPv4 addresses
- network error reporting in fetch fix
- compatibility with cypress testing (I HOPE)

* fix: typos

* feat: dns cache stats in jobs & cache page (and cleanup)

* feat(networksettings): cache dns off by default

* feat: make dnsCache optional and enable-able through network settings

* chore(i18n): extract translation keys

* test(cypress): fix cypress testing

* feat(dnscache): dns cache entries are now flushable

* style(cypress): run prettier

* chore(cypresssettings): git ignore cypress json settings

* chore: ignore cypress/config/settings.json

* fix(dnscache): use entry specific hits and misses not global

* refactor: clean up console logs

* fix(dnscache): fix miss counter

* feat(dnscache): global stats

* chore(i18n): extract translation keys

* refactor: use date-fns for formatting age and remove useless code

* refactor: remove cypress testing options in dnsCacheManager

* refactor: remove console logs

* refactor: removed useless condition when its always truthy

* fix: remove FetchAPI-related code

* fix: remove old ipv4first setting

* refactor: use our own dns-caching package instead

* fix: correct dns-caching module configuration

* fix: correct dns-caching module configuration

* fix: remove useless lru-cache dependency

* fix: update dns-caching to v0.2.0

* fix: add env variable for min/max ttl & update dns-caching

* fix: update dns-caching package

* fix: add force min/max TTL in network settings

* docs: add docs for dns caching

---------

Co-authored-by: Gauthier <mail@gauthierth.fr>

server/index.ts

@@ -25,6 +25,7 @@ import imageproxy from '@server/routes/imageproxy';
 import { appDataPermissions } from '@server/utils/appDataVolume';
 import { getAppVersion } from '@server/utils/appVersion';
 import createCustomProxyAgent from '@server/utils/customProxyAgent';
+import { initializeDnsCache } from '@server/utils/dnsCache';
 import restartFlag from '@server/utils/restartFlag';
 import { getClientIp } from '@supercharge/request-ip';
 import axios from 'axios';
@@ -80,6 +81,14 @@ app
       axios.defaults.httpsAgent = new https.Agent({ family: 4 });
     }
 
+    // Add DNS caching
+    if (settings.network.dnsCache) {
+      initializeDnsCache({
+        forceMinTtl: settings.network.dnsCache.forceMinTtl,
+        forceMaxTtl: settings.network.dnsCache.forceMaxTtl,
+      });
+    }
+
     // Register HTTP proxy
     if (settings.network.proxy.enabled) {
       await createCustomProxyAgent(settings.network.proxy);

server/interfaces/api/settingsInterfaces.ts

@@ -61,9 +61,39 @@ export interface CacheItem {
   };
 }
 
+export interface DNSAddresses {
+  ipv4: number;
+  ipv6: number;
+}
+
+export interface DNSRecord {
+  addresses: DNSAddresses;
+  activeAddress: string;
+  family: number;
+  age: number;
+  ttl: number;
+  networkErrors: number;
+  hits: number;
+  misses: number;
+}
+
+export interface DNSStats {
+  size: number;
+  maxSize: number;
+  hits: number;
+  misses: number;
+  failures: number;
+  ipv4Fallbacks: number;
+  hitRate: number;
+}
+
 export interface CacheResponse {
   apiCaches: CacheItem[];
   imageCache: Record<'tmdb' | 'avatar', { size: number; imageCount: number }>;
+  dnsCache: {
+    entries: Record<string, DNSRecord>;
+    stats: DNSStats;
+  };
 }
 
 export interface StatusResponse {

server/lib/settings/index.ts

@@ -100,17 +100,6 @@ interface Quota {
   quotaDays?: number;
 }
 
-export interface ProxySettings {
-  enabled: boolean;
-  hostname: string;
-  port: number;
-  useSsl: boolean;
-  user: string;
-  password: string;
-  bypassFilter: string;
-  bypassLocalAddresses: boolean;
-}
-
 export interface MainSettings {
   apiKey: string;
   applicationTitle: string;
@@ -138,11 +127,29 @@ export interface MainSettings {
   youtubeUrl: string;
 }
 
+export interface ProxySettings {
+  enabled: boolean;
+  hostname: string;
+  port: number;
+  useSsl: boolean;
+  user: string;
+  password: string;
+  bypassFilter: string;
+  bypassLocalAddresses: boolean;
+}
+
+export interface DnsCacheSettings {
+  enabled: boolean;
+  forceMinTtl?: number;
+  forceMaxTtl?: number;
+}
+
 export interface NetworkSettings {
   csrfProtection: boolean;
   forceIpv4First: boolean;
   trustProxy: boolean;
   proxy: ProxySettings;
+  dnsCache: DnsCacheSettings;
 }
 
 interface PublicSettings {
@@ -542,6 +549,11 @@ class Settings {
           bypassFilter: '',
           bypassLocalAddresses: true,
         },
+        dnsCache: {
+          enabled: false,
+          forceMinTtl: 0,
+          forceMaxTtl: -1,
+        },
       },
     };
     if (initialSettings) {

server/routes/settings/index.ts

@@ -28,6 +28,7 @@ import discoverSettingRoutes from '@server/routes/settings/discover';
 import { ApiError } from '@server/types/error';
 import { appDataPath } from '@server/utils/appDataVolume';
 import { getAppVersion } from '@server/utils/appVersion';
+import dnsCache from '@server/utils/dnsCache';
 import { getHostname } from '@server/utils/getHostname';
 import { Router } from 'express';
 import rateLimit from 'express-rate-limit';
@@ -755,12 +756,19 @@ settingsRoutes.get('/cache', async (_req, res) => {
   const tmdbImageCache = await ImageProxy.getImageStats('tmdb');
   const avatarImageCache = await ImageProxy.getImageStats('avatar');
 
+  const stats = dnsCache?.getStats();
+  const entries = dnsCache?.getCacheEntries();
+
   return res.status(200).json({
     apiCaches,
     imageCache: {
       tmdb: tmdbImageCache,
       avatar: avatarImageCache,
     },
+    dnsCache: {
+      stats,
+      entries,
+    },
   });
 });
 
@@ -778,6 +786,20 @@ settingsRoutes.post<{ cacheId: AvailableCacheIds }>(
   }
 );
 
+settingsRoutes.post<{ dnsEntry: string }>(
+  '/cache/dns/:dnsEntry/flush',
+  (req, res, next) => {
+    const dnsEntry = req.params.dnsEntry;
+
+    if (dnsCache) {
+      dnsCache.clear(dnsEntry);
+      return res.status(204).send();
+    }
+
+    next({ status: 404, message: 'Cache not found.' });
+  }
+);
+
 settingsRoutes.post(
   '/initialize',
   isAuthenticated(Permission.ADMIN),

server/utils/dnsCache.ts

@@ -0,0 +1,28 @@
+import logger from '@server/logger';
+import { DnsCacheManager } from 'dns-caching';
+
+let dnsCache: DnsCacheManager | undefined;
+
+export function initializeDnsCache({
+  forceMinTtl,
+  forceMaxTtl,
+}: {
+  forceMinTtl?: number;
+  forceMaxTtl?: number;
+}) {
+  if (dnsCache) {
+    logger.warn('DNS Cache is already initialized', { label: 'DNS Cache' });
+    return;
+  }
+
+  logger.info('Initializing DNS Cache', { label: 'DNS Cache' });
+
+  dnsCache = new DnsCacheManager({
+    logger,
+    forceMinTtl: typeof forceMinTtl === 'number' ? forceMinTtl * 1000 : 0,
+    forceMaxTtl: typeof forceMaxTtl === 'number' ? forceMaxTtl * 1000 : -1,
+  });
+  dnsCache.initialize();
+}
+
+export default dnsCache;