Log response.

@param {function} log
329778
function(log) {
  var date = this.date.toISOString().substring(0, 19);
  var duration = new Date() - this.date;
  log(date + ' ' + this.ip + ' "' + this.method + ' ' + this.path + '" ' + this.status + ' ' + this._length + ' ' + duration);
}
1261327
function logHttpResponse (uniqueId, res) {
    // require log client
    if (!logClient) {
        return
    }
    // log response
    logClient.log('httpResponse', {
        httpRequestId: uniqueId.id,
        httpResponseBody: res.body,
        httpResponseHeader: res.rawHeaders,
        httpResponseCreateTime: microTimestamp(),
        httpResponseStatusCode: res.statusCode,

    })
}
699832
function log( func, msg ){
  var logline = '['+func+'] '+msg;

  if ( logInfo ) {
    if ( logInfoStr == '' ) {
      console.log( logline );      
    } else if ( logInfoStr.indexOf( func ) >= 0 ) { 
      console.log( logline );
    }
  }

  // send log to event broker
  if ( loggerEvents ) { 
    var logBroker = getEventBroker('log');
    logBroker.cleanupQueue( 1000 );
    logBroker.queueEvent( { text: logline, channel:'log' } );
  }
  
}
854896
function (log, seq, cb) {
    dag.logs.get(log, seq, function (err, entry) {
      if (err && err.notFound) return cb()
      if (err) return cb(err)
      if (entry.change > changes) return cb() // ensure snapshot

      entry.log = log
      entry.seq = seq

      var i = 0
      var loop = function () {
        if (i < entry.links.length) return sendHave(entry.links[i++], loop)
        entry.links = noarr // premature opt: less mem yo
        outgoing.push(entry, cb)
      }

      loop()
    })
  }
923737
function _logGeneration (db, id, response) {
  debug('Logging try for job ID %s', id)

  return db.logGeneration(id, response)
}
456096
function _log(message) {
    if (cluster.isMaster) {
        // write directly to the log file
        console.log(_format(message));
    }
    else {
        // send to master
        cluster.worker.process.send({
            type: "logging",
            data: {
                message: message,
                workerID: cluster.worker.id,
                pid: cluster.worker.process.pid
            }
        });
    }
}
10550
protected final <R extends Response> R logResponse(R response) {
    LOGGER.trace("{} - Sending {}", context.getCluster().member().address(), response);
    return response;
  }
1057312
function _logProgress(req) {
  req.on('response', function(resp) {
    var len = parseInt(resp.headers['content-length'], 10),
      bar = new ProgressBar('[:bar]', {
        complete: '=',
        incomplete: ' ',
        total: len,
        width: 100, // just use 100
      });

    req.on('data', function(chunk) {
      bar.tick(chunk.length);
    });
  });

  req.on('error', function(err) {
    console.log(err);
    _log('error', 'failed to download node sources,');
    process.exit(1);
  });

  return req;
}
210785
function log() {
  var _console;

  for (var _len = arguments.length, msgs = Array(_len), _key = 0; _key < _len; _key++) {
    msgs[_key] = arguments[_key];
  }

  (_console = console).log.apply(_console, _toConsumableArray(['' + _config2.default.name].concat(msgs)));
}
1049857
function LogEvent(timestamp, level, messageTemplate, properties, error) {
        this.timestamp = timestamp;
        this.level = level;
        this.messageTemplate = messageTemplate;
        this.properties = properties || {};
        this.error = error || null;
    }
802645
function log () {
    if (argv.stdin && argv.fix) {
      arguments[0] = opts.cmd + ': ' + arguments[0]
      console.error.apply(console, arguments)
    } else {
      console.log.apply(console, arguments)
    }
  }
523089
function logm() {
    var args = [].slice.call(arguments);
    var level = args.shift();
    if (logFor(level)) {
      var msg = args.shift();
      args.unshift(posix.getpid());
      args.unshift(level);
      args.unshift("[%s] m(%d): " + msg);
      logv(args);
    }
  }
226652
function Log() {
    var args = CopyArguments(arguments);
    var level = args.shift();
    args.unshift("[Thread] <"+threadId+">");
    args.unshift(level);
    process.send({name: "thread-log", args: SerializeForProcess(args)});
}
414173
public static void logResponse(
            Logger logger, RequestLog log, LogLevel requestLogLevel,
            Function<? super HttpHeaders, ? extends HttpHeaders> requestHeadersSanitizer,
            Function<Object, ?> requestContentSanitizer,
            Function<? super HttpHeaders, ? extends HttpHeaders> requestTrailersSanitizer,
            LogLevel successfulResponseLogLevel,
            LogLevel failedResponseLogLevel,
            Function<? super HttpHeaders, ? extends HttpHeaders> responseHeadersSanitizer,
            Function<Object, ?> responseContentSanitizer,
            Function<? super HttpHeaders, ? extends HttpHeaders> responseTrailersSanitizer,
            Function<? super Throwable, ? extends Throwable> responseCauseSanitizer) {

        final Throwable responseCause = log.responseCause();
        final LogLevel level = responseCause == null ? successfulResponseLogLevel
                                                     : failedResponseLogLevel;
        if (level.isEnabled(logger)) {
            final String responseStr = log.toStringResponseOnly(responseHeadersSanitizer,
                                                                responseContentSanitizer,
                                                                responseTrailersSanitizer);
            if (responseCause == null) {
                level.log(logger, RESPONSE_FORMAT, responseStr);
            } else {
                if (!requestLogLevel.isEnabled(logger)) {
                    // Request wasn't logged but this is an unsuccessful response, log the request too to help
                    // debugging.
                    level.log(logger, REQUEST_FORMAT, log.toStringRequestOnly(requestHeadersSanitizer,
                                                                              requestContentSanitizer,
                                                                              requestTrailersSanitizer));
                }

                final Throwable sanitizedResponseCause = responseCauseSanitizer.apply(responseCause);
                if (sanitizedResponseCause != null) {
                    level.log(logger, RESPONSE_FORMAT, responseStr, sanitizedResponseCause);
                } else {
                    level.log(logger, RESPONSE_FORMAT, responseStr);
                }
            }
        }
    }
384234
function logs(a) {
  return a.isIgnored?         ''
  :      a.log.length === 0?  ''
  :      /* otherwise */      '\n' + pad( 2
                                        , '=== Captured logs:\n'
                                        + a.log.map(function(x){
                                            return faded('- ' + show(x.log))})
                                          .join('\n') + '\n---\n')
}
669044
public function log(array $log)
    {
        if (null !== $this->config->getLoggerCallable()) {
            call_user_func_array($this->config->getLoggerCallable(), array($log));
        }
    }
726435
function log (out, desc) {
  logger.log(header())
  if (desc) {
    logger.log(desc)
  }
  logger.log(out)
  logger.log()
}