struct-logger 0.0.1-security → 1.0.7

package/index.d.ts

@@ -0,0 +1,309 @@
+///<reference lib="ES2015"/>
+///<reference types="moment"/>
+
+import moment = require("moment");
+
+type STANDARD_LEVELS = SimpleLogger.STANDARD_LEVELS;
+type Logger = SimpleLogger.Logger;
+
+type IConsoleAppenderOptions = SimpleLogger.IConsoleAppenderOptions;
+type ConsoleAppender = SimpleLogger.appenders.ConsoleAppender;
+type IFileAppenderOptions = SimpleLogger.IFileAppenderOptions;
+type FileAppender = SimpleLogger.appenders.FileAppender;
+type IRollingFileAppenderOptions = SimpleLogger.IRollingFileAppenderOptions;
+type RollingFileAppender = SimpleLogger.appenders.RollingFileAppender;
+type PrepareLogger = SimpleLogger.PrepareLogger;
+type AbstractAppender = SimpleLogger.AbstractAppender;
+type ISimpleLoggerOptions = SimpleLogger.ISimpleLoggerOptions;
+declare class SimpleLogger
+{
+	constructor(opts?: ISimpleLoggerOptions);
+	createLogger(options?: SimpleLogger.ILoggerOptions): Logger;
+	createLogger(category?: string, level?: STANDARD_LEVELS): Logger;
+	createConsoleAppender(opts?: IConsoleAppenderOptions): ConsoleAppender;
+	createFileAppender(opts?: IFileAppenderOptions): FileAppender;
+	createPrepareLogger(options?: SimpleLogger.PrepareLogger): PrepareLogger;
+	createRollingFileAppender(opts?: IRollingFileAppenderOptions): RollingFileAppender;
+	addAppender<T extends AbstractAppender>(appender: AbstractAppender): T;
+	getAppenders(): AbstractAppender[];
+	getLoggers(): Logger[];
+	startRefreshThread(): void;
+	setAllLoggerLevels(level: STANDARD_LEVELS): void;
+	readConfig(completeCallback?: (err?: any) => void): void;
+}
+
+
+
+declare namespace SimpleLogger
+{
+	export type STANDARD_LEVELS = 'all' | 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+	interface IEntry
+	{
+		ts: moment.MomentInput;
+		pid: number;
+		domain?: string;
+		category?: string;
+		level: STANDARD_LEVELS;
+		msg: any | any[];
+	}
+	interface ISimpleLoggerOptions
+	{
+		domain?: string;
+		loggers?: Logger[];
+		level?: STANDARD_LEVELS;
+		loggerConfigFile?: string;
+		refresh?: number;
+		fs?: any;
+		createInterval?: typeof setInterval;
+		minRefresh?: number;
+		errorEventName?: string;
+	}
+	export interface ILoggerOptions
+	{
+		pid?: number;
+		errorEventName?: string;
+		domain?: string;
+		category?: string;
+		level?: STANDARD_LEVELS;
+		levels?: STANDARD_LEVELS[];
+		appenders?: AbstractAppender[]
+	}
+	export interface PrepareLogger
+	{
+		id?: number;
+		errorEventName?: string;
+		domain?: string;
+		category?: string;
+		level?: STANDARD_LEVELS;
+		levels?: STANDARD_LEVELS[];
+		appenders?: AbstractAppender[]
+	}
+	export namespace Logger
+	{
+		var STANDARD_LEVELS: STANDARD_LEVELS[];
+		var DEFAULT_LEVEL: STANDARD_LEVELS;
+	}
+	export class Logger
+	{
+
+		constructor(options?: ILoggerOptions);
+		/**
+		 * log the statement message
+		 *
+		 * @param level the level of this message (label, i.e, info, warn, etc)
+		 * @param msg
+		 */
+		log(level: STANDARD_LEVELS, msg: any[] | any): void;
+
+		/**
+		 * set the level
+		 *
+		 * @param lvl one of the recognized logger levels
+		 */
+		setLevel(lvl: STANDARD_LEVELS): void;
+
+		/**
+		 * return the current level string
+		 */
+		getLevel(): STANDARD_LEVELS;
+
+		/**
+		 * set the list of appenders
+		 * @param appenderList
+		 */
+		setAppenders(appenderList: AbstractAppender[]): void;
+
+		/**
+		 * add an appender to the list
+		 *
+		 * @param appender - implements write method
+		 */
+		addAppender<T extends AbstractAppender>(appender: T): T;
+
+		/**
+		 * remove the appender using the type name
+		 */
+		removeAppender(typeName: string): void;
+
+
+		getAppenders(): AbstractAppender[];
+		isDebug(): boolean;
+		isInfo(): boolean;
+
+		/**
+		 * return the status map with log counts for each level
+		 */
+		getStats(): Map<STANDARD_LEVELS, number>;
+
+		getCategory(): string | undefined;
+
+		getDomain(): string | undefined;
+
+		all(...arr: any[]): void;
+		trace(...arr: any[]): void;
+		debug(...arr: any[]): void;
+		info(...arr: any[]): void;
+		warn(...arr: any[]): void;
+		error(...arr: any[]): void;
+		fatal(...arr: any[]): void;
+	}
+
+	export interface IAbstractAppenderOptions
+	{
+		typeName?: string;
+		timestampFormat?: string;
+		prettyPrint?: boolean;
+		separator?: string;
+		level?: STANDARD_LEVELS;
+		levels?: STANDARD_LEVELS[];
+	}
+	export interface IConsoleAppenderOptions extends IAbstractAppenderOptions
+	{
+		typeName?: string;
+		writer?: Function;
+	}
+	export interface IFileAppenderOptions extends IAbstractAppenderOptions
+	{
+		typeName?: string;
+		fs?: any;
+		autoOpen?: boolean;
+		logFilePath: string;
+		writer?: any;
+	}
+	export interface IRollingFileAppenderOptions extends IAbstractAppenderOptions
+	{
+		typeName?: string;
+		fs?: any;
+		autoOpen?: boolean;
+		logDirectory: string;
+		fileNamePattern: string;
+		dateFormat?: string;
+		currentFile?: string;
+		createInterval?: typeof setInterval;
+	}
+
+	export abstract class AbstractAppender
+	{
+		constructor(options?: IAbstractAppenderOptions);
+		/**
+		 * format the entry and return the field list
+		 *
+		 * @param entry the log entry
+		 * @param thisArg - use this to override the base object
+		 *
+		 * @returns field array
+		 */
+		formatEntry(entry: any, thisArg?: AbstractAppender): string[];
+
+		/**
+		 * format the message
+		 *
+		 * @param msg the log message
+		 * @param thisArg - use this to override the base object
+		 *
+		 * @returns field array
+		 */
+		formatMessage(msg: any | any[], thisArg?: AbstractAppender): string;
+
+		formatDate(value: Date): string;
+		formatObject(value: any): string;
+		formatLevel(level: STANDARD_LEVELS): string;
+		formatTimestamp(ts: moment.MomentInput): string;
+		getTypeName(): string;
+
+		//formatter(entry: any): string;
+		abstract write(entry: IEntry): void;
+		abstract setLevel(level: STANDARD_LEVELS): void;
+
+		__protected(): any;
+	}
+
+	//export type IConsoleAppenderOptions = appenders.IConsoleAppenderOptions;
+	//export type IFileAppenderOptions = appenders.IFileAppenderOptions;
+	//export type IRollingFileAppenderOptions = appenders.IRollingFileAppenderOptions;
+
+	export namespace appenders
+	{
+
+
+		export class ConsoleAppender extends AbstractAppender
+		{
+			constructor(options: IAbstractAppenderOptions & IConsoleAppenderOptions);
+			formatter(entry: IEntry): string;
+			write(entry: IEntry): void;
+			setLevel(level: STANDARD_LEVELS): void;
+		}
+
+
+		export class FileAppender extends AbstractAppender
+		{
+			constructor(options?: IFileAppenderOptions);
+			formatter(entry: IEntry): string;
+			write(entry: IEntry): void;
+			setLevel(level: STANDARD_LEVELS): void;
+		}
+
+
+		export class RollingFileAppender extends AbstractAppender
+		{
+			constructor(options?: IRollingFileAppenderOptions);
+			formatter(entry: IEntry): string;
+			write(entry: IEntry): void;
+			setLevel(level: STANDARD_LEVELS): void;
+
+			checkForRoll(now?: moment.Moment): boolean;
+			createFileName(now?: moment.Moment): string;
+		}
+	}
+
+
+	/**
+	 * static convenience method to create a file logger (no console logging);
+	 *
+	 * @param options - if string then it's the logFilePath, else options with the logFilePath
+	 * @returns Logger
+	 */
+	export function createSimpleLogger(): Logger;
+	export function createPrepareLogger(): PrepareLogger;
+	export function createSimpleLogger(logFilePath: string): Logger;
+	export function createSimpleLogger(options: ISimpleLoggerOptions &
+		Partial<IConsoleAppenderOptions> &
+		Partial<IFileAppenderOptions>): Logger;
+
+	/**
+	 * create a rolling file logger by passing options to SimpleLogger and Logger.  this enables setting
+	 * of domain, category, etc.
+	 *
+	 * @param options
+	 * @returns rolling logger
+	 */
+	export function createSimpleFileLogger(logFilePath: string): Logger;
+	export function createSimpleFileLogger(options: ISimpleLoggerOptions &
+		IFileAppenderOptions): Logger;
+
+	/**
+	 * create a rolling file appender and add it to the appender list
+	 *
+	 * @param options
+	 * @returns the appender
+	 */
+	export function createRollingFileLogger(options: ISimpleLoggerOptions &
+		IRollingFileAppenderOptions &
+	{ readLoggerConfig?: Function }): Logger;
+
+	/**
+	 * create a log manager
+	 *
+	 * @param options - file or rolling file specs;
+	 */
+	export function createLogManager(options?: ISimpleLoggerOptions &
+		Partial<IRollingFileAppenderOptions> &
+		Partial<IConsoleAppenderOptions> &
+	{ readLoggerConfig?: Function }): SimpleLogger;
+}
+
+export = SimpleLogger;
+
+
+
+

