355 lines
12 KiB
JavaScript
355 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 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]);
|
|
}
|
|
}
|
|
errorMessage(...message) {
|
|
this.message(LoggingTypes.Error, message);
|
|
}
|
|
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(/\..+/, '');
|
|
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 };
|
|
}
|
|
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
|