logjs4 0.0.1-security → 6.9.1

package/lib/appenders/fileSync.js

@@ -0,0 +1,258 @@
+const debug = require('debug')('log4js:fileSync');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const eol = os.EOL;
+
+function touchFile(file, options) {
+  // attempt to create the directory
+  const mkdir = (dir) => {
+    try {
+      return fs.mkdirSync(dir, { recursive: true });
+    } catch (e) {
+      // backward-compatible fs.mkdirSync for nodejs pre-10.12.0 (without recursive option)
+      // recursive creation of parent first
+      if (e.code === 'ENOENT') {
+        mkdir(path.dirname(dir));
+        return mkdir(dir);
+      }
+
+      // throw error for all except EEXIST and EROFS (read-only filesystem)
+      if (e.code !== 'EEXIST' && e.code !== 'EROFS') {
+        throw e;
+      }
+
+      // EEXIST: throw if file and not directory
+      // EROFS : throw if directory not found
+      else {
+        try {
+          if (fs.statSync(dir).isDirectory()) {
+            return dir;
+          }
+          throw e;
+        } catch (err) {
+          throw e;
+        }
+      }
+    }
+  };
+  mkdir(path.dirname(file));
+
+  // try to throw EISDIR, EROFS, EACCES
+  fs.appendFileSync(file, '', { mode: options.mode, flag: options.flags });
+}
+
+class RollingFileSync {
+  constructor(filename, maxLogSize, backups, options) {
+    debug('In RollingFileStream');
+
+    if (maxLogSize < 0) {
+      throw new Error(`maxLogSize (${maxLogSize}) should be > 0`);
+    }
+
+    this.filename = filename;
+    this.size = maxLogSize;
+    this.backups = backups;
+    this.options = options;
+    this.currentSize = 0;
+
+    function currentFileSize(file) {
+      let fileSize = 0;
+
+      try {
+        fileSize = fs.statSync(file).size;
+      } catch (e) {
+        // file does not exist
+        touchFile(file, options);
+      }
+      return fileSize;
+    }
+
+    this.currentSize = currentFileSize(this.filename);
+  }
+
+  shouldRoll() {
+    debug(
+      'should roll with current size %d, and max size %d',
+      this.currentSize,
+      this.size
+    );
+    return this.currentSize >= this.size;
+  }
+
+  roll(filename) {
+    const that = this;
+    const nameMatcher = new RegExp(`^${path.basename(filename)}`);
+
+    function justTheseFiles(item) {
+      return nameMatcher.test(item);
+    }
+
+    function index(filename_) {
+      return (
+        parseInt(filename_.slice(`${path.basename(filename)}.`.length), 10) || 0
+      );
+    }
+
+    function byIndex(a, b) {
+      return index(a) - index(b);
+    }
+
+    function increaseFileIndex(fileToRename) {
+      const idx = index(fileToRename);
+      debug(`Index of ${fileToRename} is ${idx}`);
+      if (that.backups === 0) {
+        fs.truncateSync(filename, 0);
+      } else if (idx < that.backups) {
+        // on windows, you can get a EEXIST error if you rename a file to an existing file
+        // so, we'll try to delete the file we're renaming to first
+        try {
+          fs.unlinkSync(`${filename}.${idx + 1}`);
+        } catch (e) {
+          // ignore err: if we could not delete, it's most likely that it doesn't exist
+        }
+
+        debug(`Renaming ${fileToRename} -> ${filename}.${idx + 1}`);
+        fs.renameSync(
+          path.join(path.dirname(filename), fileToRename),
+          `${filename}.${idx + 1}`
+        );
+      }
+    }
+
+    function renameTheFiles() {
+      // roll the backups (rename file.n to file.n+1, where n <= numBackups)
+      debug('Renaming the old files');
+
+      const files = fs.readdirSync(path.dirname(filename));
+      files
+        .filter(justTheseFiles)
+        .sort(byIndex)
+        .reverse()
+        .forEach(increaseFileIndex);
+    }
+
+    debug('Rolling, rolling, rolling');
+    renameTheFiles();
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  write(chunk, encoding) {
+    const that = this;
+
+    function writeTheChunk() {
+      debug('writing the chunk to the file');
+      that.currentSize += chunk.length;
+      fs.appendFileSync(that.filename, chunk);
+    }
+
+    debug('in write');
+
+    if (this.shouldRoll()) {
+      this.currentSize = 0;
+      this.roll(this.filename);
+    }
+
+    writeTheChunk();
+  }
+}
+
+/**
+ * File Appender writing the logs to a text file. Supports rolling of logs by size.
+ *
+ * @param file the file log messages will be written to
+ * @param layout a function that takes a logevent and returns a string
+ *   (defaults to basicLayout).
+ * @param logSize - the maximum size (in bytes) for a log file,
+ *   if not provided then logs won't be rotated.
+ * @param numBackups - the number of log files to keep after logSize
+ *   has been reached (default 5)
+ * @param options - options to be passed to the underlying stream
+ * @param timezoneOffset - optional timezone offset in minutes (default system local)
+ */
+function fileAppender(
+  file,
+  layout,
+  logSize,
+  numBackups,
+  options,
+  timezoneOffset
+) {
+  if (typeof file !== 'string' || file.length === 0) {
+    throw new Error(`Invalid filename: ${file}`);
+  } else if (file.endsWith(path.sep)) {
+    throw new Error(`Filename is a directory: ${file}`);
+  } else if (file.indexOf(`~${path.sep}`) === 0) {
+    // handle ~ expansion: https://github.com/nodejs/node/issues/684
+    // exclude ~ and ~filename as these can be valid files
+    file = file.replace('~', os.homedir());
+  }
+  file = path.normalize(file);
+  numBackups = !numBackups && numBackups !== 0 ? 5 : numBackups;
+
+  debug(
+    'Creating fileSync appender (',
+    file,
+    ', ',
+    logSize,
+    ', ',
+    numBackups,
+    ', ',
+    options,
+    ', ',
+    timezoneOffset,
+    ')'
+  );
+
+  function openTheStream(filePath, fileSize, numFiles) {
+    let stream;
+
+    if (fileSize) {
+      stream = new RollingFileSync(filePath, fileSize, numFiles, options);
+    } else {
+      stream = ((f) => {
+        // touch the file to apply flags (like w to truncate the file)
+        touchFile(f, options);
+
+        return {
+          write(data) {
+            fs.appendFileSync(f, data);
+          },
+        };
+      })(filePath);
+    }
+
+    return stream;
+  }
+
+  const logFile = openTheStream(file, logSize, numBackups);
+
+  return (loggingEvent) => {
+    logFile.write(layout(loggingEvent, timezoneOffset) + eol);
+  };
+}
+
+function configure(config, layouts) {
+  let layout = layouts.basicLayout;
+  if (config.layout) {
+    layout = layouts.layout(config.layout.type, config.layout);
+  }
+
+  const options = {
+    flags: config.flags || 'a',
+    encoding: config.encoding || 'utf8',
+    mode: config.mode || 0o600,
+  };
+
+  return fileAppender(
+    config.filename,
+    layout,
+    config.maxLogSize,
+    config.backups,
+    options,
+    config.timezoneOffset
+  );
+}
+
+module.exports.configure = configure;

package/lib/appenders/index.js

@@ -0,0 +1,182 @@
+const path = require('path');
+const debug = require('debug')('log4js:appenders');
+const configuration = require('../configuration');
+const clustering = require('../clustering');
+const levels = require('../levels');
+const layouts = require('../layouts');
+const adapters = require('./adapters');
+
+// pre-load the core appenders so that webpack can find them
+const coreAppenders = new Map();
+coreAppenders.set('console', require('./console'));
+coreAppenders.set('stdout', require('./stdout'));
+coreAppenders.set('stderr', require('./stderr'));
+coreAppenders.set('logLevelFilter', require('./logLevelFilter'));
+coreAppenders.set('categoryFilter', require('./categoryFilter'));
+coreAppenders.set('noLogFilter', require('./noLogFilter'));
+coreAppenders.set('file', require('./file'));
+coreAppenders.set('dateFile', require('./dateFile'));
+coreAppenders.set('fileSync', require('./fileSync'));
+coreAppenders.set('tcp', require('./tcp'));
+
+const appenders = new Map();
+
+const tryLoading = (modulePath, config) => {
+  let resolvedPath;
+  try {
+    const modulePathCJS = `${modulePath}.cjs`;
+    resolvedPath = require.resolve(modulePathCJS);
+    debug('Loading module from ', modulePathCJS);
+  } catch (e) {
+    resolvedPath = modulePath;
+    debug('Loading module from ', modulePath);
+  }
+  try {
+    // eslint-disable-next-line global-require, import/no-dynamic-require
+    return require(resolvedPath);
+  } catch (e) {
+    // if the module was found, and we still got an error, then raise it
+    configuration.throwExceptionIf(
+      config,
+      e.code !== 'MODULE_NOT_FOUND',
+      `appender "${modulePath}" could not be loaded (error was: ${e})`
+    );
+    return undefined;
+  }
+};
+
+const loadAppenderModule = (type, config) =>
+  coreAppenders.get(type) ||
+  tryLoading(`./${type}`, config) ||
+  tryLoading(type, config) ||
+  (require.main &&
+    require.main.filename &&
+    tryLoading(path.join(path.dirname(require.main.filename), type), config)) ||
+  tryLoading(path.join(process.cwd(), type), config);
+
+const appendersLoading = new Set();
+
+const getAppender = (name, config) => {
+  if (appenders.has(name)) return appenders.get(name);
+  if (!config.appenders[name]) return false;
+  if (appendersLoading.has(name))
+    throw new Error(`Dependency loop detected for appender ${name}.`);
+  appendersLoading.add(name);
+
+  debug(`Creating appender ${name}`);
+  // eslint-disable-next-line no-use-before-define
+  const appender = createAppender(name, config);
+  appendersLoading.delete(name);
+  appenders.set(name, appender);
+  return appender;
+};
+
+const createAppender = (name, config) => {
+  const appenderConfig = config.appenders[name];
+  const appenderModule = appenderConfig.type.configure
+    ? appenderConfig.type
+    : loadAppenderModule(appenderConfig.type, config);
+  configuration.throwExceptionIf(
+    config,
+    configuration.not(appenderModule),
+    `appender "${name}" is not valid (type "${appenderConfig.type}" could not be found)`
+  );
+  if (appenderModule.appender) {
+    process.emitWarning(
+      `Appender ${appenderConfig.type} exports an appender function.`,
+      'DeprecationWarning',
+      'log4js-node-DEP0001'
+    );
+    debug(
+      '[log4js-node-DEP0001]',
+      `DEPRECATION: Appender ${appenderConfig.type} exports an appender function.`
+    );
+  }
+  if (appenderModule.shutdown) {
+    process.emitWarning(
+      `Appender ${appenderConfig.type} exports a shutdown function.`,
+      'DeprecationWarning',
+      'log4js-node-DEP0002'
+    );
+    debug(
+      '[log4js-node-DEP0002]',
+      `DEPRECATION: Appender ${appenderConfig.type} exports a shutdown function.`
+    );
+  }
+
+  debug(`${name}: clustering.isMaster ? ${clustering.isMaster()}`);
+  debug(
+    // eslint-disable-next-line global-require
+    `${name}: appenderModule is ${require('util').inspect(appenderModule)}`
+  );
+  return clustering.onlyOnMaster(
+    () => {
+      debug(
+        `calling appenderModule.configure for ${name} / ${appenderConfig.type}`
+      );
+      return appenderModule.configure(
+        adapters.modifyConfig(appenderConfig),
+        layouts,
+        (appender) => getAppender(appender, config),
+        levels
+      );
+    },
+    /* istanbul ignore next: fn never gets called by non-master yet needed to pass config validation */ () => {}
+  );
+};
+
+const setup = (config) => {
+  appenders.clear();
+  appendersLoading.clear();
+  if (!config) {
+    return;
+  }
+
+  const usedAppenders = [];
+  Object.values(config.categories).forEach((category) => {
+    usedAppenders.push(...category.appenders);
+  });
+  Object.keys(config.appenders).forEach((name) => {
+    // dodgy hard-coding of special case for tcp-server and multiprocess which may not have
+    // any categories associated with it, but needs to be started up anyway
+    if (
+      usedAppenders.includes(name) ||
+      config.appenders[name].type === 'tcp-server' ||
+      config.appenders[name].type === 'multiprocess'
+    ) {
+      getAppender(name, config);
+    }
+  });
+};
+
+const init = () => {
+  setup();
+};
+init();
+
+configuration.addListener((config) => {
+  configuration.throwExceptionIf(
+    config,
+    configuration.not(configuration.anObject(config.appenders)),
+    'must have a property "appenders" of type object.'
+  );
+  const appenderNames = Object.keys(config.appenders);
+  configuration.throwExceptionIf(
+    config,
+    configuration.not(appenderNames.length),
+    'must define at least one appender.'
+  );
+
+  appenderNames.forEach((name) => {
+    configuration.throwExceptionIf(
+      config,
+      configuration.not(config.appenders[name].type),
+      `appender "${name}" is not valid (must be an object with property "type")`
+    );
+  });
+});
+
+configuration.addListener(setup);
+
+module.exports = appenders;
+module.exports.init = init;

package/lib/appenders/logLevelFilter.js

@@ -0,0 +1,20 @@
+function logLevelFilter(minLevelString, maxLevelString, appender, levels) {
+  const minLevel = levels.getLevel(minLevelString);
+  const maxLevel = levels.getLevel(maxLevelString, levels.FATAL);
+  return (logEvent) => {
+    const eventLevel = logEvent.level;
+    if (
+      minLevel.isLessThanOrEqualTo(eventLevel) &&
+      maxLevel.isGreaterThanOrEqualTo(eventLevel)
+    ) {
+      appender(logEvent);
+    }
+  };
+}
+
+function configure(config, layouts, findAppender, levels) {
+  const appender = findAppender(config.appender);
+  return logLevelFilter(config.level, config.maxLevel, appender, levels);
+}
+
+module.exports.configure = configure;

package/lib/appenders/multiFile.js

@@ -0,0 +1,91 @@
+const debug = require('debug')('log4js:multiFile');
+const path = require('path');
+const fileAppender = require('./file');
+
+const findFileKey = (property, event) =>
+  event[property] || event.context[property];
+
+module.exports.configure = (config, layouts) => {
+  debug('Creating a multi-file appender');
+  const files = new Map();
+  const timers = new Map();
+
+  function checkForTimeout(fileKey) {
+    const timer = timers.get(fileKey);
+    const app = files.get(fileKey);
+    /* istanbul ignore else: failsafe */
+    if (timer && app) {
+      if (Date.now() - timer.lastUsed > timer.timeout) {
+        debug('%s not used for > %d ms => close', fileKey, timer.timeout);
+        clearInterval(timer.interval);
+        timers.delete(fileKey);
+        files.delete(fileKey);
+        app.shutdown((err) => {
+          if (err) {
+            debug('ignore error on file shutdown: %s', err.message);
+          }
+        });
+      }
+    } else {
+      // will never get here as files and timers are coupled to be added and deleted at same place
+      debug('timer or app does not exist');
+    }
+  }
+
+  const appender = (logEvent) => {
+    const fileKey = findFileKey(config.property, logEvent);
+    debug('fileKey for property ', config.property, ' is ', fileKey);
+    if (fileKey) {
+      let file = files.get(fileKey);
+      debug('existing file appender is ', file);
+      if (!file) {
+        debug('creating new file appender');
+        config.filename = path.join(config.base, fileKey + config.extension);
+        file = fileAppender.configure(config, layouts);
+        files.set(fileKey, file);
+        if (config.timeout) {
+          debug('creating new timer');
+          timers.set(fileKey, {
+            timeout: config.timeout,
+            lastUsed: Date.now(),
+            interval: setInterval(
+              checkForTimeout.bind(null, fileKey),
+              config.timeout
+            ),
+          });
+        }
+      } else if (config.timeout) {
+        debug('%s extending activity', fileKey);
+        timers.get(fileKey).lastUsed = Date.now();
+      }
+
+      file(logEvent);
+    } else {
+      debug('No fileKey for logEvent, quietly ignoring this log event');
+    }
+  };
+
+  appender.shutdown = (cb) => {
+    let shutdownFunctions = files.size;
+    if (shutdownFunctions <= 0) {
+      cb();
+    }
+    let error;
+    timers.forEach((timer, fileKey) => {
+      debug('clearing timer for ', fileKey);
+      clearInterval(timer.interval);
+    });
+    files.forEach((app, fileKey) => {
+      debug('calling shutdown for ', fileKey);
+      app.shutdown((err) => {
+        error = error || err;
+        shutdownFunctions -= 1;
+        if (shutdownFunctions <= 0) {
+          cb(error);
+        }
+      });
+    });
+  };
+
+  return appender;
+};