OpenServer/NodeLogging
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Removing out from repository

Browse Source
This commit is contained in:
Fabian Stamm 2018-12-08 22:19:56 +01:00
parent 7f72d28d22
commit 0f3dc07dff
10 changed files with 2 additions and 570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,3 +1,4 @@
node_modules/
logs/
yarn.lock
out/

69
out/index.d.ts vendored
View File

@ -1,69 +0,0 @@
/// <reference types="node" />
import { EventEmitter } from "events";
export declare const Colors: {
Reset: string;
Bright: string;
Dim: string;
Underscore: string;
Blink: string;
Reverse: string;
Hidden: string;
FgBlack: string;
FgRed: string;
FgGreen: string;
FgYellow: string;
FgBlue: string;
FgMagenta: string;
FgCyan: string;
FgWhite: string;
BgBlack: string;
BgRed: string;
BgGreen: string;
BgYellow: string;
BgBlue: string;
BgMagenta: string;
BgCyan: string;
BgWhite: string;
};
export interface LoggingBaseOptions {
/**
* Name will be prefixed on Console output and added to logfiles, if not specified here
*/
name: string;
/**
* Filename/path of the logfile. Skip if generated with name
*/
logfile: string;
/**
* Filename/path of the logfile. Skip if generated with name
*/
errorfile: string;
/**
* Prints output to console
*/
console_out: boolean;
}
export declare class LoggingBase {
private config;
private logFile;
private errorFile;
constructor(options?: Partial<LoggingBaseOptions> | string);
console_out: boolean;
waitForSetup(): Promise<any[]>;
events: EventEmitter;
debug(...message: any[]): void;
log(...message: any[]): void;
warning(...message: any[]): void;
logWithCustomColors(type: LoggingTypes, colors: string, ...message: any[]): void;
error(error: Error | string): void;
errorMessage(...message: any[]): void;
private message(type, message, customColors?, caller?);
}
export declare let Logging: LoggingBase;
export default Logging;
export declare enum LoggingTypes {
Log = 0,
Warning = 1,
Error = 2,
Debug = 3,
}

397
out/index.js
View File

