nodelogging/src/index.ts

import * as util from "util";
import * as fs from "fs";
import { EventEmitter } from "events";
import * as path from "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 = (<any>Error.prototype).prepareStackTrace

export class Logging {
   private static logFileLocation: string = "./logs/";
   public static stdout: boolean = true;

   private static fileStream: fs.WriteStream;
   private static errorStream: fs.WriteStream;
   private static fileSize: number = 0;
   private static errorSize: number = 0;

   private static writing = false;
   private static queue = new Array<{ message: string, error: boolean }>();

   static events: EventEmitter = new EventEmitter();

   static config(logfolder: string, stdout: boolean) {
      this.logFileLocation = logfolder;
      this.stdout = stdout;
   }

   static debug(...message: any[]) {
      Logging.message(LoggingTypes.Debug, message);
   }

   static log(...message: any[]) {
      Logging.message(LoggingTypes.Log, message);
   }

   static warning(...message: any[]) {
      Logging.message(LoggingTypes.Warning, message);
   }

   static logWithCustomColors(type: LoggingTypes, colors: string, ...message: any[]) {
      Logging.message(type, message, colors);
   }

   static error(error: Error | string) {
      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: any[]) {
      Logging.message(LoggingTypes.Error, message);
   }

   private static async message(type: LoggingTypes, message: any[] | string, customColors?: string) {
      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 });
   }

   private static writeMessageToFile(message: string, error?: boolean) {
      Logging.queue.push({ message: message.replace("\n", " "), error: error });
      Logging.checkQueue();
   }

   private 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)
      }
   }

   private 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);
      }
   }
}

export default Logging;

function fsUnlink(path) {
   return new Promise((resolve, reject) => {
      fs.unlink(path, (err) => {
         if (err) reject(err);
         else resolve();
      })
   })
}

function fsStat(path: string) {
   return new Promise<fs.Stats>((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<boolean>((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 = (<any>Error).prepareStackTrace;

   // Override with function that just returns `stack`
   (<any>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: any[] = <any>err.stack;

   // Restore original `Error.prepareStackTrace`
   (<any>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 };
}

export enum LoggingTypes {
   Log,
   Warning,
   Error,
   Debug
}