package/index.js

@@ -0,0 +1,19 @@
+
+/** darryl.west@raincitysoftware.com **/
+
+module.exports = require('./lib/SimpleLogger');
+module.exports.AbstractAppender = require('./lib/AbstractAppender');
+module.exports.Logger = require('./lib/Logger');
+module.exports.PrepareLogger = require('./lib/PrepareLogger');
+
+module.exports.appenders = {
+    ConsoleAppender:require('./lib/ConsoleAppender'),
+    FileAppender:require('./lib/FileAppender'),
+    RollingFileAppender:require('./lib/RollingFileAppender')
+};
+
+module.exports.mocks = {
+    MockAppender:require('./test/mocks/MockAppender'),
+    MockLogger:require('./test/mocks/MockLogger')
+};
+

package/lib/AbstractAppender.js

@@ -0,0 +1,161 @@
+/**
+ * @class AbstractAppender
+ *
+ * @author: darryl.west@raincitysoftware.com
+ * @created: 7/7/14 5:58 PM
+ */
+const util = require( 'util' );
+const moment = require( 'moment' );
+const dash = require( 'lodash' );
+
+const AbstractAppender = function(options) {
+    'use strict';
+
+    const appender = this;
+    const typeName = options.typeName;
+    const timestampFormat = options.timestampFormat || 'HH:mm:ss.SSS';
+    const prettyPrint = options.prettyPrint;
+
+    this.separator = options.separator || ' ';
+
+    /**
+     * format the entry and return the field list
+     *
+     * @param entry the log entry
+     * @param thisArg - use this to override the base object
+     *
+     * @returns field array
+     */
+    this.formatEntry = function(entry, thisArg) {
+        const apdr = thisArg || appender;
+
+        const fields = [];
+
+        if (entry.domain) {
+            fields.push( entry.domain );
+        }
+
+        fields.push( apdr.formatTimestamp( entry.ts ) );
+        fields.push( apdr.formatLevel( entry.level ) );
+
+        if (entry.category) {
+            fields.push( entry.category );
+        }
+
+        fields.push( apdr.formatMessage( entry.msg ) );
+
+        return fields;
+    };
+
+    /**
+     * format the message
+     *
+     * @param msg the log message
+     * @param thisArg - use this to override the base object
+     *
+     * @returns field array
+     */
+    this.formatMessage = function(msg, thisArg) {
+        const apdr = thisArg || appender;
+
+        if (!msg) {
+            return '';
+        }
+
+        if (util.isArray( msg )) {
+            const list = msg.map(function(item) {
+                if (util.isDate( item )) {
+                    return apdr.formatDate( item );
+                } else {
+                    return apdr.formatObject( item );
+                }
+            });
+
+            return list.join('');
+        } else {
+            return msg;
+        }
+    };
+
+    this.formatDate = function(value) {
+        return value.toJSON();
+    };
+
+    this.formatObject = function(value) {
+        if (!value) {
+            return '';
+        }
+
+        if (dash.isObject( value )) {
+            try {
+                if (value instanceof Error) {
+                    return [
+                        value.message,
+                        (prettyPrint) ? JSON.stringify( value, null, 2) : JSON.stringify( value ),
+                        value.stack
+                    ].join('\n');
+                }
+                
+                return (prettyPrint) ? JSON.stringify( value, null, 2) : JSON.stringify( value );
+            } catch (ignore) {
+                return 'json error: ' + value.toString();
+            }
+        } else {
+            var s = value.toString();
+            if (s === '[object Object]') {
+                return util.inspect( value );
+            } else {
+                return s;
+            }
+        }
+    };
+
+    /**
+     * format the level string by forcing to upper case and padding to 5 chars
+     *
+     * @param level
+     * @returns {string}
+     */
+    this.formatLevel = function(level) {
+        let str = level.toUpperCase();
+        if (str.length < 5) {
+            str += ' ';
+        }
+
+        return str;
+    };
+
+    /**
+     * format the timestamp to HH:mm:ss.SSS
+     *
+     * @param ts the unix milliseconds
+     * @returns formatted string
+     */
+    this.formatTimestamp = function(ts) {
+        return moment( ts ).format( timestampFormat );
+    };
+
+    /**
+     * return the type name of this appender (ConsoleAppender)
+     */
+    this.getTypeName = function() {
+        return typeName;
+    };
+
+    // constructor tests
+    if (!typeName) {
+        throw new Error('appender must be constructed with a type name');
+    }
+};
+
+module.exports = AbstractAppender;
+
+AbstractAppender.extend = function(child, options) {
+    'use strict';
+
+    const parent = new AbstractAppender( options );
+
+    dash.extend( child, parent );
+
+    return parent;
+};

