cordova-plugin-unvired-logger 0.0.1

package/src/browser/Logger.js

@@ -0,0 +1,242 @@
+const LOG_FOLDER_NAME = 'AppLogs';
+const LOG_FILE_NAME = 'log.txt';
+const BACKUP_LOG_FILE_NAME = 'log_backup.txt';
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
+
+const LogLevel = {
+    Debug: 'debug',
+    Error: 'error',
+    Info: 'info',
+};
+
+let defaultLogLevel = LogLevel.Info;
+
+// Browser storage keys
+const getStorageKey = (userId, fileName) => `unvired_logger_${userId}_${fileName}`;
+const getLogLevelKey = (userId) => `unvired_logger_${userId}_level`;
+
+function logDebug(args) {
+    return loggerWithLevel(args);
+}
+
+function logError(args) {
+    return loggerWithLevel(args);
+}
+
+function logInfo(args) {
+    return loggerWithLevel(args);
+}
+
+function setLogLevel(level) {
+    return new Promise((resolve) => {
+        // If level is an array (from Cordova), extract the first element
+        if (Array.isArray(level)) {
+            defaultLogLevel = level[0];
+        } else {
+            defaultLogLevel = level;
+        }
+        resolve();
+    });
+}
+
+function getLogLevel() {
+    return new Promise((resolve) => {
+        resolve(defaultLogLevel);
+    });
+}
+
+function getLogFileURL(args) {
+    // In browser, we return a data URL or storage reference
+    return `browser://${getStorageKey(args[0].userId, LOG_FILE_NAME)}`;
+}
+
+function getLogFileContent(args) {
+    return new Promise((resolve, reject) => {
+        try {
+            const userId = args[0].userId;
+            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+            const content = localStorage.getItem(storageKey) || '';
+            resolve(content);
+        } catch (err) {
+            reject(new Error(`Failed to read log file: ${err.message}`));
+        }
+    });
+}
+
+function clearLogFile(args) {
+    return new Promise((resolve, reject) => {
+        try {
+            const userId = args[0].userId;
+            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+            localStorage.removeItem(storageKey);
+            resolve();
+        } catch (err) {
+            reject(new Error(`Failed to clear log file: ${err.message}`));
+        }
+    });
+}
+
+function getBackupLogFileURL(args) {
+    return `browser://${getStorageKey(args[0].userId, BACKUP_LOG_FILE_NAME)}`;
+}
+
+function getBackupLogFileContent(args) {
+    return new Promise((resolve, reject) => {
+        try {
+            const userId = args[0].userId;
+            const storageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
+            const content = localStorage.getItem(storageKey) || '';
+            resolve(content);
+        } catch (err) {
+            reject(new Error(`Failed to read backup log file: ${err.message}`));
+        }
+    });
+}
+
+function copyLogToBackup(args) {
+    return new Promise((resolve, reject) => {
+        try {
+            const userId = args[0].userId;
+            const logStorageKey = getStorageKey(userId, LOG_FILE_NAME);
+            const backupStorageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
+            const logContent = localStorage.getItem(logStorageKey) || '';
+            localStorage.setItem(backupStorageKey, logContent);
+            resolve();
+        } catch (err) {
+            reject(new Error(`Failed to copy log file to backup: ${err.message}`));
+        }
+    });
+}
+
+function loggerWithLevel(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            if (!args || !args[0]) {
+                return reject(new Error("Invalid arguments provided"));
+            }
+            
+            const { userId, level, sourceClass, sourceMethod, message } = args[0];
+            
+            if (!userId) return reject(new Error("userId is required"));
+            if (!level) return reject(new Error("level is required"));
+            if (!message) return reject(new Error("message is required"));
+
+            // Normalize log levels for comparison
+            const normalizedDefaultLogLevel = (defaultLogLevel || '').toLowerCase();
+            const normalizedLevel = (level || '').toLowerCase();
+
+            // Log level filtering using normalized values
+            if (
+                (normalizedDefaultLogLevel === LogLevel.Error && (normalizedLevel === LogLevel.Debug || normalizedLevel === LogLevel.Info)) ||
+                (normalizedDefaultLogLevel === LogLevel.Info && normalizedLevel === LogLevel.Debug)
+            ) {
+                return resolve();
+            }
+
+            await checkAndRotateLogFile(args);
+
+            const currentDate = new Date();
+            const formatter = new Intl.DateTimeFormat('en-US', {
+                day: '2-digit', month: '2-digit', year: 'numeric',
+                hour: '2-digit', minute: '2-digit', second: '2-digit'
+            });
+            const localDateString = formatter.format(currentDate);
+
+            const dateUtc = new Date(currentDate.toUTCString());
+            const utcFormatter = new Intl.DateTimeFormat('en-US', {
+                day: '2-digit', month: '2-digit', year: 'numeric',
+                hour: '2-digit', minute: '2-digit', second: '2-digit', timeZone: 'UTC'
+            });
+            const utcDateString = utcFormatter.format(dateUtc);
+
+            let data = `${localDateString} | UTC:${utcDateString} | ${getStringFromLevel(level)} | ${sourceClass} | ${sourceMethod} | ${message}\n`;
+            if (level === LogLevel.Error) {
+                data = `⭕️⭕️⭕️ ${data}`;
+            }
+
+            // Log to console for browser debugging
+            console.log(data);
+
+            // Store in localStorage
+            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+            const existingContent = localStorage.getItem(storageKey) || '';
+            const newContent = existingContent + data;
+            
+            // Check size limit
+            if (newContent.length > MAX_LOG_SIZE) {
+                // If content is too large, truncate it
+                const truncatedContent = newContent.substring(newContent.length - MAX_LOG_SIZE / 2);
+                localStorage.setItem(storageKey, truncatedContent);
+            } else {
+                localStorage.setItem(storageKey, newContent);
+            }
+
+            resolve(`Logged to browser storage: ${storageKey}`);
+        } catch (err) {
+            reject(new Error(`Logging failed: ${err.message}`));
+        }
+    });
+}
+
+function getStringFromLevel(level) {
+    switch (level) {
+        case LogLevel.Info: return 'IMPORTANT';
+        case LogLevel.Error: return 'ERROR';
+        case LogLevel.Debug: return 'DEBUG';
+        default: return '';
+    }
+}
+
+function checkAndRotateLogFile(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const userId = args[0].userId;
+            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+            const content = localStorage.getItem(storageKey) || '';
+            
+            if (content.length > MAX_LOG_SIZE) {
+                const backupStorageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
+                localStorage.setItem(backupStorageKey, content);
+                localStorage.setItem(storageKey, '');
+            }
+            resolve();
+        } catch (err) {
+            reject(new Error(`Failed to rotate log file: ${err.message}`));
+        }
+    });
+}
+
+// Export for browser environment
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        logDebug,
+        logError,
+        logInfo,
+        setLogLevel,
+        getLogLevel,
+        getLogFileContent,
+        clearLogFile,
+        getBackupLogFileContent,
+        LogLevel,
+        copyLogToBackup,
+        getLogFileURL,
+        getBackupLogFileURL,
+    };
+} else if (typeof window !== 'undefined') {
+    // Browser environment
+    window.UnviredLogger = {
+        logDebug,
+        logError,
+        logInfo,
+        setLogLevel,
+        getLogLevel,
+        getLogFileContent,
+        clearLogFile,
+        getBackupLogFileContent,
+        LogLevel,
+        copyLogToBackup,
+        getLogFileURL,
+        getBackupLogFileURL,
+    };
+    window.Logger = window.UnviredLogger;
+} 

