@bitblit/ratchet-common 4.0.115-alpha → 4.0.119-alpha

package/lib/logger/logger-instance.js

@@ -1,208 +0,0 @@
-import { LoggerRingBuffer } from './logger-ring-buffer.js';
-import { LoggerLevelName } from './logger-level-name.js';
-import { LoggerUtil } from './logger-util.js';
-import { LogMessageFormatType } from './log-message-format-type.js';
-import { ClassicSingleLineLogMessageFormatter } from './classic-single-line-log-message-formatter.js';
-import { NoneLogMessageFormatter } from './none-log-message-formatter.js';
-import { StructuredJsonLogMessageFormatter } from './structured-json-log-message-formatter.js';
-import { StringRatchet } from '../lang/string-ratchet.js';
-export class LoggerInstance {
-    loggerInstanceName;
-    _loggerMeta;
-    _ringBuffer;
-    _formatter;
-    _level;
-    _handlerFunctionMap;
-    _options;
-    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() {
-        this.info('Options: %j', this.options);
-        if (this?.options?.preProcessors?.length) {
-            const labels = this.options.preProcessors.map((p) => StringRatchet.trimToNull(p.label()) || 'Unlabelled');
-            this.info('Preprocessors: %j', labels);
-        }
-    }
-    changeRingBufferSize(newSize) {
-        this._ringBuffer = null;
-        if (newSize) {
-            this._ringBuffer = new 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 LoggerRingBuffer(this._options.ringBufferSize);
-        }
-        switch (this._options.formatType) {
-            case LogMessageFormatType.None:
-                this._formatter = new NoneLogMessageFormatter();
-                break;
-            case LogMessageFormatType.StructuredJson:
-                this._formatter = new StructuredJsonLogMessageFormatter();
-                break;
-            default:
-                this._formatter = new ClassicSingleLineLogMessageFormatter();
-                break;
-        }
-        this._level = this._options.initialLevel;
-        this._handlerFunctionMap = LoggerUtil.handlerFunctionMap(this._options.outputFunction);
-        const oldId = this._loggerMeta ? this._loggerMeta.loggerInstanceId : null;
-        this._loggerMeta = {
-            options: this._options,
-            loggerInstanceName: this.loggerInstanceName,
-            loggerInstanceId: oldId || 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 (LoggerUtil.levelIsEnabled(level, this._level)) {
-            let passThruPrefix = this._options.trace || '';
-            passThruPrefix += '[' + level + '] ';
-            input.unshift(passThruPrefix);
-            const fn = this._handlerFunctionMap.get(level) || 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) {
-        let rval = null;
-        if (LoggerUtil.levelIsEnabled(inMsg.lvl, this._level)) {
-            let msg = Object.assign({}, inMsg);
-            if (this._options.preProcessors?.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) || LoggerUtil.defaultHandlerFunction;
-                fn(rval);
-                if (this._ringBuffer) {
-                    this._ringBuffer.addToRingBuffer(msg);
-                }
-            }
-        }
-        else {
-        }
-        return rval;
-    }
-    error(format, ...input) {
-        const msg = this.createLogMessage(LoggerLevelName.error, {}, format, ...input);
-        return this.recordMessage(msg);
-    }
-    errorP(...input) {
-        this.consoleLogPassThru(LoggerLevelName.error, ...input);
-    }
-    warn(format, ...input) {
-        const msg = this.createLogMessage(LoggerLevelName.warn, {}, format, ...input);
-        return this.recordMessage(msg);
-    }
-    warnP(...input) {
-        this.consoleLogPassThru(LoggerLevelName.warn, ...input);
-    }
-    info(format, ...input) {
-        const msg = this.createLogMessage(LoggerLevelName.info, {}, format, ...input);
-        return this.recordMessage(msg);
-    }
-    infoP(...input) {
-        this.consoleLogPassThru(LoggerLevelName.info, ...input);
-    }
-    verbose(format, ...input) {
-        const msg = this.createLogMessage(LoggerLevelName.verbose, {}, format, ...input);
-        return this.recordMessage(msg);
-    }
-    verboseP(...input) {
-        this.consoleLogPassThru(LoggerLevelName.verbose, ...input);
-    }
-    debug(format, ...input) {
-        const msg = this.createLogMessage(LoggerLevelName.debug, {}, format, ...input);
-        return this.recordMessage(msg);
-    }
-    debugP(...input) {
-        this.consoleLogPassThru(LoggerLevelName.debug, ...input);
-    }
-    silly(format, ...input) {
-        const msg = this.createLogMessage(LoggerLevelName.silly, {}, format, ...input);
-        return this.recordMessage(msg);
-    }
-    sillyP(...input) {
-        this.consoleLogPassThru(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);
-                }
-            });
-        }
-    }
-}

