[v0.4.0] Feature/file logger

@types/abstractions/message-handler-base.d.ts

@@ -1,4 +1,4 @@
-import { LogLevel } from "./log-level";
+import { LogLevel } from "simplr-logger";
 export declare abstract class MessageHandlerBase {
     abstract HandleMessage(level: LogLevel, isLevelEnabled: boolean, timestamp: number, messages: any[]): void;
 }

@types/builders/logger-builder.d.ts

@@ -1,5 +1,4 @@
-import { LoggerConfiguration } from "./logger-configuration-builder";
-import { LogLevel } from "../abstractions/log-level";
+import { LogLevel, LoggerConfiguration } from "simplr-logger";
 export declare class LoggerBuilder {
     private configuration;
     constructor(configuration?: LoggerConfiguration);

@types/builders/logger-configuration-builder.d.ts

@@ -1,7 +1,10 @@
-import { MessageHandlerBase } from "../abstractions/message-handler-base";
-import { LogLevel } from "../abstractions/log-level";
+import { LogLevel, MessageHandlerBase } from "simplr-logger";
 export interface LoggerConfiguration {
-    WriteMessageHandler: MessageHandlerBase;
+    /**
+     * @deprecated Use WriteMessageHandlers instead.
+     */
+    WriteMessageHandler?: MessageHandlerBase;
+    WriteMessageHandlers: MessageHandlerBase[];
     LogLevel: LogLevel;
     CustomLogLevels?: boolean;
     Prefix?: string;
@@ -17,8 +20,21 @@ export declare class LoggerConfigurationBuilder {
      * Set custom message handler.
      *
      * @param handler Log messages handler.
+     * @deprecated Use AddWriteMessageHandlers instead.
      */
     SetWriteMessageHandler(handler: MessageHandlerBase): this;
+    /**
+     * Add write message handler.
+     *
+     * @param handler Log messages handler.
+     */
+    AddWriteMessageHandler(handlers: MessageHandlerBase): this;
+    /**
+     * Add write message handlers.
+     *
+     * @param handlers Log messages handlers list.
+     */
+    AddWriteMessageHandlers(handlers: MessageHandlerBase[]): this;
     /**
      * Set log level.
      *

@types/handlers/console-message-handler.d.ts

@@ -1,5 +1,4 @@
-import { LogLevel } from "../abstractions/log-level";
-import { MessageHandlerBase } from "../abstractions/message-handler-base";
+import { MessageHandlerBase, LogLevel } from "simplr-logger";
 export declare class ConsoleMessageHandler extends MessageHandlerBase {
     constructor(configuration?: Partial<ConsoleMessageHandler.Configuration>);
     private configuration;

@types/handlers/file-message-handler.d.ts

@@ -0,0 +1,12 @@
+import { MessageHandlerBase, LogLevel } from "simplr-logger";
+export declare class FileMessageHandler extends MessageHandlerBase {
+    private isServerSide;
+    constructor(filePathName: string, isServerSide?: boolean | undefined);
+    private filePathName;
+    private readonly handleMessageStackCount;
+    HandleMessage(level: LogLevel, isLevelEnabled: boolean, timestamp: number, messages: any[]): void;
+    private writeStream;
+    private getWriteStream();
+    private readonly EOL;
+    private ensureDirectory();
+}

@types/index.d.ts

@@ -2,5 +2,5 @@ export { LoggerBuilder } from "./builders/logger-builder";
 export { LoggerConfigurationBuilder, LoggerConfiguration } from "./builders/logger-configuration-builder";
 export { LogLevel } from "./abstractions/log-level";
 export { MessageHandlerBase } from "./abstractions/message-handler-base";
-import * as Handlers from "./handlers";
-export { Handlers };
+export { ConsoleMessageHandler } from "./handlers/console-message-handler";
+export { Helpers as LoggerHelpers } from "./utils/helpers";

@types/logger-handlers.d.ts

@@ -0,0 +1,2 @@
+export { ConsoleMessageHandler } from "simplr-logger";
+export { FileMessageHandler } from "./handlers/file-message-handler";

@types/utils/helpers.d.ts

@@ -1,4 +1,4 @@
-import { LogLevel } from "../abstractions/log-level";
+import { LogLevel } from "simplr-logger";
 export declare class HelpersBuilder {
     GetLogLevelShortString(level: LogLevel): string;
     GetLogLevelString(level: LogLevel): string;

README.md

@@ -1,6 +1,6 @@
 # Simplr Logger
 
-Simple JavaScript logger written in [TypeScript](http://typescriptlang.org).
+Simple JavaScript logger written in [TypeScript](http://typescriptlang.org) that can be used in browser or node application.
 
 The package is most useful when used with [TypeScript](http://typescriptlang.org).
 
@@ -24,9 +24,11 @@ const logger = new LoggerBuilder();
 
 ```ts
 import { LoggerBuilder, LoggerConfigurationBuilder, LogLevel } from "simplr-logger";
+import { FileMessageHandler, ConsoleMessageHandler } from "simplr-logger/handlers";
 
 const config = new LoggerConfigurationBuilder()
     .SetLogLevel(LogLevel.Trace)
+    .AddWriteMessageHandlers([new ConsoleMessageHandler(), new FileMessageHandler("./logs.txt")])
     .Build();
 
 const logger = new LoggerBuilder(config);
@@ -35,11 +37,11 @@ const logger = new LoggerBuilder(config);
 #### With simple object
 
 ```ts
-import { LoggerBuilder, LoggerConfigurationBuilder, LogLevel, Handlers } from "simplr-logger";
+import { LoggerBuilder, LoggerConfigurationBuilder, LogLevel, ConsoleMessageHandler } from "simplr-logger";
 
 const logger = new LoggerBuilder({
     LogLevel: LogLevel.Trace,
-    WriteMessageHandler: new Handlers.ConsoleMessageHandler()
+    WriteMessageHandlers: [new ConsoleMessageHandler()]
 });
 ```
 

dist/simplr-logger-handlers.js

@@ -0,0 +1,246 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, {
+/******/ 				configurable: false,
+/******/ 				enumerable: true,
+/******/ 				get: getter
+/******/ 			});
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 4);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+module.exports = require("tslib");
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports) {
+
+module.exports = require("simplr-logger");
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports) {
+
+module.exports = require("path");
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports) {
+
+module.exports = require("fs");
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(0);
+tslib_1.__exportStar(__webpack_require__(5), exports);
+
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var simplr_logger_1 = __webpack_require__(1);
+exports.ConsoleMessageHandler = simplr_logger_1.ConsoleMessageHandler;
+var file_message_handler_1 = __webpack_require__(6);
+exports.FileMessageHandler = file_message_handler_1.FileMessageHandler;
+
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(0);
+var simplr_logger_1 = __webpack_require__(1);
+var FileMessageHandler = /** @class */ (function (_super) {
+    tslib_1.__extends(FileMessageHandler, _super);
+    function FileMessageHandler(filePathName, isServerSide) {
+        var _this = _super.call(this) || this;
+        _this.isServerSide = isServerSide;
+        // IMPORTANT: The value must be changed after files structure were updated!
+        _this.handleMessageStackCount = 4;
+        if (_this.isServerSide == null) {
+            try {
+                // tslint:disable-next-line:no-require-imports no-unused-expression
+                __webpack_require__(7);
+                _this.isServerSide = true;
+            }
+            catch (_a) {
+                _this.isServerSide = false;
+            }
+        }
+        if (_this.isServerSide) {
+            // tslint:disable-next-line:no-require-imports
+            var normalize = __webpack_require__(2).normalize;
+            _this.filePathName = normalize(filePathName);
+            _this.ensureDirectory();
+        }
+        return _this;
+    }
+    FileMessageHandler.prototype.HandleMessage = function (level, isLevelEnabled, timestamp, messages) {
+        if (!this.isServerSide) {
+            return;
+        }
+        var writeStream = this.getWriteStream();
+        var formattedMessages = messages.map(function (msg) {
+            switch (typeof msg) {
+                case "string":
+                    return msg;
+                case "undefined":
+                case "boolean":
+                case "number":
+                case "function":
+                case "symbol":
+                    return String(msg);
+                case "object":
+                    if (msg instanceof Error) {
+                        return String(msg.stack);
+                    }
+                    else {
+                        return JSON.stringify(msg);
+                    }
+            }
+        });
+        if (level === simplr_logger_1.LogLevel.Trace) {
+            var err = new Error();
+            var stack = String(err.stack);
+            err = undefined;
+            var stackString = "\n" + stack.split("\n").slice(this.handleMessageStackCount, stack.length).join("\n");
+            formattedMessages.push(stackString);
+        }
+        var datePrefix = "[" + new Date(timestamp).toLocaleString() + "]";
+        writeStream.write(datePrefix + " " + simplr_logger_1.LoggerHelpers.GetLogLevelShortString(level) + ": " + formattedMessages.join(" ") + this.EOL);
+    };
+    FileMessageHandler.prototype.getWriteStream = function () {
+        var _this = this;
+        if (this.writeStream != null) {
+            return this.writeStream;
+        }
+        // tslint:disable-next-line:no-require-imports
+        var fs = __webpack_require__(3);
+        this.writeStream = fs.createWriteStream(this.filePathName, { flags: "a" });
+        this.writeStream.on("close", function () {
+            _this.writeStream = undefined;
+        });
+        this.writeStream.on("error", function (err) {
+            throw err;
+        });
+        return this.writeStream;
+    };
+    Object.defineProperty(FileMessageHandler.prototype, "EOL", {
+        get: function () {
+            // tslint:disable-next-line:no-require-imports
+            var EOL = __webpack_require__(8).EOL;
+            return EOL;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    FileMessageHandler.prototype.ensureDirectory = function () {
+        // tslint:disable-next-line:no-require-imports
+        var path = __webpack_require__(2);
+        // tslint:disable-next-line:no-require-imports
+        var fs = __webpack_require__(3);
+        var dir = path.dirname(this.filePathName);
+        var dirList = dir.split(path.sep);
+        var targetDir = (dir[0] !== path.sep && path.isAbsolute(dir)) ? "" : process.cwd();
+        for (var _i = 0, dirList_1 = dirList; _i < dirList_1.length; _i++) {
+            var a = dirList_1[_i];
+            targetDir = path.join(targetDir, a);
+            if (a.length > 0 && !fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir);
+            }
+        }
+    };
+    return FileMessageHandler;
+}(simplr_logger_1.MessageHandlerBase));
+exports.FileMessageHandler = FileMessageHandler;
+
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports) {
+
+module.exports = require("process");
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports) {
+
+module.exports = require("os");
+
+/***/ })
+/******/ ]);
+});