feat: cache dns lookups in memory for 60 seconds

This reduces the load on the DNS server,
even if it runs on the same machine or the OS caches it for us.

Author: SpraxDev

src/http/clients/SimpleHttpClient.ts

@@ -1,7 +1,7 @@
 import { container } from 'tsyringe';
 import * as Undici from 'undici';
 import { IS_PRODUCTION } from '../../constants.js';
-import UnicastOnlyDnsResolver from '../dns/UnicastOnlyDnsResolver.js';
+import UnicastOnlyDnsResolver from '../dns/resolver/UnicastOnlyDnsResolver.js';
 import HttpResponse from '../HttpResponse.js';
 import UserAgentGenerator from '../UserAgentGenerator.js';
 import HttpClient, { FullRequestOptions, GetRequestOptions, PostRequestOptions } from './HttpClient.js';
@@ -64,10 +64,11 @@ export default class SimpleHttpClient extends HttpClient {
   }
 
   protected getDefaultAgentOptions(): Undici.Agent.Options {
+    const dnsResolver = container.resolve(UnicastOnlyDnsResolver);
     return {
       ...super.getDefaultAgentOptions(),
       connect: {
-        lookup: container.resolve(UnicastOnlyDnsResolver).lookup,
+        lookup: (hostname, options, callback) => dnsResolver.lookup(hostname, options, callback),
       },
     };
   }

src/http/clients/SocksProxyAgentFactory.ts

@@ -4,7 +4,7 @@ import * as Undici from 'undici';
 import { SocksProxyServer } from '../../net/proxy/ProxyServerConfigurationProvider.js';
 import SocksProxyServerConnector from '../../net/proxy/SocksProxyServerConnector.js';
 import ResolvedToNonUnicastIpError from '../dns/errors/ResolvedToNonUnicastIpError.js';
