@rife/logger 0.0.6-beta.1 → 0.0.6-beta.4

package/dist/worker/pino-rotate.cjs

@@ -0,0 +1,604 @@
+"use strict";
+var __webpack_modules__ = {
+    child_process: function(module1) {
+        module1.exports = require("child_process");
+    },
+    fs: function(module1) {
+        module1.exports = require("fs");
+    },
+    "fs/promises": function(module1) {
+        module1.exports = require("fs/promises");
+    },
+    path: function(module1) {
+        module1.exports = require("path");
+    },
+    stream: function(module1) {
+        module1.exports = require("stream");
+    },
+    timers: function(module1) {
+        module1.exports = require("timers");
+    },
+    util: function(module1) {
+        module1.exports = require("util");
+    },
+    zlib: function(module1) {
+        module1.exports = require("zlib");
+    },
+    "../../node_modules/.pnpm/rotating-file-stream@3.2.6/node_modules/rotating-file-stream/dist/cjs/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.RotatingFileStream = exports.RotatingFileStreamError = void 0;
+        exports.createStream = createStream;
+        const child_process_1 = __webpack_require__("child_process");
+        const zlib_1 = __webpack_require__("zlib");
+        const stream_1 = __webpack_require__("stream");
+        const fs_1 = __webpack_require__("fs");
+        const promises_1 = __webpack_require__("fs/promises");
+        const path_1 = __webpack_require__("path");
+        const util_1 = __webpack_require__("util");
+        const timers_1 = __webpack_require__("timers");
+        async function exists(filename) {
+            return new Promise((resolve)=>(0, fs_1.access)(filename, fs_1.constants.F_OK, (error)=>resolve(!error)));
+        }
+        class RotatingFileStreamError extends Error {
+            constructor(){
+                super("Too many destination file attempts");
+                this.code = "RFS-TOO-MANY";
+            }
+        }
+        exports.RotatingFileStreamError = RotatingFileStreamError;
+        class RotatingFileStream extends stream_1.Writable {
+            constructor(generator, options){
+                const { encoding, history, maxFiles, maxSize, path } = options;
+                super({
+                    decodeStrings: true,
+                    defaultEncoding: encoding
+                });
+                this.createGzip = zlib_1.createGzip;
+                this.exec = child_process_1.exec;
+                this.filename = path + generator(null);
+                this.fsCreateReadStream = fs_1.createReadStream;
+                this.fsCreateWriteStream = fs_1.createWriteStream;
+                this.fsOpen = promises_1.open;
+                this.fsReadFile = promises_1.readFile;
+                this.fsStat = promises_1.stat;
+                this.fsUnlink = promises_1.unlink;
+                this.generator = generator;
+                this.maxTimeout = 2147483640;
+                this.options = options;
+                this.stdout = process.stdout;
+                if (maxFiles || maxSize) options.history = path + (history ? history : this.generator(null) + ".txt");
+                this.on("close", ()=>this.finished ? null : this.emit("finish"));
+                this.on("finish", ()=>this.finished = this.clear());
+                (async ()=>{
+                    try {
+                        this.initPromise = this.init();
+                        await this.initPromise;
+                        delete this.initPromise;
+                    } catch (e) {}
+                })();
+            }
+            _destroy(error, callback) {
+                this.refinal(error, callback);
+            }
+            _final(callback) {
+                this.refinal(void 0, callback);
+            }
+            _write(chunk, encoding, callback) {
+                this.rewrite([
+                    {
+                        chunk,
+                        encoding
+                    }
+                ], 0, callback);
+            }
+            _writev(chunks, callback) {
+                this.rewrite(chunks, 0, callback);
+            }
+            async refinal(error, callback) {
+                try {
+                    this.clear();
+                    if (this.initPromise) await this.initPromise;
+                    if (this.timeoutPromise) await this.timeoutPromise;
+                    await this.reclose();
+                } catch (e) {
+                    return callback(error || e);
+                }
+                callback(error);
+            }
+            async rewrite(chunks, index, callback) {
+                const { size, teeToStdout } = this.options;
+                try {
+                    if (this.initPromise) await this.initPromise;
+                    for(let i = 0; i < chunks.length; ++i){
+                        const { chunk } = chunks[i];
+                        this.size += chunk.length;
+                        if (this.timeoutPromise) await this.timeoutPromise;
+                        await this.file.write(chunk);
+                        if (teeToStdout && !this.stdout.destroyed) this.stdout.write(chunk);
+                        if (size && this.size >= size) await this.rotate();
+                    }
+                } catch (e) {
+                    return callback(e);
+                }
+                callback();
+            }
+            async init() {
+                const { immutable, initialRotation, interval, size } = this.options;
+                if (immutable) return new Promise((resolve, reject)=>process.nextTick(()=>this.immutate(true).then(resolve).catch(reject)));
+                let stats;
+                try {
+                    stats = await (0, promises_1.stat)(this.filename);
+                } catch (e) {
+                    if ("ENOENT" !== e.code) throw e;
+                    return this.reopen(0);
+                }
+                if (!stats.isFile()) throw new Error(`Can't write on: ${this.filename} (it is not a file)`);
+                if (initialRotation) {
+                    this.intervalBounds(this.now());
+                    const prev = this.prev;
+                    this.intervalBounds(new Date(stats.mtime.getTime()));
+                    if (prev !== this.prev) return this.rotate();
+                }
+                this.size = stats.size;
+                if (!size || stats.size < size) return this.reopen(stats.size);
+                if (interval) this.intervalBounds(this.now());
+                return this.rotate();
+            }
+            async makePath(name) {
+                return (0, promises_1.mkdir)(name.split(path_1.sep).slice(0, -1).join(path_1.sep), {
+                    recursive: true
+                });
+            }
+            async reopen(size) {
+                let file;
+                try {
+                    file = await (0, promises_1.open)(this.filename, "a", this.options.mode);
+                } catch (e) {
+                    if ("ENOENT" !== e.code) throw e;
+                    await this.makePath(this.filename);
+                    file = await (0, promises_1.open)(this.filename, "a", this.options.mode);
+                }
+                this.file = file;
+                this.size = size;
+                this.interval();
+                this.emit("open", this.filename);
+            }
+            async reclose() {
+                const { file } = this;
+                if (!file) return;
+                delete this.file;
+                return file.close();
+            }
+            now() {
+                return new Date();
+            }
+            async rotate() {
+                const { immutable, rotate } = this.options;
+                this.size = 0;
+                this.rotation = this.now();
+                this.clear();
+                this.emit("rotation");
+                await this.reclose();
+                if (rotate) return this.classical();
+                if (immutable) return this.immutate(false);
+                return this.move();
+            }
+            async findName() {
+                const { interval, path, intervalBoundary } = this.options;
+                for(let index = 1; index < 1000; ++index){
+                    const filename = path + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+                    if (!await exists(filename)) return filename;
+                }
+                throw new RotatingFileStreamError();
+            }
+            async move() {
+                const { compress } = this.options;
+                const filename = await this.findName();
+                await this.touch(filename);
+                if (compress) await this.compress(filename);
+                else await (0, promises_1.rename)(this.filename, filename);
+                return this.rotated(filename);
+            }
+            async touch(filename) {
+                let file;
+                try {
+                    file = await this.fsOpen(filename, "a");
+                } catch (e) {
+                    if ("ENOENT" !== e.code) throw e;
+                    await this.makePath(filename);
+                    file = await (0, promises_1.open)(filename, "a");
+                }
+                await file.close();
+                return this.unlink(filename);
+            }
+            async classical() {
+                const { compress, path, rotate } = this.options;
+                let rotatedName = "";
+                for(let count = rotate; count > 0; --count){
+                    const currName = path + this.generator(count);
+                    const prevName = 1 === count ? this.filename : path + this.generator(count - 1);
+                    if (await exists(prevName)) {
+                        if (!rotatedName) rotatedName = currName;
+                        if (1 === count && compress) await this.compress(currName);
+                        else try {
+                            await (0, promises_1.rename)(prevName, currName);
+                        } catch (e) {
+                            if ("ENOENT" !== e.code) throw e;
+                            await this.makePath(currName);
+                            await (0, promises_1.rename)(prevName, currName);
+                        }
+                    }
+                }
+                return this.rotated(rotatedName);
+            }
+            clear() {
+                if (this.timeout) {
+                    clearTimeout(this.timeout);
+                    this.timeout = null;
+                }
+                return true;
+            }
+            intervalBoundsBig(now) {
+                const year = this.options.intervalUTC ? now.getUTCFullYear() : now.getFullYear();
+                let month = this.options.intervalUTC ? now.getUTCMonth() : now.getMonth();
+                let day = this.options.intervalUTC ? now.getUTCDate() : now.getDate();
+                let hours = this.options.intervalUTC ? now.getUTCHours() : now.getHours();
+                const { num, unit } = this.options.interval;
+                if ("M" === unit) {
+                    day = 1;
+                    hours = 0;
+                } else hours = "d" === unit ? 0 : parseInt(hours / num, 10) * num;
+                this.prev = new Date(year, month, day, hours, 0, 0, 0).getTime();
+                if ("M" === unit) month += num;
+                else if ("d" === unit) day += num;
+                else hours += num;
+                this.next = new Date(year, month, day, hours, 0, 0, 0).getTime();
+            }
+            intervalBounds(now) {
+                const unit = this.options.interval.unit;
+                if ("M" === unit || "d" === unit || "h" === unit) this.intervalBoundsBig(now);
+                else {
+                    let period = 1000 * this.options.interval.num;
+                    if ("m" === unit) period *= 60;
+                    this.prev = parseInt(now.getTime() / period, 10) * period;
+                    this.next = this.prev + period;
+                }
+                return new Date(this.prev);
+            }
+            interval() {
+                if (!this.options.interval) return;
+                this.intervalBounds(this.now());
+                const set = async ()=>{
+                    const time = this.next - this.now().getTime();
+                    if (time <= 0) try {
+                        this.timeoutPromise = this.rotate();
+                        await this.timeoutPromise;
+                        delete this.timeoutPromise;
+                    } catch (e) {}
+                    else {
+                        this.timeout = (0, timers_1.setTimeout)(set, time > this.maxTimeout ? this.maxTimeout : time);
+                        this.timeout.unref();
+                    }
+                };
+                set();
+            }
+            async compress(filename) {
+                const { compress } = this.options;
+                if ("function" == typeof compress) await new Promise((resolve, reject)=>{
+                    this.exec(compress(this.filename, filename), (error, stdout, stderr)=>{
+                        this.emit("external", stdout, stderr);
+                        error ? reject(error) : resolve();
+                    });
+                });
+                else await this.gzip(filename);
+                return this.unlink(this.filename);
+            }
+            async gzip(filename) {
+                const { mode } = this.options;
+                const options = mode ? {
+                    mode
+                } : {};
+                const inp = this.fsCreateReadStream(this.filename, {});
+                const out = this.fsCreateWriteStream(filename, options);
+                const zip = this.createGzip();
+                return new Promise((resolve, reject)=>{
+                    inp.once("error", reject);
+                    out.once("error", reject);
+                    zip.once("error", reject);
+                    out.once("finish", resolve);
+                    inp.pipe(zip).pipe(out);
+                });
+            }
+            async rotated(filename) {
+                const { maxFiles, maxSize } = this.options;
+                if (maxFiles || maxSize) await this.history(filename);
+                this.emit("rotated", filename);
+                return this.reopen(0);
+            }
+            async history(filename) {
+                const { history, maxFiles, maxSize } = this.options;
+                const res = [];
+                let files = [
+                    filename
+                ];
+                try {
+                    const content = await this.fsReadFile(history, "utf8");
+                    files = [
+                        ...content.toString().split("\n"),
+                        filename
+                    ];
+                } catch (e) {
+                    if ("ENOENT" !== e.code) throw e;
+                }
+                for (const file of files)if (file) try {
+                    const stats = await this.fsStat(file);
+                    if (stats.isFile()) res.push({
+                        name: file,
+                        size: stats.size,
+                        time: stats.mtime.getTime()
+                    });
+                    else this.emit("warning", new Error(`File '${file}' contained in history is not a regular file`));
+                } catch (e) {
+                    if ("ENOENT" !== e.code) throw e;
+                }
+                res.sort((a, b)=>a.time - b.time);
+                if (maxFiles) while(res.length > maxFiles){
+                    const file = res.shift();
+                    await this.unlink(file.name);
+                    this.emit("removed", file.name, true);
+                }
+                if (maxSize) while(res.reduce((size, file)=>size + file.size, 0) > maxSize){
+                    const file = res.shift();
+                    await this.unlink(file.name);
+                    this.emit("removed", file.name, false);
+                }
+                await (0, promises_1.writeFile)(history, res.map((e)=>e.name).join("\n") + "\n", "utf-8");
+                this.emit("history");
+            }
+            async immutate(first) {
+                const { size } = this.options;
+                const now = this.now();
+                for(let index = 1; index < 1000; ++index){
+                    let fileSize = 0;
+                    let stats;
+                    this.filename = this.options.path + this.generator(now, index);
+                    try {
+                        stats = await this.fsStat(this.filename);
+                    } catch (e) {
+                        if ("ENOENT" !== e.code) throw e;
+                    }
+                    if (stats) {
+                        fileSize = stats.size;
+                        if (!stats.isFile()) throw new Error(`Can't write on: '${this.filename}' (it is not a file)`);
+                        if (size && fileSize >= size) continue;
+                    }
+                    if (first) {
+                        this.last = this.filename;
+                        return this.reopen(fileSize);
+                    }
+                    await this.rotated(this.last);
+                    this.last = this.filename;
+                    return;
+                }
+                throw new RotatingFileStreamError();
+            }
+            async unlink(filename) {
+                try {
+                    await this.fsUnlink(filename);
+                } catch (e) {
+                    if ("ENOENT" !== e.code) throw e;
+                    this.emit("warning", e);
+                }
+            }
+        }
+        exports.RotatingFileStream = RotatingFileStream;
+        function buildNumberCheck(field) {
+            return (type, options, value)=>{
+                const converted = parseInt(value, 10);
+                if ("number" !== type || converted !== value || converted <= 0) throw new Error(`'${field}' option must be a positive integer number`);
+            };
+        }
+        function buildStringCheck(field, check) {
+            return (type, options, value)=>{
+                if ("string" !== type) throw new Error(`Don't know how to handle 'options.${field}' type: ${type}`);
+                options[field] = check(value);
+            };
+        }
+        function checkMeasure(value, what, units) {
+            const ret = {};
+            ret.num = parseInt(value, 10);
+            if (isNaN(ret.num)) throw new Error(`Unknown 'options.${what}' format: ${value}`);
+            if (ret.num <= 0) throw new Error(`A positive integer number is expected for 'options.${what}'`);
+            ret.unit = value.replace(/^[ 0]*/g, "").substr((ret.num + "").length, 1);
+            if (0 === ret.unit.length) throw new Error(`Missing unit for 'options.${what}'`);
+            if (!units[ret.unit]) throw new Error(`Unknown 'options.${what}' unit: ${ret.unit}`);
+            return ret;
+        }
+        const intervalUnits = {
+            M: true,
+            d: true,
+            h: true,
+            m: true,
+            s: true
+        };
+        function checkIntervalUnit(ret, unit, amount) {
+            if (parseInt(amount / ret.num, 10) * ret.num !== amount) throw new Error(`An integer divider of ${amount} is expected as ${unit} for 'options.interval'`);
+        }
+        function checkInterval(value) {
+            const ret = checkMeasure(value, "interval", intervalUnits);
+            switch(ret.unit){
+                case "h":
+                    checkIntervalUnit(ret, "hours", 24);
+                    break;
+                case "m":
+                    checkIntervalUnit(ret, "minutes", 60);
+                    break;
+                case "s":
+                    checkIntervalUnit(ret, "seconds", 60);
+                    break;
+            }
+            return ret;
+        }
+        const sizeUnits = {
+            B: true,
+            G: true,
+            K: true,
+            M: true
+        };
+        function checkSize(value) {
+            const ret = checkMeasure(value, "size", sizeUnits);
+            if ("K" === ret.unit) return 1024 * ret.num;
+            if ("M" === ret.unit) return 1048576 * ret.num;
+            if ("G" === ret.unit) return 1073741824 * ret.num;
+            return ret.num;
+        }
+        const checks = {
+            encoding: (type, options, value)=>new util_1.TextDecoder(value),
+            immutable: ()=>{},
+            initialRotation: ()=>{},
+            interval: buildStringCheck("interval", checkInterval),
+            intervalBoundary: ()=>{},
+            intervalUTC: ()=>{},
+            maxFiles: buildNumberCheck("maxFiles"),
+            maxSize: buildStringCheck("maxSize", checkSize),
+            mode: ()=>{},
+            omitExtension: ()=>{},
+            rotate: buildNumberCheck("rotate"),
+            size: buildStringCheck("size", checkSize),
+            teeToStdout: ()=>{},
+            ...{
+                compress: (type, options, value)=>{
+                    if (false === value) return;
+                    if (!value) throw new Error("A value for 'options.compress' must be specified");
+                    if ("boolean" === type) return options.compress = (source, dest)=>`cat ${source} | gzip -c9 > ${dest}`;
+                    if ("function" === type) return;
+                    if ("string" !== type) throw new Error(`Don't know how to handle 'options.compress' type: ${type}`);
+                    if ("gzip" !== value) throw new Error(`Don't know how to handle compression method: ${value}`);
+                },
+                history: (type)=>{
+                    if ("string" !== type) throw new Error(`Don't know how to handle 'options.history' type: ${type}`);
+                },
+                path: (type, options, value)=>{
+                    if ("string" !== type) throw new Error(`Don't know how to handle 'options.path' type: ${type}`);
+                    if (value[value.length - 1] !== path_1.sep) options.path = value + path_1.sep;
+                }
+            }
+        };
+        function checkOpts(options) {
+            const ret = {};
+            let opt;
+            for(opt in options){
+                const value = options[opt];
+                const type = typeof value;
+                if (!(opt in checks)) throw new Error(`Unknown option: ${opt}`);
+                ret[opt] = options[opt];
+                checks[opt](type, ret, value);
+            }
+            if (!ret.path) ret.path = "";
+            if (!ret.interval) {
+                delete ret.immutable;
+                delete ret.initialRotation;
+                delete ret.intervalBoundary;
+                delete ret.intervalUTC;
+            }
+            if (ret.rotate) {
+                delete ret.history;
+                delete ret.immutable;
+                delete ret.maxFiles;
+                delete ret.maxSize;
+                delete ret.intervalBoundary;
+                delete ret.intervalUTC;
+            }
+            if (ret.immutable) delete ret.compress;
+            if (!ret.intervalBoundary) delete ret.initialRotation;
+            return ret;
+        }
+        function createClassical(filename, compress, omitExtension) {
+            return (index)=>index ? `${filename}.${index}${compress && !omitExtension ? ".gz" : ""}` : filename;
+        }
+        function createGenerator(filename, compress, omitExtension) {
+            const pad = (num)=>(num > 9 ? "" : "0") + num;
+            return (time, index)=>{
+                if (!time) return filename;
+                const month = time.getFullYear() + "" + pad(time.getMonth() + 1);
+                const day = pad(time.getDate());
+                const hour = pad(time.getHours());
+                const minute = pad(time.getMinutes());
+                return month + day + "-" + hour + minute + "-" + pad(index) + "-" + filename + (compress && !omitExtension ? ".gz" : "");
+            };
+        }
+        function createStream(filename, options) {
+            if (void 0 === options) options = {};
+            else if ("object" != typeof options) throw new Error(`The "options" argument must be of type object. Received type ${typeof options}`);
+            const opts = checkOpts(options);
+            const { compress, omitExtension } = opts;
+            let generator;
+            if ("string" == typeof filename) generator = options.rotate ? createClassical(filename, !!compress, omitExtension) : createGenerator(filename, !!compress, omitExtension);
+            else if ("function" == typeof filename) generator = filename;
+            else throw new Error(`The "filename" argument must be one of type string or function. Received type ${typeof filename}`);
+            return new RotatingFileStream(generator, opts);
+        }
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module1 = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
+    return module1.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>__WEBPACK_DEFAULT_EXPORT__
+    });
+    const generator = (time, index)=>{
+        if (!time) return 'server.log';
+        time = new Date(time);
+        const month = String(time.getMonth() + 1).padStart(2, '0');
+        const day = String(time.getDate()).padStart(2, '0');
+        if (index) {
+            const count = String(index).padStart(3, '0');
+            return `server.${time.getFullYear()}${month}${day}-${count}.log`;
+        }
+        return `server.${time.getFullYear()}${month}${day}.log`;
+    };
+    const __WEBPACK_DEFAULT_EXPORT__ = (options)=>{
+        const { createStream } = __webpack_require__("../../node_modules/.pnpm/rotating-file-stream@3.2.6/node_modules/rotating-file-stream/dist/cjs/index.js");
+        const { path } = options;
+        return createStream(generator, {
+            size: '50M',
+            maxSize: '500M',
+            interval: '1d',
+            path
+        });
+    };
+})();
+module.exports = __webpack_exports__;