@bitblit/ratchet-common 4.0.80-alpha

package/dist/cjs/logger/classic-single-line-log-message-formatter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassicSingleLineLogMessageFormatter = void 0;
+const tslib_1 = require("tslib");
+const util_1 = tslib_1.__importDefault(require("util"));
+class ClassicSingleLineLogMessageFormatter {
+    formatMessage(msg, meta) {
+        let tmp = null;
+        if (msg) {
+            tmp = '';
+            tmp += meta.options.trace ? meta.options.trace + ' ' : '';
+            tmp += '[' + msg.lvl + '] ';
+            tmp += util_1.default.format(msg.messageSource, ...msg.subsVars);
+        }
+        return tmp;
+    }
+}
+exports.ClassicSingleLineLogMessageFormatter = ClassicSingleLineLogMessageFormatter;

package/dist/cjs/logger/log-message-builder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogMessageBuilder = void 0;
+class LogMessageBuilder {
+    constructor(lvl, messageSource) {
+        if (!lvl) {
+            throw Error('Cannot set level to null/undefined');
+        }
+        this.wrapped = { lvl: lvl, timestamp: Date.now(), messageSource: messageSource };
+    }
+    clone() {
+        const rval = new LogMessageBuilder(this.wrapped.lvl, this.wrapped.messageSource);
+        rval.wrapped = Object.assign({}, this.wrapped);
+        return rval;
+    }
+    level(lvl) {
+        if (!lvl) {
+            throw Error('Cannot set level to null/undefined');
+        }
+        this.wrapped.lvl = lvl;
+        return this;
+    }
+    timestamp(val) {
+        if (!val) {
+            throw Error('Cannot set timestamp to null/undefined');
+        }
+        this.wrapped.timestamp = val;
+        return this;
+    }
+    messageSource(val) {
+        this.wrapped.messageSource = val;
+        return this;
+    }
+    subVars(val) {
+        this.wrapped.subsVars = val || [];
+        return this;
+    }
+    params(val) {
+        this.wrapped.params = val || {};
+        return this;
+    }
+    p(name, value) {
+        this.wrapped.params = this.wrapped.params || {};
+        this.wrapped.params[name] = value;
+        return this;
+    }
+    toMessage() {
+        return Object.assign({}, this.wrapped);
+    }
+}
+exports.LogMessageBuilder = LogMessageBuilder;

package/dist/cjs/logger/log-message-format-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogMessageFormatType = void 0;
+var LogMessageFormatType;
+(function (LogMessageFormatType) {
+    LogMessageFormatType["ClassicSingleLine"] = "ClassicSingleLine";
+    LogMessageFormatType["StructuredJson"] = "StructuredJson";
+    LogMessageFormatType["None"] = "None";
+})(LogMessageFormatType = exports.LogMessageFormatType || (exports.LogMessageFormatType = {}));

