logjs4 0.0.1-security → 6.9.1

package/lib/appenders/multiprocess.js

@@ -0,0 +1,191 @@
+const debug = require('debug')('log4js:multiprocess');
+const net = require('net');
+const LoggingEvent = require('../LoggingEvent');
+
+const END_MSG = '__LOG4JS__';
+
+/**
+ * Creates a server, listening on config.loggerPort, config.loggerHost.
+ * Output goes to config.actualAppender (config.appender is used to
+ * set up that appender).
+ */
+function logServer(config, actualAppender, levels) {
+  /**
+   * Takes a utf-8 string, returns an object with
+   * the correct log properties.
+   */
+  function deserializeLoggingEvent(clientSocket, msg) {
+    debug('(master) deserialising log event');
+    const loggingEvent = LoggingEvent.deserialise(msg);
+    loggingEvent.remoteAddress = clientSocket.remoteAddress;
+    loggingEvent.remotePort = clientSocket.remotePort;
+
+    return loggingEvent;
+  }
+
+  const server = net.createServer((clientSocket) => {
+    debug('(master) connection received');
+    clientSocket.setEncoding('utf8');
+    let logMessage = '';
+
+    function logTheMessage(msg) {
+      debug('(master) deserialising log event and sending to actual appender');
+      actualAppender(deserializeLoggingEvent(clientSocket, msg));
+    }
+
+    function chunkReceived(chunk) {
+      debug('(master) chunk of data received');
+      let event;
+      logMessage += chunk || '';
+      if (logMessage.indexOf(END_MSG) > -1) {
+        event = logMessage.slice(0, logMessage.indexOf(END_MSG));
+        logTheMessage(event);
+        logMessage = logMessage.slice(event.length + END_MSG.length) || '';
+        // check for more, maybe it was a big chunk
+        chunkReceived();
+      }
+    }
+
+    function handleError(error) {
+      const loggingEvent = {
+        startTime: new Date(),
+        categoryName: 'log4js',
+        level: levels.ERROR,
+        data: ['A worker log process hung up unexpectedly', error],
+        remoteAddress: clientSocket.remoteAddress,
+        remotePort: clientSocket.remotePort,
+      };
+      actualAppender(loggingEvent);
+    }
+
+    clientSocket.on('data', chunkReceived);
+    clientSocket.on('end', chunkReceived);
+    clientSocket.on('error', handleError);
+  });
+
+  server.listen(
+    config.loggerPort || 5000,
+    config.loggerHost || 'localhost',
+    (e) => {
+      debug('(master) master server listening, error was ', e);
+      // allow the process to exit, if this is the only socket active
+      server.unref();
+    }
+  );
+
+  function app(event) {
+    debug('(master) log event sent directly to actual appender (local event)');
+    return actualAppender(event);
+  }
+
+  app.shutdown = function (cb) {
+    debug('(master) master shutdown called, closing server');
+    server.close(cb);
+  };
+
+  return app;
+}
+
+function workerAppender(config) {
+  let canWrite = false;
+  const buffer = [];
+  let socket;
+  let shutdownAttempts = 3;
+
+  function write(loggingEvent) {
+    debug('(worker) Writing log event to socket');
+    socket.write(loggingEvent.serialise(), 'utf8');
+    socket.write(END_MSG, 'utf8');
+  }
+
+  function emptyBuffer() {
+    let evt;
+    debug('(worker) emptying worker buffer');
+    while ((evt = buffer.shift())) {
+      write(evt);
+    }
+  }
+
+  function createSocket() {
+    debug(
+      `(worker) worker appender creating socket to ${
+        config.loggerHost || 'localhost'
+      }:${config.loggerPort || 5000}`
+    );
+    socket = net.createConnection(
+      config.loggerPort || 5000,
+      config.loggerHost || 'localhost'
+    );
+    socket.on('connect', () => {
+      debug('(worker) worker socket connected');
+      emptyBuffer();
+      canWrite = true;
+    });
+    socket.on('timeout', socket.end.bind(socket));
+    socket.on('error', (e) => {
+      debug('connection error', e);
+      canWrite = false;
+      emptyBuffer();
+    });
+    socket.on('close', createSocket);
+  }
+
+  createSocket();
+
+  function log(loggingEvent) {
+    if (canWrite) {
+      write(loggingEvent);
+    } else {
+      debug(
+        '(worker) worker buffering log event because it cannot write at the moment'
+      );
+      buffer.push(loggingEvent);
+    }
+  }
+  log.shutdown = function (cb) {
+    debug('(worker) worker shutdown called');
+    if (buffer.length && shutdownAttempts) {
+      debug('(worker) worker buffer has items, waiting 100ms to empty');
+      shutdownAttempts -= 1;
+      setTimeout(() => {
+        log.shutdown(cb);
+      }, 100);
+    } else {
+      socket.removeAllListeners('close');
+      socket.end(cb);
+    }
+  };
+  return log;
+}
+
+function createAppender(config, appender, levels) {
+  if (config.mode === 'master') {
+    debug('Creating master appender');
+    return logServer(config, appender, levels);
+  }
+
+  debug('Creating worker appender');
+  return workerAppender(config);
+}
+
+function configure(config, layouts, findAppender, levels) {
+  let appender;
+  debug(`configure with mode = ${config.mode}`);
+  if (config.mode === 'master') {
+    if (!config.appender) {
+      debug(`no appender found in config ${config}`);
+      throw new Error('multiprocess master must have an "appender" defined');
+    }
+    debug(`actual appender is ${config.appender}`);
+    appender = findAppender(config.appender);
+    if (!appender) {
+      debug(`actual appender "${config.appender}" not found`);
+      throw new Error(
+        `multiprocess master appender "${config.appender}" not defined`
+      );
+    }
+  }
+  return createAppender(config, appender, levels);
+}
+
+module.exports.configure = configure;

