mirror of
https://git.stamm.me/OpenServer/NodeLogging.git
synced 2024-11-15 06:21:04 +00:00
347 lines
11 KiB
TypeScript
347 lines
11 KiB
TypeScript
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.errorMessage(error + e.stack);
|
|
return;
|
|
}
|
|
// let m = "";
|
|
// (<any>error.stack).forEach(e => {
|
|
// m += e.toString() + "\n";
|
|
// })
|
|
var message = error.name + " " + error.message + "\n" + error.stack;
|
|
Logging.message(LoggingTypes.Error, [message]);
|
|
}
|
|
|
|
static errorMessage(...message: string[]) {
|
|
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 + " ";
|
|
}
|
|
});
|
|
}
|
|
|
|
var m = "[" + LoggingTypes[type] + "][" + _getCallerFile() + "][" + new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '') + "]: " + 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
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().getFileName();
|
|
if (current_file !== caller_file) return path.basename(caller_file);
|
|
}
|
|
} catch (err) { }
|
|
return undefined;
|
|
}
|
|
|
|
export enum LoggingTypes {
|
|
Log,
|
|
Warning,
|
|
Error,
|
|
Debug
|
|
} |