How to use the requestretry.get function in requestretry

'HTTP request can get [wp-property/composer.json].': function( done ) {
    //console.log( 'test one', 'http://' + module.host + ':3000/' );

    request.get( {
      followRedirect: false,
      timeout: 1000,
      headers: {
        host: process.env.CIRCLE_SHA1 + '-' + process.env.CIRCLE_BUILD_NUM + '.ngrok.io'
      },
      url: module.base_url + '/wp-content/plugins/wp-property-' + process.env.CIRCLE_SHA1 + '/composer.json'
    } , function checkResponse( error, resp, body ) {

      if( error ) {
        done( new Error( 'Can not reach WordPress at [' + module.base_url + '/wp-admin/admin-ajax.php].' ) );
      }
      // console.log( require( 'util' ).inspect( resp.headers, {showHidden: false, depth: 2, colors: true} ) );
      // console.log( 'resp.statusCode', resp.statusCode );

      if( resp.statusCode === 301 ) {
        console.log( "Most likely first time tests are being ran and site is trying to redirect to its default siteurl." );

ArXiv.prototype.pageQuery = function () {
  var arxiv = this

  var thisQueryUrl = arxiv.queryurl

  var pageterm =
    '&start=' + arxiv.iter +
    '&max_results=' + arxiv.pagesize
  thisQueryUrl += pageterm

  log.debug(thisQueryUrl)
  var rq = request.get({url: thisQueryUrl,
    headers: {'User-Agent': config.userAgent}})
  var convertXML2JSON = function (data) {
    // console.log(data.body)
    parseString(data.body, function (err, datum) {
      if (err) throw err
      var cb = arxiv.completeCallback.bind(arxiv, datum)
      cb()
    })
  }
  rq.on('complete', convertXML2JSON)
  rq.on('timeout', arxiv.timeoutCallback)
}

function getIstexIdsFromOnePage() {
  	var url = urls.pop();
  	request.get({
    	url: url,
    	maxAttempts: 50,   // (default) try 50 times
    	retryDelay: 10000,  // (default) wait for 10s before trying again
    	retryStrategy: request.RetryStrategies.HTTPOrNetworkError // (default) retry on 5xx or network errors
  	}, 
  	function (err, res) {
    	if (err) {
      		console.error(err, url);
      		return;
    	}
    	var json = JSON.parse(res.body);
 		if (json && json.hits) {
      		json.hits.forEach(function (doc) {
	        	var jsonRes = {
	          		corpusName: doc.corpusName,
	          		istexId: doc.id,

EuPmc.prototype.pageQuery = function () {
  var eupmc = this

  var thisQueryUrl = eupmc.queryurl + ''

  var pageterm = '&cursorMark=' + eupmc.nextCursorMark
  thisQueryUrl += pageterm

  log.debug(thisQueryUrl)

  var retryOnHTTPNetOrEuPMCFailure = function (err, response, body) {
    return requestretry.RetryStrategies.HTTPOrNetworkError(err, response, body) ||
            ~body.indexOf('') // hacky way to see if resultsList is empty
  }

  var rq = requestretry.get({url: thisQueryUrl,
    maxAttempts: 10,
    retryStrategy: retryOnHTTPNetOrEuPMCFailure,
    headers: {'User-Agent': config.userAgent}
  })
  var handleResquestResponse = function (data) {
    if (data.attempts > 1) {
      log.warn('We had to retry the last request ' + data.attempts + ' times.')
    }
    convertXML2JSON(data)
  }
  var convertXML2JSON = function (data) {
    parseString(data.body, function (err, datum) {
      if (err) throw err
      var cb = eupmc.completeCallback.bind(eupmc, datum)
      cb()
    })

async function replayUrls() {
    let urls = require('./urls');
    for (let i = 0; i < urls.length; i++) {
        let url = `http://www.gbif-staging.org${urls[i]}`;
        let response = await request.get(url, {method: 'HEAD'});
        if (response.statusCode > 404) {
            console.log('statusCode: ' + response.statusCode);
            console.log(url);
        }
    }
}
replayUrls();

router.get('/installation/ipt/inventory/dataset', function(req, res) {
    let url = decodeURIComponent(req.query.iptBaseURL) + '/inventory/dataset';

    res.header('cache-control', 'max-age=0, no-store, must-revalidate');
    res.header('Access-Control-Allow-Origin', '*');
    res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS');
    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');

    request.get({
        url: url,
        method: 'GET',
        json: true,
        fullResponse: true,
        maxAttempts: 1
    })
    .then(function(response) {
        res.header('Content-Type', response.headers['content-type'] || 'application/json');
        res.status(response.statusCode);
        res.send(response.body);
    })
    .catch(function(err) {
        log.error(err);
        res.sendStatus(500);
    });
});

function fileWriteCB (err) {
      if (err) throw err
      done()
    }

    function handleDownload (data) {
      fs.writeFile(base + rename, data, fileWriteCB)
      nextUrlTask(urlQueue)
    }

    function throwErr (err) {
      if (err) throw err
    }

    var rq = requestretry.get({
      url: url,
      fullResponse: false,
      headers: {'User-Agent': config.userAgent},
      encoding: null
    })
    rq.then(handleDownload)
    rq.catch(throwErr)
  }
}

function obtainInfo(id, action, cb) {
    request.get({
        url: action,
        timeout: 10000,
        maxAttempts: 2
    }, function (error, response, body) {
        if (error || response.statusCode != 200) {
            cb(utils.errorDown())
            return
        }

        const data = JSON.parse(body)
        if (data.errors != undefined) {
            cb(utils.errorNoData())
            return
        }

        let entity = null