cordova-plugin-unvired-logger 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cordova-plugin-unvired-logger",
-    "version": "0.0.10",
+    "version": "0.0.11",
     "description": "A logger plugin for Electron, Android, Browser, and iOS that appends logs to log.txt files organized by user ID.",
     "cordova": {
         "id": "cordova-plugin-unvired-logger",

package/plugin.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<plugin id="cordova-plugin-unvired-logger" version="0.0.10"
+<plugin id="cordova-plugin-unvired-logger" version="0.0.11"
         xmlns="http://apache.org/cordova/ns/plugins/1.0"
         xmlns:android="http://schemas.android.com/apk/res/android">
 

package/src/android/Logger.java

@@ -21,7 +21,7 @@ public class Logger extends CordovaPlugin {
     private static final String BACKUP_LOG_FILE_NAME = "log_backup.txt";
     private static final long MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
 
-    private String defaultLogLevel = "info";
+    private String defaultLogLevel = "important";
 
     @Override
     public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
@@ -111,8 +111,8 @@ public class Logger extends CordovaPlugin {
     private boolean shouldSkipLog(String level) {
         String normLevel = level.toLowerCase();
         String normDefault = defaultLogLevel.toLowerCase();
-        if (normDefault.equals("error") && (normLevel.equals("debug") || normLevel.equals("info"))) return true;
-        if (normDefault.equals("info") && normLevel.equals("debug")) return true;
+        if (normDefault.equals("error") && (normLevel.equals("debug") || normLevel.equals("important"))) return true;
+        if (normDefault.equals("important") && normLevel.equals("debug")) return true;
         return false;
     }
 
@@ -229,7 +229,7 @@ public class Logger extends CordovaPlugin {
 
     private String getStringFromLevel(String level) {
         switch (level.toLowerCase()) {
-            case "info": return "IMPORTANT";
+            case "important": return "IMPORTANT";
             case "error": return "ERROR";
             case "debug": return "DEBUG";
             default: return "";

package/src/browser/Logger.js

@@ -6,7 +6,7 @@ const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
 const LogLevel = {
     Debug: 'debug',
     Error: 'error',
-    Info: 'info',
+    Info: 'important',
 };
 
 let defaultLogLevel = LogLevel.Info;
@@ -29,12 +29,12 @@ module.exports.logInfo = async function (successCallback, errorCallback, args) {
 
 module.exports.setLogLevel = function(successCallback, errorCallback, level) {
     // If level is an array (from Cordova), extract the first element
-    if (Array.isArray(level)) {
-        defaultLogLevel = level[0];
-    } else {
-        defaultLogLevel = level;
-    }
-    successCallback("")
+    let levelToSet = Array.isArray(level) ? level[0] : level;
+    
+    // Normalize the level to lowercase for consistency
+    defaultLogLevel = (levelToSet || '').toLowerCase();
+    
+    successCallback("");
 }
 
 module.exports.getLogLevel = function(successCallback, errorCallback) {

package/src/electron/Logger.js

@@ -3,6 +3,35 @@ const path = require('path');
 const fs = require('fs');
 const fsPromises = fs.promises;
 
+// --- Proper async lock for log file operations ---
+let logLockPromise = Promise.resolve();
+let isLocked = false;
+
+async function withLogLock(fn) {
+    // Wait for any existing lock to complete
+    await logLockPromise;
+    
+    // Create a new promise for this operation
+    const operationPromise = (async () => {
+        try {
+            isLocked = true;
+            const result = await fn();
+            return result;
+        } catch (error) {
+            console.error('[Logger] Error in log operation:', error);
+            // Return error message instead of throwing to prevent unhandled promise rejections
+            return `Error in log operation: ${error.message}`;
+        } finally {
+            isLocked = false;
+        }
+    })();
+    
+    // Update the lock promise to wait for this operation
+    logLockPromise = operationPromise;
+    
+    return operationPromise;
+}
+
 const LOG_FOLDER_NAME = 'log';
 const LOG_FILE_NAME = 'log.txt';
 const BACKUP_LOG_FILE_NAME = 'log_backup.txt';
@@ -10,7 +39,7 @@ const BACKUP_LOG_FILE_NAME = 'log_backup.txt';
 const LogLevel = {
     Debug: 'debug',
     Error: 'error',
-    Info: 'info',
+    Info: 'important',
 };
 
 let defaultLogLevel = LogLevel.Info;
@@ -29,15 +58,11 @@ function logInfo(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();
-    });
+    // If level is an array (from Cordova), extract the first element
+    let levelToSet = Array.isArray(level) ? level[0] : level;
+    
+    // Normalize the level to lowercase for consistency
+    defaultLogLevel = (levelToSet || '').toLowerCase();
 }
 
 function getLogLevel() {
@@ -68,14 +93,10 @@ function getLogFileContent(args) {
 }
 
 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}`));
-        }
+    return withLogLock(async () => {
+        const logPath = getLogFileURL(args);
+        await fsPromises.writeFile(logPath, '');
+        return 'Log file cleared successfully';
     });
 }
 
@@ -101,69 +122,58 @@ function getBackupLogFileContent(args) {
 }
 
 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}`));
-        }
+    return withLogLock(async () => {
+        const logPath = getLogFileURL(args);
+        const backupPath = getBackupLogFileURL(args);
+        await fsPromises.copyFile(logPath, backupPath);
+        return 'Log file copied to backup successfully';
     });
 }
 
 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);
+    return withLogLock(async () => {
+        if (!args || !args[0]) throw new Error("Invalid arguments provided");
+        const { userId, level, sourceClass, sourceMethod, message } = args[0];
+        if (!userId) throw new Error("userId is required");
+        if (!level) throw new Error("level is required");
+        if (!message) throw 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;
+        }
 
-            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}`));
+        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');
+        return `Logged to ${logPath}`;
     });
 }
 
@@ -190,21 +200,18 @@ function getStringFromLevel(level) {
 }
 
 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, '');
-                }
+    return withLogLock(async () => {
+        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, '');
+                return 'Log file rotated due to size limit';
             }
-            resolve();
-        } catch (err) {
-            reject(new Error(`Failed to rotate log file: ${err.message}`));
         }
+        return 'Log file rotation check completed';
     });
 }
 

package/src/ios/Logger.swift

@@ -8,7 +8,7 @@ import UIKit
     private let BACKUP_LOG_FILE_NAME = "log_backup.txt"
     private let MAX_LOG_SIZE: Int64 = 5 * 1024 * 1024 // 5MB
     
-    private var defaultLogLevel: String = "info"
+    private var defaultLogLevel: String = "important"
     
     @objc(logDebug:)
     func logDebug(_ command: CDVInvokedUrlCommand) {
@@ -193,10 +193,10 @@ import UIKit
         let normLevel = level.lowercased()
         let normDefault = defaultLogLevel.lowercased()
         
-        if normDefault == "error" && (normLevel == "debug" || normLevel == "info") {
+        if normDefault == "error" && (normLevel == "debug" || normLevel == "important") {
             return true
         }
-        if normDefault == "info" && normLevel == "debug" {
+        if normDefault == "important" && normLevel == "debug" {
             return true
         }
         return false
@@ -251,7 +251,7 @@ import UIKit
     
     private func getStringFromLevel(level: String) -> String {
         switch level.lowercased() {
-        case "info": return "IMPORTANT"
+        case "important": return "IMPORTANT"
         case "error": return "ERROR"
         case "debug": return "DEBUG"
         default: return ""

package/www/logger.js

@@ -4,7 +4,7 @@ var exec = require('cordova/exec');
 exports.LogLevel = {
     Debug: 'debug',
     Error: 'error',
-    Info: 'info'
+    Info: 'important'
 };
 
 /**