package/dist/cjs/logger/log-message-formatter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/logger/log-message-processor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/logger/log-message.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/logger/log-snapshot.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/logger/logger-instance.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerInstance = void 0;
+const logger_ring_buffer_1 = require("./logger-ring-buffer");
+const logger_level_name_1 = require("./logger-level-name");
+const logger_util_1 = require("./logger-util");
+const log_message_format_type_1 = require("./log-message-format-type");
+const classic_single_line_log_message_formatter_1 = require("./classic-single-line-log-message-formatter");
+const none_log_message_formatter_1 = require("./none-log-message-formatter");
+const structured_json_log_message_formatter_1 = require("./structured-json-log-message-formatter");
+const string_ratchet_1 = require("../lang/string-ratchet");
+class LoggerInstance {
+    constructor(loggerInstanceName = 'default', inOptions) {
+        this.loggerInstanceName = loggerInstanceName;
+        this.options = inOptions;
+    }
+    addPreProcessor(proc) {
+        if (proc) {
+            this._options.preProcessors = this._options.preProcessors || [];
+            this._options.preProcessors.push(proc);
+        }
+        return Object.assign([], this._options.preProcessors);
+    }
+    get ringBuffer() {
+        return this._ringBuffer;
+    }
+    dumpConfigurationIntoLog() {
+        this.error('ERROR enabled');
+        this.warn('WARN enabled');
+        this.info('INFO enabled');
+        this.verbose('VERBOSE enabled');
+        this.debug('DEBUG enabled');
+        this.silly('SILLY enabled');
+    }
+    dumpOptionsIntoLog() {
+        var _a, _b;
+        this.info('Options: %j', this.options);
+        if ((_b = (_a = this === null || this === void 0 ? void 0 : this.options) === null || _a === void 0 ? void 0 : _a.preProcessors) === null || _b === void 0 ? void 0 : _b.length) {
+            const labels = this.options.preProcessors.map((p) => string_ratchet_1.StringRatchet.trimToNull(p.label()) || 'Unlabelled');
+            this.info('Preprocessors: %j', labels);
+        }
+    }
+    changeRingBufferSize(newSize) {
+        this._ringBuffer = null;
+        if (newSize) {
+            this._ringBuffer = new logger_ring_buffer_1.LoggerRingBuffer(newSize);
+            this._options.ringBufferSize = newSize;
+        }
+    }
+    updateTracePrefix(newValue) {
+        this._options.trace = newValue;
+    }
+    get options() {
+        return Object.assign({}, this._options);
+    }
+    set options(newOpts) {
+        this._options = Object.assign({}, newOpts);
+        if (this._options.ringBufferSize) {
+            this._ringBuffer = new logger_ring_buffer_1.LoggerRingBuffer(this._options.ringBufferSize);
+        }
+        switch (this._options.formatType) {
+            case log_message_format_type_1.LogMessageFormatType.None:
+                this._formatter = new none_log_message_formatter_1.NoneLogMessageFormatter();
+                break;
+            case log_message_format_type_1.LogMessageFormatType.StructuredJson:
+                this._formatter = new structured_json_log_message_formatter_1.StructuredJsonLogMessageFormatter();
+                break;
+            default:
+                this._formatter = new classic_single_line_log_message_formatter_1.ClassicSingleLineLogMessageFormatter();
+                break;
+        }
+        this._level = this._options.initialLevel;
+        this._handlerFunctionMap = logger_util_1.LoggerUtil.handlerFunctionMap(this._options.outputFunction);
+        const oldId = this._loggerMeta ? this._loggerMeta.loggerInstanceId : null;
+        this._loggerMeta = {
+            options: this._options,
+            loggerInstanceName: this.loggerInstanceName,
+            loggerInstanceId: oldId || string_ratchet_1.StringRatchet.createRandomHexString(8),
+        };
+    }
+    get level() {
+        return this._level;
+    }
+    set level(newLevel) {
+        if (!newLevel) {
+            throw new Error('Cannot set level to null/undefined');
+        }
+        this._level = newLevel;
+    }
+    consoleLogPassThru(level, ...input) {
+        if (logger_util_1.LoggerUtil.levelIsEnabled(level, this._level)) {
+            let passThruPrefix = this._options.trace || '';
+            passThruPrefix += '[' + level + '] ';
+            input.unshift(passThruPrefix);
+            const fn = this._handlerFunctionMap.get(level) || logger_util_1.LoggerUtil.defaultHandlerFunction;
+            fn(...input);
+        }
+    }
+    createLogMessage(level, params, format, ...input) {
+        const rval = {
+            lvl: level,
+            timestamp: Date.now(),
+            messageSource: format,
+            subsVars: input,
+            params: params,
+        };
+        return rval;
+    }
+    formatMessage(msg) {
+        const rval = msg ? this._formatter.formatMessage(msg, this._loggerMeta) : null;
+        return rval;
+    }
+    formatMessages(msgs) {
+        const rval = (msgs || []).map((m) => this.formatMessage(m)).filter((m) => !!m);
+        return rval;
+    }
+    recordMessageBuilder(msgBuild) {
+        return this.recordMessage(msgBuild.toMessage());
+    }
+    recordMessage(inMsg) {
+        var _a;
+        let rval = null;
+        if (logger_util_1.LoggerUtil.levelIsEnabled(inMsg.lvl, this._level)) {
+            let msg = Object.assign({}, inMsg);
+            if ((_a = this._options.preProcessors) === null || _a === void 0 ? void 0 : _a.length) {
+                for (let i = 0; i < this._options.preProcessors.length; i++) {
+                    msg = this._options.preProcessors[i].process(msg);
+                }
+            }
+            rval = this.formatMessage(msg);
+            if (rval) {
+                const fn = this._handlerFunctionMap.get(msg.lvl) || logger_util_1.LoggerUtil.defaultHandlerFunction;
+                fn(rval);
+                if (this._ringBuffer) {
+                    this._ringBuffer.addToRingBuffer(msg);
+                }
+            }
+        }
+        else {
+        }
+        return rval;
+    }
+    error(format, ...input) {
+        const msg = this.createLogMessage(logger_level_name_1.LoggerLevelName.error, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    errorP(...input) {
+        this.consoleLogPassThru(logger_level_name_1.LoggerLevelName.error, ...input);
+    }
+    warn(format, ...input) {
+        const msg = this.createLogMessage(logger_level_name_1.LoggerLevelName.warn, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    warnP(...input) {
+        this.consoleLogPassThru(logger_level_name_1.LoggerLevelName.warn, ...input);
+    }
+    info(format, ...input) {
+        const msg = this.createLogMessage(logger_level_name_1.LoggerLevelName.info, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    infoP(...input) {
+        this.consoleLogPassThru(logger_level_name_1.LoggerLevelName.info, ...input);
+    }
+    verbose(format, ...input) {
+        const msg = this.createLogMessage(logger_level_name_1.LoggerLevelName.verbose, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    verboseP(...input) {
+        this.consoleLogPassThru(logger_level_name_1.LoggerLevelName.verbose, ...input);
+    }
+    debug(format, ...input) {
+        const msg = this.createLogMessage(logger_level_name_1.LoggerLevelName.debug, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    debugP(...input) {
+        this.consoleLogPassThru(logger_level_name_1.LoggerLevelName.debug, ...input);
+    }
+    silly(format, ...input) {
+        const msg = this.createLogMessage(logger_level_name_1.LoggerLevelName.silly, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    sillyP(...input) {
+        this.consoleLogPassThru(logger_level_name_1.LoggerLevelName.silly, ...input);
+    }
+    logByLevel(level, format, ...input) {
+        const msg = this.createLogMessage(level, {}, format, ...input);
+        this.recordMessage(msg);
+    }
+    importMessages(msgs, prefixIn = '', addTimestamp = true) {
+        const prefix = prefixIn || '';
+        if (msgs && msgs.length > 0) {
+            this.silly('Received import data : %d msgs', msgs.length);
+            msgs.forEach((m) => {
+                if (m.messageSource) {
+                    let mOut = prefix;
+                    if (addTimestamp) {
+                        const ts = String(new Date()).substring(15, 24);
+                        mOut += ' (' + ts + ') : ';
+                        mOut += m.messageSource;
+                    }
+                    this.logByLevel(m.lvl, mOut);
+                }
+            });
+        }
+    }
+}
+exports.LoggerInstance = LoggerInstance;

package/dist/cjs/logger/logger-level-name.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerLevelName = void 0;
+var LoggerLevelName;
+(function (LoggerLevelName) {
+    LoggerLevelName["error"] = "error";
+    LoggerLevelName["warn"] = "warn";
+    LoggerLevelName["info"] = "info";
+    LoggerLevelName["verbose"] = "verbose";
+    LoggerLevelName["debug"] = "debug";
+    LoggerLevelName["silly"] = "silly";
+})(LoggerLevelName = exports.LoggerLevelName || (exports.LoggerLevelName = {}));

package/dist/cjs/logger/logger-meta.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/logger/logger-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/logger/logger-output-function.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerOutputFunction = void 0;
+var LoggerOutputFunction;
+(function (LoggerOutputFunction) {
+    LoggerOutputFunction["Console"] = "Console";
+    LoggerOutputFunction["ConsoleNoDebug"] = "ConsoleNoDebug";
+    LoggerOutputFunction["StdOut"] = "StdOut";
+})(LoggerOutputFunction = exports.LoggerOutputFunction || (exports.LoggerOutputFunction = {}));

package/dist/cjs/logger/logger-ring-buffer.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerRingBuffer = void 0;
+const logger_1 = require("./logger");
+const logger_level_name_1 = require("./logger-level-name");
+class LoggerRingBuffer {
+    constructor(size) {
+        this._lastLogMessage = { messageSource: 'No message yet', timestamp: new Date().getTime(), lvl: logger_level_name_1.LoggerLevelName.info };
+        this._buffer = [];
+        this._bufferIdx = 0;
+        this._lastSnapshotIdx = 0;
+        if (!size) {
+            throw new Error('Cannot create ring buffer of size 0');
+        }
+        this._bufferSize = size;
+    }
+    get currentIndex() {
+        return this._bufferIdx;
+    }
+    get lastSnapshotIdx() {
+        return this._lastSnapshotIdx;
+    }
+    set bufferSize(newSize) {
+        if (!newSize) {
+            throw new Error('Cannot create ring buffer of size 0');
+        }
+        this._bufferSize = newSize;
+        this.clearRingBuffer();
+    }
+    getMessages(inStartFrom = null, clear = false, reverseSort = false) {
+        let rval = null;
+        if (this._bufferIdx < this._bufferSize) {
+            const start = inStartFrom == null ? 0 : inStartFrom;
+            rval = this._buffer.slice(start, this._bufferIdx);
+        }
+        else {
+            rval = [];
+            const firstIdx = this._bufferIdx - this._bufferSize;
+            const startFrom = inStartFrom ? Math.max(inStartFrom, firstIdx) : firstIdx;
+            for (let i = startFrom; i < this._bufferIdx; i++) {
+                rval.push(this._buffer[i % this._bufferSize]);
+            }
+        }
+        if (clear) {
+            this.clearRingBuffer();
+        }
+        if (reverseSort) {
+            rval = rval.reverse();
+        }
+        return rval;
+    }
+    takeSnapshot() {
+        const trailingEdge = Math.max(0, this._bufferIdx - this._bufferSize);
+        const rval = {
+            messages: logger_1.Logger.getMessages(this._lastSnapshotIdx),
+            logMessagesTruncated: Math.max(0, trailingEdge - this._lastSnapshotIdx),
+        };
+        this._lastSnapshotIdx = this._bufferIdx;
+        return rval;
+    }
+    getLastLogMessage() {
+        return Object.assign({}, this._lastLogMessage);
+    }
+    clearRingBuffer() {
+        this._buffer = [];
+        this._bufferIdx = 0;
+        this._lastSnapshotIdx = 0;
+        logger_1.Logger.info('Cleared ring buffer (size is now %d)', this._bufferSize);
+    }
+    addToRingBuffer(newMsg) {
+        this._lastLogMessage = newMsg;
+        this._buffer[this._bufferIdx % this._bufferSize] = newMsg;
+        this._bufferIdx++;
+    }
+}
+exports.LoggerRingBuffer = LoggerRingBuffer;

package/dist/cjs/logger/logger-util.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerUtil = void 0;
+const logger_level_name_1 = require("./logger-level-name");
+const logger_output_function_1 = require("./logger-output-function");
+class LoggerUtil {
+    static handlerFunctionMap(outputFn = logger_output_function_1.LoggerOutputFunction.Console) {
+        var _a;
+        const output = new Map();
+        if (outputFn === logger_output_function_1.LoggerOutputFunction.StdOut) {
+            if (!((_a = process === null || process === void 0 ? void 0 : process.stdout) === null || _a === void 0 ? void 0 : _a.write)) {
+                throw new Error('Cannot use standard out - process.stdout.write not found');
+            }
+            const myStdOut = (chunk, cb) => process.stdout.write(chunk, 'utf-8', cb);
+            output.set(logger_level_name_1.LoggerLevelName.error, myStdOut);
+            output.set(logger_level_name_1.LoggerLevelName.warn, myStdOut);
+            output.set(logger_level_name_1.LoggerLevelName.info, myStdOut);
+            output.set(logger_level_name_1.LoggerLevelName.verbose, myStdOut);
+            output.set(logger_level_name_1.LoggerLevelName.debug, myStdOut);
+            output.set(logger_level_name_1.LoggerLevelName.silly, myStdOut);
+        }
+        else {
+            output.set(logger_level_name_1.LoggerLevelName.error, console.error);
+            output.set(logger_level_name_1.LoggerLevelName.warn, console.warn);
+            output.set(logger_level_name_1.LoggerLevelName.info, console.info);
+            output.set(logger_level_name_1.LoggerLevelName.verbose, outputFn === logger_output_function_1.LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+            output.set(logger_level_name_1.LoggerLevelName.debug, outputFn === logger_output_function_1.LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+            output.set(logger_level_name_1.LoggerLevelName.silly, outputFn === logger_output_function_1.LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+        }
+        return output;
+    }
+    static defaultHandlerFunction() {
+        return console.info;
+    }
+    static levelIsEnabled(targetLevel, currentEnabled) {
+        const idxTarget = LoggerUtil.LOG_LEVELS_IN_ORDER.indexOf(targetLevel);
+        const lvl = LoggerUtil.LOG_LEVELS_IN_ORDER.indexOf(currentEnabled);
+        return idxTarget > -1 && lvl > -1 && lvl >= idxTarget;
+    }
+}
+exports.LoggerUtil = LoggerUtil;
+LoggerUtil.LOG_LEVELS_IN_ORDER = [
+    logger_level_name_1.LoggerLevelName.error,
+    logger_level_name_1.LoggerLevelName.warn,
+    logger_level_name_1.LoggerLevelName.info,
+    logger_level_name_1.LoggerLevelName.verbose,
+    logger_level_name_1.LoggerLevelName.debug,
+    logger_level_name_1.LoggerLevelName.silly,
+];

package/dist/cjs/logger/logger.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const logger_instance_1 = require("./logger-instance");
+const log_message_format_type_1 = require("./log-message-format-type");
+const logger_level_name_1 = require("./logger-level-name");
+const logger_output_function_1 = require("./logger-output-function");
+class Logger {
+    static applyDefaultsToOptions(input) {
+        var _a, _b, _c, _d, _e, _f;
+        const rval = input || {};
+        rval.initialLevel = (_a = rval.initialLevel) !== null && _a !== void 0 ? _a : Logger.DEFAULT_OPTIONS.initialLevel;
+        rval.formatType = (_b = rval.formatType) !== null && _b !== void 0 ? _b : Logger.DEFAULT_OPTIONS.formatType;
+        rval.trace = (_c = rval.trace) !== null && _c !== void 0 ? _c : Logger.DEFAULT_OPTIONS.trace;
+        rval.globalVars = (_d = rval.globalVars) !== null && _d !== void 0 ? _d : Logger.DEFAULT_OPTIONS.globalVars;
+        rval.outputFunction = (_e = rval.outputFunction) !== null && _e !== void 0 ? _e : Logger.DEFAULT_OPTIONS.outputFunction;
+        rval.ringBufferSize = (_f = rval.ringBufferSize) !== null && _f !== void 0 ? _f : Logger.DEFAULT_OPTIONS.ringBufferSize;
+        return rval;
+    }
+    static changeDefaultOptions(input, retroactive) {
+        if (!input || !input.initialLevel || !input.formatType) {
+            throw new Error('Default options must be non-null, and provide initial level and format type');
+        }
+        Logger.DEFAULT_OPTIONS = Object.assign({}, input);
+        if (retroactive) {
+            Array.from(Logger.LOGGER_INSTANCES.values()).forEach((li) => (li.options = input));
+        }
+    }
+    static getLogger(loggerName = 'default', inOptions) {
+        let inst = Logger.LOGGER_INSTANCES.get(loggerName);
+        if (!inst) {
+            const options = Logger.applyDefaultsToOptions(inOptions);
+            inst = new logger_instance_1.LoggerInstance(loggerName, options);
+            Logger.LOGGER_INSTANCES.set(loggerName, inst);
+        }
+        return inst;
+    }
+    static recordMessageBuilder(msgBuild) {
+        return Logger.getLogger().recordMessageBuilder(msgBuild);
+    }
+    static recordMessage(msg) {
+        return Logger.getLogger().recordMessage(msg);
+    }
+    static formatMessages(msgs) {
+        return Logger.getLogger().formatMessages(msgs);
+    }
+    static updateTracePrefix(newValue) {
+        return Logger.getLogger().updateTracePrefix(newValue);
+    }
+    static changeRingBufferSize(newValue) {
+        return Logger.getLogger().changeRingBufferSize(newValue);
+    }
+    static getRingBuffer() {
+        return Logger.getLogger().ringBuffer;
+    }
+    static dumpConfigurationIntoLog() {
+        return Logger.getLogger().dumpConfigurationIntoLog();
+    }
+    static dumpOptionsIntoLog() {
+        return Logger.getLogger().dumpOptionsIntoLog();
+    }
+    static getLevel() {
+        return Logger.getLogger().level;
+    }
+    static setLevel(newLevel) {
+        Logger.getLogger().level = newLevel;
+    }
+    static getOptions() {
+        return Logger.getLogger().options;
+    }
+    static getMessages(inStartFrom = null, clear = false, reverseSort = false) {
+        const buf = Logger.getLogger().ringBuffer;
+        return buf ? buf.getMessages(inStartFrom, clear, reverseSort) : null;
+    }
+    static consoleLogPassThru(level, ...input) {
+        return Logger.getLogger().consoleLogPassThru(level, ...input);
+    }
+    static error(format, ...input) {
+        return Logger.getLogger().error(format, ...input);
+    }
+    static errorP(...input) {
+        return Logger.getLogger().errorP(...input);
+    }
+    static warn(format, ...input) {
+        return Logger.getLogger().warn(format, ...input);
+    }
+    static warnP(...input) {
+        return Logger.getLogger().warnP(...input);
+    }
+    static info(format, ...input) {
+        return Logger.getLogger().info(format, ...input);
+    }
+    static infoP(...input) {
+        return Logger.getLogger().infoP(...input);
+    }
+    static verbose(format, ...input) {
+        return Logger.getLogger().verbose(format, ...input);
+    }
+    static verboseP(...input) {
+        return Logger.getLogger().verboseP(...input);
+    }
+    static debug(format, ...input) {
+        return Logger.getLogger().debug(format, ...input);
+    }
+    static debugP(...input) {
+        return Logger.getLogger().debugP(...input);
+    }
+    static silly(format, ...input) {
+        return Logger.getLogger().silly(format, ...input);
+    }
+    static sillyP(...input) {
+        return Logger.getLogger().sillyP(...input);
+    }
+    static takeSnapshot() {
+        const buf = Logger.getLogger().ringBuffer;
+        return buf ? buf.takeSnapshot() : null;
+    }
+    static logByLevel(level, format, ...input) {
+        return Logger.getLogger().logByLevel(level, format, ...input);
+    }
+    static importMessages(msgs, prefixIn = '', addTimestamp = true) {
+        return Logger.getLogger().importMessages(msgs, prefixIn, addTimestamp);
+    }
+    static getLastLogMessage() {
+        const buf = Logger.getLogger().ringBuffer;
+        return buf ? buf.getLastLogMessage() : null;
+    }
+}
+exports.Logger = Logger;
+Logger.LOGGER_INSTANCES = new Map();
+Logger.DEFAULT_OPTIONS = {
+    initialLevel: logger_level_name_1.LoggerLevelName.info,
+    formatType: log_message_format_type_1.LogMessageFormatType.ClassicSingleLine,
+    trace: null,
+    globalVars: {},
+    outputFunction: logger_output_function_1.LoggerOutputFunction.Console,
+    ringBufferSize: 0,
+    preProcessors: [],
+};

package/dist/cjs/logger/none-log-message-formatter.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoneLogMessageFormatter = void 0;
+class NoneLogMessageFormatter {
+    formatMessage(msg, meta) {
+        return null;
+    }
+}
+exports.NoneLogMessageFormatter = NoneLogMessageFormatter;

package/dist/cjs/logger/structured-json-log-message-formatter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructuredJsonLogMessageFormatter = void 0;
+const tslib_1 = require("tslib");
+const util_1 = tslib_1.__importDefault(require("util"));
+class StructuredJsonLogMessageFormatter {
+    formatMessage(msg, meta) {
+        let rval = null;
+        if (msg) {
+            const tmp = Object.assign({}, meta.options.globalVars || {}, msg.params || {});
+            tmp['msg'] = util_1.default.format(msg.messageSource, ...msg.subsVars);
+            tmp['utcDateTime'] = new Date(msg.timestamp).toISOString();
+            tmp['logLevel'] = msg.lvl;
+            if (meta.options.trace) {
+                tmp['trace'] = meta.options.trace;
+            }
+            tmp['logName'] = meta.loggerInstanceName;
+            tmp['logId'] = meta.loggerInstanceId;
+            rval = JSON.stringify(tmp) + '\n';
+        }
+        return rval;
+    }
+}
+exports.StructuredJsonLogMessageFormatter = StructuredJsonLogMessageFormatter;

package/dist/cjs/network/browser-local-ip-provider.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserLocalIpProvider = void 0;
+const network_ratchet_1 = require("./network-ratchet");
+const logger_1 = require("../logger/logger");
+class BrowserLocalIpProvider {
+    constructor() {
+        this.currentIp = 'UNSET';
+        network_ratchet_1.NetworkRatchet.findLocalIp(false)
+            .then((result) => {
+            logger_1.Logger.info('Setting local IP to %s', result);
+            this.currentIp = result;
+        })
+            .catch((err) => {
+            logger_1.Logger.warn('Unable to set current IP - leaving as UNSET : %s', err);
+        });
+    }
+    ready() {
+        return this.currentIp !== 'UNSET';
+    }
+    currentLocalIpAddress() {
+        return this.currentIp;
+    }
+}
+exports.BrowserLocalIpProvider = BrowserLocalIpProvider;

package/dist/cjs/network/fixed-local-ip-provider.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixedLocalIpProvider = void 0;
+class FixedLocalIpProvider {
+    constructor(fixed) {
+        this.fixed = fixed;
+    }
+    currentLocalIpAddress() {
+        return this.fixed;
+    }
+}
+exports.FixedLocalIpProvider = FixedLocalIpProvider;