How to fix Error: DNS SERVFAIL with all try again responses in Node.js

# Query with dig to see the full response
dig example.com

# Look for the status line - it should show "status: SERVFAIL"
# Example output:
# ; <<>> DiG 9.16.1-Ubuntu <<>> example.com
# ;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 12345

# Try querying with a specific DNS server
dig @8.8.8.8 example.com
dig @1.1.1.1 example.com

# Check if recursive queries work
dig +trace example.com

# Find the authoritative nameservers
dig example.com NS

# Check what nameservers are responsible
nslookup -type=NS example.com

# Query the authoritative server directly
dig @ns1.example.com example.com

# Check for DNSSEC records
dig example.com +dnssec

# Validate DNSSEC if enabled
dig example.com +dnssec +trusted-ad

# Test with Google DNS
dig @8.8.8.8 example.com
dig @8.8.4.4 example.com

# Test with Cloudflare DNS
dig @1.1.1.1 example.com
dig @1.0.0.1 example.com

# Test with Quad9 (privacy-focused)
dig @9.9.9.9 example.com

# Test with your ISP's DNS (usually in /etc/resolv.conf)
dig @<ISP_DNS_IP> example.com

# Edit the resolver configuration
sudo nano /etc/systemd/resolved.conf

# Set these DNS servers
[Resolve]
DNS=8.8.8.8 8.8.4.4 1.1.1.1 1.0.0.1
FallbackDNS=8.8.8.8 8.8.4.4

# Restart the service
sudo systemctl restart systemd-resolved

# Verify the change
systemd-resolve --status

# Set DNS servers for your primary connection
sudo networksetup -setdnsservers Wi-Fi 8.8.8.8 8.8.4.4 1.1.1.1

# Verify
networksetup -getdnsservers Wi-Fi

# Flush DNS cache
sudo dscacheutil -flushcache

# Get the network adapter index
Get-NetAdapter | Where-Object {$_.Status -eq "Up"}

# Set DNS (replace "Ethernet" with your adapter name)
Set-DnsClientServerAddress -InterfaceAlias "Ethernet" -ServerAddresses ("8.8.8.8","8.8.4.4","1.1.1.1")

# Verify
Get-DnsClientServerAddress -InterfaceAlias "Ethernet"

# Flush cache
ipconfig /flushdns

const https = require('https');
const dns = require('dns').promises;

async function makeRequestWithDnsRetry(hostname, maxRetries = 3, baseDelay = 1000) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`Attempt ${attempt}: Resolving ${hostname}...`);

      // Try DNS resolution
      const address = await dns.resolve4(hostname);
      console.log(`✅ Resolved ${hostname} to ${address[0]}`);

      // DNS succeeded, make the HTTP request
      return new Promise((resolve, reject) => {
        const options = {
          hostname: hostname,
          port: 443,
          path: '/',
          method: 'GET'
        };

        const request = https.request(options, (res) => {
          let data = '';
          res.on('data', chunk => data += chunk);
          res.on('end', () => resolve({ status: res.statusCode, body: data }));
        });

        request.on('error', reject);
        request.end();
      });
    } catch (err) {
      console.error(`❌ Attempt ${attempt} failed:`, err.message);

      if (attempt < maxRetries) {
        const delay = baseDelay * Math.pow(2, attempt - 1);
        console.log(`  Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw new Error(`DNS resolution failed after ${maxRetries} attempts: ${err.message}`);
      }
    }
  }
}

// Usage
makeRequestWithDnsRetry('example.com')
  .then(result => console.log('Success:', result))
  .catch(err => console.error('Failed:', err.message));

npm install cacheable-lookup

const https = require('https');
const http = require('http');
const CacheableLookup = require('cacheable-lookup');

// Create cacheable DNS resolver
const cacheable = new CacheableLookup({
  maxTtl: 300,    // Cache for 5 minutes
  minTtl: 0,      // No minimum cache time
  errorTtl: 0.1   // Cache errors for 100ms (short, to retry quickly on SERVFAIL)
});

// Install globally for all HTTP/HTTPS requests
cacheable.install(http.globalAgent);
cacheable.install(https.globalAgent);

// Now all requests benefit from DNS caching
https.get('https://example.com', (res) => {
  console.log('Request completed with cached DNS');
});

dig example.com ANY
  dnsviz example.com  # Online tool for DNSSEC visualization

const dns = require('dns').promises;

// Custom error handling for DNS
async function resolveWithFallback(hostname, fallbackIp = null) {
  try {
    const addresses = await dns.resolve4(hostname);
    return addresses[0];
  } catch (err) {
    if (err.code === 'SERVFAIL') {
      console.error(`DNS SERVFAIL for ${hostname}`);

      // Send alert to monitoring system
      await sendAlert({
        type: 'DNS_SERVFAIL',
        hostname: hostname,
        timestamp: new Date()
      });

      // Use fallback IP if available
      if (fallbackIp) {
        console.warn(`Using fallback IP: ${fallbackIp}`);
        return fallbackIp;
      }
    }
    throw err;
  }
}

// Health check for critical DNS names
async function monitorCriticalDomains() {
  const criticalDomains = ['api.example.com', 'cdn.example.com'];

  setInterval(async () => {
    for (const domain of criticalDomains) {
      try {
        await dns.resolve4(domain);
        console.log(`✅ ${domain}`);
      } catch (err) {
        console.error(`❌ ${domain}: ${err.message}`);
        // Trigger PagerDuty alert, Slack notification, etc.
      }
    }
  }, 60000); // Check every minute
}

monitorCriticalDomains();