dox-foundation-demo node_modules/express/node_modules/connect/lib/middleware/logger.js

bytes

declaration
bytes

    Description

    Module dependencies.

    Source

    var bytes = require('bytes');
    • @param: {String,Function,Object}formator options
    • @return: {Function}

    Description

    Logger:

    Log requests with the given options or a format string.

    Options:

    • format Format string, see below for tokens
    • stream Output stream, defaults to stdout
    • buffer Buffer duration, defaults to 1000ms when true
    • immediate Write log line on request instead of response (for response times)

    Tokens:

    • :req[header] ex: :req[Accept]
    • :res[header] ex: :res[Content-Length]
    • :http-version
    • :response-time
    • :remote-addr
    • :date
    • :method
    • :url
    • :referrer
    • :user-agent
    • :status

    Formats:

    Pre-defined formats that ship with connect:

    • default ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"'
    • short ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms'
    • tiny ':method :url :status :res[content-length] - :response-time ms'
    • dev concise output colored by response status for development use

    Examples:

     connect.logger() // default
     connect.logger('short')
     connect.logger('tiny')
     connect.logger({ immediate: true, format: 'dev' })
     connect.logger(':method :url - :referrer')
     connect.logger(':req[content-type] -> :res[content-type]')
     connect.logger(function(tokens, req, res){ return 'some format string' })
    

    Defining Tokens:

    To define a token, simply invoke connect.logger.token() with the
    name and a callback function. The value returned is then available
    as ":type" in this case.

     connect.logger.token('type', function(req, res){ return req.headers['content-type']; })
    

    Defining Formats:

    All default formats are defined this way, however it's public API as well:

      connect.logger.format('name', 'string or function')
    

    Source

    exports = module.exports = function logger(options) {
      if ('object' == typeof options) {
        options = options || {};
      } else if (options) {
        options = { format: options };
      } else {
        options = {};
      }
    
      // output on request instead of response
      var immediate = options.immediate;
    
      // format name
      var fmt = exports[options.format] || options.format || exports.default;
    
      // compile format
      if ('function' != typeof fmt) fmt = compile(fmt);
    
      // options
      var stream = options.stream || process.stdout
        , buffer = options.buffer;
    
      // buffering support
      if (buffer) {
        var realStream = stream
          , interval = 'number' == typeof buffer
            ? buffer
            : defaultBufferDuration;
    
        // flush interval
        setInterval(function(){
          if (buf.length) {
            realStream.write(buf.join(''));
            buf.length = 0;
          }
        }, interval); 
    
        // swap the stream
        stream = {
          write: function(str){
            buf.push(str);
          }
        };
      }
    
      return function logger(req, res, next) {
        req._startTime = new Date;
    
        // immediate
        if (immediate) {
          var line = fmt(exports, req, res);
          if (null == line) return;
          stream.write(line + '\n');
        // proxy end to output logging
        } else {
          var end = res.end;
          res.end = function(chunk, encoding){
            res.end = end;
            res.end(chunk, encoding);
            var line = fmt(exports, req, res);
            if (null == line) return;
            stream.write(line + '\n');
          };
        }
    
    
        next();
      };
    };

    token

    method
    exports.token()
    • @param: {String}name
    • @param: {Function}fn
    • @return: {Object}exports for chaining

    Description

    Define a token function with the given name,
    and callback fn(req, res).

    Source

    exports.token = function(name, fn) {
      exports[name] = fn;
      return this;
    };

    format

    method
    exports.format()
    • @param: {String}name
    • @param: {String,Function}fmt
    • @return: {Object}exports for chaining

    Description

    Define a fmt with the given name.

    Source

    exports.format = function(name, str){
      exports[name] = str;
      return this;
    };

      Description

      Default format.

      Source

      exports.format('default', ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"');

        Description

        Short format.

        Source

        exports.format('short', ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms');

          Description

          Tiny format.

          Source

          exports.format('tiny', ':method :url :status :res[content-length] - :response-time ms');

            Description

            dev (colored)

            Source

            exports.format('dev', function(tokens, req, res){
              var status = res.statusCode
                , len = parseInt(res.getHeader('Content-Length'), 10)
                , color = 32;
            
              if (status >= 500) color = 31
              else if (status >= 400) color = 33
              else if (status >= 300) color = 36;
            
              len = isNaN(len)
                ? ''
                : len = ' - ' + bytes(len);
            
              return '\x1b[90m' + req.method
                + ' ' + req.originalUrl + ' '
                + '\x1b[' + color + 'm' + res.statusCode
                + ' \x1b[90m'
                + (new Date - req._startTime)
                + 'ms' + len
                + '\x1b[0m';
            });

              Description

              request url

              Source

              exports.token('url', function(req){
                return req.originalUrl || req.url;
              });

                Description

                request method

                Source

                exports.token('method', function(req){
                  return req.method;
                });

                  Description

                  response time in milliseconds

                  Source

                  exports.token('response-time', function(req){
                    return new Date - req._startTime;
                  });

                    Description

                    UTC date

                    Source

                    exports.token('date', function(){
                      return new Date().toUTCString();
                    });

                      Description

                      response status code

                      Source

                      exports.token('status', function(req, res){
                        return res.statusCode;
                      });

                        Description

                        normalized referrer

                        Source

                        exports.token('referrer', function(req){
                          return req.headers['referer'] || req.headers['referrer'];
                        });

                          Description

                          remote address

                          Source

                          exports.token('remote-addr', function(req){
                            if (req.ip) return req.ip;
                            var sock = req.socket;
                            if (sock.socket) return sock.socket.remoteAddress;
                            return sock.remoteAddress;
                          });

                            Description

                            HTTP version

                            Source

                            exports.token('http-version', function(req){
                              return req.httpVersionMajor + '.' + req.httpVersionMinor;
                            });

                              Description

                              UA string

                              Source

                              exports.token('user-agent', function(req){
                                return req.headers['user-agent'];
                              });

                                Description

                                request header

                                Source

                                exports.token('req', function(req, res, field){
                                  return req.headers[field.toLowerCase()];
                                });

                                  Description

                                  response header

                                  Source

                                  exports.token('res', function(req, res, field){
                                    return (res._headers || {})[field.toLowerCase()];
                                  });