NodeLogging/out/index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const util = require("util");
const fs = require("fs");
const events_1 = require("events");
const path = require("path");
const Reset = "\x1b[0m";
const Bright = "\x1b[1m";
const Dim = "\x1b[2m";
const Underscore = "\x1b[4m";
const Blink = "\x1b[5m";
const Reverse = "\x1b[7m";
const Hidden = "\x1b[8m";
const FgBlack = "\x1b[30m";
const FgRed = "\x1b[31m";
const FgGreen = "\x1b[32m";
const FgYellow = "\x1b[33m";
const FgBlue = "\x1b[34m";
const FgMagenta = "\x1b[35m";
const FgCyan = "\x1b[36m";
const FgWhite = "\x1b[37m";
const BgBlack = "\x1b[40m";
const BgRed = "\x1b[41m";
const BgGreen = "\x1b[42m";
const BgYellow = "\x1b[43m";
const BgBlue = "\x1b[44m";
const BgMagenta = "\x1b[45m";
const BgCyan = "\x1b[46m";
const BgWhite = "\x1b[47m";
const maxFileSize = 500000000;
const OriginalErrorStackFunction = Error.prototype.prepareStackTrace;
class Logging {
    static config(logfolder, stdout) {
        this.logFileLocation = logfolder;
        this.stdout = stdout;
    }
    static debug(...message) {
        Logging.message(LoggingTypes.Debug, message);
    }
    static log(...message) {
        Logging.message(LoggingTypes.Log, message);
    }
    static warning(...message) {
        Logging.message(LoggingTypes.Warning, message);
    }
    static logWithCustomColors(type, colors, ...message) {
        Logging.message(type, message, colors);
    }
    static error(error) {
        if (typeof error === "string") {
            let e = new Error();
            Logging.message(LoggingTypes.Error, [error, ":", e.stack]);
        }
        else {
            Logging.message(LoggingTypes.Error, [error.name, ":", error.message, ":", error.stack]);
        }
    }
    static errorMessage(...message) {
        Logging.message(LoggingTypes.Error, message);
    }
    static async message(type, message, customColors) {
        var consoleLogFormat = Reset;
        if (!customColors) {
            switch (type) {
                case LoggingTypes.Log:
                    //m += FgWhite + BgBlack;
                    break;
                case LoggingTypes.Error:
                    consoleLogFormat += FgRed; //FgWhite + BgRed + FgWhite;
                    break;
                case LoggingTypes.Debug:
                    consoleLogFormat += FgCyan;
                    break;
                case LoggingTypes.Warning:
                    consoleLogFormat += FgYellow;
                    break;
            }
        }
        else {
            consoleLogFormat += customColors;
        }
        var mb = "";
        if (typeof message === "string") {
            mb = message;
        }
        else {
            message.forEach(e => {
                if (typeof e !== "string")
                    e = util.inspect(e, false, null);
                if (e.endsWith("\n")) {
                    mb += e;
                }
                else {
                    mb += e + " ";
                }
            });
        }
        let file = getCallerFile();
        let date = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
        var m = `[${LoggingTypes[type]}][${file.file}:${file.line}][${date}]: ${mb}`;
        if (this.stdout)
            console.log(consoleLogFormat + m + Reset);
        let index = m.indexOf("\x1b");
        while (index >= 0) {
            m = m.substring(0, index) + m.substring(index + 5, m.length);
            index = m.indexOf("\x1b");
        }
        m = m.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
        if (this.logFileLocation) {
            if ((!this.fileStream || !this.errorStream) && !this.writing) {
                Logging.initializeFile();
            }
            Logging.writeMessageToFile(m, type === LoggingTypes.Error);
        }
        Logging.events.emit("message", { type: type, message: mb });
    }
    static writeMessageToFile(message, error) {
        Logging.queue.push({ message: message.replace("\n", " "), error: error });
        Logging.checkQueue();
    }
    static async checkQueue() {
        try {
            if (Logging.writing)
                return;
            if (Logging.queue.length <= 0)
                return;
            Logging.writing = true;
            var message = Logging.queue[0];
            message.message += "\n";
            let data = new Buffer(message.message, "utf8");
            if (data.byteLength < maxFileSize && data.byteLength + Logging.fileSize > maxFileSize) {
                Logging.fileStream.close();
                if (await fsExists(this.logFileLocation + "all.log.old"))
                    await fsUnlink(this.logFileLocation + "all.log.old");
                await fsMove(this.logFileLocation + "all.log", this.logFileLocation + "all.log.old");
                Logging.fileStream = fs.createWriteStream(this.logFileLocation + "all.log");
                Logging.fileSize = 0;
            }
            Logging.fileSize += data.byteLength;
            Logging.fileStream.write(data, async () => {
                if (message.error) {
                    if (data.byteLength < maxFileSize && data.byteLength + Logging.errorSize > maxFileSize) {
                        Logging.errorStream.close();
                        if (await fsExists(this.logFileLocation + "error.log.old"))
                            await fsUnlink(this.logFileLocation + "error.log.old");
                        await fsMove(this.logFileLocation + "error.log", this.logFileLocation + "error.log.old");
                        Logging.errorStream = fs.createWriteStream(this.logFileLocation + "error.log");
                        Logging.errorSize = 0;
                    }
                    Logging.errorSize += data.byteLength;
                    Logging.errorStream.write(data, () => {
                        Logging.queue.splice(Logging.queue.indexOf(message), 1);
                        Logging.writing = false;
                        Logging.checkQueue();
                    });
                }
                else {
                    Logging.queue.splice(Logging.queue.indexOf(message), 1);
                    Logging.writing = false;
                    Logging.checkQueue();
                }
            });
        }
        catch (e) {
            console.log(e);
        }
    }
    static async initializeFile() {
        if (this.fileStream && this.errorStream)
            return;
        if (!this.logFileLocation)
            return;
        this.writing = true;
        try {
            await new Promise((resolve, reject) => {
                fs.exists(this.logFileLocation, (exists) => {
                    if (!exists) {
                        fs.mkdir(this.logFileLocation, (err) => {
                            if (err) {
                                reject(err);
                            }
                            else {
                                resolve();
                            }
                        });
                    }
                    else
                        resolve();
                });
            });
            if (await fsExists(this.logFileLocation + "all.log")) {
                if (await fsExists(this.logFileLocation + "all.log.old"))
                    await fsUnlink(this.logFileLocation + "all.log.old");
                await fsMove(this.logFileLocation + "all.log", this.logFileLocation + "all.log.old");
            }
            if (await fsExists(this.logFileLocation + "error.log")) {
                let stats = await fsStat(this.logFileLocation + "error.log");
                if (stats.size > maxFileSize) {
                    if (await fsExists(this.logFileLocation + "error.log.old"))
                        await fsUnlink(this.logFileLocation + "error.log.old");
                    await fsMove(this.logFileLocation + "error.log", this.logFileLocation + "error.log.old");
                }
                else {
                    this.errorSize = stats.size;
                }
            }
            this.fileStream = fs.createWriteStream(this.logFileLocation + "all.log", { flags: "a" });
            this.errorStream = fs.createWriteStream(this.logFileLocation + "error.log", { flags: "a" });
            this.writing = false;
            this.checkQueue();
        }
        catch (e) {
            console.log(e);
        }
    }
}
Logging.logFileLocation = "./logs/";
Logging.stdout = true;
Logging.fileSize = 0;
Logging.errorSize = 0;
Logging.writing = false;
Logging.queue = new Array();
Logging.events = new events_1.EventEmitter();
exports.Logging = Logging;
exports.default = Logging;
function fsUnlink(path) {
    return new Promise((resolve, reject) => {
        fs.unlink(path, (err) => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fsStat(path) {
    return new Promise((resolve, reject) => {
        fs.stat(path, (err, stats) => {
            if (err)
                reject(err);
            else
                resolve(stats);
        });
    });
}
function fsMove(oldPath, newPath) {
    return new Promise((resolve, reject) => {
        let callback = (err) => {
            if (err)
                reject(err);
            else
                resolve();
        };
        fs.rename(oldPath, newPath, function (err) {
            if (err) {
                if (err.code === 'EXDEV') {
                    copy();
                }
                else {
                    callback(err);
                }
                return;
            }
            callback();
        });
        function copy() {
            var readStream = fs.createReadStream(oldPath);
            var writeStream = fs.createWriteStream(newPath);
            readStream.on('error', callback);
            writeStream.on('error', callback);
            readStream.on('close', function () {
                fs.unlink(oldPath, callback);
            });
            readStream.pipe(writeStream);
        }
    });
}
function fsExists(path) {
    return new Promise((resolve, reject) => {
        fs.exists(path, resolve);
    });
}
function fsMkDir(path) {
    return new Promise((resolve, reject) => {
        fs.exists(path, resolve);
    });
}
function getStack() {
    // Save original Error.prepareStackTrace
    let origPrepareStackTrace = Error.prepareStackTrace;
    // Override with function that just returns `stack`
    Error.prepareStackTrace = function (_, stack) {
        return stack;
    };
    // Create a new `Error`, which automatically gets `stack`
    let err = new Error();
    // Evaluate `err.stack`, which calls our new `Error.prepareStackTrace`
    let stack = err.stack;
    // Restore original `Error.prepareStackTrace`
    Error.prepareStackTrace = origPrepareStackTrace;
    // Remove superfluous function call on stack
    stack.shift(); // getStack --> Error
    return stack;
}
function getCallerFile() {
    try {
        let stack = getStack();
        let current_file = stack.shift().getFileName();
        while (stack.length) {
            let caller_file = stack.shift();
            const util = require("util");
            if (current_file !== caller_file.getFileName())
                return {
                    file: path.basename(caller_file.getFileName()),
                    line: caller_file.getLineNumber()
                };
        }
    }
    catch (err) { }
    return { file: undefined, line: 0 };
}
var LoggingTypes;
(function (LoggingTypes) {
    LoggingTypes[LoggingTypes["Log"] = 0] = "Log";
    LoggingTypes[LoggingTypes["Warning"] = 1] = "Warning";
    LoggingTypes[LoggingTypes["Error"] = 2] = "Error";
    LoggingTypes[LoggingTypes["Debug"] = 3] = "Debug";
})(LoggingTypes = exports.LoggingTypes || (exports.LoggingTypes = {}));
//# sourceMappingURL=index.js.map