329 lines
12 KiB
JavaScript
329 lines
12 KiB
JavaScript
"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.errorMessage(error + e.stack);
|
|
return;
|
|
}
|
|
var message = error.name + " " + error.message + "\n" + error.stack;
|
|
Logging.message(LoggingTypes.Error, [message]);
|
|
}
|
|
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
|