@verdaccio/proxy 6.0.0-6-next.18 → 6.0.0-6-next.21

package/src/{up-storage.ts → proxy.ts}

@@ -1,33 +1,31 @@
-/* global AbortController */
 import JSONStream from 'JSONStream';
 import buildDebug from 'debug';
+import got, { RequiredRetryOptions, Headers as gotHeaders } from 'got';
+import type { Agents, Options } from 'got';
 import _ from 'lodash';
-import request from 'request';
 import Stream, { PassThrough, Readable } from 'stream';
-import { Headers, Request } from 'undici-fetch';
+import { Headers, fetch as undiciFetch } from 'undici';
 import { URL } from 'url';
 
 import {
-  CHARACTER_ENCODING,
+  API_ERROR,
   HEADERS,
-  HEADER_TYPE,
   HTTP_STATUS,
   TOKEN_BASIC,
   TOKEN_BEARER,
   constants,
   errorUtils,
   searchUtils,
-  validatioUtils,
 } from '@verdaccio/core';
-import { ReadTarball } from '@verdaccio/streams';
-import { Callback, Config, IReadTarball, Logger, UpLinkConf } from '@verdaccio/types';
+import { Manifest } from '@verdaccio/types';
+import { Config, Logger, UpLinkConf } from '@verdaccio/types';
 import { buildToken } from '@verdaccio/utils';
 
+import CustomAgents, { AgentOptionsConf } from './agent';
 import { parseInterval } from './proxy-utils';
 
 const LoggerApi = require('@verdaccio/logger');
 
