How to use the winston.log function in winston

return Game.find(query).exec().then(matchedGames => {
					if (!mapped) {
						// +-2 years is okay
						matchedGames = matchedGames.filter(g => Math.abs(pinsideGame.year - g.year) < 3);
					}
					if (matchedGames.length === 0) {
						logger.log('No match for %s (%s %s): %s', pinsideGame.title, pinsideGame.mfg, pinsideGame.year, pinsideGame.id);
						result.missed++;

					} else if (matchedGames.length === 1) {
						const g = matchedGames[0];
						logger.log('Found game: %s (%s %s): %s', g.title, g.manufacturer, g.year, pinsideGame.id);
						g.pinside = g.pinside || [];
						g.pinside.ids = g.pinside.ids || [];
						g.pinside.ranks = g.pinside.ranks || [];
						g.pinside.ids.push(pinsideGame.id);
						g.pinside.ranks.push(pinsideGame.rank);
						g.pinside.rating = pinsideGame.rating;
						g.pinside.ids = _.uniq(g.pinside.ids);
						g.pinside.ranks = _.uniq(g.pinside.ranks);
						result.matched++;
						return g.save();

server.listen(context.config.stratum.port, function () {
    winston.log('info', '[STRATUM] listening on %s:%d', server.address().address, server.address().port);
    _this.emit('server.started');
  })
    .on('error', function (err) {

return Q.Promise(function (resolve, reject) {
      const s3 = new AWS.S3();

      const body = options.body === undefined ? 'Arbitrary content for a test object' : options.body;
      const params = {Bucket: this.bucketName, Key: options.key, Body: body, ServerSideEncryption: 'AES256'};

      winston.log('info', 'Requested POST on bucket {%s}', this.bucketName);
      s3.putObject(params, function (err, data) {
        if (err) {
          winston.log('error', 'Error uploading data: ', err, err.message);
          throw err.message;
        } else {
          winston.log('info', 'Successfully uploaded new object');
          resolve(data);
        }
      });

    });
  }

.then(res => {
      requestId = res.body.id
      requestIds.push(requestId)
      checkPositions()
      winston.log('info', 'New submission request created.', res.body)
    })
}

const deferred = q.defer();
  try {
    let promise = null;
    if (message) {
      message = JSON.parse(message);
      if (message.operation === 'tableDelete') promise = _tableDelete(message.appId, message.tableName, message.db);
      else if (message.operation === 'appDelete') promise = _appDelete(message.appId, message.db);
      else promise = _columnDelete(message.appId, message.tableName, message.columnName, message.db);
    }
    promise.then(() => {
      deferred.resolve();
    }, (err) => {
      deferred.reject(err);
    });
  } catch (err) {
    winston.log('error', {
      error: String(err),
      stack: new Error().stack,
    });
    deferred.reject(err);
  }
  return deferred.promise;
}

var speak = false;
  var hasRule = false;

  var rules = SARAH.ConfigManager.getConfig().rules
  if (!rules){ return false; }
  
  for (var i = 0 ; i < rules.length ; i++){
    try {
      var rule = rules[i];
      if (rule['disabled'] == 'true'){ continue; }
      if (rule['if'] != cmd){ continue; } hasRule = true;
      if (rule['script']){ eval(rule['script']); }
      if (rule['then'] == 'speak'){ speak = true; continue; }
      if (!rule['then']){ continue; }
      SARAH.run(rule['then'], options);
    } catch(ex) { winston.log('warn', 'Rule: ',ex); }
  }
  
  return hasRule && !speak;
}

forwardRTCMessage: function(clientId, data) {
		if (!data.to) {
			logger.log('debug', 'forwardRTCMessage: no destination');
			return;
		}

		var client = this.clients[data.to];
		if (!client) {
			logger.log('debug', 'forwardRTCMessage: destination not an active client');
			return;
		}
		data.from = clientId;
		this.send(client, 'rtcMessage', data);
	},

export async function verifyUser(req: Request, res: Response) {
  const { username, token } = req.body;

  if (token !== VERIFY_USER_TOKEN) {
    return res.status(401).end();
  }

  const verifyRequest = await JoinGameRequest.findOne({ username });

  if (!verifyRequest) {
    return res.status(404).end();
  }

  winston.log('info', 'verifyRequest', [
    verifyRequest.username,
    verifyRequest.verified,
    verifyRequest.expiresAt,
    verifyRequest.gameId,
  ]);

  if (verifyRequest.verified) {
    return res.status(401).end();
  }

  if (verifyRequest.expiresAt < new Date()) {
    return res.status(408).end();
  }

  const user = await getUser(verifyRequest.username);
  const game = await Game.findById(verifyRequest.gameId);