tardis-machine 18.0.0 → 18.1.0

package/src/tardismachine.ts

@@ -1,9 +1,9 @@
 import http from 'node:http'
 import { createRequire } from 'module'
 import { clearCache, init } from 'tardis-dev'
-import { App, DISABLED, TemplatedApp } from 'uWebSockets.js'
 import { healthCheck, replayHttp, replayNormalizedHttp } from './http/index.ts'
 import { replayNormalizedWS, replayWS, streamNormalizedWS } from './ws/index.ts'
+import { MachineWebSocketServer } from './ws/server.ts'
 import { debug } from './debug.ts'
 
 const require = createRequire(import.meta.url)
@@ -11,7 +11,7 @@ const packageJson = require('../package.json') as { version: string }
 
 export class TardisMachine {
   private readonly _httpServer: http.Server
-  private readonly _wsServer: TemplatedApp
+  private readonly _wsServer: MachineWebSocketServer
   private _eventLoopTimerId: NodeJS.Timeout | undefined = undefined
 
   constructor(private readonly options: Options) {
@@ -43,55 +43,33 @@ export class TardisMachine {
     // set timeout to 0 meaning infinite http timout - streaming may take some time expecially for longer date ranges
     this._httpServer.timeout = 0
 
-    const wsRoutes = {
+    this._wsServer = new MachineWebSocketServer({
       '/ws-replay': replayWS,
       '/ws-replay-normalized': replayNormalizedWS,
       '/ws-stream-normalized': streamNormalizedWS
-    } as any
-
-    this._wsServer = App().ws('/*', {
-      compression: DISABLED,
-      maxPayloadLength: 512 * 1024,
-      idleTimeout: 60,
-      maxBackpressure: 5 * 1024 * 1024,
-      closeOnBackpressureLimit: true,
-      upgrade: (res: any, req: any, context: any) => {
-        res.upgrade(
-          { req },
-          req.getHeader('sec-websocket-key'),
-          req.getHeader('sec-websocket-protocol'),
-          req.getHeader('sec-websocket-extensions'),
-          context
-        )
-      },
-      open: (ws: any) => {
-        const path = ws.req.getUrl().toLocaleLowerCase()
-        ws.closed = false
-        const matchingRoute = wsRoutes[path]
-
-        if (matchingRoute !== undefined) {
-          matchingRoute(ws, ws.req)
-        } else {
-          ws.end(1008)
-        }
-      },
-
-      message: (ws: any, message: ArrayBuffer) => {
-        if (ws.onmessage !== undefined) {
-          ws.onmessage(message)
-        }
-      },
-
-      close: (ws: any) => {
-        ws.closed = true
-        if (ws.onclose !== undefined) {
-          ws.onclose()
-        }
-      }
-    } as any)
+    })
   }
 
   public async start(port: number) {
+    if (this.options.clearCache) {
+      await clearCache()
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      this._httpServer.once('error', reject)
+      this._httpServer.listen(port, () => {
+        this._httpServer.removeListener('error', reject)
+        resolve()
+      })
+    })
+
+    try {
+      await this._wsServer.listen(port + 1)
+    } catch (error) {
+      await new Promise<void>((resolve) => this._httpServer.close(() => resolve()))
+      throw error
+    }
+
     let start = process.hrtime()
     const interval = 500
 
@@ -108,30 +86,11 @@ export class TardisMachine {
 
       start = process.hrtime()
     }, interval)
-
-    if (this.options.clearCache) {
-      await clearCache()
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      try {
-        this._httpServer.on('error', reject)
-        this._httpServer.listen(port, () => {
-          this._wsServer.listen(port + 1, (listenSocket) => {
-            if (listenSocket) {
-              resolve()
-            } else {
-              reject(new Error('ws server did not start'))
-            }
-          })
-        })
-      } catch (e) {
-        reject(e)
-      }
-    })
   }
 
   public async stop() {
+    await this._wsServer.close()
+
     await new Promise<void>((resolve, reject) => {
       this._httpServer.close((err) => {
         err ? reject(err) : resolve()

package/src/ws/replay.ts

@@ -1,15 +1,15 @@
 import { decode } from 'node:querystring'
 import { combine, Exchange, replay, ReplayOptions } from 'tardis-dev'
-import type { HttpRequest } from 'uWebSockets.js'
 import { debug } from '../debug.ts'
 import { wait } from '../helpers.ts'
+import type { MachineWebSocket } from './server.ts'
 import { SubscriptionMapper, subscriptionsMappers } from './subscriptionsmappers.ts'
 
 const replaySessions: { [sessionKey: string]: ReplaySession | undefined } = {}
 let sessionsCounter = 0
 
-export function replayWS(ws: any, req: HttpRequest) {
-  const parsedQuery = decode(req.getQuery())
+export function replayWS(ws: MachineWebSocket, query: string) {
+  const parsedQuery = decode(query)
   const from = parsedQuery['from'] as string
   const to = parsedQuery['to'] as string
   const exchange = parsedQuery['exchange'] as Exchange
@@ -94,10 +94,12 @@ class ReplaySession {
         })
 
         for await (const { message } of messages) {
+          if (connection.ws.closed) break
+
           const success = connection.ws.send(message)
           // handle backpressure in case of slow clients
           if (!success) {
-            while (connection.ws.getBufferedAmount() > 0) {
+            while (!connection.ws.closed && connection.ws.getBufferedAmount() > 0) {
               await wait(1)
             }
           }
@@ -122,10 +124,13 @@ class ReplaySession {
         })
 
         for await (const { ws, message } of combine(...messagesWithConnections)) {
+          if (this._connections.every((connection) => connection.ws.closed)) break
+          if (ws.closed) continue
+
           const success = ws.send(message)
           // handle backpressure in case of slow clients
           if (!success) {
-            while (ws.getBufferedAmount() > 0) {
+            while (!ws.closed && ws.getBufferedAmount() > 0) {
               await wait(1)
             }
           }
@@ -155,7 +160,7 @@ class ReplaySession {
       }
 
       // let's wait until buffer is empty before closing normal connections
-      while (!error && connection.ws.getBufferedAmount() > 0) {
+      while (!error && !connection.ws.closed && connection.ws.getBufferedAmount() > 0) {
         await wait(100)
       }
 
@@ -174,7 +179,7 @@ class WebsocketConnection {
   public subscriptionsCount = 0
 
   constructor(
-    public readonly ws: any,
+    public readonly ws: MachineWebSocket,
     exchange: Exchange,
     from: string,
     to: string
@@ -212,7 +217,7 @@ class WebsocketConnection {
     return `${JSON.stringify(this.replayOptions)}`
   }
 
-  private _convertSubscribeRequestToFilter(messageRaw: ArrayBuffer) {
+  private _convertSubscribeRequestToFilter(messageRaw: Buffer) {
     const message = Buffer.from(messageRaw).toString()
     try {
       const messageDeserialized = JSON.parse(message)

package/src/ws/replaynormalized.ts

@@ -1,14 +1,14 @@
 import { decode } from 'node:querystring'
 import { combine, compute, replayNormalized } from 'tardis-dev'
-import type { HttpRequest } from 'uWebSockets.js'
 import { debug } from '../debug.ts'
 import { constructDataTypeFilter, getComputables, getNormalizers, ReplayNormalizedRequestOptions, wait } from '../helpers.ts'
+import type { MachineWebSocket } from './server.ts'
 
-export async function replayNormalizedWS(ws: any, req: HttpRequest) {
+export async function replayNormalizedWS(ws: MachineWebSocket, query: string) {
   let messages: AsyncIterableIterator<any> | undefined
   try {
     const startTimestamp = new Date().getTime()
-    const parsedQuery = decode(req.getQuery())
+    const parsedQuery = decode(query)
     const optionsString = parsedQuery['options'] as string
     const replayNormalizedOptions = JSON.parse(optionsString) as ReplayNormalizedRequestOptions
 
@@ -34,6 +34,8 @@ export async function replayNormalizedWS(ws: any, req: HttpRequest) {
     messages = messagesIterables.length === 1 ? messagesIterables[0] : combine(...messagesIterables)
 
     for await (const message of messages) {
+      if (ws.closed) return
+
       if (!filterByDataType(message)) {
         continue
       }
@@ -41,13 +43,13 @@ export async function replayNormalizedWS(ws: any, req: HttpRequest) {
       const success = ws.send(JSON.stringify(message))
       // handle backpressure in case of slow clients
       if (!success) {
-        while (ws.getBufferedAmount() > 0) {
+        while (!ws.closed && ws.getBufferedAmount() > 0) {
           await wait(1)
         }
       }
     }
 
-    while (ws.getBufferedAmount() > 0) {
+    while (!ws.closed && ws.getBufferedAmount() > 0) {
       await wait(100)
     }
 
@@ -63,7 +65,7 @@ export async function replayNormalizedWS(ws: any, req: HttpRequest) {
   } catch (e: any) {
     // this will underlying open WS connections
     if (messages !== undefined) {
-      messages!.return!()
+      await messages.return?.()
     }
     if (!ws.closed) {
       ws.end(1011, e.toString())

package/src/ws/server.ts

@@ -0,0 +1,173 @@
+import http from 'node:http'
+import WebSocket, { WebSocketServer } from 'ws'
+
+const IDLE_TIMEOUT_MS = 60_000
+const HEARTBEAT_INTERVAL_MS = IDLE_TIMEOUT_MS / 2
+const MAX_HEADER_BYTES = 20_000
+const MAX_PAYLOAD_BYTES = 512 * 1024
+const MAX_BACKPRESSURE_BYTES = 5 * 1024 * 1024
+const MAX_CLOSE_REASON_BYTES = 123
+
+export type MachineWebSocket = {
+  closed: boolean
+  onmessage?: (message: Buffer) => void
+  send(message: string | ArrayBuffer | Buffer): boolean
+  getBufferedAmount(): number
+  end(code?: number, reason?: string): void
+}
+
+export type MachineWebSocketRoute = (socket: MachineWebSocket, query: string) => void | Promise<void>
+
+export class MachineWebSocketServer {
+  private readonly httpServer = http.createServer({ maxHeaderSize: MAX_HEADER_BYTES }, (_, response) => {
+    response.writeHead(426).end()
+  })
+  private readonly server = new WebSocketServer({
+    server: this.httpServer,
+    perMessageDeflate: false,
+    maxPayload: MAX_PAYLOAD_BYTES
+  })
+  private readonly connections = new Set<MachineWebSocketConnection>()
+  private heartbeatTimer: NodeJS.Timeout | undefined
+
+  constructor(private readonly routes: Record<string, MachineWebSocketRoute>) {
+    // `ws` re-emits errors from the supplied HTTP server; `listen` reports the same error to its caller.
+    this.server.on('error', () => {})
+    this.server.on('connection', (webSocket, request) => this.connect(webSocket, request.url))
+  }
+
+  public async listen(port: number) {
+    await new Promise<void>((resolve, reject) => {
+      this.httpServer.once('error', reject)
+      this.httpServer.listen(port, () => {
+        this.httpServer.removeListener('error', reject)
+        resolve()
+      })
+    })
+
+    this.heartbeatTimer = setInterval(() => {
+      for (const connection of this.connections) connection.checkHeartbeat()
+    }, HEARTBEAT_INTERVAL_MS)
+  }
+
+  public async close() {
+    if (this.heartbeatTimer !== undefined) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = undefined
+    }
+    for (const connection of this.connections) connection.terminate()
+
+    await Promise.all([
+      new Promise<void>((resolve, reject) => {
+        this.server.close((error) => (error === undefined ? resolve() : reject(error)))
+      }),
+      new Promise<void>((resolve, reject) => {
+        this.httpServer.close((error) => (error === undefined ? resolve() : reject(error)))
+      })
+    ])
+  }
+
+  private connect(webSocket: WebSocket, requestUrl: string | undefined) {
+    const connection = new MachineWebSocketConnection(webSocket, () => this.connections.delete(connection))
+    this.connections.add(connection)
+
+    let url: URL
+    try {
+      url = new URL(requestUrl ?? '/', 'http://localhost')
+    } catch {
+      connection.end(1008)
+      return
+    }
+
+    const route = this.routes[url.pathname.toLowerCase()]
+    if (route === undefined) {
+      connection.end(1008)
+      return
+    }
+
+    try {
+      const result = route(connection, url.search.slice(1))
+      if (result !== undefined) void result.catch((error) => connection.end(1011, String(error)))
+    } catch (error) {
+      connection.end(1011, String(error))
+    }
+  }
+}
+
+class MachineWebSocketConnection implements MachineWebSocket {
+  public closed = false
+  public onmessage: ((message: Buffer) => void) | undefined
+  private receivedHeartbeat = true
+
+  constructor(
+    private readonly socket: WebSocket,
+    private readonly remove: () => void
+  ) {
+    socket.on('message', (message) => {
+      this.receivedHeartbeat = true
+      this.onmessage?.(Buffer.isBuffer(message) ? message : Buffer.from(message as ArrayBuffer))
+    })
+    socket.on('pong', () => (this.receivedHeartbeat = true))
+    // `ws` closes the connection after protocol and transport errors; cleanup happens in `close`.
+    socket.on('error', () => {})
+    socket.on('close', () => {
+      this.closed = true
+      this.remove()
+    })
+  }
+
+  public send(message: string | ArrayBuffer | Buffer) {
+    if (this.socket.readyState !== WebSocket.OPEN) return false
+
+    try {
+      // uWebSockets.js sent replay payload buffers as text frames by default.
+      this.socket.send(message, { binary: false, compress: false })
+    } catch {
+      this.terminate()
+      return false
+    }
+
+    if (this.socket.bufferedAmount > MAX_BACKPRESSURE_BYTES) {
+      this.end(1008, 'Too much backpressure')
+      return false
+    }
+
+    return this.socket.bufferedAmount === 0
+  }
+
+  public getBufferedAmount() {
+    return this.socket.bufferedAmount
+  }
+
+  public end(code = 1000, reason = '') {
+    if (this.socket.readyState !== WebSocket.OPEN) return
+
+    try {
+      this.socket.close(code, truncateCloseReason(reason))
+    } catch {
+      this.terminate()
+    }
+  }
+
+  public checkHeartbeat() {
+    if (!this.receivedHeartbeat) {
+      this.terminate()
+      return
+    }
+
+    this.receivedHeartbeat = false
+    if (this.socket.readyState === WebSocket.OPEN) this.socket.ping()
+  }
+
+  public terminate() {
+    if (this.socket.readyState !== WebSocket.CLOSED) this.socket.terminate()
+  }
+}
+
+function truncateCloseReason(reason: string) {
+  const encodedReason = Buffer.from(reason)
+  if (encodedReason.length <= MAX_CLOSE_REASON_BYTES) return reason
+
+  // Leave room for the UTF-8 replacement character if truncation splits a code point.
+  return encodedReason.subarray(0, MAX_CLOSE_REASON_BYTES - 3).toString()
+}

package/src/ws/streamnormalized.ts

@@ -1,15 +1,15 @@
 import { decode } from 'node:querystring'
 import { combine, compute, Exchange, streamNormalized } from 'tardis-dev'
-import type { HttpRequest } from 'uWebSockets.js'
 import { debug } from '../debug.ts'
 import { constructDataTypeFilter, getComputables, getNormalizers, StreamNormalizedRequestOptions, wait } from '../helpers.ts'
+import type { MachineWebSocket } from './server.ts'
 
-export async function streamNormalizedWS(ws: any, req: HttpRequest) {
+export async function streamNormalizedWS(ws: MachineWebSocket, query: string) {
   let messages: AsyncIterableIterator<any> | undefined
 
   try {
     const startTimestamp = new Date().getTime()
-    const parsedQuery = decode(req.getQuery())
+    const parsedQuery = decode(query)
     const optionsString = parsedQuery['options'] as string
     const streamNormalizedOptions = JSON.parse(optionsString) as StreamNormalizedRequestOptions
 
@@ -84,7 +84,7 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
       retries = 0
       bufferedAmount = 0
       // handle backpressure in case of slow clients
-      while ((bufferedAmount = ws.getBufferedAmount()) > 0) {
+      while (!ws.closed && (bufferedAmount = ws.getBufferedAmount()) > 0) {
         retries += 1
         const isState = new Date().valueOf() - message.localTimestamp.valueOf() >= 6
 
@@ -101,6 +101,8 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
         await wait(3 * retries)
       }
 
+      if (ws.closed) return
+
       ws.send(JSON.stringify(message))
 
       if (message.type !== 'disconnect') {
@@ -108,7 +110,7 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
       }
     }
 
-    while (ws.getBufferedAmount() > 0) {
+    while (!ws.closed && ws.getBufferedAmount() > 0) {
       await wait(100)
     }
 
@@ -131,7 +133,7 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
   } finally {
     // this will close underlying open WS connections
     if (messages !== undefined) {
-      messages!.return!()
+      await messages.return?.()
     }
   }
 }

package/src/ws/subscriptionsmappers.ts

@@ -1,4 +1,4 @@
-import { Exchange, Filter } from 'tardis-dev'
+import type { Exchange, Filter } from 'tardis-dev'
 
 // https://www.bitmex.com/app/wsAPI
 const bitmexMapper: SubscriptionMapper = {

package/node_modules/follow-redirects/LICENSE

@@ -1,18 +0,0 @@
-Copyright 2014–present Olivier Lalonde <olalonde@gmail.com>, James Talmage <james@talmage.io>, Ruben Verborgh
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/follow-redirects/README.md

@@ -1,157 +0,0 @@
-## Follow Redirects
-
-Drop-in replacement for Node's `http` and `https` modules that automatically follows redirects.
-
-[![npm version](https://img.shields.io/npm/v/follow-redirects.svg)](https://www.npmjs.com/package/follow-redirects)
-[![Build Status](https://github.com/follow-redirects/follow-redirects/workflows/CI/badge.svg)](https://github.com/follow-redirects/follow-redirects/actions)
-[![Coverage Status](https://coveralls.io/repos/follow-redirects/follow-redirects/badge.svg?branch=master)](https://coveralls.io/r/follow-redirects/follow-redirects?branch=master)
-[![npm downloads](https://img.shields.io/npm/dm/follow-redirects.svg)](https://www.npmjs.com/package/follow-redirects)
-[![Sponsor on GitHub](https://img.shields.io/static/v1?label=Sponsor&message=%F0%9F%92%96&logo=GitHub)](https://github.com/sponsors/RubenVerborgh)
-
-`follow-redirects` provides [request](https://nodejs.org/api/http.html#http_http_request_options_callback) and [get](https://nodejs.org/api/http.html#http_http_get_options_callback)
- methods that behave identically to those found on the native [http](https://nodejs.org/api/http.html#http_http_request_options_callback) and [https](https://nodejs.org/api/https.html#https_https_request_options_callback)
- modules, with the exception that they will seamlessly follow redirects.
-
-```javascript
-const { http, https } = require('follow-redirects');
-
-http.get('http://en.wikipedia.org/', response => {
-  response.on('data', chunk => {
-    console.log(chunk);
-  });
-}).on('error', err => {
-  console.error(err);
-});
-```
-
-You can inspect the final redirected URL through the `responseUrl` property on the `response`.
-If no redirection happened, `responseUrl` is the original request URL.
-
-```javascript
-const request = https.request({
-  host: 'en.wikipedia.org',
-  path: '/',
-}, response => {
-  console.log(response.responseUrl);
-  // 'http://duckduckgo.com/robots.txt'
-});
-request.end();
-```
-
-## Options
-### Global options
-Global options are set directly on the `follow-redirects` module:
-
-```javascript
-const followRedirects = require('follow-redirects');
-followRedirects.maxRedirects = 10;
-followRedirects.maxBodyLength = 20 * 1024 * 1024; // 20 MB
-```
-
-The following global options are supported:
-
-- `maxRedirects` (default: `21`) – sets the maximum number of allowed redirects; if exceeded, an error will be emitted.
-
-- `maxBodyLength` (default: 10MB) – sets the maximum size of the request body; if exceeded, an error will be emitted.
-
-### Per-request options
-Per-request options are set by passing an `options` object:
-
-```javascript
-const url = require('url');
-const { http, https } = require('follow-redirects');
-
-const options = url.parse('http://en.wikipedia.org/');
-options.maxRedirects = 10;
-options.beforeRedirect = (options, response, request) => {
-  // Use this to adjust the request options upon redirecting,
-  // to inspect the latest response headers,
-  // or to cancel the request by throwing an error
-
-  // response.headers = the redirect response headers
-  // response.statusCode = the redirect response code (eg. 301, 307, etc.)
-
-  // request.url = the requested URL that resulted in a redirect
-  // request.headers = the headers in the request that resulted in a redirect
-  // request.method = the method of the request that resulted in a redirect
-  if (options.hostname === "example.org") {
-    options.auth = "user:password";
-  }
-};
-http.request(options);
-```
-
-In addition to the [standard HTTP](https://nodejs.org/api/http.html#http_http_request_options_callback) and [HTTPS options](https://nodejs.org/api/https.html#https_https_request_options_callback),
-the following per-request options are supported:
-- `followRedirects` (default: `true`) – whether redirects should be followed.
-
-- `maxRedirects` (default: `21`) – sets the maximum number of allowed redirects; if exceeded, an error will be emitted.
-
-- `maxBodyLength` (default: 10MB) – sets the maximum size of the request body; if exceeded, an error will be emitted.
-
-- `beforeRedirect` (default: `undefined`) – optionally change the request `options` on redirects, or abort the request by throwing an error.
-
-- `agents` (default: `undefined`) – sets the `agent` option per protocol, since HTTP and HTTPS use different agents. Example value: `{ http: new http.Agent(), https: new https.Agent() }`
-
-- `trackRedirects` (default: `false`) – whether to store the redirected response details into the `redirects` array on the response object.
-
-- `sensitiveHeaders` (default: `[]`) – names of headers to omit when making redirected requests (such as `X-API-Key`, `X-Auth-Token`…)
-
-
-### Advanced usage
-By default, `follow-redirects` will use the Node.js default implementations
-of [`http`](https://nodejs.org/api/http.html)
-and [`https`](https://nodejs.org/api/https.html).
-To enable features such as caching and/or intermediate request tracking,
-you might instead want to wrap `follow-redirects` around custom protocol implementations:
-
-```javascript
-const { http, https } = require('follow-redirects').wrap({
-  http: require('your-custom-http'),
-  https: require('your-custom-https'),
-});
-```
-
-Such custom protocols only need an implementation of the `request` method.
-
-## Browser Usage
-
-Due to the way the browser works,
-the `http` and `https` browser equivalents perform redirects by default.
-
-By requiring `follow-redirects` this way:
-```javascript
-const http = require('follow-redirects/http');
-const https = require('follow-redirects/https');
-```
-you can easily tell webpack and friends to replace
-`follow-redirect` by the built-in versions:
-
-```json
-{
-  "follow-redirects/http"  : "http",
-  "follow-redirects/https" : "https"
-}
-```
-
-## Contributing
-
-Pull Requests are always welcome. Please [file an issue](https://github.com/follow-redirects/follow-redirects/issues)
- detailing your proposal before you invest your valuable time. Additional features and bug fixes should be accompanied
- by tests. You can run the test suite locally with a simple `npm test` command.
-
-## Debug Logging
-
-`follow-redirects` uses the excellent [debug](https://www.npmjs.com/package/debug) for logging. To turn on logging
- set the environment variable `DEBUG=follow-redirects` for debug output from just this module. When running the test
- suite it is sometimes advantageous to set `DEBUG=*` to see output from the express server as well.
-
-## Authors
-
-- [Ruben Verborgh](https://ruben.verborgh.org/)
-- [Olivier Lalonde](mailto:olalonde@gmail.com)
-- [James Talmage](mailto:james@talmage.io)
-
-## License
-
-[MIT License](https://github.com/follow-redirects/follow-redirects/blob/master/LICENSE)

package/node_modules/follow-redirects/debug.js

@@ -1,15 +0,0 @@
-var debug;
-
-module.exports = function () {
-  if (!debug) {
-    try {
-      /* eslint global-require: off */
-      debug = require("debug")("follow-redirects");
-    }
-    catch (error) { /* */ }
-    if (typeof debug !== "function") {
-      debug = function () { /* */ };
-    }
-  }
-  debug.apply(null, arguments);
-};

package/node_modules/follow-redirects/http.js

@@ -1 +0,0 @@
-module.exports = require("./").http;

package/node_modules/follow-redirects/https.js

@@ -1 +0,0 @@
-module.exports = require("./").https;