package/lib/logger/logger-level-name.js

@@ -1,9 +0,0 @@
-export var LoggerLevelName;
-(function (LoggerLevelName) {
-    LoggerLevelName["error"] = "error";
-    LoggerLevelName["warn"] = "warn";
-    LoggerLevelName["info"] = "info";
-    LoggerLevelName["verbose"] = "verbose";
-    LoggerLevelName["debug"] = "debug";
-    LoggerLevelName["silly"] = "silly";
-})(LoggerLevelName || (LoggerLevelName = {}));

package/lib/logger/logger-meta.js

@@ -1 +0,0 @@
-export {};

package/lib/logger/logger-options.js

@@ -1 +0,0 @@
-export {};

package/lib/logger/logger-output-function.js

@@ -1,6 +0,0 @@
-export var LoggerOutputFunction;
-(function (LoggerOutputFunction) {
-    LoggerOutputFunction["Console"] = "Console";
-    LoggerOutputFunction["ConsoleNoDebug"] = "ConsoleNoDebug";
-    LoggerOutputFunction["StdOut"] = "StdOut";
-})(LoggerOutputFunction || (LoggerOutputFunction = {}));

package/lib/logger/logger-ring-buffer.js

@@ -1,73 +0,0 @@
-import { Logger } from './logger.js';
-import { LoggerLevelName } from './logger-level-name.js';
-export class LoggerRingBuffer {
-    _lastLogMessage = { messageSource: 'No message yet', timestamp: new Date().getTime(), lvl: LoggerLevelName.info };
-    _buffer = [];
-    _bufferIdx = 0;
-    _lastSnapshotIdx = 0;
-    _bufferSize;
-    constructor(size) {
-        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.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.info('Cleared ring buffer (size is now %d)', this._bufferSize);
-    }
-    addToRingBuffer(newMsg) {
-        this._lastLogMessage = newMsg;
-        this._buffer[this._bufferIdx % this._bufferSize] = newMsg;
-        this._bufferIdx++;
-    }
-}

package/lib/logger/logger-util.js

