TypeScript winston.warn函数代码示例

  public async getRepository(user: string, name: string) {
    const response: request.FullResponse = await request({
      auth: {
        pass: this.token,
        sendImmediately: true,
        user: 'token'
      },
      headers: { 'User-Agent': 'CodeHub-Trending' },
      method: 'GET',
      resolveWithFullResponse: true,
      url: `https://api.github.com/repos/${user}/${name}`
    });

    const rateLimitRemaining = parseInt(response.headers['x-ratelimit-remaining'] as string, 10);
    const resetSeconds = parseInt(response.headers['x-ratelimit-reset'] as string, 10);
    const nowSeconds = Math.round(new Date().getTime() / 1000);
    const duration = resetSeconds - nowSeconds + 60;

    // We need to drop the permission object from every repository
    // because that state belongs to the user that is authenticated
    // at the curren time; which is misrepresentitive of the client
    // attempting to query this information.
    const repoBody = _.omit(JSON.parse(response.body.toString()), 'permissions');

    // Make sure we don't drain the rate limit
    if (rateLimitRemaining < 400) {
      winston.warn('Pausing for %s to allow rateLimit to reset', duration);
      await wait(duration);
    }

    return repoBody;
  }

    worker.on("exit", (code, signal) => {
      var replacement, lifetime = Date.now() - startTimes[pid(worker)];
      delete startTimes[pid(worker)];

      if (worker.suicide) {
        log.info("Worker", pid(worker), "terminated voluntarily.");
        return;
      }

      log.info("Process", pid(worker), "terminated with signal", signal,
                  "code", code + "; restarting.");

      if (lifetime < options.failureThreshold) {
        failures++;
      } else {
        failures = 0;
      }

      if (failures > options.retryThreshold) {
        log.warn(failures + " consecutive failures; pausing for",
                 options.retryDelay + "ms before respawning.");
      }

      setTimeout(() => {
        replacement = spawnMore();
        replacement.on("online", () =>
                       log.info("Process", replacement.process.pid,
                                "has successfully replaced", pid(worker)));
      }, (failures > options.retryThreshold) ? options.retryDelay : 0);
    });

 this.cache.dirtySock.on('message', (dirtyness:string) => {
   const dirtyInfo = dirtyness.split('|');
   if (dirtyInfo.length !== 2) {
     winston.warn(`${new Date()}: Got weird dirty sock data? ${dirtyness}`);
     return;
   }
   this.cache.getIdsCaches[dirtyInfo[0]] = null;
   this.cache.aggregateCaches[dirtyInfo[0]] = null;
   if ((dirtyInfo.length === 2) && this.cache.objectCache[dirtyInfo[0]]) {
     this.cache.objectCache[dirtyInfo[0]][dirtyInfo[1]] = null;
   }
 });

export function routeNotFound(
    req: exp.Request,
    res: exp.Response,
    next: exp.NextFunction) {

    logger.warn('route not found');

    var json = {
        code: 404,
        name: 'API Route does not exist.',
        message: 'API Route does not exist. Check the url.'
    };

    return res.status(json.code).json(json);
};

async function scrape(options: request.OptionsWithUrl): Promise<request.FullResponse> {
  while (true) {
    const result = await request({
      ...options,
      resolveWithFullResponse: true,
      simple: false
    });

    const { statusCode } = result;

    if (statusCode === 429) {
      winston.warn(`429 received (${options.url})!. Waiting 2mins.`);
      await wait(60 * 2);
      continue;
    } else if (statusCode === 200) {
      return result;
    } else {
      throw new Error(`Invalid status code: ${statusCode}`);
    }
  }
}

 .on('disconnect', (event: any) => {
     winston.warn(`Disconnected [${event.code}]: ${event.reason || 'Unknown reason'}.`)
 })

 const repos = await gh.getTrendingRepositories(time, langSlug).catch(err => {
   winston.warn(`Error trying to retrieve repositories for ${time} ${language.name}`, err);
   return [];
 });