got 9.3.0 → 9.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "9.3.0",
+	"version": "9.5.0",
 	"description": "Simplified HTTP requests",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -34,7 +34,7 @@
 		"electron"
 	],
 	"dependencies": {
-		"@sindresorhus/is": "^0.12.0",
+		"@sindresorhus/is": "^0.14.0",
 		"@szmarczak/http-timer": "^1.1.0",
 		"cacheable-request": "^5.1.0",
 		"decompress-response": "^3.3.0",
@@ -47,17 +47,17 @@
 		"url-parse-lax": "^3.0.0"
 	},
 	"devDependencies": {
-		"ava": "1.0.0-rc.1",
+		"ava": "^1.0.1",
 		"coveralls": "^3.0.0",
 		"delay": "^4.1.0",
 		"form-data": "^2.3.3",
 		"get-port": "^4.0.0",
-		"np": "^3.0.4",
+		"np": "^3.1.0",
 		"nyc": "^13.1.0",
 		"p-event": "^2.1.0",
 		"pem": "^1.13.2",
 		"proxyquire": "^2.0.1",
-		"sinon": "^7.1.0",
+		"sinon": "^7.2.2",
 		"slow-stream": "0.0.4",
 		"tempfile": "^2.0.0",
 		"tempy": "^0.2.1",

package/readme.md

@@ -42,8 +42,9 @@ Got is for Node.js. For browsers, we recommend [Ky](https://github.com/sindresor
 - [Used by ~2000 packages and ~500K repos](https://github.com/sindresorhus/got/network/dependents)
 - Actively maintained
 
-[See how Got compares to other HTTP libraries](#comparison)
+[Moving from Request?](migration-guides.md)
 
+[See how Got compares to other HTTP libraries](#comparison)
 
 ## Install
 
@@ -258,22 +259,26 @@ Default:
 - methods: `GET` `PUT` `HEAD` `DELETE` `OPTIONS` `TRACE`
 - statusCodes: [`408`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) [`413`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/413) [`429`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) [`500`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) [`502`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/502) [`503`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/503) [`504`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/504)
 - maxRetryAfter: `undefined`
+- errorCodes: `ETIMEDOUT` `ECONNRESET` `EADDRINUSE` `ECONNREFUSED` `EPIPE` `ENOTFOUND` `ENETUNREACH` `EAI_AGAIN`
 
-An object representing `retries`, `methods`, `statusCodes` and `maxRetryAfter` fields for the time until retry, allowed methods, allowed status codes and maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time.
+An object representing `retries`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for the time until retry, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
 
 If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.<br>
 If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
 
-Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 0).
+Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
 
 The `retries` property can be a `number` or a `function` with `retry` and `error` arguments. The function must return a delay in milliseconds (`0` return value cancels retry).
 
-**Note:** It retries only on the specified methods, status codes, and on these network errors:
+**Note:** By default, it retries *only* on the specified methods, status codes, and on these network errors:
 - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
 - `ECONNRESET`: Connection was forcibly closed by a peer.
 - `EADDRINUSE`: Could not bind to any free port.
 - `ECONNREFUSED`: Connection was refused by the server.
 - `EPIPE`: The remote side of the stream being written has been closed.
+- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
+- `ENETUNREACH`: No internet connection.
+- `EAI_AGAIN`: DNS lookup timed out.
 
 ###### followRedirect
 
@@ -448,6 +453,14 @@ const instance = got.extend({
 
 The response object will typically be a [Node.js HTTP response stream](https://nodejs.org/api/http.html#http_class_http_incomingmessage), however, if returned from the cache it will be a [response-like object](https://github.com/lukechilds/responselike) which behaves in the same way.
 
+##### request
+
+Type: `Object`
+
+**Note:** This is not a [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest).
+
+- `gotOptions` - The options that were set on this request.
+
 ##### body
 
 Type: `string` `Object` *(depending on `options.json`)*
@@ -584,7 +597,7 @@ Sets `options.method` to the method name and makes a request.
 
 #### got.extend([options])
 
-Configure a new `got` instance with default `options`. `options` are merged with the parent instance's `defaults.options` using [`got.mergeOptions`](#gotmergeoptionsparentoptions-newoptions).
+Configure a new `got` instance with default `options`. The `options` are merged with the parent instance's `defaults.options` using [`got.mergeOptions`](#gotmergeoptionsparentoptions-newoptions). You can access the resolved options with the `.defaults` property on the instance.
 
 ```js
 const client = got.extend({
@@ -650,9 +663,15 @@ Options are deeply merged to a new object. The value of each key is determined a
 - If the new property is an `Array`, it overwrites the old one with a deep clone of the new property.
 - Otherwise, the new value is assigned to the key.
 
+#### got.defaults
+
+Type: `Object`
+
+The default Got options.
+
 ## Errors
 
-Each error contains (if available) `body`, `statusCode`, `statusMessage`, `host`, `hostname`, `method`, `path`, `protocol` and `url` properties to make debugging easier.
+Each error contains `host`, `hostname`, `method`, `path`, `protocol`, `url` and `gotOptions` properties to make debugging easier.
 
 In Promise mode, the `response` is attached to the error.
 
@@ -670,15 +689,15 @@ When reading from response stream fails.
 
 #### got.ParseError
 
-When `json` option is enabled, server response code is 2xx, and `JSON.parse` fails.
+When `json` option is enabled, server response code is 2xx, and `JSON.parse` fails. Includes `statusCode` and `statusMessage` properties.
 
 #### got.HTTPError
 
-When the server response code is not 2xx. Includes `statusCode`, `statusMessage`, and `redirectUrls` properties.
+When the server response code is not 2xx. Includes `body`, `statusCode`, `statusMessage`, and `redirectUrls` properties.
 
 #### got.MaxRedirectsError
 
-When the server redirects you more than ten times. Includes a `redirectUrls` property, which is an array of the URLs Got was redirected to before giving up.
+When the server redirects you more than ten times. Includes a `statusCode`, `statusMessage`, and `redirectUrls` property which is an array of the URLs Got was redirected to before giving up.
 
 #### got.UnsupportedProtocolError
 
@@ -690,7 +709,7 @@ When the request is aborted with `.cancel()`.
 
 #### got.TimeoutError
 
-When the request is aborted due to a [timeout](#timeout)
+When the request is aborted due to a [timeout](#timeout). Includes an `event` property.
 
 ## Aborting the request
 
@@ -1023,7 +1042,7 @@ const h2got = got.extend({request});
 | Electron support      |       ✔      |       ✖      |       ✖      |       ✖      |
 | Promise API           |       ✔      |       ✔      |       ✔      |       ✔      |
 | Stream API            |       ✔      |       ✔      | Node.js only |       ✖      |
-| Request cancelation   |       ✔      |       ✖      |       ✖      |       ✔      |
+| Request cancelation   |       ✔      |       ✖      |       ✔      |       ✔      |
 | RFC compliant caching |       ✔      |       ✖      |       ✖      |       ✖      |
 | Cookies (out-of-box)  |       ✔      |       ✔      |       ✖      |       ✖      |
 | Follows redirects     |       ✔      |       ✔      |       ✔      |       ✔      |

package/source/errors.js

@@ -5,7 +5,7 @@ const PCancelable = require('p-cancelable');
 const is = require('@sindresorhus/is');
 
 class GotError extends Error {
-	constructor(message, error, opts) {
+	constructor(message, error, options) {
 		super(message);
 		Error.captureStackTrace(this, this.constructor);
 		this.name = 'GotError';
@@ -15,13 +15,14 @@ class GotError extends Error {
 		}
 
 		Object.assign(this, {
-			host: opts.host,
-			hostname: opts.hostname,
-			method: opts.method,
-			path: opts.path,
-			socketPath: opts.socketPath,
-			protocol: opts.protocol,
-			url: opts.href
+			host: options.host,
+			hostname: options.hostname,
+			method: options.method,
+			path: options.path,
+			socketPath: options.socketPath,
+			protocol: options.protocol,
+			url: options.href,
+			gotOptions: options
 		});
 	}
 }
@@ -29,29 +30,29 @@ class GotError extends Error {
 module.exports.GotError = GotError;
 
 module.exports.CacheError = class extends GotError {
-	constructor(error, opts) {
-		super(error.message, error, opts);
+	constructor(error, options) {
+		super(error.message, error, options);
 		this.name = 'CacheError';
 	}
 };
 
 module.exports.RequestError = class extends GotError {
-	constructor(error, opts) {
-		super(error.message, error, opts);
+	constructor(error, options) {
+		super(error.message, error, options);
 		this.name = 'RequestError';
 	}
 };
 
 module.exports.ReadError = class extends GotError {
-	constructor(error, opts) {
-		super(error.message, error, opts);
+	constructor(error, options) {
+		super(error.message, error, options);
 		this.name = 'ReadError';
 	}
 };
 
 module.exports.ParseError = class extends GotError {
-	constructor(error, statusCode, opts, data) {
-		super(`${error.message} in "${urlLib.format(opts)}": \n${data.slice(0, 77)}...`, error, opts);
+	constructor(error, statusCode, options, data) {
+		super(`${error.message} in "${urlLib.format(options)}": \n${data.slice(0, 77)}...`, error, options);
 		this.name = 'ParseError';
 		this.statusCode = statusCode;
 		this.statusMessage = http.STATUS_CODES[this.statusCode];
@@ -59,7 +60,7 @@ module.exports.ParseError = class extends GotError {
 };
 
 module.exports.HTTPError = class extends GotError {
-	constructor(response, opts) {
+	constructor(response, options) {
 		const {statusCode} = response;
 		let {statusMessage} = response;
 
@@ -68,7 +69,7 @@ module.exports.HTTPError = class extends GotError {
 		} else {
 			statusMessage = http.STATUS_CODES[statusCode];
 		}
-		super(`Response code ${statusCode} (${statusMessage})`, {}, opts);
+		super(`Response code ${statusCode} (${statusMessage})`, {}, options);
 		this.name = 'HTTPError';
 		this.statusCode = statusCode;
 		this.statusMessage = statusMessage;
@@ -78,8 +79,8 @@ module.exports.HTTPError = class extends GotError {
 };
 
 module.exports.MaxRedirectsError = class extends GotError {
-	constructor(statusCode, redirectUrls, opts) {
-		super('Redirected 10 times. Aborting.', {}, opts);
+	constructor(statusCode, redirectUrls, options) {
+		super('Redirected 10 times. Aborting.', {}, options);
 		this.name = 'MaxRedirectsError';
 		this.statusCode = statusCode;
 		this.statusMessage = http.STATUS_CODES[this.statusCode];
@@ -88,15 +89,15 @@ module.exports.MaxRedirectsError = class extends GotError {
 };
 
 module.exports.UnsupportedProtocolError = class extends GotError {
-	constructor(opts) {
-		super(`Unsupported protocol "${opts.protocol}"`, {}, opts);
+	constructor(options) {
+		super(`Unsupported protocol "${options.protocol}"`, {}, options);
 		this.name = 'UnsupportedProtocolError';
 	}
 };
 
 module.exports.TimeoutError = class extends GotError {
-	constructor(error, opts) {
-		super(error.message, {code: 'ETIMEDOUT'}, opts);
+	constructor(error, options) {
+		super(error.message, {code: 'ETIMEDOUT'}, options);
 		this.name = 'TimeoutError';
 		this.event = error.event;
 	}

package/source/index.js

@@ -22,6 +22,16 @@ const defaults = {
 				502,
 				503,
 				504
+			],
+			errorCodes: [
+				'ETIMEDOUT',
+				'ECONNRESET',
+				'EADDRINUSE',
+				'ECONNREFUSED',
+				'EPIPE',
+				'ENOTFOUND',
+				'ENETUNREACH',
+				'EAI_AGAIN'
 			]
 		},
 		headers: {

package/source/normalize-arguments.js

@@ -4,7 +4,6 @@ const urlLib = require('url');
 const is = require('@sindresorhus/is');
 const urlParseLax = require('url-parse-lax');
 const lowercaseKeys = require('lowercase-keys');
-const isRetryOnNetworkErrorAllowed = require('./utils/is-retry-on-network-error-allowed');
 const urlToOptions = require('./utils/url-to-options');
 const isFormData = require('./utils/is-form-data');
 const merge = require('./merge');
@@ -56,7 +55,8 @@ const preNormalize = (options, defaults) => {
 	options.retry = {
 		retries: 0,
 		methods: [],
-		statusCodes: []
+		statusCodes: [],
+		errorCodes: []
 	};
 
 	if (is.nonEmptyObject(defaults) && retry !== false) {
@@ -83,20 +83,24 @@ const preNormalize = (options, defaults) => {
 		options.retry.statusCodes = new Set(options.retry.statusCodes);
 	}
 
+	if (is.array(options.retry.errorCodes)) {
+		options.retry.errorCodes = new Set(options.retry.errorCodes);
+	}
+
 	return options;
 };
 
 const normalize = (url, options, defaults) => {
-	if (is.plainObject(url) && Reflect.has(url, 'url')) {
-		options = url;
-		url = url.url;
+	if (is.plainObject(url)) {
+		options = {...url, ...options};
+		url = options.url || {};
 		delete options.url;
 	}
 
 	if (defaults) {
 		options = merge({}, defaults.options, options ? preNormalize(options, defaults.options) : {});
 	} else {
-		options = merge({}, options ? preNormalize(options) : {});
+		options = merge({}, preNormalize(options));
 	}
 
 	if (!is.string(url) && !is.object(url)) {
@@ -112,22 +116,14 @@ const normalize = (url, options, defaults) => {
 			url = urlToOptions(new URL(url, options.baseUrl));
 		} else {
 			url = url.replace(/^unix:/, 'http://$&');
-
 			url = urlParseLax(url);
-			if (url.auth) {
-				throw new Error('Basic authentication must be done with the `auth` option');
-			}
 		}
 	} else if (is(url) === 'URL') {
 		url = urlToOptions(url);
 	}
 
-	options = {
-		path: '',
-		...url,
-		protocol: url.protocol || 'https:', // Override both null/undefined with default protocol
-		...options
-	};
+	// Override both null/undefined with default protocol
+	options = merge({path: ''}, url, {protocol: url.protocol || 'https:'}, options);
 
 	const {baseUrl} = options;
 	Object.defineProperty(options, 'baseUrl', {
@@ -214,33 +210,31 @@ const normalize = (url, options, defaults) => {
 				return 0;
 			}
 
-			if (error !== null) {
-				if (!isRetryOnNetworkErrorAllowed(error) && (!options.retry.methods.has(error.method) || !options.retry.statusCodes.has(error.statusCode))) {
-					return 0;
-				}
-
-				if (Reflect.has(error, 'headers') && Reflect.has(error.headers, 'retry-after') && retryAfterStatusCodes.has(error.statusCode)) {
-					let after = Number(error.headers['retry-after']);
-					if (is.nan(after)) {
-						after = Date.parse(error.headers['retry-after']) - Date.now();
-					} else {
-						after *= 1000;
-					}
-
-					if (after > options.retry.maxRetryAfter) {
-						return 0;
-					}
+			if ((!error || !options.retry.errorCodes.has(error.code)) && (!options.retry.methods.has(error.method) || !options.retry.statusCodes.has(error.statusCode))) {
+				return 0;
+			}
 
-					return after;
+			if (Reflect.has(error, 'headers') && Reflect.has(error.headers, 'retry-after') && retryAfterStatusCodes.has(error.statusCode)) {
+				let after = Number(error.headers['retry-after']);
+				if (is.nan(after)) {
+					after = Date.parse(error.headers['retry-after']) - Date.now();
+				} else {
+					after *= 1000;
 				}
 
-				if (error.statusCode === 413) {
+				if (after > options.retry.maxRetryAfter) {
 					return 0;
 				}
+
+				return after;
+			}
+
+			if (error.statusCode === 413) {
+				return 0;
 			}
 
 			const noise = Math.random() * 100;
-			return ((1 << iteration) * 1000) + noise;
+			return ((2 ** (iteration - 1)) * 1000) + noise;
 		};
 	}
 

package/source/request-as-event-emitter.js

@@ -27,7 +27,6 @@ module.exports = (options, input) => {
 	let redirectString;
 	let uploadBodySize;
 	let retryCount = 0;
-	let retryTries = 0;
 	let shouldAbort = false;
 
 	const setCookie = options.cookieJar ? util.promisify(options.cookieJar.setCookie.bind(options.cookieJar)) : null;
@@ -93,6 +92,9 @@ module.exports = (options, input) => {
 				response.retryCount = retryCount;
 				response.timings = timings;
 				response.redirectUrls = redirects;
+				response.request = {
+					gotOptions: options
+				};
 
 				const rawCookies = response.headers['set-cookie'];
 				if (options.cookieJar && rawCookies) {
@@ -120,19 +122,19 @@ module.exports = (options, input) => {
 
 						redirects.push(redirectString);
 
-						const redirectOpts = {
+						const redirectOptions = {
 							...options,
 							...urlToOptions(redirectURL)
 						};
 
 						for (const hook of options.hooks.beforeRedirect) {
 							// eslint-disable-next-line no-await-in-loop
-							await hook(redirectOpts);
+							await hook(redirectOptions);
 						}
 
-						emitter.emit('redirect', response, redirectOpts);
+						emitter.emit('redirect', response, redirectOptions);
 
-						await get(redirectOpts);
+						await get(redirectOptions);
 						return;
 					}
 				}
@@ -202,9 +204,9 @@ module.exports = (options, input) => {
 
 		if (options.cache) {
 			const cacheableRequest = new CacheableRequest(fn.request, options.cache);
-			const cacheReq = cacheableRequest(options, handleResponse);
+			const cacheRequest = cacheableRequest(options, handleResponse);
 
-			cacheReq.once('error', error => {
+			cacheRequest.once('error', error => {
 				if (error instanceof CacheableRequest.RequestError) {
 					emitter.emit('error', new RequestError(error, options));
 				} else {
@@ -212,7 +214,7 @@ module.exports = (options, input) => {
 				}
 			});
 
-			cacheReq.once('request', handleRequest);
+			cacheRequest.once('request', handleRequest);
 		} else {
 			// Catches errors thrown by calling fn.request(...)
 			try {
@@ -227,7 +229,7 @@ module.exports = (options, input) => {
 		let backoff;
 
 		try {
-			backoff = options.retry.retries(++retryTries, error);
+			backoff = options.retry.retries(++retryCount, error);
 		} catch (error2) {
 			emitter.emit('error', error2);
 			return;
@@ -241,7 +243,6 @@ module.exports = (options, input) => {
 						await hook(options, error, retryCount);
 					}
 
-					retryCount++;
 					await get(options);
 				} catch (error) {
 					emitter.emit('error', error);
@@ -276,7 +277,7 @@ module.exports = (options, input) => {
 			}
 
 			if (is.undefined(options.headers['content-length']) && is.undefined(options.headers['transfer-encoding'])) {
-				if (uploadBodySize > 0 || options.method === 'PUT') {
+				if ((uploadBodySize > 0 || options.method === 'PUT') && !is.null(uploadBodySize)) {
 					options.headers['content-length'] = uploadBodySize;
 				}
 			}

package/source/utils/timed-out.js

@@ -12,31 +12,7 @@ class TimeoutError extends Error {
 
 const reentry = Symbol('reentry');
 
-function addTimeout(delay, callback, ...args) {
-	// Event loop order is timers, poll, immediates.
-	// The timed event may emit during the current tick poll phase, so
-	// defer calling the handler until the poll phase completes.
-	let immediate;
-	const timeout = setTimeout(() => {
-		immediate = setImmediate(callback, delay, ...args);
-		/* istanbul ignore next: added in node v9.7.0 */
-		if (immediate.unref) {
-			immediate.unref();
-		}
-	}, delay);
-
-	/* istanbul ignore next: in order to support electron renderer */
-	if (timeout.unref) {
-		timeout.unref();
-	}
-
-	const cancel = () => {
-		clearTimeout(timeout);
-		clearImmediate(immediate);
-	};
-
-	return cancel;
-}
+const noop = () => {};
 
 module.exports = (request, delays, options) => {
 	/* istanbul ignore next: this makes sure timed-out isn't called twice */
@@ -45,6 +21,43 @@ module.exports = (request, delays, options) => {
 	}
 
 	request[reentry] = true;
+
+	let stopNewTimeouts = false;
+
+	const addTimeout = (delay, callback, ...args) => {
+		// An error had been thrown before. Going further would result in uncaught errors.
+		// See https://github.com/sindresorhus/got/issues/631#issuecomment-435675051
+		if (stopNewTimeouts) {
+			return noop;
+		}
+
+		// Event loop order is timers, poll, immediates.
+		// The timed event may emit during the current tick poll phase, so
+		// defer calling the handler until the poll phase completes.
+		let immediate;
+		const timeout = setTimeout(() => {
+			immediate = setImmediate(callback, delay, ...args);
+			/* istanbul ignore next: added in node v9.7.0 */
+			if (immediate.unref) {
+				immediate.unref();
+			}
+		}, delay);
+
+		/* istanbul ignore next: in order to support electron renderer */
+		if (timeout.unref) {
+			timeout.unref();
+		}
+
+		const cancel = () => {
+			clearTimeout(timeout);
+			clearImmediate(immediate);
+		};
+
+		cancelers.push(cancel);
+
+		return cancel;
+	};
+
 	const {host, hostname} = options;
 	const timeoutHandler = (delay, event) => {
 		request.emit('error', new TimeoutError(delay, event));
@@ -55,6 +68,7 @@ module.exports = (request, delays, options) => {
 
 	const cancelers = [];
 	const cancelTimeouts = () => {
+		stopNewTimeouts = true;
 		cancelers.forEach(cancelTimeout => cancelTimeout());
 	};
 
@@ -64,14 +78,15 @@ module.exports = (request, delays, options) => {
 	});
 
 	if (delays.request !== undefined) {
-		const cancelTimeout = addTimeout(delays.request, timeoutHandler, 'request');
-		cancelers.push(cancelTimeout);
+		addTimeout(delays.request, timeoutHandler, 'request');
 	}
 
 	if (delays.socket !== undefined) {
 		request.setTimeout(delays.socket, () => {
 			timeoutHandler(delays.socket, 'socket');
 		});
+
+		cancelers.push(() => request.setTimeout(0));
 	}
 
 	if (delays.lookup !== undefined && !request.socketPath && !net.isIP(hostname || host)) {
@@ -79,7 +94,6 @@ module.exports = (request, delays, options) => {
 			/* istanbul ignore next: hard to test */
 			if (socket.connecting) {
 				const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, 'lookup');
-				cancelers.push(cancelTimeout);
 				socket.once('lookup', cancelTimeout);
 			}
 		});
@@ -89,17 +103,15 @@ module.exports = (request, delays, options) => {
 		request.once('socket', socket => {
 			/* istanbul ignore next: hard to test */
 			if (socket.connecting) {
-				const timeConnect = () => {
-					const cancelTimeout = addTimeout(delays.connect, timeoutHandler, 'connect');
-					cancelers.push(cancelTimeout);
-					return cancelTimeout;
-				};
+				const timeConnect = () => addTimeout(delays.connect, timeoutHandler, 'connect');
 
 				if (request.socketPath || net.isIP(hostname || host)) {
 					socket.once('connect', timeConnect());
 				} else {
-					socket.once('lookup', () => {
-						socket.once('connect', timeConnect());
+					socket.once('lookup', error => {
+						if (error === null) {
+							socket.once('connect', timeConnect());
+						}
 					});
 				}
 			}
@@ -112,7 +124,6 @@ module.exports = (request, delays, options) => {
 			if (socket.connecting) {
 				socket.once('connect', () => {
 					const cancelTimeout = addTimeout(delays.secureConnect, timeoutHandler, 'secureConnect');
-					cancelers.push(cancelTimeout);
 					socket.once('secureConnect', cancelTimeout);
 				});
 			}
@@ -121,11 +132,7 @@ module.exports = (request, delays, options) => {
 
 	if (delays.send !== undefined) {
 		request.once('socket', socket => {
-			const timeRequest = () => {
-				const cancelTimeout = addTimeout(delays.send, timeoutHandler, 'send');
-				cancelers.push(cancelTimeout);
-				return cancelTimeout;
-			};
+			const timeRequest = () => addTimeout(delays.send, timeoutHandler, 'send');
 			/* istanbul ignore next: hard to test */
 			if (socket.connecting) {
 				socket.once('connect', () => {
@@ -140,7 +147,6 @@ module.exports = (request, delays, options) => {
 	if (delays.response !== undefined) {
 		request.once('upload-complete', () => {
 			const cancelTimeout = addTimeout(delays.response, timeoutHandler, 'response');
-			cancelers.push(cancelTimeout);
 			request.once('response', cancelTimeout);
 		});
 	}

package/source/utils/is-retry-on-network-error-allowed.js

@@ -1,20 +0,0 @@
-'use strict';
-
-const WHITELIST = new Set([
-	'ETIMEDOUT',
-	'ECONNRESET',
-	'EADDRINUSE',
-	'ECONNREFUSED',
-	'EPIPE',
-	'ENOTFOUND',
-	'ENETUNREACH',
-	'EAI_AGAIN'
-]);
-
-module.exports = error => {
-	if (error && WHITELIST.has(error.code)) {
-		return true;
-	}
-
-	return false;
-};