package/lib/appenders/noLogFilter.js

@@ -0,0 +1,43 @@
+const debug = require('debug')('log4js:noLogFilter');
+
+/**
+ * The function removes empty or null regexp from the array
+ * @param {string[]} regexp
+ * @returns {string[]} a filtered string array with not empty or null regexp
+ */
+function removeNullOrEmptyRegexp(regexp) {
+  const filtered = regexp.filter((el) => el != null && el !== '');
+  return filtered;
+}
+
+/**
+ * Returns a function that will exclude the events in case they match
+ * with the regular expressions provided
+ * @param {(string|string[])} filters contains the regexp that will be used for the evaluation
+ * @param {*} appender
+ * @returns {function}
+ */
+function noLogFilter(filters, appender) {
+  return (logEvent) => {
+    debug(`Checking data: ${logEvent.data} against filters: ${filters}`);
+    if (typeof filters === 'string') {
+      filters = [filters];
+    }
+    filters = removeNullOrEmptyRegexp(filters);
+    const regex = new RegExp(filters.join('|'), 'i');
+    if (
+      filters.length === 0 ||
+      logEvent.data.findIndex((value) => regex.test(value)) < 0
+    ) {
+      debug('Not excluded, sending to appender');
+      appender(logEvent);
+    }
+  };
+}
+
+function configure(config, layouts, findAppender) {
+  const appender = findAppender(config.appender);
+  return noLogFilter(config.exclude, appender);
+}
+
+module.exports.configure = configure;

package/lib/appenders/recording.js

@@ -0,0 +1,29 @@
+const debug = require('debug')('log4js:recording');
+
+const recordedEvents = [];
+
+function configure() {
+  return function (logEvent) {
+    debug(
+      `received logEvent, number of events now ${recordedEvents.length + 1}`
+    );
+    debug('log event was ', logEvent);
+    recordedEvents.push(logEvent);
+  };
+}
+
+function replay() {
+  return recordedEvents.slice();
+}
+
+function reset() {
+  recordedEvents.length = 0;
+}
+
+module.exports = {
+  configure,
+  replay,
+  playback: replay,
+  reset,
+  erase: reset,
+};

package/lib/appenders/stderr.js

