feat: dns cache logger (#388)

##### Checklist

- [ x] `npm test` passes
- [ x] tests and/or benchmarks are included

##### Affected core subsystem(s)
Feature: Add dns cache customLogger

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
  * Improved DNS cache lifecycle for more reliable startup and shutdown.

* **Improvements**
  * Dedicated DNS cache logger for clearer diagnostics.
* More consistent and informative DNS lookup/resolution logging,
including TTL awareness.
  * Safer shutdown handling to avoid errors when DNS resolver is absent.

* **Configuration**
* DNS cache settings reorganized under a nested config section; test app
logging level default reduced.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: Dipper30

plugin/dns-cache/app.ts

@@ -15,10 +15,14 @@ export default class DnsCacheAppHook {
         '[tegg-dns-cache-plugin] DNS cache is disabled, please setup dnsCache config.',
       );
     }
+  }
+
+  async configDidLoad() {
     const config = this.app.config.dnsCache || {};
 
     // Create DNS resolver instance
     const useDNSResolver = config.mode !== 'lookup';
+    const dnsCacheLogger = this.app.coreLogger;
     this.dnsResolver = new DnsResolver(
       {
         useResolver: useDNSResolver,
@@ -27,14 +31,13 @@ export default class DnsCacheAppHook {
         dnsCacheLookupInterval: config.lookupInterval || 10000,
         addressRotation: config.addressRotation !== false,
       },
-      { logger: this.app.logger },
+      { logger: dnsCacheLogger },
     );
+
     const lookupFunction = this.dnsResolver.getLookupFunction();
     this.app.config.httpclient = this.app.config.httpclient || {};
     this.app.config.httpclient.lookup = lookupFunction;
-  }
 
-  configDidLoad() {
     // Add dnsResolver to app
     this.app.dnsResolver = this.dnsResolver;
   }
@@ -45,6 +48,8 @@ export default class DnsCacheAppHook {
 
   beforeClose() {
     // Cleanup DNS cache resources
-    this.dnsResolver.resetCache();
+    if (this.app.dnsResolver) {
+      this.app.dnsResolver.resetCache();
+    }
   }
 }

plugin/dns-cache/config/config.default.ts

@@ -1,27 +1,32 @@
-/**
- * DNS Cache Configuration
- *
- * The DNS cache plugin provides DNS caching and resolution capabilities to improve performance
- * by caching DNS lookups and supports both dns.lookup and dns.resolve modes with address rotation.
- *
- * @property {'lookup' | 'resolve'} mode - Use dns.lookup or dns.resolve, default is 'resolve'.
- *   - lookup: Use dns.lookup mode (old behavior), respects system DNS configuration and /etc/hosts, but does not support ttl.
- *   - resolve: Use dns.resolve mode (new feature), queries DNS servers directly, ttl supported.
- *     Note: When using resolve mode, /etc/hosts is not respected. You may need to implement custom logic
- *     if you want to include /etc/hosts resolution.
- * @property {Number} maxCacheLength - Maximum number of DNS cache entries, default is 1000.
- *   Uses LRU (Least Recently Used) algorithm to evict old entries when cache is full.
- * @property {Number} lookupInterval - Only works when mode is 'lookup'. DNS cache lookup interval in milliseconds, default is 10000 (10 seconds).
- * @property {Boolean} addressRotation - Enable round-robin address rotation when multiple IP addresses
- *   are returned for a hostname, default is true. Helps distribute load across multiple servers.
- * @property {Array<String>} dnsServers - Custom DNS nameservers for dns.resolve mode, e.g. ['8.8.8.8', '1.1.1.1'].
- *   Only effective when mode is 'resolve'. If not set, uses system default DNS servers.
- */
+export default () => {
+  const config = {
+    /**
+     * DNS Cache Configuration
+     *
+     * The DNS cache plugin provides DNS caching and resolution capabilities to improve performance
+     * by caching DNS lookups and supports both dns.lookup and dns.resolve modes with address rotation.
+     *
+     * @property {'lookup' | 'resolve'} mode - Use dns.lookup or dns.resolve, default is 'resolve'.
+     *   - lookup: Use dns.lookup mode (old behavior), respects system DNS configuration and /etc/hosts, but does not support ttl.
+     *   - resolve: Use dns.resolve mode (new feature), queries DNS servers directly, ttl supported.
+     *     Note: When using resolve mode, /etc/hosts is not respected. You may need to implement custom logic
+     *     if you want to include /etc/hosts resolution.
+     * @property {Number} maxCacheLength - Maximum number of DNS cache entries, default is 1000.
+     *   Uses LRU (Least Recently Used) algorithm to evict old entries when cache is full.
+     * @property {Number} lookupInterval - Only works when mode is 'lookup'. DNS cache lookup interval in milliseconds, default is 10000 (10 seconds).
+     * @property {Boolean} addressRotation - Enable round-robin address rotation when multiple IP addresses
+     *   are returned for a hostname, default is true. Helps distribute load across multiple servers.
+     * @property {Array<String>} dnsServers - Custom DNS nameservers for dns.resolve mode, e.g. ['8.8.8.8', '1.1.1.1'].
+     *   Only effective when mode is 'resolve'. If not set, uses system default DNS servers.
+     */
+    dnsCache: {
+      mode: 'resolve' as 'lookup' | 'resolve',
+      maxCacheLength: 1000,
+      lookupInterval: 10000,
+      addressRotation: true,
+      dnsServers: undefined as string[] | undefined,
+    },
+  };
 
-export const dnsCache = {
-  mode: 'resolve' as 'lookup' | 'resolve',
-  maxCacheLength: 1000,
-  lookupInterval: 10000,
-  addressRotation: true,
-  dnsServers: undefined as string[] | undefined,
+  return config;
 };

plugin/dns-cache/lib/DnsResolver.ts

@@ -36,7 +36,7 @@ export class DnsResolver {
   private resolver?: dns.Resolver;
   private _resolve4?: typeof dns.resolve4.__promisify__;
   private _lookup?: typeof dns.lookup.__promisify__;
-  logger: EggLogger;
+  private logger: EggLogger;
 
   /**
    * Create a DNS cache resolver instance
@@ -69,7 +69,7 @@ export class DnsResolver {
 
     this.resetCache = this.resetCache.bind(this);
 
-    this.logger.debug(
+    this._debugLog(
       `[dns-cache] DNS Resolver initialized in ${
         this.useResolver ? 'resolve' : 'lookup'
       } mode, maxCacheSize: ${this._maxCacheSize}, addressRotation: ${
@@ -328,7 +328,7 @@ export class DnsResolver {
           currentIndex: 0,
         };
         this._dnsCache.set(hostname, cacheEntry);
-        this._debugLog(
+        this.logger.info(
           `[dns-cache] dns.lookup succeeded for ${hostname}, resolved ${
             records.length
           } address(es): ${records.map(r => r.ip).join(', ')}, TTL: ${
@@ -352,6 +352,11 @@ export class DnsResolver {
         const address = typeof addr === 'string' ? addr : addr.address;
         const ttlSeconds =
           addr && Number.isInteger(addr.ttl) && addr.ttl >= 0 ? addr.ttl : 0;
+        if (ttlSeconds === 0) {
+          this.logger.warn(
+            `[dns-cache] Warning: TTL is 0 for ${hostname} address ${address}`,
+          );
+        }
         return {
           ip: address,
           family: 4,
@@ -371,7 +376,7 @@ export class DnsResolver {
         currentIndex: 0,
       };
       this._dnsCache.set(hostname, cacheEntry);
-      this._debugLog(
+      this.logger.info(
         `[dns-cache] dns.resolve4 succeeded for ${hostname}, resolved ${
           records.length
         } address(es): ${records
@@ -393,7 +398,7 @@ export class DnsResolver {
    */
   private _errorDNS(err: any, mode: 'lookup' | 'resolve', hostname: string) {
     this.logger.error(
-      `error occurred when resolving ${hostname} with dns.${mode}: ${
+      `[dns-cache] error occurred when resolving ${hostname} with dns.${mode}: ${
         err && err.message ? err.message : err
       }`,
     );

plugin/dns-cache/test/fixtures/apps/dns_cache_lookup/config/config.js

@@ -1,11 +1,11 @@
 'use strict';
 
-module.exports = function () {
+module.exports = function (appInfo) {
   const config = {
     keys: 'test key',
     logger: {
       level: 'DEBUG',
-      consoleLevel: 'DEBUG',
+      consoleLevel: 'NONE',
     },
     httpclient: {
       httpAgent: {
@@ -18,7 +18,7 @@ module.exports = function () {
       lookupInterval: 3000,
       addressRotation: true,
       resolveLocalhost: false,
-    }
+    },
   }
   return config;
 };