const jsonReplacers = require('./json-replacers');
const dataSanitizers = require('./data-sanitizers');
-/**
- * Log as JSON to stdout/stderr.
- */
-
-const nop = () => { /**/ };
-
+const nop = () => undefined;
class Logger {
/**
- * Wrap backend calls with payload normalization.
- * @param {Object} options
- * @param {String} options.nodeId - unique identifier for running instance, usually a uuid
- * @param {Object} options.logger
- * @param {String} options.logger.ignoreBelowLevel - minimum level to log
+ * @callback LogFn
+ * @param {any} ...args values to log
+ * @returns {void} nothing
+ */
+ /**
+ * @typedef {object} ConsoleLike
+ * @property {LogFn} error error level
+ * @property {LogFn} warn warn level
+ * @property {LogFn} info info level
+ * @property {LogFn} log log level
+ * @property {LogFn} debug debug level
+ */
+ /**
+ * @typedef AsyncLocalStorage
+ * @property {Function} getStore local storage
*/
- constructor(options) {
+ /**
+ * @typedef {object} LoggerOptions
+ * @property {string} ignoreBelowLevel minimum level to log, e.g. 'info'
+ */
+ /**
+ * Wrap backend calls with payload normalization and metadata.
+ * @param {LoggerOptions} options options
+ * @param {object} commonObject object to be merged into logged json
+ * @param {AsyncLocalStorage} asyncLocalStorage async storage for an object to be merged into logged json
+ * @param {ConsoleLike} backend default is console
+ */
+ constructor(options, commonObject, asyncLocalStorage, backend) {
const logLevels = Object.keys(Logger.nullLogger);
- const ignoreBelowLevel = options && options.logger && options.logger.ignoreBelowLevel || 'debug';
- this.backend = console;
- this.nodeId = options.nodeId;
+ const ignoreBelowLevel = options?.ignoreBelowLevel || 'debug';
+ this.backend = backend || console;
+ this.commonObject = commonObject || {};
this.jsonReplacers = Object.values(jsonReplacers);
this.dataSanitizers = Object.values(dataSanitizers);
+ if (asyncLocalStorage) {
+ // Override the class getter.
+ Object.defineProperty(this, 'asyncLogObject', {
+ enumerable: true,
+ get: asyncLocalStorage.getStore.bind(asyncLocalStorage),
+ });
+ }
+
if (!logLevels.includes(ignoreBelowLevel)) {
throw new RangeError(`unrecognized minimum log level '${ignoreBelowLevel}'`);
}
const ignoreLevelIdx = logLevels.indexOf(ignoreBelowLevel);
logLevels.forEach((level) => {
+ const includeBackendLevel = (logLevels.indexOf(level) > ignoreLevelIdx) && this.backend[level]; // eslint-disable-line security/detect-object-injection
// eslint-disable-next-line security/detect-object-injection
- this[level] = (logLevels.indexOf(level) > ignoreLevelIdx) ?
+ this[level] = (includeBackendLevel) ?
nop :
(...args) => this.backend[level](this.payload(level, ...args)); // eslint-disable-line security/detect-object-injection
});
/**
* All the expected Console levels, but do nothing.
* Ordered from highest priority to lowest.
+ * @returns {object} no-op backend
*/
static get nullLogger() {
return {
}
+ /**
+ * Default of empty object when no asyncLocalStorage is defined.
+ * Overridden on instance when asyncLocalStorage is defined.
+ * @returns {object} empty
+ */
+ // eslint-disable-next-line class-methods-use-this
+ get asyncLogObject() {
+ return {};
+ }
+
+
/**
* Structure all expected log data into JSON string.
- * @param {String} level
- * @param {String} scope
- * @param {String} message
- * @param {Object} data
- * @param {...any} other
- * @returns {String} JSON string
+ * @param {string} level log level
+ * @param {string} scope scope
+ * @param {string} message message
+ * @param {object} data data
+ * @param {...any} other more data merged into payload
+ * @returns {string} JSON string
*/
payload(level, scope, message, data, ...other) {
+ const replacer = this.getReplacer();
+
if (this.sanitizationNeeded(data)) {
// Create copy of data so we are not changing anything important.
- data = JSON.parse(JSON.stringify(data, this.jsonReplacer.bind(this)));
+ try {
+ data = structuredClone(data);
+ } catch (e) { // eslint-disable-line no-unused-vars
+ data = JSON.parse(JSON.stringify(data, replacer));
+ }
this.sanitize(data);
}
const now = new Date();
- return JSON.stringify({
- nodeId: this.nodeId,
+ const logPayload = {
+ ...this.commonObject,
timestamp: now.toISOString(),
timestampMs: now.getTime(),
level: level,
message: message || '',
data: data || {},
...(other.length && { other }),
- }, this.jsonReplacer.bind(this));
+ ...this.asyncLogObject,
+ };
+ return JSON.stringify(logPayload, replacer);
}
/**
* Determine if data needs sanitizing.
- * @param {Object} data
- * @returns {Boolean}
+ * @param {object} data data
+ * @returns {boolean} needs sanitization
*/
sanitizationNeeded(data) {
return this.dataSanitizers.some((sanitizer) => sanitizer(data, false));
/**
* Mogrify data.
- * @param {Object} data
+ * @param {object} data data
*/
sanitize(data) {
this.dataSanitizers.forEach((sanitizer) => sanitizer(data));
/**
- * Convert data into JSON.
- * @param {String} _key
- * @param {*} value
- * @returns {String} serialized value
+ * Return a replacer function which does de-cycling, as well as the rest of our replacers.
+ * @returns {Function} replacer
*/
- jsonReplacer(key, value) {
- let replaced;
-
- // Try applying all our replacers, until one does something.
- this.jsonReplacers.every((replacer) => {
- ({ replaced, value } = replacer(key, value));
- return !replaced;
- });
- return value;
+ getReplacer() {
+ const ancestors = [];
+ const loggerReplacers = this.jsonReplacers;
+ return function cycleReplacer(key, value) {
+ loggerReplacers.every((replacer) => {
+ const oldValue = value;
+ value = replacer(key, value);
+ return oldValue === value;
+ });
+ if (typeof value === 'object' && value !== null) {
+ // 'this' is object where key/value came from
+ while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+ ancestors.pop();
+ }
+ if (ancestors.includes(value)) {
+ return '[Circular]';
+ } else {
+ ancestors.push(value);
+ }
+ }
+
+ return value;
+ };
}
}
projects / squeep-logger-json-console / blobdiff