@@ -0,0 +1,15 @@
+function stderrAppender(layout, timezoneOffset) {
+  return (loggingEvent) => {
+    process.stderr.write(`${layout(loggingEvent, timezoneOffset)}\n`);
+  };
+}
+
+function configure(config, layouts) {
+  let layout = layouts.colouredLayout;
+  if (config.layout) {
+    layout = layouts.layout(config.layout.type, config.layout);
+  }
+  return stderrAppender(layout, config.timezoneOffset);
+}
+
+module.exports.configure = configure;

package/lib/appenders/stdout.js

@@ -0,0 +1,15 @@
+function stdoutAppender(layout, timezoneOffset) {
+  return (loggingEvent) => {
+    process.stdout.write(`${layout(loggingEvent, timezoneOffset)}\n`);
+  };
+}
+
+function configure(config, layouts) {
+  let layout = layouts.colouredLayout;
+  if (config.layout) {
+    layout = layouts.layout(config.layout.type, config.layout);
+  }
+  return stdoutAppender(layout, config.timezoneOffset);
+}
+
+exports.configure = configure;

package/lib/appenders/tcp-server.js

@@ -0,0 +1,49 @@
+const debug = require('debug')('log4js:tcp-server');
+const net = require('net');
+const clustering = require('../clustering');
+const LoggingEvent = require('../LoggingEvent');
+
+const DELIMITER = '__LOG4JS__';
+
+exports.configure = (config) => {
+  debug('configure called with ', config);
+
+  const server = net.createServer((socket) => {
+    let dataSoFar = '';
+    const send = (data) => {
+      if (data) {
+        dataSoFar += data;
+        if (dataSoFar.indexOf(DELIMITER)) {
+          const events = dataSoFar.split(DELIMITER);
+          if (!dataSoFar.endsWith(DELIMITER)) {
+            dataSoFar = events.pop();
+          } else {
+            dataSoFar = '';
+          }
+          events
+            .filter((e) => e.length)
+            .forEach((e) => {
+              clustering.send(LoggingEvent.deserialise(e));
+            });
+        } else {
+          dataSoFar = '';
+        }
+      }
+    };
+    socket.setEncoding('utf8');
+    socket.on('data', send);
+    socket.on('end', send);
+  });
+
+  server.listen(config.port || 5000, config.host || 'localhost', () => {
+    debug(`listening on ${config.host || 'localhost'}:${config.port || 5000}`);
+    server.unref();
+  });
+
+  return {
+    shutdown: (cb) => {
+      debug('shutdown called.');
+      server.close(cb);
+    },
+  };
+};

package/lib/appenders/tcp.js

@@ -0,0 +1,92 @@
+const debug = require('debug')('log4js:tcp');
+const net = require('net');
+
+function appender(config, layout) {
+  let canWrite = false;
+  const buffer = [];
+  let socket;
+  let shutdownAttempts = 3;
+  let endMsg = '__LOG4JS__';
+
+  function write(loggingEvent) {
+    debug('Writing log event to socket');
+    canWrite = socket.write(`${layout(loggingEvent)}${endMsg}`, 'utf8');
+  }
+
+  function emptyBuffer() {
+    let evt;
+    debug('emptying buffer');
+    while ((evt = buffer.shift())) {
+      write(evt);
+    }
+  }
+
+  function createSocket() {
+    debug(
+      `appender creating socket to ${config.host || 'localhost'}:${
+        config.port || 5000
+      }`
+    );
+    endMsg = `${config.endMsg || '__LOG4JS__'}`;
+    socket = net.createConnection(
+      config.port || 5000,
+      config.host || 'localhost'
+    );
+    socket.on('connect', () => {
+      debug('socket connected');
+      emptyBuffer();
+      canWrite = true;
+    });
+    socket.on('drain', () => {
+      debug('drain event received, emptying buffer');
+      canWrite = true;
+      emptyBuffer();
+    });
+    socket.on('timeout', socket.end.bind(socket));
+    socket.on('error', (e) => {
+      debug('connection error', e);
+      canWrite = false;
+      emptyBuffer();
+    });
+    socket.on('close', createSocket);
+  }
+
+  createSocket();
+
+  function log(loggingEvent) {
+    if (canWrite) {
+      write(loggingEvent);
+    } else {
+      debug('buffering log event because it cannot write at the moment');
+      buffer.push(loggingEvent);
+    }
+  }
+
+  log.shutdown = function (cb) {
+    debug('shutdown called');
+    if (buffer.length && shutdownAttempts) {
+      debug('buffer has items, waiting 100ms to empty');
+      shutdownAttempts -= 1;
+      setTimeout(() => {
+        log.shutdown(cb);
+      }, 100);
+    } else {
+      socket.removeAllListeners('close');
+      socket.end(cb);
+    }
+  };
+  return log;
+}
+
+function configure(config, layouts) {
+  debug(`configure with config = ${config}`);
+  let layout = function (loggingEvent) {
+    return loggingEvent.serialise();
+  };
+  if (config.layout) {
+    layout = layouts.layout(config.layout.type, config.layout);
+  }
+  return appender(config, layout);
+}
+
+module.exports.configure = configure;

