@emartech/json-logger 4.0.1 → 5.0.2

package/README.md

@@ -1,8 +1,7 @@
 # @emartech/json-logger
 
 A tiny and fast logging library that outputs logs in JSON format.
-It has the same namespace based enabling/disabling mechanism as [debug]
-and has the same log levels as [bunyan].
+It has the same namespace based enabling/disabling mechanism as [debug].
 
 ### Installation
 

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+interface Color {
+    number: number;
+    name: string;
+}
+export declare const config: {
+    levels: Record<string, Color>;
+    availableLevels: string[];
+    coloredNames: Record<string, string>;
+};
+export {};

package/dist/config.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const levels = {
+    trace: {
+        number: 10,
+        name: 'TRACE'
+    },
+    debug: {
+        number: 20,
+        name: 'DEBUG'
+    },
+    info: {
+        number: 30,
+        name: 'INFO'
+    },
+    warn: {
+        number: 40,
+        name: chalk_1.default.yellow('WARN')
+    },
+    error: {
+        number: 50,
+        name: chalk_1.default.red('ERROR')
+    },
+    fatal: {
+        number: 60,
+        name: chalk_1.default.red('FATAL')
+    },
+};
+const availableLevels = Object.keys(levels);
+const coloredNames = {};
+availableLevels.forEach((levelName) => {
+    coloredNames[levels[levelName].number] = levels[levelName].name;
+});
+exports.config = { levels, availableLevels, coloredNames };

package/dist/enabled/enabled.d.ts

@@ -0,0 +1 @@
+export declare function isNamespaceEnabled(availableNamespace: string, namespace: string): boolean;

package/dist/enabled/enabled.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNamespaceEnabled = void 0;
+function isNamespaceEnabled(availableNamespace, namespace) {
+    const availableNamespaces = availableNamespace.split(/[\s,]+/);
+    let enabled = false;
+    const adds = [];
+    const skips = [];
+    availableNamespaces.forEach(function (name) {
+        if (!name) {
+            return;
+        }
+        name = name.replace(/\*/g, '.*?');
+        if (name[0] === '-') {
+            skips.push(new RegExp('^' + name.substr(1) + '$'));
+        }
+        else {
+            adds.push(new RegExp('^' + name + '$'));
+        }
+    });
+    adds.forEach(function (addRegexp) {
+        if (addRegexp.test(namespace)) {
+            enabled = true;
+        }
+    });
+    skips.forEach(function (addRegexp) {
+        if (addRegexp.test(namespace)) {
+            enabled = false;
+        }
+    });
+    return enabled;
+}
+exports.isNamespaceEnabled = isNamespaceEnabled;

package/dist/formatter/debug.d.ts

@@ -0,0 +1,6 @@
+interface Log {
+    name: string;
+    level: string;
+}
+export declare function debugFormatter(log: Log): string;
+export {};

package/dist/formatter/debug.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugFormatter = void 0;
+const color_name_1 = require("../output/color-name/color-name");
+const stringify_level_1 = require("../output/stringify-level/stringify-level");
+const format_time_1 = require("../output/format-time/format-time");
+const format_body_1 = require("../output/format-body/format-body");
+const formatTime = new format_time_1.FormatTime();
+function debugFormatter(log) {
+    return [
+        color_name_1.ColorName.addColor(log.name),
+        (0, stringify_level_1.stringifyLevel)(log.level),
+        formatTime.elapsedTime(),
+        (0, format_body_1.formatBody)(log)
+    ].join(' ');
+}
+exports.debugFormatter = debugFormatter;
+;

package/dist/formatter/index.d.ts

@@ -0,0 +1,8 @@
+import { jsonFormatter } from './json';
+import { logentriesFormatter } from './logentries';
+import { debugFormatter } from './debug';
+export declare const formatter: {
+    json: typeof jsonFormatter;
+    debug: typeof debugFormatter;
+    logentries: typeof logentriesFormatter;
+};