package/lib/ConsoleAppender.js

@@ -0,0 +1,57 @@
+/**
+ * @class ConsoleAppender
+ * @classdesc ConsoleAppender writes to the console all entries at or above the specified level.
+ *
+ * @author: darryl.west@raincitysoftware.com
+ * @created: 7/6/14 12:02 PM
+ */
+const Logger = require('./Logger' );
+const AbstractAppender = require('./AbstractAppender' );
+
+/*eslint no-console: "off"*/
+const ConsoleAppender = function(opts) {
+    'use strict';
+
+    // get a copy of the opts
+    const options = Object.assign({}, opts);
+
+    const appender = this;
+    const typeName = options.typeName || 'ConsoleAppender';
+    const writer = options.writer || console.log;
+
+    let level = options.level || Logger.STANDARD_LEVELS[0];
+    let levels = options.levels || Logger.STANDARD_LEVELS;
+    let currentLevel = levels.indexOf( level );
+
+    options.typeName = typeName;
+    AbstractAppender.extend( this, options );
+
+    /**
+     * default formatter for this appender;
+     * @param entry
+     */
+    this.formatter = function(entry) {
+        const fields = appender.formatEntry( entry );
+
+        return fields.join( appender.separator );
+    };
+
+    /**
+     * call formatter then write the entry to the console output
+     * @param entry - the log entry
+     */
+    this.write = function(entry) {
+        if (levels.indexOf( entry.level ) >= currentLevel) {
+            writer( appender.formatter( entry ));
+        }
+    };
+
+    this.setLevel = function(level) {
+        const idx = levels.indexOf( level );
+        if (idx >= 0) {
+            currentLevel = idx;
+        }
+    };
+};
+
+module.exports = ConsoleAppender;

