vnfmarket/src/main/webapp/vnfmarket/node_modules/log4js/lib/appenders/clustered.js

   1 "use strict";
   2
   3 var cluster = require('cluster');
   4 var log4js = require('../log4js');
   5
   6 /**
   7  * Takes a loggingEvent object, returns string representation of it.
   8  */
   9 function serializeLoggingEvent(loggingEvent) {
  10         // JSON.stringify(new Error('test')) returns {}, which is not really useful for us.
  11         // The following allows us to serialize errors correctly.
  12         for (var i = 0; i < loggingEvent.data.length; i++) {
  13                 var item = loggingEvent.data[i];
  14                 // Validate that we really are in this case
  15                 if (item && item.stack && JSON.stringify(item) === '{}') {
  16                         loggingEvent.data[i] = {stack : item.stack};
  17                 }
  18         }
  19         return JSON.stringify(loggingEvent);
  20 }
  21
  22 /**
  23  * Takes a string, returns an object with
  24  * the correct log properties.
  25  *
  26  * This method has been "borrowed" from the `multiprocess` appender
  27  * by `nomiddlename`
  28  * (https://github.com/nomiddlename/log4js-node/blob/master/lib/appenders/multiprocess.js)
  29  *
  30  * Apparently, node.js serializes everything to strings when using `process.send()`,
  31  * so we need smart deserialization that will recreate log date and level for further
  32  * processing by log4js internals.
  33  */
  34 function deserializeLoggingEvent(loggingEventString) {
  35
  36         var loggingEvent;
  37
  38         try {
  39
  40                 loggingEvent = JSON.parse(loggingEventString);
  41                 loggingEvent.startTime = new Date(loggingEvent.startTime);
  42                 loggingEvent.level = log4js.levels.toLevel(loggingEvent.level.levelStr);
  43                 // Unwrap serialized errors
  44                 for (var i = 0; i < loggingEvent.data.length; i++) {
  45                         var item = loggingEvent.data[i];
  46                         if (item && item.stack) {
  47                                 loggingEvent.data[i] = item.stack;
  48                         }
  49                 }
  50
  51         } catch (e) {
  52
  53                 // JSON.parse failed, just log the contents probably a naughty.
  54                 loggingEvent = {
  55                         startTime: new Date(),
  56                         categoryName: 'log4js',
  57                         level: log4js.levels.ERROR,
  58                         data: [ 'Unable to parse log:', loggingEventString ]
  59                 };
  60         }
  61         return loggingEvent;
  62 }
  63
  64 /**
  65  * Creates an appender.
  66  *
  67  * If the current process is a master (`cluster.isMaster`), then this will be a "master appender".
  68  * Otherwise this will be a worker appender, that just sends loggingEvents to the master process.
  69  *
  70  * If you are using this method directly, make sure to provide it with `config.actualAppenders`
  71  * array of actual appender instances.
  72  *
  73  * Or better use `configure(config, options)`
  74  */
  75 function createAppender(config) {
  76
  77         if (cluster.isMaster) {
  78
  79                 var masterAppender = function(loggingEvent) {
  80
  81                         if (config.actualAppenders) {
  82                                 var size = config.actualAppenders.length;
  83                                 for(var i = 0; i < size; i++) {
  84             if (
  85                                                         !config.appenders[i].category ||
  86                                                         config.appenders[i].category === loggingEvent.categoryName
  87                                                 ) {
  88                                                         // Relying on the index is not a good practice but otherwise
  89                                                         // the change would have been bigger.
  90                                                         config.actualAppenders[i](loggingEvent);
  91                         }
  92                                 }
  93                         }
  94                 };
  95
  96                 // Listen on new workers
  97                 cluster.on('fork', function(worker) {
  98
  99                         worker.on('message', function(message) {
 100                                 if (message.type && message.type === '::log-message') {
 101                                         var loggingEvent = deserializeLoggingEvent(message.event);
 102
 103                                         // Adding PID metadata
 104                                         loggingEvent.pid = worker.process.pid;
 105                                         loggingEvent.cluster = {
 106                                                 master: process.pid,
 107                                                 worker: worker.process.pid,
 108                                                 workerId: worker.id
 109                                         };
 110
 111                                         masterAppender(loggingEvent);
 112                                 }
 113                         });
 114
 115                 });
 116
 117                 return masterAppender;
 118
 119         } else {
 120
 121                 return function(loggingEvent) {
 122                         // If inside the worker process, then send the logger event to master.
 123                         if (cluster.isWorker) {
 124                                 // console.log("worker " + cluster.worker.id + " is sending message");
 125                                 process.send({ type: '::log-message', event: serializeLoggingEvent(loggingEvent)});
 126                         }
 127                 };
 128         }
 129 }
 130
 131 function configure(config, options) {
 132
 133         if (config.appenders && cluster.isMaster) {
 134
 135                 var size = config.appenders.length;
 136                 config.actualAppenders = new Array(size);
 137
 138                 for(var i = 0; i < size; i++) {
 139
 140                         log4js.loadAppender(config.appenders[i].type);
 141                         config.actualAppenders[i] = log4js.appenderMakers[config.appenders[i].type](
 142                                 config.appenders[i],
 143                                 options
 144                         );
 145
 146                 }
 147         }
 148
 149         return createAppender(config);
 150 }
 151
 152 exports.appender = createAppender;
 153 exports.configure = configure;