@@ -1,44 +0,0 @@
-import { LoggerLevelName } from './logger-level-name.js';
-import { LoggerOutputFunction } from './logger-output-function.js';
-export class LoggerUtil {
-    static LOG_LEVELS_IN_ORDER = [
-        LoggerLevelName.error,
-        LoggerLevelName.warn,
-        LoggerLevelName.info,
-        LoggerLevelName.verbose,
-        LoggerLevelName.debug,
-        LoggerLevelName.silly,
-    ];
-    static handlerFunctionMap(outputFn = LoggerOutputFunction.Console) {
-        const output = new Map();
-        if (outputFn === LoggerOutputFunction.StdOut) {
-            if (!process?.stdout?.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(LoggerLevelName.error, myStdOut);
-            output.set(LoggerLevelName.warn, myStdOut);
-            output.set(LoggerLevelName.info, myStdOut);
-            output.set(LoggerLevelName.verbose, myStdOut);
-            output.set(LoggerLevelName.debug, myStdOut);
-            output.set(LoggerLevelName.silly, myStdOut);
-        }
-        else {
-            output.set(LoggerLevelName.error, console.error);
-            output.set(LoggerLevelName.warn, console.warn);
-            output.set(LoggerLevelName.info, console.info);
-            output.set(LoggerLevelName.verbose, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
-            output.set(LoggerLevelName.debug, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
-            output.set(LoggerLevelName.silly, outputFn === 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;
-    }
-}

package/lib/logger/logger-util.spec.js

@@ -1,9 +0,0 @@
-import { LoggerUtil } from './logger-util.js';
-import { LoggerLevelName } from './logger-level-name.js';
-describe('#checkLevel', function () {
-    it('should check that level logging works', function () {
-        expect(LoggerUtil.levelIsEnabled(LoggerLevelName.info, LoggerLevelName.warn)).toEqual(false);
-        expect(LoggerUtil.levelIsEnabled(LoggerLevelName.warn, LoggerLevelName.info)).toEqual(true);
-        expect(LoggerUtil.levelIsEnabled(LoggerLevelName.warn, LoggerLevelName.warn)).toEqual(true);
-    });
-});

package/lib/logger/logger.js

@@ -1,134 +0,0 @@
-import { LoggerInstance } from './logger-instance.js';
-import { LogMessageFormatType } from './log-message-format-type.js';
-import { LoggerLevelName } from './logger-level-name.js';
-import { LoggerOutputFunction } from './logger-output-function.js';
-export class Logger {
-    static LOGGER_INSTANCES = new Map();
-    static DEFAULT_OPTIONS = {
-        initialLevel: LoggerLevelName.info,
-        formatType: LogMessageFormatType.ClassicSingleLine,
-        trace: null,
-        globalVars: {},
-        outputFunction: LoggerOutputFunction.Console,
-        ringBufferSize: 0,
-        preProcessors: [],
-    };
-    static applyDefaultsToOptions(input) {
-        const rval = input || {};
-        rval.initialLevel = rval.initialLevel ?? Logger.DEFAULT_OPTIONS.initialLevel;
-        rval.formatType = rval.formatType ?? Logger.DEFAULT_OPTIONS.formatType;
-        rval.trace = rval.trace ?? Logger.DEFAULT_OPTIONS.trace;
-        rval.globalVars = rval.globalVars ?? Logger.DEFAULT_OPTIONS.globalVars;
-        rval.outputFunction = rval.outputFunction ?? Logger.DEFAULT_OPTIONS.outputFunction;
-        rval.ringBufferSize = rval.ringBufferSize ?? 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 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;
-    }
-}

package/lib/logger/logger.spec.js

@@ -1,134 +0,0 @@
-import { Logger } from './logger.js';
-import { LoggerLevelName } from './logger-level-name.js';
-import { StringRatchet } from '../lang/string-ratchet.js';
-import { LogMessageBuilder } from './log-message-builder.js';
-import { LogMessageFormatType } from './log-message-format-type.js';
-import { LoggerOutputFunction } from './logger-output-function.js';
-describe('#setLevel', function () {
-    it('should change the level to debug then info then debug', function () {
-        Logger.dumpConfigurationIntoLog();
-        expect(Logger.getLevel()).toEqual(LoggerLevelName.info);
-        Logger.setLevel(LoggerLevelName.debug);
-        expect(Logger.getLevel()).toEqual(LoggerLevelName.debug);
-        Logger.setLevel(LoggerLevelName.info);
-        expect(Logger.getLevel()).toEqual(LoggerLevelName.info);
-        Logger.setLevel(LoggerLevelName.debug);
-        expect(Logger.getLevel()).toEqual(LoggerLevelName.debug);
-    });
-});
-describe('#takeSnapshot', function () {
-    it('should advance the pointer correctly after a snapshot', function () {
-        Logger.changeRingBufferSize(5);
-        expect(Logger.getRingBuffer().currentIndex).toEqual(0);
-        Logger.info('m1');
-        Logger.info('m2');
-        Logger.info('m3');
-        const snap1 = Logger.takeSnapshot();
-        Logger.info('m4');
-        Logger.info('m5');
-        const snap2 = Logger.takeSnapshot();
-        Logger.info('m6');
-        Logger.info('m7');
-        Logger.info('m8');
-        const snap3 = Logger.takeSnapshot();
-        expect(snap1.messages.length).toEqual(3);
-        expect(snap2.messages.length).toEqual(2);
-        expect(snap3.messages.length).toEqual(3);
-        expect(Logger.getRingBuffer().currentIndex).toEqual(8);
-    });
-});
-describe('#testTracePrefix', function () {
-    it('should apply a trace prefix correctly', function () {
-        Logger.updateTracePrefix('::TRACE::');
-        Logger.changeRingBufferSize(3);
-        Logger.info('m1');
-        Logger.info('m2');
-        const snap1 = Logger.takeSnapshot();
-        const snap1String = Logger.formatMessages(snap1.messages);
-        expect(snap1String.length).toBeGreaterThan(0);
-        snap1String.forEach((m) => {
-            expect(m.indexOf('::TRACE::')).toBeGreaterThan(-1);
-        });
-        Logger.updateTracePrefix(null);
-        Logger.info('m1');
-        Logger.info('m2');
-        const snap2 = Logger.takeSnapshot();
-        expect(snap2.messages.length).toBeGreaterThan(0);
-        snap2.messages.forEach((m) => {
-            expect(m.messageSource.indexOf('::TRACE::')).toEqual(-1);
-        });
-    });
-});
-describe('#testLastMessage', function () {
-    it('should return the last message', function () {
-        Logger.info('m1');
-        Logger.info('m2');
-        const last = Logger.getLastLogMessage();
-        expect(last).toBeTruthy();
-        expect(last.lvl).toEqual(LoggerLevelName.info);
-        expect(last.messageSource.endsWith('m2')).toBeTruthy();
-    });
-});
-describe('#testPassThruFunctions', function () {
-    it('should pass through values', function () {
-        Logger.setLevel(LoggerLevelName.debug);
-        Logger.error('Test %s', 'tVal');
-        Logger.errorP('TestP %s', 'tVal');
-        Logger.errorP('TestP 2', 27, { some: 'Object' });
-        Logger.warn('Test %s', 'tVal');
-        Logger.warnP('TestP %s', 'tVal');
-        Logger.info('Test %s', 'tVal');
-        Logger.infoP('TestP %s', 'tVal');
-        Logger.debug('Test %s', 'tVal');
-        Logger.debugP('TestP %s', 'tVal');
-        Logger.verbose('Test %s', 'tVal');
-        Logger.verboseP('TestP %s', 'tVal');
-        Logger.silly('Test %s', 'tVal');
-        Logger.sillyP('TestP %s', 'tVal');
-        Logger.setLevel(LoggerLevelName.debug);
-    });
-});
-describe('#testFormatter', function () {
-    it('should format values', function () {
-        const msg = {
-            lvl: LoggerLevelName.info,
-            timestamp: Date.now(),
-            messageSource: 'Test %d %d',
-            subsVars: [1, 2],
-            params: {},
-        };
-        Logger.info('Test %d %d', 3, 4);
-        const msgS = Logger.formatMessages([msg])[0];
-        expect(msgS).toEqual('[info] Test 1 2');
-    });
-});
-describe('#testPreProcessor', function () {
-    it('should perform a preprocess', function () {
-        const preProc = {
-            process(msg) {
-                msg.messageSource = 'Preprocess';
-                return msg;
-            },
-        };
-        const output = Logger.getLogger(StringRatchet.createRandomHexString(4), { preProcessors: [preProc] }).info('This is a test %s', 'bob');
-        expect(output).toEqual('[info] Preprocess bob');
-    });
-});
-describe('#testBuilder', function () {
-    it('should use a builder', function () {
-        const output = Logger.getLogger(StringRatchet.createRandomHexString(4)).recordMessageBuilder(new LogMessageBuilder(LoggerLevelName.warn, 'This is a test %s').subVars(['bob']));
-        expect(output).toEqual('[warn] This is a test bob');
-    });
-});
-describe('#testStructured', function () {
-    it('should use a structured logger', function () {
-        const output = Logger.getLogger(StringRatchet.createRandomHexString(4), {
-            formatType: LogMessageFormatType.StructuredJson,
-            outputFunction: LoggerOutputFunction.StdOut,
-        }).recordMessageBuilder(new LogMessageBuilder(LoggerLevelName.warn, 'This is a test %s').subVars(['bob']).p('a', 27));
-        const parsed = JSON.parse(output);
-        expect(parsed.msg).toEqual('This is a test bob');
-        expect(parsed.logLevel).toEqual('warn');
-        expect(parsed.a).toEqual(27);
-    });
-});

package/lib/logger/none-log-message-formatter.js

@@ -1,5 +0,0 @@
-export class NoneLogMessageFormatter {
-    formatMessage(msg, meta) {
-        return null;
-    }
-}

package/lib/logger/structured-json-log-message-formatter.js

@@ -1,19 +0,0 @@
-import util from 'util';
-export class StructuredJsonLogMessageFormatter {
-    formatMessage(msg, meta) {
-        let rval = null;
-        if (msg) {
-            const tmp = Object.assign({}, meta.options.globalVars || {}, msg.params || {});
-            tmp['msg'] = util.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;
-    }
-}

package/lib/network/browser-local-ip-provider.js

@@ -1,21 +0,0 @@
-import { NetworkRatchet } from './network-ratchet.js';
-import { Logger } from '../logger/logger.js';
-export class BrowserLocalIpProvider {
-    currentIp = 'UNSET';
-    constructor() {
-        NetworkRatchet.findLocalIp(false)
-            .then((result) => {
-            Logger.info('Setting local IP to %s', result);
-            this.currentIp = result;
-        })
-            .catch((err) => {
-            Logger.warn('Unable to set current IP - leaving as UNSET : %s', err);
-        });
-    }
-    ready() {
-        return this.currentIp !== 'UNSET';
-    }
-    currentLocalIpAddress() {
-        return this.currentIp;
-    }
-}