@icoms-detection/server-esp32
Version:
This is the OFFICIAL SERVER library created by Icoms Detection to run their apps.
182 lines • 6.88 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Logger = exports.LogType = void 0;
var fs = __importStar(require("fs"));
var path = __importStar(require("path"));
var Util_1 = require("./Util");
var LogType;
(function (LogType) {
LogType[LogType["TRACE"] = 0] = "TRACE";
LogType[LogType["DEBUG"] = 1] = "DEBUG";
LogType[LogType["INFO"] = 2] = "INFO";
LogType[LogType["WARN"] = 3] = "WARN";
LogType[LogType["ERROR"] = 4] = "ERROR";
LogType[LogType["FATAL"] = 5] = "FATAL";
})(LogType = exports.LogType || (exports.LogType = {}));
/**
* In case no folder to store logs was defined, logs will be writing there by default
*/
var defaultFolder = path.join(__dirname, "logs");
/**
* Static data to store parameters
*/
var LOGGER_PARAMS = {
logLevel: LogType.DEBUG,
folder: undefined,
folderMaxSize: 1 * 1024 * 1024,
currentFile: undefined,
fileMaxSize: 100 * 1024,
filenameFormat: "log-",
fileExtension: "txt",
};
/**
* Creates a folder if it does not exists and the first log file inside it
* @param absolutePath
*/
var initFolder = function (absolutePath) {
if (!(0, Util_1.isFolder)(absolutePath)) {
fs.mkdirSync(absolutePath);
}
var folder = {
name: absolutePath,
size: (0, Util_1.getFolderSize)(absolutePath),
};
LOGGER_PARAMS.folder = folder;
//Write in new file
newLogFile(absolutePath);
};
/**
* Returns the number contained in the name of the file
* @param filename
* @returns number of this file
*/
var getFileNumber = function (filename) {
return parseInt(filename.replace(LOGGER_PARAMS.filenameFormat, "").split(".")[0]);
};
/**
* Create a new empty file for log
* @param absolutePath
*/
var newLogFile = function (absolutePath) {
//Look to get the next filename
var files = (0, Util_1.getFilesInFolder)(absolutePath).filter(function (file) {
return file.includes(".".concat(LOGGER_PARAMS.fileExtension));
});
var lastFileName = files[files.length - 1];
var newNameNumber = lastFileName ? getFileNumber(lastFileName) + 1 : 1;
var newName = "".concat(LOGGER_PARAMS.filenameFormat).concat(newNameNumber, ".").concat(LOGGER_PARAMS.fileExtension);
LOGGER_PARAMS.currentFile = {
name: newName,
size: 0,
};
fs.writeFileSync(path.join(absolutePath, LOGGER_PARAMS.currentFile.name), "");
};
/**
* Find the oldest log and delete it
*/
var deleteOldestFile = function () {
var oldestFile = (0, Util_1.getFilesInFolder)(LOGGER_PARAMS.folder.name).reduce(function (prev, cur) { return (getFileNumber(prev) < getFileNumber(cur) ? prev : cur); });
var oldestFilePath = path.join(LOGGER_PARAMS.folder.name, oldestFile);
var oldestFileSize = (0, Util_1.getFileSize)(oldestFilePath);
LOGGER_PARAMS.folder.size -= oldestFileSize;
fs.rmSync(oldestFilePath);
};
/**
* Format the log line for file
* @param log
* @returns the log message to store in fie
*/
var makeLine = function (log) {
var appender = log.appender ? "[".concat(log.appender, "] ") : "";
return "[".concat(log.date.toISOString(), "] [").concat(LogType[log.level], "] ").concat(appender, "- ").concat(log.content, "\n");
};
/**
* Write the first queue element in current file.
* Manage files to respect the folder and file max size.
* While data are contained in the queue, this will call itself. Once queue is empty, this function stop
* It runs like a async function
*/
var write = function (log) {
//Don't write the log if level is lower than expected
if (log.level < LOGGER_PARAMS.logLevel)
return;
//Setup folder if not exists
if (!LOGGER_PARAMS.folder)
initFolder(defaultFolder);
var line = makeLine(log);
var lineSize = line.length;
//Check and manage files size
if (LOGGER_PARAMS.currentFile.size + lineSize > LOGGER_PARAMS.fileMaxSize) {
LOGGER_PARAMS.folder.size += LOGGER_PARAMS.currentFile.size;
newLogFile(LOGGER_PARAMS.folder.name);
}
if (LOGGER_PARAMS.folder.size + LOGGER_PARAMS.currentFile.size + lineSize >
LOGGER_PARAMS.folderMaxSize) {
deleteOldestFile();
}
//write in file
fs.appendFileSync(path.join(LOGGER_PARAMS.folder.name, LOGGER_PARAMS.currentFile.name), line);
LOGGER_PARAMS.currentFile.size += lineSize;
};
/**
* Use to set desired parameters for the Logger
* @param {?string} params.folderAbsolutePath Path of folder where store logs
* @param {?LogType} params.logLevel Log level to store
* @param {?number} params.folderMaxSize Number max of bytes which folder don't have to exceed
* @param {?number} params.fileMaxSize Number max of bytes a file cannot exceed
*/
var init = function (params) {
Object.keys(params).forEach(function (key) { return (LOGGER_PARAMS[key] = params[key]); });
if (params.folderAbsolutePath)
initFolder(params.folderAbsolutePath);
};
/**
* write log
* @param {LogType} level
* @param {string} content message of log
*/
var writeLog = function (level, appender, content) {
write({
level: level,
date: new Date(),
appender: appender,
content: content,
});
};
/**
* Give a Logger object which give you functions to write logs.
* @param appender If not undefined, this string will be present in every log line
* @returns
*/
var getLogger = function (appender) { return ({
trace: function (message) { return writeLog(LogType.TRACE, appender, message); },
debug: function (message) { return writeLog(LogType.DEBUG, appender, message); },
info: function (message) { return writeLog(LogType.INFO, appender, message); },
warn: function (message) { return writeLog(LogType.WARN, appender, message); },
error: function (message) { return writeLog(LogType.ERROR, appender, message); },
fatal: function (message) { return writeLog(LogType.FATAL, appender, message); },
}); };
exports.Logger = {
getLogger: getLogger,
init: init,
};
//# sourceMappingURL=Logger.js.map