@ -1,397 +0,0 @@
"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");
exports.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 = Error.prototype.prepareStackTrace;
class LoggingFiles {
constructor(file) {
this.size = 0;
this.stream = undefined;
this.lock = new lock_1.default();
this.queue = [];
this.file = path.resolve(file);
this.init();
}
static getFile(filename) {
filename = path.resolve(filename);
let file = this.files.find(e => e.file === filename);
if (!file) {
file = new LoggingFiles(filename);
this.files.push(file);
}
return file;
}
async awaitinit() {
(await this.lock.getLock()).release();
}
async init() {
let lock = await this.lock.getLock();
await this.initializeFile();
lock.release();
this.checkQueue();
}
async initializeFile(new_file = false) {
try {
if (this.stream) {
this.stream.close();
}
const folder = path.dirname(this.file);
if (folder) {
if (!await fsExists(folder)) {
await fsMkDir(folder).catch(() => { }); //Could happen, if two seperate instances want to create the same folder so ignoring
}
}
let size = 0;
if (await fsExists(this.file)) {
let stats = await fsStat(this.file);
if (new_file || stats.size >= maxFileSize) {
if (await fsExists(this.file + ".old"))
await fsUnlink(this.file + ".old");
await fsMove(this.file, this.file + ".old");
}
else {
size = stats.size;
}
}
this.stream = fs.createWriteStream(this.file, { flags: "a" });
this.size = size;
}
catch (e) {
console.log(e);
//ToDo is this the right behavior?
process.exit(1);
}
}
async checkQueue() {
if (this.lock.locked)
return;
let lock = await this.lock.getLock();
let msg;
while (msg = this.queue.shift()) {
await this.write_to_file(msg);
}
lock.release();
}
async write_to_file(data) {
try {
if (data.byteLength < maxFileSize && this.size + data.byteLength > maxFileSize) {
await this.initializeFile(true);
}
this.size += data.byteLength;
this.stream.write(data);
}
catch (err) {
console.error(err);
this.initializeFile(false);
this.write_to_file(data);
}
}
write(data) {
this.queue.push(data);
this.checkQueue();
}
}
LoggingFiles.files = [];
class LoggingBase {
constructor(options) {
this.events = new events_1.EventEmitter();
let opt;
if (!options)
opt = {};
else if (typeof options === "string") {
opt = { name: options };
}
else {
opt = options;
}
if (opt.name) {
if (opt.logfile === undefined) {
opt.logfile = `./logs/all.${opt.name}.log`;
}
if (opt.errorfile === undefined) {
opt.errorfile = `./logs/error.${opt.name}.log`;
}
}
this.config = Object.assign({
name: undefined,
console_out: true,
logfile: "./logs/all.log",
errorfile: "./logs/error.log"
}, opt);
for (let key in this) {
if (typeof this[key] === "function")
this[key] = this[key].bind(this);
}
if (this.config.logfile) {
this.logFile = LoggingFiles.getFile(this.config.logfile);
}
if (this.config.errorfile) {
this.errorFile = LoggingFiles.getFile(this.config.errorfile);
}
}
get console_out() {
return this.config.console_out;
}
set console_out(value) {
this.config.console_out = value;
}
waitForSetup() {
let w = [];
if (this.logFile)
w.push(this.logFile.awaitinit());
if (this.errorFile)
w.push(this.errorFile.awaitinit());
return Promise.all(w);
}
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 (!error)
error = "Empty ERROR was passed, so no informations available";
if (typeof error === "string") {
let e = new Error();
this.message(LoggingTypes.Error, [error, "\n", e.stack]);
}
else {
this.message(LoggingTypes.Error, [error.message, "\n", error.stack], undefined, getCallerFromExisting(error));
}
}
errorMessage(...message) {
this.message(LoggingTypes.Error, message);
}
message(type, message, customColors, caller) {
var consoleLogFormat = exports.Colors.Reset;
if (!customColors) {
switch (type) {
case LoggingTypes.Log:
//m += FgWhite + BgBlack;
break;
case LoggingTypes.Error:
consoleLogFormat += exports.Colors.FgRed; //FgWhite + BgRed + FgWhite;
break;
case LoggingTypes.Debug:
consoleLogFormat += exports.Colors.FgCyan;
break;
case LoggingTypes.Warning:
consoleLogFormat += exports.Colors.FgYellow;
break;
}
}
else {
consoleLogFormat += customColors;
}
var mb = "";
if (typeof message === "string") {
mb = message;
}
else {
message.forEach((e, i) => {
if (typeof e !== "string")
e = util.inspect(e, false, null);
if (e.endsWith("\n") || i === message.length - 1) {
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) {
let name = "";
if (this.config.name)
name = `[${this.config.name}]`;
message_lines.forEach(line => console.log(consoleLogFormat + name + line + exports.Colors.Reset));
}
let m = message_lines.join("\n");
m = m.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
let index = m.indexOf("\x1b");
while (index >= 0) {
m = m.substring(0, index) + m.substring(index + 5, m.length);
index = m.indexOf("\x1b");
}
let data = Buffer.from(m + "\n");
if (type === LoggingTypes.Error && this.errorFile) {
this.errorFile.write(data);
}
if (this.logFile) {
this.logFile.write(data);
}
this.events.emit("message", { type: type, message: m, module: this.config.name });
}
}
exports.LoggingBase = LoggingBase;
exports.Logging = undefined;
if (process.env.LOGGING_NO_DEFAULT !== "true") {
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() {
fs.copyFile(oldPath, newPath, (err) => {
if (err)
callback(err);
else
fs.unlink(oldPath, callback);
});
// 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.mkdir(path, (err) => err ? reject(err) : 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 };
}
function getCallerFromExisting(err) {
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)
};
}
}
}
}
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

1
out/index.js.map
View File

File diff suppressed because one or more lines are too long

12
out/lock.d.ts vendored
View File

@ -1,12 +0,0 @@
export declare type Release = {
release: () => void;
};
export default class Lock {
private _locked;
readonly locked: boolean;
private toCome;
constructor();
getLock(): Promise<Release>;
private lock();
private release();
}

37
out/lock.js
View File

