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 lock_1 = require("./lock");
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 LoggingBase {
    constructor(options) {
        this.writeLock = new lock_1.default();
        this.fileSize = 0;
        this.errorSize = 0;
        this.queue = new Array();
        this.events = new events_1.EventEmitter();
        if (!options)
            options = {};
        this.config = Object.assign({
            console_out: true,
            logfile: "./logs/all.log",
            errorfile: "./logs/error.log"
        }, options);
        this.setup();
    }
    get console_out() {
        return this.config.console_out;
    }
    set console_out(value) {
        this.config.console_out = value;
    }
    async waitForSetup() {
        (await this.writeLock.getLock()).release();
    }
    async setup() {
        let lock = await this.writeLock.getLock();
        if (this.config.logfile) {
            let f = await this.initializeFile(this.config.logfile, true);
            this.fileStream = f.stream;
            this.fileSize = f.size;
        }
        if (this.config.errorfile) {
            let f = await this.initializeFile(this.config.errorfile, true);
            this.errorStream = f.stream;
            this.errorSize = f.size;
        }
        lock.release();
        this.checkQueue();
    }
    debug(...message) {
        this.message(LoggingTypes.Debug, message);
    }
    log(...message) {
        this.message(LoggingTypes.Log, message);
    }
    warning(...message) {
        this.message(LoggingTypes.Warning, message);
    }
    logWithCustomColors(type, colors, ...message) {
        this.message(type, message, colors);
    }
    error(error) {
        if (typeof error === "string") {
            let e = new Error();
            this.message(LoggingTypes.Error, [error, ":", e.stack]);
        }
        else {
            this.message(LoggingTypes.Error, [error.name, ":", error.message, ":", error.stack], undefined, getCallerFromExisting(error));
        }
    }
    errorMessage(...message) {
        this.message(LoggingTypes.Error, message);
    }
    async message(type, message, customColors, caller) {
        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 = caller || getCallerFile();
        let date = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
        let prefix = `[${LoggingTypes[type]}][${file.file}:${file.line}][${date}]: `;
        let message_lines = mb.split("\n").map(line => prefix + line);
        if (this.config.console_out)
            message_lines.forEach(line => console.log(consoleLogFormat + line + Reset));
        let m = message_lines.join("\n");
        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, "");
        this.writeMessageToFile(m, type === LoggingTypes.Error);
        this.events.emit("message", { type: type, message: mb });
    }
    writeMessageToFile(message, error) {
        if (!this.writeLock.locked && !this.fileStream && !(error || this.errorStream))
            return;
        this.queue.push({ message: message.replace("\n", " "), error: error });
        this.checkQueue();
    }
    async checkQueue() {
        try {
            if (this.writeLock.locked)
                return;
            if (this.queue.length <= 0)
                return;
            let lock = await this.writeLock.getLock();
            var message = this.queue.shift();
            message.message += "\n";
            let data = new Buffer(message.message, "utf8");
            await this.writeToLogFile(data);
            if (message.error)
                await this.writeToErrorFile(data);
            lock.release();
            if (this.queue.length > 0)
                this.checkQueue();
        }
        catch (e) {
            console.log(e);
        }
    }
    async writeToLogFile(data) {
        if (data.byteLength < maxFileSize && this.fileSize + data.byteLength > maxFileSize) {
            let f = await this.initializeFile(this.config.logfile, true);
            this.fileStream = f.stream;
            this.fileSize = f.size;
        }
        this.fileSize += data.byteLength;
        this.fileStream.write(data);
    }
    async writeToErrorFile(data) {
        if (data.byteLength < maxFileSize && this.errorSize + data.byteLength > maxFileSize) {
            let f = await this.initializeFile(this.config.errorfile, true);
            this.errorStream = f.stream;
            this.errorSize = f.size;
        }
        this.errorSize += data.byteLength;
        this.errorStream.write(data);
    }
    async initializeFile(file, new_file = true) {
        try {
            await new Promise((resolve, reject) => {
                const folder = path.dirname(file);
                if (folder)
                    fs.exists(folder, (exists) => {
                        if (!exists) {
                            fs.mkdir(folder, (err) => {
                                if (err) {
                                    reject(err);
                                }
                                else {
                                    resolve();
                                }
                            });
                        }
                        else
                            resolve();
                    });
            });
            let size = 0;
            if (await fsExists(file)) {
                let stats = await fsStat(file);
                if (new_file || stats.size > maxFileSize) {
                    if (await fsExists(file + ".old"))
                        await fsUnlink(file + ".old");
                    await fsMove(file, file + ".old");
                }
                else {
                    size = stats.size;
                }
            }
            return { stream: fs.createWriteStream(file, { flags: "a" }), size: size };
            // 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);
        }
        return { size: 0, stream: undefined };
    }
}
exports.LoggingBase = LoggingBase;
exports.Logging = new LoggingBase();
exports.default = exports.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 };
}
function getCallerFromExisting(err) {
    let lines = err.stack.split("\n");
    let current = path.basename(__filename);
    lines.shift(); // removing first line
    while (lines.length > 0) {
        let line = lines.shift();
        let matches = line.match(/[a-zA-Z]+[.][a-zA-Z]+[:][0-9]+/g);
        if (matches && matches.length > 0) {
            let [f, line] = matches[0].split(":");
            if (f != current) {
                return {
                    file: f, line: Number(line)
                };
            }
        }
    }
}
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