analogger 1.26.1 → 1.28.0

package/README.md

@@ -263,18 +263,23 @@ Display the browser native message box if run from it; otherwise, it displays th
 ### setOptions()
 
 
-| **Options**      | **default** | **Expect**                        | **Description**                                                                    | 
-|------------------|-------------|-----------------------------------|------------------------------------------------------------------------------------|
-| silent           | false       | boolean                           | _Hide logs from console (not errors)_                                              |
-| hideLog          | false       | boolean                           | _Same as above (silent has precedence over hideLog)_                               |              
-| hideError        | false       | boolean                           | _Hide errors from console_                                                         |              
-| hideHookMessage  | false       | boolean                           | _Hide the automatic message shown when some native console methods are overridden_ |
-| hidePassingTests | false       | boolean                           | _Hide Live test results_                                                           |           
-| logToDom         | false       | string (DOM Selector)             | _display log in a DOM container_                                                   |
-| logToFile        | false       | string (File path)                | _write log to a file if running from Node_                                         |
-| logToRemote      | undefined   | string (URL)                      | _Send log to a remote (more info in the next version)_                             |
-| requiredLogLevel | "LOG"       | "LOG" / "INFO" / "WARN" / "ERROR" | _Define the log level from which the system can show a log entry_                  |
-| enableDate       | false       | boolean                           | _Show date + time (instead of time only)_                                          |
+| **Options**         | **default** | **Expect**                        | **Description**                                                                    | 
+|---------------------|-------------|-----------------------------------|------------------------------------------------------------------------------------|
+| silent              | false       | boolean                           | _Hide logs from console (not errors)_                                              |
+| hideLog             | false       | boolean                           | _Same as above (silent has precedence over hideLog)_                               |              
+| hideError           | false       | boolean                           | _Hide errors from console_                                                         |              
+| hideHookMessage     | false       | boolean                           | _Hide the automatic message shown when some native console methods are overridden_ |
+| hidePassingTests    | false       | boolean                           | _Hide Live test results_                                                           |           
+| logToDom            | false       | string (DOM Selector)             | _display log in a DOM container_                                                   |
+| logToFile           | false       | string (File path)                | _write log to a file if running from Node_                                         |
+| logToRemote         | undefined   | string (URL)                      | _Send log to a remote (more info in the next version)_                             |
+| logMaxSize          | 0           | number                            | _Set maximum size for the log file_                                                |
+| compressArchives    | false       | boolean                           | _Whether to archive and compress the logs after deleting an archive_               |
+| compressionLevel    | 1           | number                            | _Archive compression level (0 to 9 with 0 = no compression)_                       |
+| addArchiveTimestamp | true        | boolean                           | _Whether to add a timestamp to the generated rotated logs_                         |
+| logMaxArchives      | 3           | number                            | _Maximum number of log files to use_                                               |
+| requiredLogLevel    | "LOG"       | "LOG" / "INFO" / "WARN" / "ERROR" | _Define the log level from which the system can show a log entry_                  |
+| enableDate          | false       | boolean                           | _Show date + time (instead of time only)_                                          |
 
 <br/>
 

package/ana-logger.d.cts