package/lib/FileAppender.js

@@ -0,0 +1,91 @@
+/**
+ * @class FileAppender
+ *
+ * @author: darryl.west@raincitysoftware.com
+ * @created: 7/7/14 5:15 PM
+ */
+const Logger = require('./Logger' );
+const AbstractAppender = require('./AbstractAppender' );
+const dash = require( 'lodash' );
+const path = require( 'path' );
+
+const FileAppender = function(options) {
+    'use strict';
+
+    const appender = this;
+    const fs = options.fs || require( 'fs' );        
+    const newline = /^win/.test(process.platform) ? '\r\n' : '\n';
+    const typeName = options.typeName || 'FileAppender';
+    const autoOpen = dash.isBoolean( options.autoOpen ) ? options.autoOpen : true;
+    const levels = options.levels || Logger.STANDARD_LEVELS;
+
+    let level = options.level || Logger.DEFAULT_LEVEL;
+    let currentLevel = levels.indexOf( level );
+    let logFilePath = options.logFilePath;
+    let writer = options.writer;
+
+    options.typeName = typeName;
+    AbstractAppender.extend( this, options );
+
+    /**
+     * default formatter for this appender;
+     * @param entry
+     */
+    this.formatter = function(entry) {
+        const fields = appender.formatEntry( entry );
+
+        // add new line (for linux and windows)
+        fields.push( newline );
+        
+        return fields.join( appender.separator );
+    };
+
+    /**
+     * call formatter then write the entry to the console output
+     * @param entry - the log entry
+     */
+    this.write = function(entry) {
+        if (levels.indexOf( entry.level ) >= currentLevel) {
+            writer.write( appender.formatter( entry ) );
+        }
+    };
+
+    this.setLevel = function(level) {
+        const idx = levels.indexOf( level );
+        if (idx >= 0) {
+            currentLevel = idx;
+        }
+    };
+
+    // writer is opened on construction
+    const openWriter = function() {
+        if (!writer) {
+            const file = path.normalize( logFilePath );
+            const opts = {
+                flags:'a',
+                encoding:'utf8'
+            };
+
+            writer = fs.createWriteStream( file, opts );
+        }
+    };
+
+    this.closeWriter = function() {
+        if (writer) {
+            writer.end('\n');
+        }
+    };
+
+    // constructor tests
+    (function() {
+        if (!logFilePath) {
+            throw new Error('appender must be constructed with a log file path');
+        }
+    }());
+
+    if (autoOpen) {
+        openWriter();
+    }
+};
+
+module.exports = FileAppender;