package/lib/categories.js

@@ -0,0 +1,219 @@
+const debug = require('debug')('log4js:categories');
+const configuration = require('./configuration');
+const levels = require('./levels');
+const appenders = require('./appenders');
+
+const categories = new Map();
+
+/**
+ * Add inherited config to this category.  That includes extra appenders from parent,
+ * and level, if none is set on this category.
+ * This is recursive, so each parent also gets loaded with inherited appenders.
+ * Inheritance is blocked if a category has inherit=false
+ * @param  {*} config
+ * @param  {*} category the child category
+ * @param  {string} categoryName dotted path to category
+ * @return {void}
+ */
+function inheritFromParent(config, category, categoryName) {
+  if (category.inherit === false) return;
+  const lastDotIndex = categoryName.lastIndexOf('.');
+  if (lastDotIndex < 0) return; // category is not a child
+  const parentCategoryName = categoryName.slice(0, lastDotIndex);
+  let parentCategory = config.categories[parentCategoryName];
+
+  if (!parentCategory) {
+    // parent is missing, so implicitly create it, so that it can inherit from its parents
+    parentCategory = { inherit: true, appenders: [] };
+  }
+
+  // make sure parent has had its inheritance taken care of before pulling its properties to this child
+  inheritFromParent(config, parentCategory, parentCategoryName);
+
+  // if the parent is not in the config (because we just created it above),
+  // and it inherited a valid configuration, add it to config.categories
+  if (
+    !config.categories[parentCategoryName] &&
+    parentCategory.appenders &&
+    parentCategory.appenders.length &&
+    parentCategory.level
+  ) {
+    config.categories[parentCategoryName] = parentCategory;
+  }
+
+  category.appenders = category.appenders || [];
+  category.level = category.level || parentCategory.level;
+
+  // merge in appenders from parent (parent is already holding its inherited appenders)
+  parentCategory.appenders.forEach((ap) => {
+    if (!category.appenders.includes(ap)) {
+      category.appenders.push(ap);
+    }
+  });
+  category.parent = parentCategory;
+}
+
+/**
+ * Walk all categories in the config, and pull down any configuration from parent to child.
+ * This includes inherited appenders, and level, where level is not set.
+ * Inheritance is skipped where a category has inherit=false.
+ * @param  {*} config
+ */
+function addCategoryInheritance(config) {
+  if (!config.categories) return;
+  const categoryNames = Object.keys(config.categories);
+  categoryNames.forEach((name) => {
+    const category = config.categories[name];
+    // add inherited appenders and level to this category
+    inheritFromParent(config, category, name);
+  });
+}
+
+configuration.addPreProcessingListener((config) =>
+  addCategoryInheritance(config)
+);
+
+configuration.addListener((config) => {
+  configuration.throwExceptionIf(
+    config,
+    configuration.not(configuration.anObject(config.categories)),
+    'must have a property "categories" of type object.'
+  );
+
+  const categoryNames = Object.keys(config.categories);
+  configuration.throwExceptionIf(
+    config,
+    configuration.not(categoryNames.length),
+    'must define at least one category.'
+  );
+
+  categoryNames.forEach((name) => {
+    const category = config.categories[name];
+    configuration.throwExceptionIf(
+      config,
+      [
+        configuration.not(category.appenders),
+        configuration.not(category.level),
+      ],
+      `category "${name}" is not valid (must be an object with properties "appenders" and "level")`
+    );
+
+    configuration.throwExceptionIf(
+      config,
+      configuration.not(Array.isArray(category.appenders)),
+      `category "${name}" is not valid (appenders must be an array of appender names)`
+    );
+
+    configuration.throwExceptionIf(
+      config,
+      configuration.not(category.appenders.length),
+      `category "${name}" is not valid (appenders must contain at least one appender name)`
+    );
+
+    if (Object.prototype.hasOwnProperty.call(category, 'enableCallStack')) {
+      configuration.throwExceptionIf(
+        config,
+        typeof category.enableCallStack !== 'boolean',
+        `category "${name}" is not valid (enableCallStack must be boolean type)`
+      );
+    }
+
+    category.appenders.forEach((appender) => {
+      configuration.throwExceptionIf(
+        config,
+        configuration.not(appenders.get(appender)),
+        `category "${name}" is not valid (appender "${appender}" is not defined)`
+      );
+    });
+
+    configuration.throwExceptionIf(
+      config,
+      configuration.not(levels.getLevel(category.level)),
+      `category "${name}" is not valid (level "${category.level}" not recognised;` +
+        ` valid levels are ${levels.levels.join(', ')})`
+    );
+  });
+
+  configuration.throwExceptionIf(
+    config,
+    configuration.not(config.categories.default),
+    'must define a "default" category.'
+  );
+});
+
+const setup = (config) => {
+  categories.clear();
+  if (!config) {
+    return;
+  }
+
+  const categoryNames = Object.keys(config.categories);
+  categoryNames.forEach((name) => {
+    const category = config.categories[name];
+    const categoryAppenders = [];
+    category.appenders.forEach((appender) => {
+      categoryAppenders.push(appenders.get(appender));
+      debug(`Creating category ${name}`);
+      categories.set(name, {
+        appenders: categoryAppenders,
+        level: levels.getLevel(category.level),
+        enableCallStack: category.enableCallStack || false,
+      });
+    });
+  });
+};
+
+const init = () => {
+  setup();
+};
+init();
+
+configuration.addListener(setup);
+
+const configForCategory = (category) => {
+  debug(`configForCategory: searching for config for ${category}`);
+  if (categories.has(category)) {
+    debug(`configForCategory: ${category} exists in config, returning it`);
+    return categories.get(category);
+  }
+
+  let sourceCategoryConfig;
+  if (category.indexOf('.') > 0) {
+    debug(`configForCategory: ${category} has hierarchy, cloning from parents`);
+    sourceCategoryConfig = {
+      ...configForCategory(category.slice(0, category.lastIndexOf('.'))),
+    };
+  } else {
+    if (!categories.has('default')) {
+      setup({ categories: { default: { appenders: ['out'], level: 'OFF' } } });
+    }
+    debug('configForCategory: cloning default category');
+    sourceCategoryConfig = { ...categories.get('default') };
+  }
+  categories.set(category, sourceCategoryConfig);
+  return sourceCategoryConfig;
+};
+
+const appendersForCategory = (category) =>
+  configForCategory(category).appenders;
+
+const getLevelForCategory = (category) => configForCategory(category).level;
+const setLevelForCategory = (category, level) => {
+  configForCategory(category).level = level;
+};
+
+const getEnableCallStackForCategory = (category) =>
+  configForCategory(category).enableCallStack === true;
+const setEnableCallStackForCategory = (category, useCallStack) => {
+  configForCategory(category).enableCallStack = useCallStack;
+};
+
+module.exports = categories;
+module.exports = Object.assign(module.exports, {
+  appendersForCategory,
+  getLevelForCategory,
+  setLevelForCategory,
+  getEnableCallStackForCategory,
+  setEnableCallStackForCategory,
+  init,
+});