@@ -110,7 +110,7 @@ declare class ____AnaLogger {
     isBrowser(): boolean;
     resetLogger(): void;
     resetOptions(): void;
-    setOptions({ contextLenMax, idLenMax, lidLenMax, symbolLenMax, messageLenMax, hideLog, hideError, hideHookMessage, hidePassingTests, logToDom, logToFile, logToRemote, logToRemoteUrl, logToRemoteBinaryUrl, loopback, requiredLogLevel, oneConsolePerContext, silent, enableDate, protocol, host, port, pathname, binarypathname }?: any): void;
+    setOptions({ contextLenMax, idLenMax, lidLenMax, symbolLenMax, messageLenMax, hideLog, hideError, hideHookMessage, hidePassingTests, logToDom, logToFile, logMaxSize, logMaxArchives, logIndexArchive, addArchiveTimestamp, addArchiveIndex, compressArchives, compressionLevel, logToRemote, logToRemoteUrl, logToRemoteBinaryUrl, loopback, requiredLogLevel, oneConsolePerContext, silent, enableDate, protocol, host, port, pathname, binarypathname }?: any): void;
     EOL: string;
     getOptions(): {
         hideHookMessage: boolean;

package/browser/ana-logger.mjs

@@ -15,7 +15,6 @@ import {CONSOLE_HEADER_CLASSNAME, CONSOLE_FOOTER_CLASSNAME}  from "./constants.m
 // to-ansi is also used by the browser
 
 
-
 const DEFAULT = {
     moduleName: "analogger",
     // Default values for remote-logging
@@ -171,6 +170,166 @@ const symbolNames = {
 // --------------------------------------------------
 // Helpers
 // --------------------------------------------------
+function getFilePathProperties(filePath) {
+    try {
+        const ext = path.extname(filePath);
+        const basename = path.basename(filePath, ext);
+        const dirname = path.dirname(filePath);
+        const fPath = filePath.slice(0, filePath.length - ext.length);
+        return {
+            extension: ext, filePath: fPath, basename, dirname
+        };
+    } catch (e) {
+        console.error("FILEPATH_EXT_FAILURE: ", e.message);
+    }
+    return {
+        extension: ".log", filePath
+    };
+}
+
+function getConsistentTimestamp() {
+    const now = new Date();
+
+    // ISO 8601 format with milliseconds and timezone offset
+    const isoString = now.toISOString();
+
+    return isoString.replace(/:/g, "-").replace(/\./g, "-");
+}
+
+/**
+ * Deletes all files in the given directory that match the specified filename prefix, index, and extension.
+ *
+ * @param {string} directory - The directory containing the files.
+ * @param {string} filenamePrefix - The prefix of the filename (e.g., "demo").
+ * @param {string} index - The index to match (e.g., "01", "02", "03").
+ * @param {string} extension - The file extension (e.g., "log").
+ * @param archiveName
+ * @param compressionLevel
+ * @param {function} deletionCallback - A callback function to handle the result.
+ */
+function deleteFilesWithIndex(directory, filenamePrefix, index, extension, archiveName, compressionLevel, deletionCallback) {
+    fs.readdir(directory, (err, files) => {
+        if (err) {
+            deletionCallback(err, null);
+            return;
+        }
+
+        const deletedFiles = [];
+        let filesProcessed = 0;
+
+        const removeFile = (filePath, callback) => {
+            if (!fs.existsSync(filePath)) {
+                callback(null, null);
+                return;
+            }
+            fs.unlink(filePath, (unlinkErr) => {
+                if (unlinkErr) {
+                    console.error(`DELETION_FAILURE: Error deleting file ${filePath}: ${unlinkErr}`);
+                } else {
+                    deletedFiles.push(filePath);
+                }
+                filesProcessed++;
+                if (filesProcessed === files.length) {
+                    callback(null, deletedFiles);
+                }
+            });
+        };
+
+        const processFile = (file) => {
+            if (file.startsWith(filenamePrefix + ".") && file.endsWith(index + extension)) {
+                const filePath = path.join(directory, file);
+
+                if (archiveName)
+                {
+                    createTarGzArchiveSync(filePath, archiveName, compressionLevel);
+                    removeFile(filePath, deletionCallback);
+                }
+                else
+                {
+                    removeFile(filePath, deletionCallback);
+                }
+
+            } else {
+                filesProcessed++;
+                if (filesProcessed === files.length) {
+                    deletionCallback(null, deletedFiles);
+                }
+            }
+        };
+
+        if (files.length === 0) {
+            deletionCallback(null, deletedFiles); // Handle empty directory
+        } else {
+            files.forEach(processFile, compressionLevel);
+        }
+    });
+}
+
+/**
+ * Adds a log file to a tar.gz archive.
+ *
+ * @param {string} inputFile - The path to the log file to be added to the archive.
+ * @param {string} archivePath - The path to the tar.gz archive.
+ * @param compressionLevel
+ */
+function createTarGzArchiveSync(inputFile, archivePath, compressionLevel = 1) {
+    try {
+        return ;
+
+        // Check if the input file exists
+        if (!fs.existsSync(inputFile)) {
+            return;
+        }
+
+        // Create the archive if it doesn't exist, otherwise append
+        if (!fs.existsSync(archivePath)) {
+            // Create a new archive with the single file at root
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tar-gz-init-'));
+            try {
+                const destFilePath = path.join(tempDir, path.basename(inputFile));
+                fs.copyFileSync(inputFile, destFilePath);
+                tar.c({
+                    sync: true,
+                    gzip: { level: compressionLevel },
+                    file: archivePath,
+                    cwd: tempDir,
+                    portable: true,
+                }, [path.basename(inputFile)]);
+            } finally {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+            return;
+        }
+
+        // If archive exists, append
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tar-gz-append-'));
+
+        try {
+            tar.x({
+                file: archivePath,
+                cwd: tempDir,
+                sync: true,
+            });
+
+            const destFilePath = path.join(tempDir, path.basename(inputFile));
+            fs.copyFileSync(inputFile, destFilePath);
+
+            tar.c({
+                gzip: true,
+                file: archivePath,
+                cwd: tempDir,
+                sync: true,
+                portable: true,
+            }, fs.readdirSync(tempDir));
+
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    } catch (err) {
+        console.error(`ARCHIVE_FAILURE: ${e.message}`);
+    }
+}
+
 /**
  * https://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
  * @returns {string}
@@ -449,10 +608,16 @@ class ____AnaLogger
         this.options.oneConsolePerContext = true;
         this.options.logToDom = undefined;
         this.options.logToFile = undefined;
+        this.options.logMaxSize = 0;
+        this.options.logMaxArchives = 3;
+        this.options.logIndexArchive = 0;
         this.options.logToRemote = undefined;
+        this.options.addArchiveTimestamp = true;
+        this.options.addArchiveIndex = true;
         this.options.logToRemoteUrl = undefined;
         this.options.logToRemoteBinaryUrl = undefined;
-        this.options.logToDomlogToFile = undefined;
+        this.options.compressArchives = false;
+        this.options.compressionLevel = 1;
         this.options.protocol = undefined;
         this.options.host = undefined;
         this.options.port = undefined;
@@ -478,6 +643,13 @@ class ____AnaLogger
                    hidePassingTests = undefined,
                    logToDom = undefined,
                    logToFile = undefined,
+                   logMaxSize = 0,
+                   logMaxArchives = 3,
+                   logIndexArchive = 0,
+                   addArchiveTimestamp = true,
+                   addArchiveIndex = true,
+                   compressArchives = false,
+                   compressionLevel = 1,
                    logToRemote = undefined,
                    logToRemoteUrl = undefined,
                    logToRemoteBinaryUrl = undefined,
@@ -500,6 +672,14 @@ class ____AnaLogger
         this.options.messageLenMax = messageLenMax;
         this.options.symbolLenMax = symbolLenMax;
 
+        this.options.logMaxSize = logMaxSize;
+        this.options.logMaxArchives = logMaxArchives;
+        this.options.logIndexArchive = logIndexArchive;
+        this.options.addArchiveTimestamp = addArchiveTimestamp;
+        this.options.addArchiveIndex = addArchiveIndex;
+        this.options.compressArchives = compressArchives;
+        this.options.compressionLevel = compressionLevel;
+
         this.options.requiredLogLevel = requiredLogLevel;
 
         // TODO: Make one of silent or hideToLog options obsolete
@@ -1357,10 +1537,56 @@ class ____AnaLogger
     {
         try
         {
+            if (!fs.existsSync(this.options.logToFilePath))
+            {
+                const dir = path.dirname(this.options.logToFilePath);
+                if (!fs.existsSync(dir))
+                {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                fs.writeFileSync(this.options.logToFilePath, "");
+            }
+
+            // Check filesize doesn't exceed the limit set by the user
+            if (this.options.logMaxSize) {
+                const stats = fs.statSync(this.options.logToFilePath);
+                const fileSizeInBytes = stats.size;
+                if (fileSizeInBytes > this.options.logMaxSize) {
+
+                    if (this.options.logIndexArchive < this.options.logMaxArchives) {
+                        ++this.options.logIndexArchive;
+                    } else {
+                        this.options.logIndexArchive = 1;
+                    }
+
+                    // Extract the archive name without the extension
+                    const padding = this.options.logMaxArchives.toString().length + 1;
+                    const {filePath, extension, basename, dirname} = getFilePathProperties(this.options.logToFilePath);
+
+                    // Find index of the next archive
+                    let indexStr, timeStamp;
+                    indexStr = this.options.addArchiveIndex ? "." + this.options.logIndexArchive.toString().padStart(padding, "0") : "";
+                    timeStamp = this.options.addArchiveTimestamp ? "." + getConsistentTimestamp() : "";
+
+                    // Deduce old log file name
+                    const oldFileName = `${filePath}${timeStamp}${indexStr}${extension}`;
+
+                    // Deduce archive name
+                    const archiveFileName = this.options.compressArchives ? `${filePath}.tar.gz` : "";
+
+                    // Delete old archives
+                    deleteFilesWithIndex(dirname, basename, indexStr, extension, archiveFileName, this.options.compressionLevel, (error/*, deletedFiles*/) => {
+                        if (error) {
+                            console.error(`DELETION_FAILURE: Failed to delete some files`);
+                        }
+                    });
+
+                    fs.renameSync(this.options.logToFilePath, oldFileName);
+                    fs.writeFileSync(this.options.logToFilePath, "");
+                }
+            }
             fs.appendFileSync(this.options.logToFilePath, text + this.EOL);
-        }
-        catch (e)
-        {
+        } catch (e) {
             /* istanbul ignore next */
             console.rawError("LOG_TO_FILE_FAILURE: ", e.message);
         }