cacheable-lookup
Advanced tools
Package description
The cacheable-lookup npm package is designed to enhance the Node.js DNS module with caching capabilities. It provides a way to cache DNS lookup results in order to improve performance for repeated DNS queries. This is particularly useful for applications making numerous requests to the same domains, as it reduces the number of DNS queries that need to be performed over the network.
Caching DNS lookups
This feature allows you to cache DNS lookups to improve performance. The code sample demonstrates how to perform a DNS lookup for 'example.com' and cache the result.
const CacheableLookup = require('cacheable-lookup');
const cacheable = new CacheableLookup();
cacheable.lookup('example.com', (err, address, family) => {
console.log(address);
});Integration with http.Agent
This feature demonstrates how cacheable-lookup can be integrated with Node.js http.Agent to automatically use cached DNS lookups for HTTP requests. This can significantly reduce DNS lookup times for repeated requests to the same domain.
const CacheableLookup = require('cacheable-lookup');
const http = require('http');
const cacheable = new CacheableLookup();
const agent = new http.Agent({
lookup: cacheable.lookup
});
http.get('http://example.com', { agent }, (res) => {
// Handle response
});dns-cache is a simple DNS cache module. It provides basic caching functionalities similar to cacheable-lookup but lacks some of the advanced features and customizability options such as integration with http.Agent.
node-dns-cache offers DNS caching capabilities to Node.js applications. While it serves a similar purpose to cacheable-lookup, it might not offer the same level of performance optimizations and ease of integration with existing Node.js networking components.
Readme
A cacheable
dns.lookup(…)that respects TTL :tada:
Making lots of HTTP requests? You can save some time by caching DNS lookups :zap:
lookup optionconst http = require('http');
const CacheableLookup = require('cacheable-lookup');
const cacheable = new CacheableLookup();
http.get('https://example.com', {lookup: cacheable.lookup}, response => {
// Handle the response here
});
const http = require('http');
const CacheableLookup = require('cacheable-lookup');
const cacheable = new CacheableLookup();
cacheable.install(http.globalAgent);
http.get('https://example.com', response => {
// Handle the response here
});
Returns a new instance of CacheableLookup.
Type: object
Default: {}
Options used to cache the DNS lookups.
Type: number
Default: Infinity
Limits the cache time (TTL in seconds).
If set to 0, it will make a new DNS query each time.
Type: dns.Resolver | dns.promises.Resolver
Default: new dns.promises.Resolver()
An instance of DNS Resolver used to make DNS queries.
Type: object
Type: string
The IP address (can be an IPv4 or IPv6 address).
Type: number
The IP family (4 or 6).
Type: number
Note: This is not present when using the native dns.lookup(...)!
The timestamp (Date.now() + ttl * 1000) when the entry expires.
Note: This is not present when using the native dns.lookup(...)!
The time in seconds for its lifetime.
When options.all is false, then callback(error, address, family, expires, ttl) is called.
When options.all is true, then callback(error, entries) is called.
Type: Array
DNS servers used to make the query. Can be overridden - then the new servers will be used.
The asynchronous version of dns.lookup(…).
Returns an entry object.
If options.all is true, returns an array of entry objects.
Note: If entry(ies) were not found, it will return undefined by default.
Type: string
Type: object
The same as the dns.lookup(…) options.
Type: boolean
Default: false
If set to false and it gets no match, it will return undefined.
If set to true and it gets no match, it will throw ENOTFOUND error.
Note: This option is meant only for the asynchronous implementation! The callback version will always pass an error if no match found.
An asynchronous function which returns cached DNS lookup entries.
This is the base for lookupAsync(hostname, options) and lookup(hostname, options, callback).
Note: This function has no options.
Returns an array of objects with address, family, ttl and expires properties.
An asynchronous function which makes two DNS queries: A and AAAA. The result is cached.
This is used by query(hostname) if no entry in the database is present.
Returns an array of objects with address, family, ttl and expires properties.
Removes outdated entries.
Updates interface info. For example, you need to run this when you plug or unplug your WiFi driver.
Note: Running updateInterfaceInfo() will also trigger clear()!
Clears the cache.
See the benchmarks (queries localhost, performed on i7-7700k):
CacheableLookup#lookupAsync x 2,525,219 ops/sec ±1.66% (86 runs sampled)
CacheableLookup#lookupAsync.all x 2,648,106 ops/sec ±0.59% (88 runs sampled)
CacheableLookup#lookupAsync.all.ADDRCONFIG x 2,263,173 ops/sec ±0.95% (88 runs sampled)
CacheableLookup#lookup x 2,108,952 ops/sec ±0.97% (89 runs sampled)
CacheableLookup#lookup.all x 2,081,357 ops/sec ±1.19% (83 runs sampled)
CacheableLookup#lookup.all.ADDRCONFIG x 1,913,955 ops/sec ±0.60% (89 runs sampled)
CacheableLookup#lookupAsync - zero TTL x 36.50 ops/sec ±11.21% (39 runs sampled)
CacheableLookup#lookup - zero TTL x 33.66 ops/sec ±7.57% (47 runs sampled)
dns#resolve4 x 40.31 ops/sec ±16.10% (49 runs sampled)
dns#lookup x 13,722 ops/sec ±20.69% (37 runs sampled)
dns#lookup.all x 30,343 ops/sec ±28.97% (47 runs sampled)
dns#lookup.all.ADDRCONFIG x 7,023 ops/sec ±15.86% (31 runs sampled)
Fastest is CacheableLookup#lookupAsync.all
The package is based on dns.resolve4(…) and dns.resolve6(…).
It is not possible to use
dns.lookup(…)because underlying calls like getaddrinfo have no concept of servers or TTL (caching is done on OS level instead).
MIT
FAQs
A cacheable dns.lookup(…) that respects TTL
We found that cacheable-lookup demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
CISA launched a new project called Vulnrichment to enrich CVEs with details that help prioritize patching and mitigation efforts, as the NVD backlog of unenriched CVEs awaiting analysis surpasses 10,000.
Security News
Socket is joining forces with CISA and other industry leaders at the RSA Conference to sign the Secure by Design pledge, committing to uphold the highest security standards in our products.
Research
The Socket research team breaks down a sampling of malicious packages that download and execute files, among other suspicious behaviors, targeting the popular Discord platform.