package/dist/formatter/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatter = void 0;
+const json_1 = require("./json");
+const logentries_1 = require("./logentries");
+const debug_1 = require("./debug");
+exports.formatter = {
+    json: json_1.jsonFormatter,
+    debug: debug_1.debugFormatter,
+    logentries: logentries_1.logentriesFormatter
+};

package/dist/formatter/json.d.ts

@@ -0,0 +1 @@
+export declare function jsonFormatter(log: unknown): string;

package/dist/formatter/json.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonFormatter = void 0;
+function jsonFormatter(log) {
+    return JSON.stringify(log);
+}
+exports.jsonFormatter = jsonFormatter;

package/dist/formatter/logentries.d.ts

@@ -0,0 +1 @@
+export declare function logentriesFormatter(data: Record<string, unknown>): string;

package/dist/formatter/logentries.js

@@ -0,0 +1,24 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logentriesFormatter = void 0;
+const isNumeric = (value) => !isNaN(parseFloat(value)) && isFinite(value);
+const isString = (value) => typeof value === 'string' || value instanceof String;
+const convertToTag = (value, key) => {
+    if (isString(value)) {
+        value = JSON.stringify(value);
+    }
+    else if (isNumeric(value)) {
+        value = value.toString();
+    }
+    else {
+        value = '"' + JSON.stringify(value) + '"';
+    }
+    return key + '=' + value;
+};
+function logentriesFormatter(data) {
+    return Object
+        .keys(data)
+        .map(key => convertToTag(data[key], key))
+        .join(' ');
+}
+exports.logentriesFormatter = logentriesFormatter;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { Logger, LoggerConfig } from './logger/logger';
+export { Logger, LoggerConfig } from './logger/logger';
+export { Timer } from './timer/timer';
+export declare function logFactory(namespace: string): Logger;
+export declare namespace logFactory {
+    var Logger: typeof import("./logger/logger").Logger;
+    var Timer: typeof import("./timer/timer").Timer;
+    var getNamespaces: () => string;
+    var configure: (options: LoggerConfig) => void;
+    var formatter: {
+        json: typeof import("./formatter/json").jsonFormatter;
+        debug: typeof import("./formatter/debug").debugFormatter;
+        logentries: typeof import("./formatter/logentries").logentriesFormatter;
+    };
+}
+export default logFactory;

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFactory = exports.Timer = exports.Logger = void 0;
+const logger_1 = require("./logger/logger");
+var logger_2 = require("./logger/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_2.Logger; } });
+const timer_1 = require("./timer/timer");
+var timer_2 = require("./timer/timer");
+Object.defineProperty(exports, "Timer", { enumerable: true, get: function () { return timer_2.Timer; } });
+const enabled_1 = require("./enabled/enabled");
+const formatter_1 = require("./formatter");
+function logFactory(namespace) {
+    return new logger_1.Logger(namespace, (0, enabled_1.isNamespaceEnabled)(logFactory.getNamespaces(), namespace));
+}
+exports.logFactory = logFactory;
+logFactory.Logger = logger_1.Logger;
+logFactory.Timer = timer_1.Timer;
+logFactory.getNamespaces = function () {
+    return process.env.DEBUG || '';
+};
+logFactory.configure = function (options) {
+    logger_1.Logger.configure(options);
+};
+logFactory.formatter = formatter_1.formatter;
+exports.default = logFactory;
+module.exports = logFactory;

package/dist/logger/logger.d.ts

@@ -0,0 +1,55 @@
+import { Timer } from '../timer/timer';
+interface AxiosError extends Error {
+    isAxiosError: boolean;
+    config: {
+        method: string;
+        url: string;
+    };
+    response?: {
+        status: number;
+        statusText: string;
+        data: string;
+    };
+}
+export interface LoggerConfig {
+    formatter: Function;
+    output: Function;
+    transformers: Function[];
+}
+export declare class Logger {
+    _namespace: string;
+    _enabled: boolean;
+    constructor(namespace: string, enabled: boolean);
+    static configure(options: LoggerConfig): void;
+    static _validate(options: LoggerConfig): void;
+    static config: LoggerConfig;
+    isEnabled(): boolean;
+    trace(action: string, data?: unknown): void;
+    debug(action: string, data?: unknown): void;
+    info(action: string, data?: unknown): void;
+    warn(action: string, data?: unknown): void;
+    error(action: string, data?: unknown): void;
+    fatal(action: string, data?: unknown): void;
+    _log(level: string, action: string, data: unknown): void;
+    customError(severity: string, action: string, error: Error, data?: unknown): void;
+    fromError(action: string, error: unknown, data?: unknown): void;
+    warnFromError(action: string, error: unknown, data?: unknown): void;
+    timer(): Timer;
+    _shortenStackTrace(stack: string): string | undefined;
+    _shortenData(data: unknown): string | undefined;
+    _getErrorDetails(error: Error): {};
+    _getAxiosErrorDetails(error: AxiosError): {
+        request_method?: undefined;
+        request_url?: undefined;
+        response_status?: undefined;
+        response_status_text?: undefined;
+        response_data?: undefined;
+    } | {
+        request_method: string;
+        request_url: string;
+        response_status: number | undefined;
+        response_status_text: string | undefined;
+        response_data: string | undefined;
+    };
+}
+export {};

package/dist/logger/logger.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const config_1 = require("../config");
+const STACK_TRACE_LIMIT = 3000;
+const DATA_LIMIT = 3000;
+const timer_1 = require("../timer/timer");
+const json_1 = require("../formatter/json");
+const console_1 = require("../output/console");
+const allowedKeys = ['output', 'formatter', 'transformers'];
+class Logger {
+    constructor(namespace, enabled) {
+        this._namespace = namespace;
+        this._enabled = enabled;
+    }
+    static configure(options) {
+        this._validate(options);
+        Object.assign(Logger.config, options);
+    }
+    static _validate(options) {
+        Object.keys(options).forEach(key => {
+            if (!allowedKeys.includes(key)) {
+                throw new Error('Only the following keys are allowed: formatter, output');
+            }
+        });
+    }
+    isEnabled() {
+        return this._enabled;
+    }
+    trace(action, data = {}) {
+        this._log('trace', action, data);
+    }
+    debug(action, data = {}) {
+        this._log('debug', action, data);
+    }
+    info(action, data = {}) {
+        this._log('info', action, data);
+    }
+    warn(action, data = {}) {
+        this._log('warn', action, data);
+    }
+    error(action, data = {}) {
+        this._log('error', action, data);
+    }
+    fatal(action, data = {}) {
+        this._log('fatal', action, data);
+    }
+    _log(level, action, data) {
+        if (!this._enabled) {
+            return;
+        }
+        let dataToLog = Object.assign({
+            name: this._namespace,
+            action: action,
+            level: config_1.config.levels[level].number,
+            time: new Date().toISOString()
+        }, data);
+        Logger.config.transformers.forEach((transform) => {
+            dataToLog = transform(dataToLog);
+        });
+        Logger.config.output(Logger.config.formatter(dataToLog));
+    }
+    customError(severity, action, error, data = {}) {
+        this._log(severity, action, Object.assign(this._getErrorDetails(error), data));
+    }
+    fromError(action, error, data = {}) {
+        this.customError('error', action, error, data);
+    }
+    warnFromError(action, error, data = {}) {
+        this.customError('warn', action, error, data);
+    }
+    timer() {
+        return new timer_1.Timer(this);
+    }
+    _shortenStackTrace(stack) {
+        if (!stack) {
+            return;
+        }
+        return stack.length > STACK_TRACE_LIMIT
+            ? stack.substring(0, STACK_TRACE_LIMIT) + ' ...'
+            : stack;
+    }
+    _shortenData(data) {
+        if (typeof data === 'undefined') {
+            return;
+        }
+        const stringifiedData = typeof data === 'object' ? JSON.stringify(data) : data;
+        return stringifiedData.length > DATA_LIMIT
+            ? stringifiedData.substring(0, DATA_LIMIT) + ' ...'
+            : stringifiedData;
+    }
+    _getErrorDetails(error) {
+        if (!(error instanceof Object)) {
+            return {};
+        }
+        const baseDetails = {
+            error_name: error.name,
+            error_stack: this._shortenStackTrace(error.stack || ''),
+            error_message: error.message,
+            error_data: this._shortenData(error.data)
+        };
+        return Object.assign(baseDetails, this._getAxiosErrorDetails(error));
+    }
+    _getAxiosErrorDetails(error) {
+        if (!error.isAxiosError)
+            return {};
+        return {
+            request_method: error.config.method,
+            request_url: error.config.url,
+            response_status: error.response ? error.response.status : undefined,
+            response_status_text: error.response ? error.response.statusText : undefined,
+            response_data: error.response ? this._shortenData(error.response.data) : undefined
+        };
+    }
+}
+exports.Logger = Logger;
+Logger.config = {
+    formatter: json_1.jsonFormatter,
+    output: console_1.consoleOutput,
+    transformers: []
+};

package/dist/output/color-name/color-name.d.ts

@@ -0,0 +1,11 @@
+interface Color {
+    color: number;
+}
+export declare class ColorName {
+    static counter: number;
+    static colors: string[];
+    static names: Record<string, Color>;
+    static addColor(name: string): any;
+    static reset(): void;
+}
+export {};

package/dist/output/color-name/color-name.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorName = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const colors = ['cyan', 'magenta', 'grey', 'blue', 'green', 'yellow', 'white', 'red'];
+class ColorName {
+    static addColor(name) {
+        if (!this.names[name]) {
+            this.names[name] = { color: this.counter % colors.length };
+            this.counter++;
+        }
+        const color = colors[this.names[name].color];
+        // @ts-ignore
+        return chalk_1.default[color](name);
+    }
+    static reset() {
+        this.counter = 0;
+        this.names = {};
+    }
+}
+exports.ColorName = ColorName;
+ColorName.counter = 0;
+ColorName.colors = colors;
+ColorName.names = {};

package/dist/output/console.d.ts

@@ -0,0 +1 @@
+export declare function consoleOutput(formattedLog: unknown): void;

package/dist/output/console.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleOutput = void 0;
+function consoleOutput(formattedLog) {
+    console.log(formattedLog);
+}
+exports.consoleOutput = consoleOutput;

package/dist/output/format-body/format-body.d.ts

@@ -0,0 +1 @@
+export declare function formatBody(logBody: any): string;

package/dist/output/format-body/format-body.js

@@ -0,0 +1,23 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBody = void 0;
+function formatBody(logBody) {
+    const log = Object.assign({}, logBody);
+    delete log.name;
+    delete log.level;
+    delete log.v;
+    delete log.pid;
+    delete log.hostname;
+    delete log.time;
+    if (!log.msg) {
+        delete log.msg;
+    }
+    const keys = Object.keys(log);
+    return keys
+        .sort()
+        .map(function (key) {
+        return key + '=' + JSON.stringify(log[key]);
+    })
+        .join(' ');
+}
+exports.formatBody = formatBody;

package/dist/output/format-time/format-time.d.ts

@@ -0,0 +1,5 @@
+export declare class FormatTime {
+    lastLog: number;
+    elapsedTime(): string;
+    getCurrentTime(): number;
+}

package/dist/output/format-time/format-time.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatTime = void 0;
+class FormatTime {
+    constructor() {
+        this.lastLog = 0;
+    }
+    elapsedTime() {
+        const current = this.getCurrentTime();
+        let elapsed = 0;
+        if (this.lastLog) {
+            elapsed = current - this.lastLog;
+        }
+        this.lastLog = current;
+        return '+' + elapsed + 'ms';
+    }
+    getCurrentTime() {
+        return new Date().getTime();
+    }
+}
+exports.FormatTime = FormatTime;

package/dist/output/stringify-level/stringify-level.d.ts

@@ -0,0 +1 @@
+export declare function stringifyLevel(level: string): string;

package/dist/output/stringify-level/stringify-level.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyLevel = void 0;
+const config_1 = require("../../config");
+function stringifyLevel(level) {
+    return config_1.config.coloredNames[level];
+}
+exports.stringifyLevel = stringifyLevel;

package/dist/timer/timer.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from '../logger/logger';
+export declare class Timer {
+    _logger: Logger;
+    _start: number;
+    constructor(logger: Logger);
+    trace(action: string, data?: unknown): void;
+    debug(action: string, data?: unknown): void;
+    info(action: string, data?: unknown): void;
+    warn(action: string, data?: unknown): void;
+    error(action: string, data?: unknown): void;
+    fatal(action: string, data?: unknown): void;
+    fromError(action: string, error: unknown, data?: unknown): void;
+    warnFromError(action: string, error: unknown, data?: unknown): void;
+    _duration(): number;
+}

package/dist/timer/timer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor(logger) {
+        this._logger = logger;
+        this._start = new Date().getTime();
+    }
+    trace(action, data = {}) {
+        this._logger.trace(action, Object.assign({ duration: this._duration() }, data));
+    }
+    debug(action, data = {}) {
+        this._logger.debug(action, Object.assign({ duration: this._duration() }, data));
+    }
+    info(action, data = {}) {
+        this._logger.info(action, Object.assign({ duration: this._duration() }, data));
+    }
+    warn(action, data = {}) {
+        this._logger.warn(action, Object.assign({ duration: this._duration() }, data));
+    }
+    error(action, data = {}) {
+        this._logger.error(action, Object.assign({ duration: this._duration() }, data));
+    }
+    fatal(action, data = {}) {
+        this._logger.fatal(action, Object.assign({ duration: this._duration() }, data));
+    }
+    fromError(action, error, data = {}) {
+        this._logger.fromError(action, error, Object.assign({ duration: this._duration() }, data));
+    }
+    warnFromError(action, error, data = {}) {
+        this._logger.warnFromError(action, error, Object.assign({ duration: this._duration() }, data));
+    }
+    _duration() {
+        const end = new Date().getTime();
+        return end - this._start;
+    }
+}
+exports.Timer = Timer;

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@emartech/json-logger",
-  "version": "4.0.1",
+  "version": "5.0.2",
   "description": "Tiny and fast json logger with namespace support",