-import UnicastOnlyDnsResolver from '../dns/UnicastOnlyDnsResolver.js';
+import UnicastOnlyDnsResolver from '../dns/resolver/UnicastOnlyDnsResolver.js';
 
 @singleton()
 export default class SocksProxyAgentFactory {

src/http/dns/UnicastOnlyDnsResolver.ts

@@ -0,0 +1,37 @@
+import Dns from 'node:dns';
+import { singleton } from 'tsyringe';
+import MapWithTtl from '../../../util/MapWithTtl.js';
+import DnsResolver from './DnsResolver.js';
+import DnsResolverInterface, { LookupAsyncResult } from './DnsResolverInterface.js';
+
+@singleton()
+export default class CachedDnsResolver implements DnsResolverInterface {
+  private readonly cache = MapWithTtl.create<string, LookupAsyncResult>(60);
+
+  constructor(
+    private readonly dnsResolver: DnsResolver,
+  ) {
+  }
+
+  lookup(
+    hostname: string,
+    options: Dns.LookupOptions,
+    callback: (err: NodeJS.ErrnoException | null, address: string | Dns.LookupAddress[], family?: number) => void,
+  ): void {
+    this.lookupAsync(hostname, options)
+      .then(result => callback(null, result.address, result.family))
+      .catch((err) => callback(err, [], undefined));
+  }
+
+  async lookupAsync(hostname: string, options: Dns.LookupOptions): Promise<LookupAsyncResult> {
+    const cacheKey = `${hostname}${options.family}${options.hints}${options.all}${options.order}${options.verbatim}`;
+
+    let lookupResult = this.cache.get(cacheKey);
+    if (lookupResult == null) {
+      lookupResult = await this.dnsResolver.lookupAsync(hostname, options);
+      this.cache.set(cacheKey, lookupResult);
+    }
+
+    return lookupResult;
+  }
+}

src/http/dns/resolver/CachedDnsResolver.ts

@@ -0,0 +1,27 @@
+import Dns from 'node:dns';
+import { singleton } from 'tsyringe';
+import DnsResolverInterface, { type LookupAsyncResult } from './DnsResolverInterface.js';
+
+@singleton()
+export default class DnsResolver implements DnsResolverInterface {
+  lookup(
+    hostname: string,
+    options: Dns.LookupOptions,
+    callback: (err: NodeJS.ErrnoException | null, address: string | Dns.LookupAddress[], family?: number) => void,
+  ): void {
+    Dns.lookup(hostname, options, (err, address, family): void => {
+      return callback(err, address, family);
+    });
+  }
+
+  lookupAsync(hostname: string, options: Dns.LookupOptions): Promise<LookupAsyncResult> {
+    return new Promise((resolve, reject) => {
+      this.lookup(hostname, options, (err, address, family): void => {
+        if (err) {
+          return reject(err);
+        }
+        resolve({ address, family });
+      });
+    });
+  }
+}

src/http/dns/resolver/DnsResolver.ts

@@ -0,0 +1,16 @@
+import type Dns from 'node:dns';
+
+export type LookupAsyncResult = {
+  address: string | Dns.LookupAddress[],
+  family?: number,
+}
+
+export default interface DnsResolverInterface {
+  lookup(
+    hostname: string,
+    options: Dns.LookupOptions,
+    callback: (err: NodeJS.ErrnoException | null, address: string | Dns.LookupAddress[], family?: number) => void,
+  ): void;
+
+  lookupAsync(hostname: string, options: Dns.LookupOptions): Promise<LookupAsyncResult>;
+}

src/http/dns/resolver/DnsResolverInterface.ts

@@ -0,0 +1,51 @@
+import IpAddrJs from 'ipaddr.js';
+import Dns from 'node:dns';
+import { singleton } from 'tsyringe';
+import CachedDnsResolver from './CachedDnsResolver.js';
+import DnsResolverInterface, { LookupAsyncResult } from './DnsResolverInterface.js';
+import ResolvedToNonUnicastIpError from '../errors/ResolvedToNonUnicastIpError.js';
+
+@singleton()
+export default class UnicastOnlyDnsResolver implements DnsResolverInterface {
+  constructor(
+    private readonly dnsResolver: CachedDnsResolver,
+  ) {
+  }
+
+  lookup(
+    hostname: string,
+    options: Dns.LookupOptions,
+    callback: (err: (NodeJS.ErrnoException | null), address: (string | Dns.LookupAddress[]), family?: number) => void,
+  ): void {
+    this.lookupAsync(hostname, options)
+      .then(result => callback(null, result.address, result.family))
+      .catch((err) => callback(err, [], undefined));
+  }
+
+  async lookupAsync(hostname: string, options: Dns.LookupOptions): Promise<LookupAsyncResult> {
+    const result = await this.dnsResolver.lookupAsync(hostname, options);
+
+    const addressesToCheck = Array.isArray(result.address) ? result.address : [{ address: result.address }];
+    for (const addressItem of addressesToCheck) {
+      const parsedHost = IpAddrJs.parse(addressItem.address);
+      if (parsedHost.range() !== 'unicast') {
+        throw new ResolvedToNonUnicastIpError(parsedHost.range());
+      }
+    }
+
+    return result;
+  }
+
+  async resolvesToUnicastIp(hostname: string): Promise<boolean> {
+    try {
+      await this.lookupAsync(hostname, { all: true });
+      return true;
+    } catch (err) {
+      if (err instanceof ResolvedToNonUnicastIpError) {
+        return false;
+      }
+
+      throw err;
+    }
+  }
+}

src/http/dns/resolver/UnicastOnlyDnsResolver.ts

@@ -1,52 +1,29 @@
-import { container } from 'tsyringe';
-import ClearExpiredEntriesInSetsWithTtlTask from '../task_queue/tasks/ClearExpiredEntriesInSetsWithTtlTask.js';
+import MapWithTtl from '../util/MapWithTtl.js';
 
 export default class SetWithTtl<T> {
-  private readonly values = new Map<T, number>();
-  private readonly ttlInMilliseconds: number;
+  private readonly values: MapWithTtl<T, null>;
 
-  private constructor(ttlInSeconds: number) {
-    this.ttlInMilliseconds = ttlInSeconds * 1000;
+  constructor(ttlInSeconds: number) {
+    this.values = MapWithTtl.create(ttlInSeconds);
   }
 
   add(key: T): void {
-    this.values.set(key, Date.now() + this.ttlInMilliseconds);
+    this.values.set(key, null);
   }
 
   has(key: T): boolean {
-    const expiration = this.values.get(key);
-    return expiration != null && !this.isExpired(expiration);
+    return this.values.has(key);
   }
 
   getAgeInSeconds(key: T): number {
-    const expiration = this.values.get(key);
-    if (expiration == null || this.isExpired(expiration)) {
-      return 0;
-    }
-
-    const creationTime = expiration - this.ttlInMilliseconds;
-    return Math.floor((Date.now() - creationTime) / 1000);
+    return this.values.getAgeInSeconds(key);
   }
 
   clear(): void {
     this.values.clear();
   }
 
   clearExpired(): void {
-    for (const [value, expiration] of this.values.entries()) {
-      if (this.isExpired(expiration)) {
-        this.values.delete(value);
-      }
-    }
-  }
-
-  private isExpired(expiration: number): boolean {
-    return expiration < Date.now();
-  }
-
-  static create<T>(ttlInSeconds: number): SetWithTtl<T> {
-    const setWithTTL = new SetWithTtl<T>(ttlInSeconds);
-    container.resolve(ClearExpiredEntriesInSetsWithTtlTask).registerSet(setWithTTL);
-    return setWithTTL;
+    this.values.clearExpired();
   }
 }

src/minecraft/SetWithTtl.ts

@@ -14,7 +14,7 @@ export type Profile = {
 
 @singleton()
 export default class MinecraftProfileService {
-  private readonly nullProfileCache = SetWithTtl.create<string>(60);
+  private readonly nullProfileCache = new SetWithTtl<string>(60);
   private readonly inFlightRequests = new Map<string, Promise<Profile | null>>();
 
   constructor(

src/minecraft/profile/MinecraftProfileService.ts

@@ -16,7 +16,7 @@ export type CachedServerStatus = {
 
 @singleton()
 export default class MinecraftServerStatusService {
-  private readonly offlineServerCache = SetWithTtl.create<string>(60);
+  private readonly offlineServerCache = new SetWithTtl<string>(60);
 
   constructor(
     private readonly minecraftServerStatusPinger: MinecraftServerStatusPinger,