package/src/electron/Logger.js

@@ -0,0 +1,224 @@
+const { app } = require('electron');
+const path = require('path');
+const fs = require('fs');
+const fsPromises = fs.promises;
+
+const LOG_FOLDER_NAME = 'log';
+const LOG_FILE_NAME = 'log.txt';
+const BACKUP_LOG_FILE_NAME = 'log_backup.txt';
+
+const LogLevel = {
+    Debug: 'debug',
+    Error: 'error',
+    Info: 'info',
+};
+
+let defaultLogLevel = LogLevel.Info;
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
+
+function logDebug(args) {
+    return loggerWithLevel(args);
+}
+
+function logError(args) {
+    return loggerWithLevel(args);
+}
+
+function logInfo(args) {
+    return loggerWithLevel(args);
+}
+
+function setLogLevel(level) {
+    return new Promise((resolve) => {
+        // If level is an array (from Cordova), extract the first element
+        if (Array.isArray(level)) {
+            defaultLogLevel = level[0];
+        } else {
+            defaultLogLevel = level;
+        }
+        resolve();
+    });
+}
+
+function getLogLevel() {
+    return new Promise((resolve) => {
+        resolve(defaultLogLevel);
+    });
+}
+
+function getLogFileURL(args) {
+    const userPath = getLogDirectory(args);
+    return path.join(userPath, LOG_FILE_NAME);
+}
+
+function getLogFileContent(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const logPath = getLogFileURL(args);
+            if (fs.existsSync(logPath)) {
+                const content = await fsPromises.readFile(logPath, 'utf8');
+                resolve(content);
+            } else {
+                resolve('');
+            }
+        } catch (err) {
+            reject(new Error(`Failed to read log file: ${err.message}`));
+        }
+    });
+}
+
+function clearLogFile(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const logPath = getLogFileURL(args);
+            await fsPromises.writeFile(logPath, '');
+            resolve();
+        } catch (err) {
+            reject(new Error(`Failed to clear log file: ${err.message}`));
+        }
+    });
+}
+
+function getBackupLogFileURL(args) {
+    const userPath = getLogDirectory(args);
+    return path.join(userPath, BACKUP_LOG_FILE_NAME);
+}
+
+function getBackupLogFileContent(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const backupPath = getBackupLogFileURL(args);
+            if (fs.existsSync(backupPath)) {
+                const content = await fsPromises.readFile(backupPath, 'utf8');
+                resolve(content);
+            } else {
+                resolve('');
+            }
+        } catch (err) {
+            reject(new Error(`Failed to read backup log file: ${err.message}`));
+        }
+    });
+}
+
+function copyLogToBackup(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const logPath = getLogFileURL(args);
+            const backupPath = getBackupLogFileURL(args);
+            await fsPromises.copyFile(logPath, backupPath);
+            resolve();
+        } catch (err) {
+            reject(new Error(`Failed to copy log file to backup: ${err.message}`));
+        }
+    });
+}
+
+function loggerWithLevel(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+
+            if (!args || !args[0]) {
+                return reject(new Error("Invalid arguments provided"));
+            }
+            const { userId, level, sourceClass, sourceMethod, message } = args[0];
+            if (!userId) return reject(new Error("userId is required"));
+            if (!level) return reject(new Error("level is required"));
+            if (!message) return reject(new Error("message is required"));
+
+            // Normalize log levels for comparison
+            const normalizedDefaultLogLevel = (defaultLogLevel || '').toLowerCase();
+            const normalizedLevel = (level || '').toLowerCase();
+
+            // Log level filtering using normalized values
+            if (
+                (normalizedDefaultLogLevel === LogLevel.Error && (normalizedLevel === LogLevel.Debug || normalizedLevel === LogLevel.Info)) ||
+                (normalizedDefaultLogLevel === LogLevel.Info && normalizedLevel === LogLevel.Debug)
+            ) {
+                return resolve();
+            }
+
+            await checkAndRotateLogFile(args);
+
+            const logPath = getLogFileURL(args);
+            const currentDate = new Date();
+            const formatter = new Intl.DateTimeFormat('en-US', {
+                day: '2-digit', month: '2-digit', year: 'numeric',
+                hour: '2-digit', minute: '2-digit', second: '2-digit'
+            });
+            const localDateString = formatter.format(currentDate);
+
+            const dateUtc = new Date(currentDate.toUTCString());
+            const utcFormatter = new Intl.DateTimeFormat('en-US', {
+                day: '2-digit', month: '2-digit', year: 'numeric',
+                hour: '2-digit', minute: '2-digit', second: '2-digit', timeZone: 'UTC'
+            });
+            const utcDateString = utcFormatter.format(dateUtc);
+
+            let data = `${localDateString} | UTC:${utcDateString} | ${getStringFromLevel(level)} | ${sourceClass} | ${sourceMethod} | ${message}\n`;
+            if (level === LogLevel.Error) {
+                data = `⭕️⭕️⭕️ ${data}`;
+            }
+            console.log(data);
+            await fsPromises.appendFile(logPath, data, 'utf8');
+            resolve(`Logged to ${logPath}`);
+        } catch (err) {
+            reject(new Error(`Logging failed: ${err.message}`));
+        }
+    });
+}
+
+function getLogDirectory(args) {
+    if (!args || !args[0] || !args[0].userId) {
+        throw new Error("userId is required");
+    }
+    const userId = args[0].userId;
+    const userDataPath = app.getPath('userData');
+    const userPath = path.join(userDataPath, userId, LOG_FOLDER_NAME);
+    if (!fs.existsSync(userPath)) {
+        fs.mkdirSync(userPath, { recursive: true });
+    }
+    return userPath;
+}
+
+function getStringFromLevel(level) {
+    switch (level) {
+        case LogLevel.Info: return 'IMPORTANT';
+        case LogLevel.Error: return 'ERROR';
+        case LogLevel.Debug: return 'DEBUG';
+        default: return '';
+    }
+}
+
+function checkAndRotateLogFile(args) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const logPath = getLogFileURL(args);
+            if (fs.existsSync(logPath)) {
+                const stats = await fsPromises.stat(logPath);
+                if (stats.size > MAX_LOG_SIZE) {
+                    const backupPath = getBackupLogFileURL(args);
+                    await fsPromises.copyFile(logPath, backupPath);
+                    await fsPromises.writeFile(logPath, '');
+                }
+            }
+            resolve();
+        } catch (err) {
+            reject(new Error(`Failed to rotate log file: ${err.message}`));
+        }
+    });
+}
+
+module.exports = {
+    logDebug,
+    logError,
+    logInfo,
+    setLogLevel,
+    getLogLevel,
+    getLogFileContent,
+    clearLogFile,
+    getBackupLogFileContent,
+    LogLevel,
+    copyLogToBackup,
+    getLogFileURL,
+    getBackupLogFileURL,
+};

package/src/electron/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "cordova-plugin-unvired-logger",
+    "version": "@PACKAGE_NUMBER@",
+    "description": "Electron platform package for cordova-plugin-unvired-logger",
+    "main": "Logger.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [
+        "electron",
+        "cordova",
+        "plugin",
+        "logger"
+    ],
+    "cordova": {
+        "serviceName": "UnviredLogger"
+    },
+    "author": "Unvired Inc",
+    "license": "MIT",
+    "dependencies": {
+        "electron": ">=20.0.0"
+    },
+    "devDependencies": {},
+    "engines": {
+        "node": ">=14.0.0",
+        "electron": ">=20.0.0"
+    },
+    "peerDependencies": {
+        "electron": ">=20.0.0"
+    }
+}