@ -1,37 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class Lock {
constructor() {
this._locked = false;
this.toCome = [];
this.release = this.release.bind(this);
}
get locked() {
return this._locked;
}
async getLock() {
if (!this._locked)
return { release: this.lock() };
else {
return new Promise((resolve) => {
this.toCome.push(() => {
resolve({ release: this.lock() });
});
});
}
}
lock() {
this._locked = true;
return this.release;
}
async release() {
if (this.toCome.length > 0) {
this.toCome.shift()();
}
else {
this._locked = false;
}
}
}
exports.default = Lock;
//# sourceMappingURL=lock.js.map

1
out/lock.js.map
View File

@ -1 +0,0 @@
{"version":3,"file":"lock.js","sourceRoot":"","sources":["../src/lock.ts"],"names":[],"mappings":";;AACA;IAOG;QANQ,YAAO,GAAY,KAAK,CAAC;QAIzB,WAAM,GAAmB,EAAE,CAAC;QAGjC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAPD,IAAI,MAAM;QACP,OAAO,IAAI,CAAC,OAAO,CAAC;IACvB,CAAC;IAOD,KAAK,CAAC,OAAO;QACV,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;aAC9C;YACF,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,EAAE;gBACrC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;oBACnB,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBACrC,CAAC,CAAC,CAAA;YACL,CAAC,CAAC,CAAA;SACJ;IACJ,CAAC;IAEO,IAAI;QACT,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC;IACvB,CAAC;IAEO,KAAK,CAAC,OAAO;QAClB,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACzB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;SACxB;aAAM;YACJ,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;SACvB;IACJ,CAAC;CACH;AAlCD,uBAkCC"}

1
out/test.d.ts vendored
View File

@ -1 +0,0 @@
export {};

50
out/test.js
View File

@ -1,50 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const index_1 = require("./index");
const crypto_1 = require("crypto");
index_1.Logging.log("test");
index_1.Logging.log("i", "am", { a: "an" }, 1000);
index_1.Logging.error(new Error("fehler 001"));
index_1.Logging.debug("Some Debug infos");
index_1.Logging.errorMessage("i", "am", "an", "error");
index_1.Logging.log("\x1b[31m\x1b[31m\x1b[31m\x1b[31m\x1b[31m\x1b[31m TEST \x1b[31m\x1b[31m\x1b[31m");
let err = new Error();
if (typeof err.stack !== "string")
console.log("Stacktrace invalid", err.stack);
let cus = new index_1.LoggingBase({ name: "test" });
cus.log("Hello from custom Logger");
let cus2 = new index_1.LoggingBase("test2");
cus2.log("Hello from custom Logger 2");
let cus22 = new index_1.LoggingBase("test2");
cus22.log("Hello from custom Logger 22");
cus2.log("Hello from custom Logger 2");
cus22.log("Hello from custom Logger 22");
cus2.log("Hello from custom Logger 2");
cus22.log("Hello from custom Logger 22");
cus2.log("Hello from custom Logger 2");
cus22.log("Hello from custom Logger 22");
cus2.log("Hello from custom Logger 2");
cus22.log("Hello from custom Logger 22");
cus2.log("Hello from custom Logger 2");
index_1.Logging.console_out = false;
async function benchmark(count, message_size) {
await index_1.Logging.waitForSetup();
const randData = crypto_1.randomBytes(message_size).toString("hex");
const t = process.hrtime();
for (let i = 0; i < count; i++) {
index_1.Logging.log(randData);
}
const diff = process.hrtime(t);
const NS_PER_SEC = 1e9;
await index_1.Logging.waitForSetup();
const ns = diff[0] * NS_PER_SEC + diff[1];
console.log(`Benchmark took ${ns / 1000000}ms for ${count} messages with a size of ${message_size} characters`);
console.log(`This is equal to ${(ns / 1000000) / count} ms per message`);
}
index_1.Logging.waitForSetup().then(async () => {
console.log("Large data benchmark:");
await benchmark(7000, 50000);
console.log("Realdata data benchmark:");
await benchmark(100000, 100);
});
//# sourceMappingURL=test.js.map

1
out/test.js.map
View File

@ -1 +0,0 @@
{"version":3,"file":"test.js","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"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"}