nodelogging/src/index.ts

import * as util from "util";
import * as fs from "fs";
import { EventEmitter } from "events";
import * as path from "path";
import Lock from "./lock";

export const Colors = {
   Reset: "\x1b[0m",
   Bright: "\x1b[1m",
   Dim: "\x1b[2m",
   Underscore: "\x1b[4m",
   Blink: "\x1b[5m",
   Reverse: "\x1b[7m",
   Hidden: "\x1b[8m",

   FgBlack: "\x1b[30m",
   FgRed: "\x1b[31m",
   FgGreen: "\x1b[32m",
   FgYellow: "\x1b[33m",
   FgBlue: "\x1b[34m",
   FgMagenta: "\x1b[35m",
   FgCyan: "\x1b[36m",
   FgWhite: "\x1b[37m",

   BgBlack: "\x1b[40m",
   BgRed: "\x1b[41m",
   BgGreen: "\x1b[42m",
   BgYellow: "\x1b[43m",
   BgBlue: "\x1b[44m",
   BgMagenta: "\x1b[45m",
   BgCyan: "\x1b[46m",
   BgWhite: "\x1b[47m"
}

const maxFileSize = 500000000;

const OriginalErrorStackFunction = (<any>Error.prototype).prepareStackTrace

export interface LoggingBaseOptions {
   logfile: string;
   errorfile: string;
   console_out: boolean;
}

export class LoggingBase {
   private config: LoggingBaseOptions;
   private writeLock = new Lock();

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

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

   constructor(options?: Partial<LoggingBaseOptions>) {
      if (!options) options = {};
      this.config = Object.assign(<LoggingBaseOptions>{
         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;
   }

   public async waitForSetup() {
      (await this.writeLock.getLock()).release();
   }

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

   events: EventEmitter = new EventEmitter();

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

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

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

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

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

   private async message(type: LoggingTypes, message: any[] | string, customColors?: string, caller?: { file: string, line: number }) {
      var consoleLogFormat = Colors.Reset;
      if (!customColors) {
         switch (type) {
            case LoggingTypes.Log:
               //m += FgWhite + BgBlack;
               break;
            case LoggingTypes.Error:
               consoleLogFormat += Colors.FgRed;//FgWhite + BgRed + FgWhite;
               break;
            case LoggingTypes.Debug:
               consoleLogFormat += Colors.FgCyan;
               break;
            case LoggingTypes.Warning:
               consoleLogFormat += Colors.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 + Colors.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 });
   }

   private writeMessageToFile(message: string, error?: boolean) {
      if (!this.writeLock.locked && !this.fileStream && !(error || this.errorStream)) return;
      this.queue.push({ message: message.replace("\n", " "), error: error });
      this.checkQueue();
   }

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

   private async writeToLogFile(data: Buffer) {
      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);
   }

   private async writeToErrorFile(data: Buffer) {
      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);
   }

   private async initializeFile(file: string, new_file = true): Promise<{ stream: fs.WriteStream, size: number }> {
      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 };
   }
}
export const Logging = new LoggingBase();
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 };
}

function getCallerFromExisting(err: Error): { file: string, line: number } {
   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)
            };
         }
      }
   }
}

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