feat: dns caching manager

package.json

@@ -62,6 +62,7 @@
     "formik": "^2.4.6",
     "gravatar-url": "3.1.0",
     "lodash": "4.17.21",
+    "lru-cache": "^11.0.2",
     "mime": "3",
     "next": "^14.2.4",
     "node-cache": "5.1.2",

server/index.ts

@@ -24,6 +24,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 { dnsCache } from '@server/utils/dnsCacheManager';
 import restartFlag from '@server/utils/restartFlag';
 import { getClientIp } from '@supercharge/request-ip';
 import { TypeormStore } from 'connect-typeorm/out';
@@ -86,6 +87,57 @@ app
       );
     }
 
+    // Add DNS caching
+    dns.lookup = (() => {
+      const wrappedLookup = function (
+        hostname: string,
+        options:
+          | number
+          | dns.LookupOneOptions
+          | dns.LookupOptions
+          | dns.LookupAllOptions,
+        callback: (
+          err: NodeJS.ErrnoException | null,
+          address: string | dns.LookupAddress[] | undefined,
+          family?: number
+        ) => void
+      ): void {
+        if (typeof options === 'function') {
+          callback = options;
+          options = {};
+        }
+
+        dnsCache
+          .lookup(hostname)
+          .then((result) => {
+            if ((options as dns.LookupOptions).all) {
+              callback(null, [
+                { address: result.address, family: result.family },
+              ]);
+            } else {
+              callback(null, result.address, result.family);
+            }
+          })
+          .catch((error) => {
+            callback(error, undefined, undefined);
+          });
+      } as typeof dns.lookup;
+
+      (wrappedLookup as any).__promisify__ = async function (
+        hostname: string,
+        options?: dns.LookupAllOptions | dns.LookupOneOptions
+      ): Promise<dns.LookupAddress[] | { address: string; family: number }> {
+        const result = await dnsCache.lookup(hostname);
+
+        if (options && 'all' in options && options.all === true) {
+          return [{ address: result.address, family: result.family }];
+        }
+        return { address: result.address, family: result.family };
+      };
+
+      return wrappedLookup;
+    })();
+
     // Register HTTP proxy
     if (settings.main.proxy.enabled) {
       await createCustomProxyAgent(settings.main.proxy);

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/dnsCacheManager';
 import { getHostname } from '@server/utils/getHostname';
 import { Router } from 'express';
 import rateLimit from 'express-rate-limit';
@@ -59,8 +60,23 @@ const filteredMainSettings = (
   return main;
 };
 
+settingsRoutes.get('/dnsCache', async (req, res) => {
+  const stats = dnsCache.getStats();
+  const entries = dnsCache.getCacheEntries();
+
+  res.json({
+    stats,
+    entries,
+  });
+});
+
 settingsRoutes.get('/main', (req, res, next) => {
   const settings = getSettings();
+  const stats = dnsCache.getStats();
+  const entries = dnsCache.getCacheEntries();
+
+  console.log(entries);
+  console.log(stats);
 
   if (!req.user) {
     return next({ status: 400, message: 'User missing from request.' });