-  "main": "index.js",
+  "main": "dist/index.js",
   "scripts": {
-    "test": "mocha ./src/ --recursive",
-    "test:watch": "mocha ./src/ --recursive --watch",
+    "test": "mocha --require ts-node/register ./src/ --recursive",
+    "test:watch": "mocha --require ts-node/register ./src/ --recursive --watch",
+    "build": "rm -rf dist && tsc --project ./tsconfig.json",
     "semantic-release": "CI=true semantic-release",
+    "example-js": "DEBUG=* node examples/index-js.js",
+    "example-ts": "DEBUG=* ts-node examples/index-ts.ts",
     "koa-example": "DEBUG=* node examples/koa.js",
     "express-example": "DEBUG=* node examples/express.js"
   },
@@ -29,13 +32,16 @@
   },
   "devDependencies": {
     "@emartech/cls-adapter": "1.3.0",
+    "@types/node": "18.7.2",
     "chai": "4.3.6",
     "express": "4.18.1",
     "koa": "2.13.4",
     "mocha": "10.0.0",
     "semantic-release": "15.5.0",
     "sinon": "14.0.0",
-    "sinon-chai": "3.7.0"
+    "sinon-chai": "3.7.0",
+    "ts-node": "10.9.1",
+    "typescript": "4.7.4"
   },
   "repository": {
     "type": "git",

package/tsconfig.json

@@ -0,0 +1,105 @@
+{
+  "exclude": ["dist", "node_modules", "src/**/*.js"],
+  "include": ["src/**/*.ts", "src/**/*.js"],
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2020",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    "experimentalDecorators": true,                     /* Enable experimental support for TC39 stage 2 draft decorators. */
+    "emitDecoratorMetadata": true,                      /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    "allowJs": true,                                     /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                  /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    "noEmit": false,                                     /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

package/index.js

@@ -1,29 +0,0 @@
-'use strict';
-
-const Logger = require('./src/logger/logger');
-const Timer = require('./src/timer/timer');
-const isNamespaceEnabled = require('./src/enabled/enabled');
-const formatter = require('./src/formatter');
-
-/**
- * @param namespace
- * @param options
- * @returns {Logger}
- */
-function logFactory(namespace, options) {
-  return new Logger(namespace, isNamespaceEnabled(
-    logFactory.getNamespaces(), namespace
-  ), options);
-}
-
-logFactory.Logger = Logger;
-logFactory.Timer = Timer;
-logFactory.getNamespaces = function() {
-  return process.env.DEBUG || '';
-};
-logFactory.configure = function(options) {
-  Logger.configure(options);
-};
-logFactory.formatter = formatter;
-
-module.exports = logFactory;

package/src/config.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const chalk = require('chalk');
-
-const levels = {
-  trace: {
-    number: 10,
-    name: 'TRACE'
-  },
-  debug: {
-    number: 20,
-    name: 'DEBUG'
-  },
-  info: {
-    number: 30,
-    name: 'INFO'
-  },
-  warn: {
-    number: 40,
-    name: chalk.yellow('WARN')
-  },
-  error: {
-    number: 50,
-    name: chalk.red('ERROR')
-  },
-  fatal: {
-    number: 60,
-    name: chalk.red('FATAL')
-  },
-};
-
-const availableLevels = Object.keys(levels);
-
-const coloredNames = {};
-availableLevels.forEach((levelName) => {
-  coloredNames[levels[levelName].number] = levels[levelName].name;
-});
-
-module.exports = { levels, availableLevels, coloredNames };

package/src/enabled/enabled.js

@@ -1,37 +0,0 @@
-'use strict';
-
-function isNamespaceEnabled(availableNamespaces, namespace) {
-  availableNamespaces = availableNamespaces.split(/[\s,]+/);
-  let enabled = false;
-  const adds = [];
-  const skips = [];
-
-  availableNamespaces.forEach(function(name) {
-    if (!name) {
-      return;
-    }
-
-    name = name.replace(/\*/g, '.*?');
-    if (name[0] === '-') {
-      skips.push(new RegExp('^' + name.substr(1) + '$'));
-    } else {
-      adds.push(new RegExp('^' + name + '$'));
-    }
-  });
-
-  adds.forEach(function(addRegexp) {
-    if (addRegexp.test(namespace)) {
-      enabled = true;
-    }
-  });
-
-  skips.forEach(function(addRegexp) {
-    if (addRegexp.test(namespace)) {
-      enabled = false;
-    }
-  });
-
-  return enabled;
-}
-
-module.exports = isNamespaceEnabled;

package/src/formatter/debug.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const ColorName = require('../output/color-name/color-name');
-const stringifyLevel = require('../output/stringify-level/stringify-level');
-const formatTime = require('../output/format-time/format-time');
-const formatBody = require('../output/format-body/format-body');
-
-module.exports = function(log) {
-  return [
-    ColorName.addColor(log.name),
-    stringifyLevel(log.level),
-    formatTime.elapsedTime(log.time),
-    formatBody(log)
-  ].join(' ');
-};

package/src/formatter/index.js

@@ -1,7 +0,0 @@
-'use strict';
-
-module.exports = {
-  json: require('./json'),
-  debug: require('./debug'),
-  logentries: require('./logentries')
-};

package/src/formatter/json.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = function(log) {
-  return JSON.stringify(log);
-};

package/src/formatter/logentries.js

@@ -1,24 +0,0 @@
-'use strict';
-
-const isNumeric = (value) => !isNaN(parseFloat(value)) && isFinite(value);
-
-const isString = (value) => typeof value === 'string' || value instanceof String;
-
-const convertToTag = (value, key) => {
-  if (isString(value)) {
-    value = JSON.stringify(value);
-  } else if(isNumeric(value)) {
-    value = value.toString();
-  } else {
-    value = '"' + JSON.stringify(value) + '"';
-  }
-
-  return key + '=' + value;
-};
-
-module.exports = function(data) {
-  return Object
-    .keys(data)
-    .map(key => convertToTag(data[key], key))
-    .join(' ');
-};

package/src/logger/logger.js

@@ -1,139 +0,0 @@
-'use strict';
-
-const config = require('../config');
-const STACK_TRACE_LIMIT = 3000;
-const DATA_LIMIT = 3000;
-const Timer = require('../timer/timer');
-const jsonFormatter = require('../formatter/json');
-const consoleOutput = require('../output/console');
-const allowedKeys = ['output', 'formatter', 'transformers'];
-
-class Logger {
-  constructor(namespace, enabled) {
-    this._namespace = namespace;
-    this._enabled = enabled;
-  }
-
-  static configure(options = {}) {
-    this._validate(options);
-    Object.assign(Logger.config, options);
-  }
-
-  static _validate(options) {
-    Object.keys(options).forEach(key => {
-      if (!allowedKeys.includes(key)) {
-        throw new Error('Only the following keys are allowed: formatter, output');
-      }
-    });
-  }
-
-  isEnabled() {
-    return this._enabled;
-  }
-
-  customError(severity, action, error, data = {}) {
-    logMethodFactory(severity).bind(this)(action, Object.assign(this._getErrorDetails(error), data));
-  }
-
-  fromError(action, error, data = {}) {
-    this.customError('error', action, error, data);
-  }
-
-  warnFromError(action, error, data = {}) {
-    this.customError('warn', action, error, data);
-  }
-
-  timer() {
-    return new Timer(this);
-  }
-
-  _shortenStackTrace(stack) {
-    if (typeof stack === 'undefined') {
-      return;
-    }
-
-    return stack.length > STACK_TRACE_LIMIT
-      ? stack.substring(0, STACK_TRACE_LIMIT) + ' ...'
-      : stack;
-  }
-
-  _shortenData(data) {
-    if (typeof data === 'undefined') {
-      return;
-    }
-
-    const stringifiedData = typeof data === 'object' ? JSON.stringify(data) : data;
-
-    return stringifiedData.length > DATA_LIMIT
-      ? stringifiedData.substring(0, DATA_LIMIT) + ' ...'
-      : stringifiedData;
-  }
-
-  _getErrorDetails(error) {
-    if (!(error instanceof Object)) {
-      return {};
-    }
-
-    const baseDetails = {
-      error_name: error.name,
-      error_stack: this._shortenStackTrace(error.stack),
-      error_message: error.message,
-      error_data: this._shortenData(error.data)
-    };
-
-    return Object.assign(baseDetails, this._getAxiosErrorDetails(error));
-  }
-
-  _getAxiosErrorDetails(error) {
-    if (!error.isAxiosError) return {};
-
-    return {
-      request_method: error.config.method,
-      request_url: error.config.url,
-      response_status: error.response ? error.response.status : undefined,
-      response_status_text: error.response ? error.response.statusText : undefined,
-      response_data: error.response ? this._shortenData(error.response.data) : undefined
-    };
-  }
-}
-
-Logger.config = {
-  formatter: jsonFormatter,
-  output: consoleOutput,
-  transformers: []
-};
-
-const logMethodFactory = function(level) {
-  return function(action, data = {}) {
-    if (!this._enabled) {
-      return;
-    }
-
-    let dataToLog = Object.assign(
-      {
-        name: this._namespace,
-        action: action,
-        level: config.levels[level].number,
-        time: new Date().toISOString()
-      },
-      data
-    );
-
-    Logger.config.transformers.forEach((transform) => {
-      dataToLog = transform(dataToLog);
-    });
-
-    Logger.config.output(
-      Logger.config.formatter(dataToLog)
-    );
-  };
-};
-
-Logger.prototype.trace = logMethodFactory('trace');
-Logger.prototype.debug = logMethodFactory('debug');
-Logger.prototype.info = logMethodFactory('info');
-Logger.prototype.warn = logMethodFactory('warn');
-Logger.prototype.error = logMethodFactory('error');
-Logger.prototype.fatal = logMethodFactory('fatal');
-
-module.exports = Logger;

package/src/output/color-name/color-name.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const chalk = require('chalk');
-const colors = ['cyan', 'magenta', 'grey', 'blue', 'green', 'yellow', 'white', 'red'];
-
-class ColorName {
-  static addColor(name) {
-    if (!this.names[name]) {
-      this.names[name] = { color: this.counter % colors.length };
-      this.counter++;
-    }
-
-    const color = colors[this.names[name].color];
-    return chalk[color](name);
-  }
-
-  static reset() {
-    this.counter = 0;
-    this.names = {};
-  }
-}
-
-ColorName.counter = 0;
-ColorName.names = {};
-ColorName.colors = colors;
-
-module.exports = ColorName;

package/src/output/console.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = function(formattedLog) {
-  console.log(formattedLog);
-};

package/src/output/format-body/format-body.js

@@ -1,25 +0,0 @@
-'use strict';
-
-module.exports = function(logBody) {
-  const log = Object.assign({}, logBody);
-
-  delete log.name;
-  delete log.level;
-  delete log.v;
-  delete log.pid;
-  delete log.hostname;
-  delete log.time;
-
-  if (!log.msg) {
-    delete log.msg;
-  }
-
-  const keys = Object.keys(log);
-
-  return keys
-    .sort()
-    .map(function(key) {
-      return key + '=' + JSON.stringify(log[key]);
-    })
-    .join(' ');
-};

package/src/output/format-time/format-time.js

@@ -1,21 +0,0 @@
-'use strict';
-
-module.exports = {
-  lastLog: null,
-
-  elapsedTime: function() {
-    const current = this.getCurrentTime();
-    let elapsed = 0;
-
-    if (this.lastLog) {
-      elapsed = current - this.lastLog;
-    }
-
-    this.lastLog = current;
-    return '+' + elapsed + 'ms';
-  },
-
-  getCurrentTime: function() {
-    return new Date().getTime();
-  }
-};

package/src/output/stringify-level/stringify-level.js

@@ -1,7 +0,0 @@
-'use strict';
-
-const config = require('../../config');
-
-module.exports = function stringifyLevel(level) {
-  return config.coloredNames[level];
-};

package/src/timer/timer.js

@@ -1,48 +0,0 @@
-'use strict';
-
-const logMethodFactory = function(level) {
-  return function(action, data) {
-    this._logger[level](
-      action,
-      Object.assign({ duration: this._duration() }, data)
-    );
-  }
-};
-
-class Timer {
-  constructor(logger) {
-    this._logger = logger;
-    this._start = new Date().getTime();
-  }
-
-  fromError(action, error, data = {}) {
-    this._logger.fromError(
-      action,
-      error,
-      Object.assign({ duration: this._duration() }, data)
-    );
-  }
-
-  warnFromError(action, error, data = {}) {
-    this._logger.warnFromError(
-      action,
-      error,
-      Object.assign({ duration: this._duration() }, data)
-    );
-  }
-
-  _duration() {
-    const end = new Date().getTime();
-
-    return end - this._start;
-  }
-}
-
-Timer.prototype.trace = logMethodFactory('trace');
-Timer.prototype.debug = logMethodFactory('debug');
-Timer.prototype.info = logMethodFactory('info');
-Timer.prototype.warn = logMethodFactory('warn');
-Timer.prototype.error = logMethodFactory('error');
-Timer.prototype.fatal = logMethodFactory('fatal');
-
-module.exports = Timer;