-const fetch = require('undici-fetch');
 const debug = buildDebug('verdaccio:proxy');
 
 const encode = function (thing): string {
@@ -40,7 +38,7 @@ const contentTypeAccept = `${jsonContentType};`;
 /**
  * Just a helper (`config[key] || default` doesn't work because of zeroes)
  */
-const setConfig = (config, key, def): string => {
+const setConfig = (config: UpLinkConfLocal, key: string, def): string => {
   return _.isNil(config[key]) === false ? config[key] : def;
 };
 
@@ -71,9 +69,21 @@ export interface IProxy {
   max_fails: number;
   fail_timeout: number;
   upname: string;
-  fetchTarball(url: string): IReadTarball;
   search(options: ProxySearchParams): Promise<Stream.Readable>;
-  getRemoteMetadata(name: string, options: any, callback: Callback): void;
+  getRemoteMetadataNext(name: string, options: ISyncUplinksOptions): Promise<[Manifest, string]>;
+  fetchTarballNext(
+    url: string,
+    options: Pick<ISyncUplinksOptions, 'remoteAddress' | 'etag' | 'retry'>
+  ): PassThrough;
+}
+
+// this type is need it by storage
+export { Options as FetchOptions };
+
+export interface ISyncUplinksOptions extends Options {
+  uplinksLook?: boolean;
+  etag?: string;
+  remoteAddress?: string;
 }
 
 /**
@@ -92,33 +102,33 @@ class ProxyStorage implements IProxy {
   public timeout: number;
   public max_fails: number;
   public fail_timeout: number;
-  public agent_options: any;
+  public agent_options: AgentOptionsConf;
   // FIXME: upname is assigned to each instance
   // @ts-ignore
   public upname: string;
-  // FIXME: proxy can be boolean or object, something smells here
-  // @ts-ignore
-  public proxy: any;
+  public proxy: string | undefined;
+  private agent: Agents;
   // @ts-ignore
   public last_request_time: number | null;
   public strict_ssl: boolean;
+  private retry: Partial<RequiredRetryOptions> | number;
 
-  /**
-   * Constructor
-   * @param {*} config
-   * @param {*} mainConfig
-   */
-  public constructor(config: UpLinkConfLocal, mainConfig: Config) {
+  public constructor(config: UpLinkConfLocal, mainConfig: Config, agent?: Agents) {
     this.config = config;
     this.failed_requests = 0;
     this.userAgent = mainConfig.user_agent;
     this.ca = config.ca;
     this.logger = LoggerApi.logger.child({ sub: 'out' });
     this.server_id = mainConfig.server_id;
-
+    this.agent_options = setConfig(this.config, 'agent_options', {
+      keepAlive: true,
+      maxSockets: 40,
+      maxFreeSockets: 10,
+    }) as AgentOptionsConf;
     this.url = new URL(this.config.url);
-    this._setupProxy(this.url.hostname, config, mainConfig, this.url.protocol === 'https:');
-
+    const isHTTPS = this.url.protocol === 'https:';
+    this._setupProxy(this.url.hostname, config, mainConfig, isHTTPS);
+    this.agent = agent ?? this.getAgent();
     this.config.url = this.config.url.replace(/\/$/, '');
 
     if (this.config.timeout && Number(this.config.timeout) >= 1000) {
@@ -134,192 +144,25 @@ class ProxyStorage implements IProxy {
 
     // a bunch of different configurable timers
     this.maxage = parseInterval(setConfig(this.config, 'maxage', '2m'));
+    // https://github.com/sindresorhus/got/blob/main/documentation/6-timeout.md
     this.timeout = parseInterval(setConfig(this.config, 'timeout', '30s'));
-    this.max_fails = Number(setConfig(this.config, 'max_fails', 2));
+    this.max_fails = Number(setConfig(this.config, 'max_fails', this.config.max_fails ?? 2));
     this.fail_timeout = parseInterval(setConfig(this.config, 'fail_timeout', '5m'));
     this.strict_ssl = Boolean(setConfig(this.config, 'strict_ssl', true));
-    this.agent_options = setConfig(this.config, 'agent_options', {
-      keepAlive: true,
-      maxSockets: 40,
-      maxFreeSockets: 10,
-    });
+    this.retry = { limit: this.max_fails ?? 2 };
   }
 
-  /**
-   * Fetch an asset.
-   * @param {*} options
-   * @param {*} cb
-   * @return {Request}
-   */
-  private request(options: any, cb?: Callback): Stream.Readable {
-    let json;
-
-    if (this._statusCheck() === false) {
-      const streamRead = new Stream.Readable();
-
-      process.nextTick(function (): void {
-        if (cb) {
-          cb(errorUtils.getInternalError(errorUtils.API_ERROR.UPLINK_OFFLINE));
-        }
-        streamRead.emit('error', errorUtils.getInternalError(errorUtils.API_ERROR.UPLINK_OFFLINE));
-      });
-      streamRead._read = function (): void {};
-      // preventing 'Uncaught, unspecified "error" event'
-      streamRead.on('error', function (): void {});
-      return streamRead;
-    }
-
-    const self = this;
-    const headers: Headers = this._setHeaders(options);
-
-    this._addProxyHeaders(options.req, headers);
-    this._overrideWithUpLinkConfLocaligHeaders(headers);
-
-    const method = options.method || 'GET';
-    const uri = options.uri_full || this.config.url + options.uri;
-
-    self.logger.info(
-      {
-        method: method,
-        headers: headers,
-        uri: uri,
-      },
-      "making request: '@{method} @{uri}'"
-    );
-
-    if (validatioUtils.isObject(options.json)) {
-      json = JSON.stringify(options.json);
-      headers['Content-Type'] = headers['Content-Type'] || HEADERS.JSON;
-    }
-
-    const requestCallback = cb
-      ? function (err, res, body): void {
-          let error;
-          const responseLength = err ? 0 : body.length;
-          // $FlowFixMe
-          processBody();
-          logActivity();
-          // $FlowFixMe
-          cb(err, res, body);
-
-          /**
-           * Perform a decode.
-           */
-          function processBody(): void {
-            if (err) {
-              error = err.message;
-              return;
-            }
-
-            if (options.json && res.statusCode < 300) {
-              try {
-                // $FlowFixMe
-                body = JSON.parse(body.toString(CHARACTER_ENCODING.UTF8));
-              } catch (_err: any) {
-                body = {};
-                err = _err;
-                error = err.message;
-              }
-            }
-
-            if (!err && validatioUtils.isObject(body)) {
-              if (_.isString(body.error)) {
-                error = body.error;
-              }
-            }
-          }
-          /**
-           * Perform a log.
-           */
-          function logActivity(): void {
-            let message = "@{!status}, req: '@{request.method} @{request.url}'";
-            // FIXME: use LOG_VERDACCIO_BYTES
-            message += error ? ', error: @{!error}' : ', bytes: @{bytes.in}/@{bytes.out}';
-            self.logger.http(
-              {
-                // if error is null/false change this to undefined so it wont log
-                err: err || undefined,
-                request: { method: method, url: uri },
-                status: res != null ? res.statusCode : 'ERR',
-                error: error,
-                bytes: {
-                  in: json ? json.length : 0,
-                  out: responseLength || 0,
-                },
-              },
-              message
-            );
-          }
-        }
-      : undefined;
-
-    let requestOptions = {
-      url: uri,
-      method: method,
-      headers: headers,
-      body: json,
-      proxy: this.proxy,
-      encoding: null,
-      gzip: true,
-      timeout: this.timeout,
-      strictSSL: this.strict_ssl,
-      agentOptions: this.agent_options,
-    };
-
-    if (this.ca) {
-      requestOptions = Object.assign({}, requestOptions, {
-        ca: this.ca,
-      });
+  private getAgent() {
+    if (!this.agent) {
+      // TODO: the config.ca (certificates) is not yet injected here
+      const agentInstance = new CustomAgents(this.config.url, this.proxy, this.agent_options);
+      return agentInstance.get();
+    } else {
+      return this.agent;
     }
-
-    const req = request(requestOptions, requestCallback);
-
-    let statusCalled = false;
-    req.on('response', function (res): void {
-      // FIXME: _verdaccio_aborted seems not used
-      // @ts-ignore
-      if (!req._verdaccio_aborted && !statusCalled) {
-        statusCalled = true;
-        self._statusCheck(true);
-      }
-
-      if (_.isNil(requestCallback) === false) {
-        (function do_log(): void {
-          const message = "@{!status}, req: '@{request.method} @{request.url}' (streaming)";
-          self.logger.http(
-            {
-              request: {
-                method: method,
-                url: uri,
-              },
-              status: _.isNull(res) === false ? res.statusCode : 'ERR',
-            },
-            message
-          );
-        })();
-      }
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    req.on('error', function (_err): void {
-      // FIXME: _verdaccio_aborted seems not used
-      // @ts-ignore
-      if (!req._verdaccio_aborted && !statusCalled) {
-        statusCalled = true;
-        self._statusCheck(false);
-      }
-    });
-    // @ts-ignore
-    return req;
   }
 
-  /**
-   * Set default headers.
-   * @param {Object} options
-   * @return {Object}
-   * @private
-   */
-  private _setHeaders(options: any): Headers {
-    const headers = options.headers || {};
+  public getHeadersNext(headers = {}): gotHeaders {
     const accept = HEADERS.ACCEPT;
     const acceptEncoding = HEADERS.ACCEPT_ENCODING;
     const userAgent = HEADERS.USER_AGENT;
@@ -328,8 +171,7 @@ class ProxyStorage implements IProxy {
     headers[acceptEncoding] = headers[acceptEncoding] || 'gzip';
     // registry.npmjs.org will only return search result if user-agent include string 'npm'
     headers[userAgent] = headers[userAgent] || `npm (${this.userAgent})`;
-
-    return this._setAuth(headers);
+    return this.setAuthNext(headers);
   }
 
   /**
@@ -338,10 +180,9 @@ class ProxyStorage implements IProxy {
    * @return {Object}
    * @private
    */
-  private _setAuth(headers: any): Headers {
+  private setAuthNext(headers: gotHeaders): gotHeaders {
     const { auth } = this.config;
-
-    if (_.isNil(auth) || headers[HEADERS.AUTHORIZATION]) {
+    if (typeof auth === 'undefined' || typeof headers[HEADERS.AUTHORIZATION] === 'string') {
       return headers;
     }
 
@@ -354,13 +195,12 @@ class ProxyStorage implements IProxy {
     // https://github.com/verdaccio/verdaccio/releases/tag/v2.5.0
     let token: any;
     const tokenConf: any = auth;
-
     if (_.isNil(tokenConf.token) === false && _.isString(tokenConf.token)) {
       token = tokenConf.token;
     } else if (_.isNil(tokenConf.token_env) === false) {
-      if (_.isString(tokenConf.token_env)) {
+      if (typeof tokenConf.token_env === 'string') {
         token = process.env[tokenConf.token_env];
-      } else if (_.isBoolean(tokenConf.token_env) && tokenConf.token_env) {
+      } else if (typeof tokenConf.token_env === 'boolean' && tokenConf.token_env) {
         token = process.env.NPM_TOKEN;
       } else {
         this.logger.error(constants.ERROR_CODE.token_required);
@@ -370,7 +210,7 @@ class ProxyStorage implements IProxy {
       token = process.env.NPM_TOKEN;
     }
 
-    if (_.isNil(token)) {
+    if (typeof token === 'undefined') {
       this._throwErrorAuth(constants.ERROR_CODE.token_required);
     }
 
@@ -427,6 +267,7 @@ class ProxyStorage implements IProxy {
 
    * @param {Object} headers
    * @private
+   * @deprecated use applyUplinkHeaders
    */
   private _overrideWithUpLinkConfLocaligHeaders(headers: Headers): any {
     if (!this.config.headers) {
@@ -440,98 +281,200 @@ class ProxyStorage implements IProxy {
     }
   }
 
-  /**
-   * Get a remote package metadata
-   * @param {*} name package name
-   * @param {*} options request options, eg: eTag.
-   * @param {*} callback
-   */
-  public getRemoteMetadata(name: string, options: any, callback: Callback): void {
-    const headers = {};
+  private applyUplinkHeaders(headers: gotHeaders): gotHeaders {
+    if (!this.config.headers) {
+      return headers;
+    }
+
+    // add/override headers specified in the config
+    /* eslint guard-for-in: 0 */
+    for (const key in this.config.headers) {
+      headers[key] = this.config.headers[key];
+    }
+    return headers;
+  }
+
+  public async getRemoteMetadataNext(
+    name: string,
+    options: ISyncUplinksOptions
+  ): Promise<[Manifest, string]> {
+    if (this._ifRequestFailure()) {
+      throw errorUtils.getInternalError(API_ERROR.UPLINK_OFFLINE);
+    }
+
+    // FUTURE: allow mix headers that comes from the client
+    debug('get metadata for %s', name);
+    let headers = this.getHeadersNext(options?.headers);
+    headers = this.addProxyHeaders(headers, options.remoteAddress);
+    headers = this.applyUplinkHeaders(headers);
+    // the following headers cannot be overwritten
     if (_.isNil(options.etag) === false) {
-      headers['If-None-Match'] = options.etag;
+      headers[HEADERS.NONE_MATCH] = options.etag;
       headers[HEADERS.ACCEPT] = contentTypeAccept;
     }
+    const method = options.method || 'GET';
+    const uri = this.config.url + `/${encode(name)}`;
+    debug('request uri for %s retry %s', uri);
+    let response;
+    let responseLength = 0;
+    try {
+      const retry = options?.retry ?? this.retry;
+      debug('retry times %s for %s', retry, uri);
+      response = await got(uri, {
+        headers,
+        responseType: 'json',
+        method,
+        agent: this.agent,
+        retry,
+        // @ts-ignore
+        timeout: { request: options?.timeout ?? this.timeout },
+        hooks: {
+          afterResponse: [
+            (afterResponse) => {
+              const code = afterResponse.statusCode;
+              debug('code response %s', code);
+              if (code >= HTTP_STATUS.OK && code < HTTP_STATUS.MULTIPLE_CHOICES) {
+                if (this.failed_requests >= this.max_fails) {
+                  this.failed_requests = 0;
+                  this.logger.warn(
+                    {
+                      host: this.url.host,
+                    },
+                    'host @{host} is now online'
+                  );
+                }
+              }
 
-    this.request(
-      {
-        uri: `/${encode(name)}`,
-        json: true,
-        headers: headers,
-        req: options.req,
-      },
-      (err, res, body): void => {
-        if (err) {
-          return callback(err);
-        }
-        if (res.statusCode === HTTP_STATUS.NOT_FOUND) {
-          return callback(errorUtils.getNotFound(errorUtils.API_ERROR.NOT_PACKAGE_UPLINK));
+              return afterResponse;
+            },
+          ],
+          beforeRetry: [
+            // FUTURE: got 12.0.0, the option arg should be removed
+            (_options, error: any, count) => {
+              this.failed_requests = count ?? 0;
+              this.logger.info(
+                {
+                  request: {
+                    method: method,
+                    url: uri,
+                  },
+                  error: error.message,
+                  retryCount: this.failed_requests,
+                },
+                "retry @{retryCount} req: '@{request.method} @{request.url}'"
+              );
+              if (this.failed_requests >= this.max_fails) {
+                this.logger.warn(
+                  {
+                    host: this.url.host,
+                  },
+                  'host @{host} is now offline'
+                );
+              }
+            },
+          ],
+        },
+      })
+        .on('request', () => {
+          this.last_request_time = Date.now();
+        })
+        .on('response', (eventResponse) => {
+          const message = "@{!status}, req: '@{request.method} @{request.url}' (streaming)";
+          this.logger.http(
+            {
+              request: {
+                method: method,
+                url: uri,
+              },
+              status: _.isNull(eventResponse) === false ? eventResponse.statusCode : 'ERR',
+            },
+            message
+          );
+        })
+        .on('downloadProgress', (progress) => {
+          if (progress.total) {
+            debug('responseLength %s', progress.total);
+            responseLength = progress.total;
+          }
+        });
+      const etag = response.headers.etag as string;
+      const data = response.body;
+
+      // not modified status (304) registry does not return any payload
+      // it is handled as an error
+      if (response?.statusCode === HTTP_STATUS.NOT_MODIFIED) {
+        throw errorUtils.getCode(HTTP_STATUS.NOT_MODIFIED, API_ERROR.NOT_MODIFIED_NO_DATA);
+      }
+
+      debug('uri %s success', uri);
+      const message = "@{!status}, req: '@{request.method} @{request.url}'";
+      this.logger.http(
+        {
+          // if error is null/false change this to undefined so it wont log
+          request: { method: method, url: uri },
+          status: response.statusCode,
+          bytes: {
+            in: options?.json ? JSON.stringify(options?.json).length : 0,
+            out: responseLength || 0,
+          },
+        },
+        message
+      );
+      return [data, etag];
+    } catch (err: any) {
+      debug('uri %s fail', uri);
+      if (err.code === 'ERR_NON_2XX_3XX_RESPONSE') {
+        const code = err.response.statusCode;
+        if (code === HTTP_STATUS.NOT_FOUND) {
+          throw errorUtils.getNotFound(errorUtils.API_ERROR.NOT_PACKAGE_UPLINK);
         }
-        if (!(res.statusCode >= HTTP_STATUS.OK && res.statusCode < HTTP_STATUS.MULTIPLE_CHOICES)) {
+
+        if (!(code >= HTTP_STATUS.OK && code < HTTP_STATUS.MULTIPLE_CHOICES)) {
           const error = errorUtils.getInternalError(
-            `${errorUtils.API_ERROR.BAD_STATUS_CODE}: ${res.statusCode}`
+            `${errorUtils.API_ERROR.BAD_STATUS_CODE}: ${code}`
           );
-
-          error.remoteStatus = res.statusCode;
-          return callback(error);
+          // we need this code to identify outside which status code triggered the error
+          error.remoteStatus = code;
+          throw error;
         }
-        callback(null, body, res.headers.etag);
       }
-    );
+      throw err;
+    }
   }
 
-  /**
-   * Fetch a tarball from the uplink.
-   * @param {String} url
-   * @return {Stream}
-   */
-  public fetchTarball(url: string) {
-    const stream = new ReadTarball({});
-    let current_length = 0;
-    let expected_length;
-
-    stream.abort = () => {};
-    const readStream = this.request({
-      uri_full: url,
-      encoding: null,
-      headers: {
-        Accept: contentTypeAccept,
-      },
-    });
-
-    readStream.on('response', function (res: any) {
-      if (res.statusCode === HTTP_STATUS.NOT_FOUND) {
-        return stream.emit('error', errorUtils.getNotFound(errorUtils.API_ERROR.NOT_FILE_UPLINK));
-      }
-      if (!(res.statusCode >= HTTP_STATUS.OK && res.statusCode < HTTP_STATUS.MULTIPLE_CHOICES)) {
-        return stream.emit(
-          'error',
-          errorUtils.getInternalError(`bad uplink status code: ${res.statusCode}`)
-        );
-      }
-      if (res.headers[HEADER_TYPE.CONTENT_LENGTH]) {
-        expected_length = res.headers[HEADER_TYPE.CONTENT_LENGTH];
-        stream.emit(HEADER_TYPE.CONTENT_LENGTH, res.headers[HEADER_TYPE.CONTENT_LENGTH]);
-      }
+  // FIXME: handle stream and retry
+  public fetchTarballNext(
+    url: string,
+    overrideOptions: Pick<ISyncUplinksOptions, 'remoteAddress' | 'etag' | 'retry'>
+  ): any {
+    debug('fetching url for %s', url);
+    const options = { ...this.config, ...overrideOptions };
+    let headers = this.getHeadersNext(options?.headers);
+    headers = this.addProxyHeaders(headers, options.remoteAddress);
+    headers = this.applyUplinkHeaders(headers);
+    // the following headers cannot be overwritten
+    if (_.isNil(options.etag) === false) {
+      headers[HEADERS.NONE_MATCH] = options.etag;
+      headers[HEADERS.ACCEPT] = contentTypeAccept;
+    }
+    const method = 'GET';
+    // const uri = this.config.url + `/${encode(name)}`;
+    debug('request uri for %s', url);
+
+    const readStream = got
+      .stream(url, {
+        headers,
+        method,
+        agent: this.agent,
+        // FIXME: this should be taken from construtor as priority
+        retry: this.retry ?? options?.retry,
+        timeout: this.timeout,
+      })
+      .on('request', () => {
+        this.last_request_time = Date.now();
+      });
 
-      readStream.pipe(stream);
-    });
-
-    readStream.on('error', function (err) {
-      stream.emit('error', err);
-    });
-    readStream.on('data', function (data) {
-      current_length += data.length;
-    });
-    readStream.on('end', function (data) {
-      if (data) {
-        current_length += data.length;
-      }
-      if (expected_length && current_length != expected_length) {
-        stream.emit('error', errorUtils.getInternalError(errorUtils.API_ERROR.CONTENT_MISMATCH));
-      }
-    });
-    return stream;
+    return readStream;
   }
 
   /**
@@ -548,7 +491,7 @@ class ProxyStorage implements IProxy {
       // FIXME: a better way to remove duplicate slashes?
       const uri = fullURL.href.replace(/([^:]\/)\/+/g, '$1');
       this.logger.http({ uri, uplink: this.upname }, 'search request to uplink @{uplink} - @{uri}');
-      const request = new Request(uri, {
+      response = await undiciFetch(uri, {
         method: 'GET',
         // FUTURE: whitelist domains what we are sending not need it headers, security check
         // headers: new Headers({
@@ -557,7 +500,6 @@ class ProxyStorage implements IProxy {
         // }),
         signal: abort?.signal,
       });
-      response = await fetch(request);
       debug('response.status  %o', response.status);
 
       if (response.status >= HTTP_STATUS.BAD_REQUEST) {
@@ -571,70 +513,29 @@ class ProxyStorage implements IProxy {
       streamResponse.pipe(JSONStream.parse('objects')).pipe(streamSearch, { end: true });
       return streamSearch;
     } catch (err: any) {
-      this.logger.error({ errorMessage: err?.message }, 'proxy search error: @{errorMessage}');
+      this.logger.error(
+        { errorMessage: err?.message, name: this.upname },
+        'proxy uplink @{name} search error: @{errorMessage}'
+      );
       throw err;
     }
   }
 
-  /**
-   * Add proxy headers.
-   * FIXME: object mutations, it should return an new object
-   * @param {*} req the http request
-   * @param {*} headers the request headers
-   */
-  private _addProxyHeaders(req: any, headers: any): void {
-    if (req) {
-      // Only submit X-Forwarded-For field if we don't have a proxy selected
-      // in the config file.
-      //
-      // Otherwise misconfigured proxy could return 407:
-      // https://github.com/rlidwka/sinopia/issues/254
-      // @ts-ignore
-      if (!this.proxy) {
-        headers[HEADERS.FORWARDED_FOR] =
-          (req.headers['x-forwarded-for'] ? req.headers['x-forwarded-for'] + ', ' : '') +
-          req.connection.remoteAddress;
-      }
+  private addProxyHeaders(headers: gotHeaders, remoteAddress?: string): gotHeaders {
+    // Only submit X-Forwarded-For field if we don't have a proxy selected
+    // in the config file.
+    //
+    // Otherwise misconfigured proxy could return 407
+    if (!this.proxy) {
+      headers[HEADERS.FORWARDED_FOR] =
+        (headers['x-forwarded-for'] ? headers['x-forwarded-for'] + ', ' : '') + remoteAddress;
     }
 
     // always attach Via header to avoid loops, even if we're not proxying
-    headers['Via'] = req?.headers['via'] ? req.headers['via'] + ', ' : '';
-
-    headers['Via'] += '1.1 ' + this.server_id + ' (Verdaccio)';
-  }
+    headers['via'] = headers['via'] ? headers['via'] + ', ' : '';
+    headers['via'] += '1.1 ' + this.server_id + ' (Verdaccio)';
 
-  /**
-   * Check whether the remote host is available.
-   * @param {*} alive
-   * @return {Boolean}
-   */
-  private _statusCheck(alive?: boolean): boolean | void {
-    if (arguments.length === 0) {
-      return this._ifRequestFailure() === false;
-    }
-    if (alive) {
-      if (this.failed_requests >= this.max_fails) {
-        this.logger.warn(
-          {
-            host: this.url.host,
-          },
-          'host @{host} is back online'
-        );
-      }
-      this.failed_requests = 0;
-    } else {
-      this.failed_requests++;
-      if (this.failed_requests === this.max_fails) {
-        this.logger.warn(
-          {
-            host: this.url.host,
-          },
-          'host @{host} is now offline'
-        );
-      }
-    }
-
-    this.last_request_time = Date.now();
+    return headers;
   }
 
   /**
@@ -692,24 +593,20 @@ class ProxyStorage implements IProxy {
         if (noProxyItem[0] !== '.') {
           noProxyItem = '.' + noProxyItem;
         }
-        if (hostname.lastIndexOf(noProxyItem) === hostname.length - noProxyItem.length) {
+        if (hostname.endsWith(noProxyItem)) {
           if (this.proxy) {
             this.logger.debug(
               { url: this.url.href, rule: noProxyItem },
               'not using proxy for @{url}, excluded by @{rule} rule'
             );
-            // @ts-ignore
-            this.proxy = false;
+            this.proxy = undefined;
           }
           break;
         }
       }
     }
 
-    // if it's non-string (i.e. "false"), don't use it
-    if (_.isString(this.proxy) === false) {
-      delete this.proxy;
-    } else {
+    if (typeof this.proxy === 'string') {
       this.logger.debug(
         { url: this.url.href, proxy: this.proxy },
         'using proxy @{proxy} for @{url}'