vnfmarket/src/main/webapp/vnfmarket/node_modules/log4js/lib/layouts.js

   1 "use strict";
   2 var dateFormat = require('./date_format')
   3 , os = require('os')
   4 , eol = os.EOL || '\n'
   5 , util = require('util')
   6 , semver = require('semver')
   7 , replacementRegExp = /%[sdj]/g
   8 , layoutMakers = {
   9   "messagePassThrough": function() { return messagePassThroughLayout; },
  10   "basic": function() { return basicLayout; },
  11   "colored": function() { return colouredLayout; },
  12   "coloured": function() { return colouredLayout; },
  13   "pattern": function (config) {
  14     return patternLayout(config && config.pattern, config && config.tokens);
  15         },
  16   "dummy": function() { return dummyLayout; }
  17 }
  18 , colours = {
  19   ALL: "grey",
  20   TRACE: "blue",
  21   DEBUG: "cyan",
  22   INFO: "green",
  23   WARN: "yellow",
  24   ERROR: "red",
  25   FATAL: "magenta",
  26   OFF: "grey"
  27 };
  28
  29 function wrapErrorsWithInspect(items) {
  30   return items.map(function(item) {
  31     if ((item instanceof Error) && item.stack) {
  32       return { inspect: function() {
  33         if (semver.satisfies(process.version, '>=6')) {
  34           return util.format(item);
  35         } else {
  36           return util.format(item) + '\n' + item.stack;
  37         }
  38       } };
  39     } else {
  40       return item;
  41     }
  42   });
  43 }
  44
  45 function formatLogData(logData) {
  46   var data = Array.isArray(logData) ? logData : Array.prototype.slice.call(arguments);
  47   return util.format.apply(util, wrapErrorsWithInspect(data));
  48 }
  49
  50 var styles = {
  51     //styles
  52   'bold'      : [1,  22],
  53   'italic'    : [3,  23],
  54   'underline' : [4,  24],
  55   'inverse'   : [7,  27],
  56   //grayscale
  57   'white'     : [37, 39],
  58   'grey'      : [90, 39],
  59   'black'     : [90, 39],
  60   //colors
  61   'blue'      : [34, 39],
  62   'cyan'      : [36, 39],
  63   'green'     : [32, 39],
  64   'magenta'   : [35, 39],
  65   'red'       : [31, 39],
  66   'yellow'    : [33, 39]
  67 };
  68
  69 function colorizeStart(style) {
  70   return style ? '\x1B[' + styles[style][0] + 'm' : '';
  71 }
  72 function colorizeEnd(style) {
  73   return style ? '\x1B[' + styles[style][1] + 'm' : '';
  74 }
  75 /**
  76  * Taken from masylum's fork (https://github.com/masylum/log4js-node)
  77  */
  78 function colorize (str, style) {
  79   return colorizeStart(style) + str + colorizeEnd(style);
  80 }
  81
  82 function timestampLevelAndCategory(loggingEvent, colour, timezoneOffest) {
  83   var output = colorize(
  84     formatLogData(
  85       '[%s] [%s] %s - '
  86       , dateFormat.asString(loggingEvent.startTime, timezoneOffest)
  87       , loggingEvent.level
  88       , loggingEvent.categoryName
  89     )
  90     , colour
  91   );
  92   return output;
  93 }
  94
  95 /**
  96  * BasicLayout is a simple layout for storing the logs. The logs are stored
  97  * in following format:
  98  * <pre>
  99  * [startTime] [logLevel] categoryName - message\n
 100  * </pre>
 101  *
 102  * @author Stephan Strittmatter
 103  */
 104 function basicLayout (loggingEvent, timezoneOffset) {
 105   return timestampLevelAndCategory(
 106     loggingEvent,
 107     undefined,
 108     timezoneOffset
 109   ) + formatLogData(loggingEvent.data);
 110 }
 111
 112 /**
 113  * colouredLayout - taken from masylum's fork.
 114  * same as basicLayout, but with colours.
 115  */
 116 function colouredLayout (loggingEvent, timezoneOffset) {
 117   return timestampLevelAndCategory(
 118     loggingEvent,
 119     colours[loggingEvent.level.toString()],
 120     timezoneOffset
 121   ) + formatLogData(loggingEvent.data);
 122 }
 123
 124 function messagePassThroughLayout (loggingEvent) {
 125   return formatLogData(loggingEvent.data);
 126 }
 127
 128 function dummyLayout(loggingEvent) {
 129   return loggingEvent.data[0];
 130 }
 131
 132 /**
 133  * PatternLayout
 134  * Format for specifiers is %[padding].[truncation][field]{[format]}
 135  * e.g. %5.10p - left pad the log level by 5 characters, up to a max of 10
 136  * Fields can be any of:
 137  *  - %r time in toLocaleTimeString format
 138  *  - %p log level
 139  *  - %c log category
 140  *  - %h hostname
 141  *  - %m log data
 142  *  - %d date in various formats
 143  *  - %% %
 144  *  - %n newline
 145  *  - %z pid
 146  *  - %x{<tokenname>} add dynamic tokens to your log. Tokens are specified in the tokens parameter
 147  * You can use %[ and %] to define a colored block.
 148  *
 149  * Tokens are specified as simple key:value objects.
 150  * The key represents the token name whereas the value can be a string or function
 151  * which is called to extract the value to put in the log message. If token is not
 152  * found, it doesn't replace the field.
 153  *
 154  * A sample token would be: { "pid" : function() { return process.pid; } }
 155  *
 156  * Takes a pattern string, array of tokens and returns a layout function.
 157  * @param {String} Log format pattern String
 158  * @param {object} map object of different tokens
 159  * @param {number} timezone offset in minutes
 160  * @return {Function}
 161  * @author Stephan Strittmatter
 162  * @author Jan Schmidle
 163  */
 164 function patternLayout (pattern, tokens, timezoneOffset) {
 165   // jshint maxstatements:22
 166   var TTCC_CONVERSION_PATTERN  = "%r %p %c - %m%n";
 167   var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([\[\]cdhmnprzxy%])(\{([^\}]+)\})?|([^%]+)/;
 168
 169   pattern = pattern || TTCC_CONVERSION_PATTERN;
 170
 171   function categoryName(loggingEvent, specifier) {
 172     var loggerName = loggingEvent.categoryName;
 173     if (specifier) {
 174       var precision = parseInt(specifier, 10);
 175       var loggerNameBits = loggerName.split(".");
 176       if (precision < loggerNameBits.length) {
 177         loggerName = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
 178       }
 179     }
 180     return loggerName;
 181   }
 182
 183   function formatAsDate(loggingEvent, specifier) {
 184     var format = dateFormat.ISO8601_FORMAT;
 185     if (specifier) {
 186       format = specifier;
 187       // Pick up special cases
 188       if (format == "ISO8601") {
 189         format = dateFormat.ISO8601_FORMAT;
 190       } else if (format == "ISO8601_WITH_TZ_OFFSET") {
 191         format = dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT;
 192       } else if (format == "ABSOLUTE") {
 193         format = dateFormat.ABSOLUTETIME_FORMAT;
 194       } else if (format == "DATE") {
 195         format = dateFormat.DATETIME_FORMAT;
 196       }
 197     }
 198     // Format the date
 199     return dateFormat.asString(format, loggingEvent.startTime, timezoneOffset);
 200   }
 201
 202   function hostname() {
 203     return os.hostname().toString();
 204   }
 205
 206   function formatMessage(loggingEvent) {
 207     return formatLogData(loggingEvent.data);
 208   }
 209
 210   function endOfLine() {
 211     return eol;
 212   }
 213
 214   function logLevel(loggingEvent) {
 215     return loggingEvent.level.toString();
 216   }
 217
 218   function startTime(loggingEvent) {
 219     return dateFormat.asString('hh:mm:ss', loggingEvent.startTime, timezoneOffset);
 220   }
 221
 222   function startColour(loggingEvent) {
 223     return colorizeStart(colours[loggingEvent.level.toString()]);
 224   }
 225
 226   function endColour(loggingEvent) {
 227     return colorizeEnd(colours[loggingEvent.level.toString()]);
 228   }
 229
 230   function percent() {
 231     return '%';
 232   }
 233
 234   function pid(loggingEvent) {
 235     if (loggingEvent && loggingEvent.pid) {
 236       return loggingEvent.pid;
 237     } else {
 238       return process.pid;
 239     }
 240   }
 241
 242   function clusterInfo(loggingEvent, specifier) {
 243     if (loggingEvent.cluster && specifier) {
 244       return specifier
 245         .replace('%m', loggingEvent.cluster.master)
 246         .replace('%w', loggingEvent.cluster.worker)
 247         .replace('%i', loggingEvent.cluster.workerId);
 248     } else if (loggingEvent.cluster) {
 249       return loggingEvent.cluster.worker+'@'+loggingEvent.cluster.master;
 250     } else {
 251       return pid();
 252     }
 253   }
 254
 255   function userDefined(loggingEvent, specifier) {
 256     if (typeof(tokens[specifier]) !== 'undefined') {
 257       if (typeof(tokens[specifier]) === 'function') {
 258         return tokens[specifier](loggingEvent);
 259       } else {
 260         return tokens[specifier];
 261       }
 262     }
 263     return null;
 264   }
 265
 266   var replacers = {
 267     'c': categoryName,
 268     'd': formatAsDate,
 269     'h': hostname,
 270     'm': formatMessage,
 271     'n': endOfLine,
 272     'p': logLevel,
 273     'r': startTime,
 274     '[': startColour,
 275     ']': endColour,
 276     'y': clusterInfo,
 277     'z': pid,
 278     '%': percent,
 279     'x': userDefined
 280   };
 281
 282   function replaceToken(conversionCharacter, loggingEvent, specifier) {
 283     return replacers[conversionCharacter](loggingEvent, specifier);
 284   }
 285
 286   function truncate(truncation, toTruncate) {
 287     var len;
 288     if (truncation) {
 289       len = parseInt(truncation.substr(1), 10);
 290       return toTruncate.substring(0, len);
 291     }
 292
 293     return toTruncate;
 294   }
 295
 296   function pad(padding, toPad) {
 297     var len;
 298     if (padding) {
 299       if (padding.charAt(0) == "-") {
 300         len = parseInt(padding.substr(1), 10);
 301         // Right pad with spaces
 302         while (toPad.length < len) {
 303           toPad += " ";
 304         }
 305       } else {
 306         len = parseInt(padding, 10);
 307         // Left pad with spaces
 308         while (toPad.length < len) {
 309           toPad = " " + toPad;
 310         }
 311       }
 312     }
 313     return toPad;
 314   }
 315
 316   function truncateAndPad(toTruncAndPad, truncation, padding) {
 317     var replacement = toTruncAndPad;
 318     replacement = truncate(truncation, replacement);
 319     replacement = pad(padding, replacement);
 320     return replacement;
 321   }
 322
 323   return function(loggingEvent) {
 324     var formattedString = "";
 325     var result;
 326     var searchString = pattern;
 327
 328     while ((result = regex.exec(searchString))) {
 329       var matchedString = result[0];
 330       var padding = result[1];
 331       var truncation = result[2];
 332       var conversionCharacter = result[3];
 333       var specifier = result[5];
 334       var text = result[6];
 335
 336       // Check if the pattern matched was just normal text
 337       if (text) {
 338         formattedString += "" + text;
 339       } else {
 340         // Create a raw replacement string based on the conversion
 341         // character and specifier
 342         var replacement = replaceToken(conversionCharacter, loggingEvent, specifier);
 343         formattedString += truncateAndPad(replacement, truncation, padding);
 344       }
 345       searchString = searchString.substr(result.index + result[0].length);
 346     }
 347     return formattedString;
 348   };
 349
 350 }
 351
 352 module.exports = {
 353   basicLayout: basicLayout,
 354   messagePassThroughLayout: messagePassThroughLayout,
 355   patternLayout: patternLayout,
 356   colouredLayout: colouredLayout,
 357   coloredLayout: colouredLayout,
 358   dummyLayout: dummyLayout,
 359   addLayout: function(name, serializerGenerator) {
 360     layoutMakers[name] = serializerGenerator;
 361   },
 362   layout: function(name, config) {
 363     return layoutMakers[name] && layoutMakers[name](config);
 364   }
 365 };