cordova-plugin-unvired-logger 0.0.9 → 0.0.11

package/README.md

@@ -128,7 +128,7 @@ Logger.getBackupLogFileContent("user123",
 ```javascript
 function testLogger() {
     if (window && Logger) {
-        console.log("Testing UnviredLogger plugin...");
+        console.log("Testing Logger plugin...");
         
         // Test basic logging
         Logger.logInfo("testuser", "AuthService", "login", "User login successful",
@@ -170,7 +170,7 @@ function testLogger() {
             }
         );
     } else {
-        console.warn("UnviredLogger not available.");
+        console.warn("Logger not available.");
     }
 }
 
@@ -256,9 +256,9 @@ Where:
 - `logError(userId, sourceClass, sourceMethod, message, success, error)` - Log error message
 
 ### Constants
-- `UnviredLogger.LogLevel.Debug` - Debug log level
-- `UnviredLogger.LogLevel.Info` - Info log level
-- `UnviredLogger.LogLevel.Error` - Error log level
+- `Logger.LogLevel.Debug` - Debug log level
+- `Logger.LogLevel.Info` - Info log level
+- `Logger.LogLevel.Error` - Error log level
 
 ## Requirements
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cordova-plugin-unvired-logger",
-    "version": "0.0.9",
+    "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,12 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<plugin id="cordova-plugin-unvired-logger" version="0.0.9"
+<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">
 
-    <name>UnviredLogger</name>
+    <name>Logger</name>
     <description>A logger plugin for Android, iOS, Electron, and Browser that appends logs to log.txt files organized by user ID.</description>
     
-    <js-module src="www/logger.js" name="UnviredLogger">
+    <js-module src="www/logger.js" name="Logger">
         <clobbers target="Logger" />
     </js-module>
 
@@ -16,12 +16,12 @@
 
     <platform name="android">
         <config-file target="res/xml/config.xml" parent="/*">
-            <feature name="UnviredLogger">
-                <param name="android-package" value="cordova.plugin.unvired.logger.UnviredLogger" />
+            <feature name="Logger">
+                <param name="android-package" value="cordova.plugin.unvired.logger.Logger" />
             </feature>
         </config-file>
         
-        <source-file src="src/android/UnviredLogger.java" target-dir="src/cordova/plugin/unvired/logger" />
+        <source-file src="src/android/Logger.java" target-dir="src/cordova/plugin/unvired/logger" />
         
         <uses-permission android:name="android.permission.READ_PHONE_STATE" />
         <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
@@ -30,20 +30,20 @@
 
     <platform name="ios">
         <config-file target="config.xml" parent="/*">
-            <feature name="UnviredLogger">
-                <param name="ios-package" value="UnviredLogger" />
+            <feature name="Logger">
+                <param name="ios-package" value="Logger" />
             </feature>
         </config-file>
         
-        <source-file src="src/ios/UnviredLogger.swift" />
+        <source-file src="src/ios/Logger.swift" />
         
         <framework src="Foundation.framework" />
         <framework src="UIKit.framework" />
     </platform>
 
     <platform name="browser">
-        <js-module src="src/browser/Logger.js" name="UnviredLogger">
-            <run />
+        <js-module src="src/browser/Logger.js" name="LoggerProxy">
+            <runs />
         </js-module>
     </platform>
 </plugin>

package/src/android/{UnviredLogger.java → Logger.java}

@@ -14,14 +14,14 @@ import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Locale;
 
-public class UnviredLogger extends CordovaPlugin {
+public class Logger extends CordovaPlugin {
 
     private static final String LOG_FOLDER_NAME = "AppLogs";
     private static final String LOG_FILE_NAME = "log.txt";
     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 UnviredLogger 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 UnviredLogger 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) {
@@ -100,12 +100,12 @@ module.exports.loggerWithLevel = async function(successCallback, errorCallback,
     await logWitLevel(successCallback, errorCallback, args)
 }
 
-module.exports.getStringFromLevel = async function (successCallback, errorCallback, level) {
+function getStringFromLevel(level) {
     switch (level) {
-        case LogLevel.Info: successCallback('IMPORTANT');return;
-        case LogLevel.Error: successCallback('ERROR');return;
-        case LogLevel.Debug: successCallback('DEBUG');return;
-        default: successCallback('');return;
+        case LogLevel.Info: return 'IMPORTANT';
+        case LogLevel.Error: return 'ERROR';
+        case LogLevel.Debug: return 'DEBUG';
+        default: return '';
     }
 }
 
@@ -117,9 +117,9 @@ async function logWitLevel(successCallback, errorCallback, args)  {
         
         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"));
+        if (!userId) return errorCallback(new Error("userId is required"));
+        if (!level) return errorCallback(new Error("level is required"));
+        if (!message) return errorCallback(new Error("message is required"));
 
         // Normalize log levels for comparison
         const normalizedDefaultLogLevel = (defaultLogLevel || '').toLowerCase();
@@ -177,7 +177,7 @@ async function logWitLevel(successCallback, errorCallback, args)  {
     }
 }
 
-async function checkAndRotateLogFile (successCallback, errorCallback, args) {
+async function checkAndRotateLogFile (args) {
     return new Promise((resolve, reject) => {
         try {
             const userId = args[0].userId;
@@ -196,4 +196,4 @@ async function checkAndRotateLogFile (successCallback, errorCallback, args) {
     })
 }
 
-require('cordova/exec/proxy').add('UnviredLogger', module.exports);
+require('cordova/exec/proxy').add('Logger', module.exports);

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/electron/package.json

@@ -13,7 +13,7 @@
         "logger"
     ],
     "cordova": {
-        "serviceName": "UnviredLogger"
+        "serviceName": "Logger"
     },
     "author": "Unvired Inc",
     "license": "MIT",

package/src/ios/{UnviredLogger.swift → Logger.swift}

@@ -1,14 +1,14 @@
 import Foundation
 import UIKit
 
-@objc(UnviredLogger) class UnviredLogger : CDVPlugin {
+@objc(Logger) class Logger : CDVPlugin {
     
     private let LOG_FOLDER_NAME = "AppLogs"
     private let LOG_FILE_NAME = "log.txt"
     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'
 };
 
 /**
@@ -20,7 +20,7 @@ exports.LogLevel = {
 const logFolder = "LogFiles"
 
 exports.loggerWithLevel = function (level, sourceClass, sourceMethod, message, success, error) {
-    exec(success, error, 'UnviredLogger', 'loggerWithLevel', [{ userId: logFolder, level: level, sourceClass: sourceClass, sourceMethod: sourceMethod, message: message }]);
+    exec(success, error, 'Logger', 'loggerWithLevel', [{ userId: logFolder, level: level, sourceClass: sourceClass, sourceMethod: sourceMethod, message: message }]);
 };
 
 /**
@@ -34,7 +34,7 @@ exports.setLogLevel = function (level, success, error) {
         if (error) error('Log level is required');
         return;
     }
-    exec(success, error, 'UnviredLogger', 'setLogLevel', [level]);
+    exec(success, error, 'Logger', 'setLogLevel', [level]);
 };
 
 /**
@@ -43,7 +43,7 @@ exports.setLogLevel = function (level, success, error) {
  * @param {function} error - Error callback
  */
 exports.getLogFileContent = function (success, error) {
-    exec(success, error, 'UnviredLogger', 'getLogFileContent', [{ userId: logFolder }]);
+    exec(success, error, 'Logger', 'getLogFileContent', [{ userId: logFolder }]);
 };
 
 /**
@@ -52,7 +52,7 @@ exports.getLogFileContent = function (success, error) {
  * @param {function} error - Error callback
  */
 exports.clearLogFile = function (success, error) {
-    exec(success, error, 'UnviredLogger', 'clearLogFile', [{ userId: logFolder}]);
+    exec(success, error, 'Logger', 'clearLogFile', [{ userId: logFolder}]);
 };
 
 /**
@@ -61,7 +61,7 @@ exports.clearLogFile = function (success, error) {
  * @param {function} error - Error callback
  */
 exports.getBackupLogFileContent = function (success, error) {
-    exec(success, error, 'UnviredLogger', 'getBackupLogFileContent', [{ userId: logFolder }]);
+    exec(success, error, 'Logger', 'getBackupLogFileContent', [{ userId: logFolder }]);
 };
 
 /**
@@ -70,7 +70,7 @@ exports.getBackupLogFileContent = function (success, error) {
  * @param {function} error - Error callback
  */
 exports.copyLogToBackup = function (success, error) {
-    exec(success, error, 'UnviredLogger', 'copyLogToBackup', [{ userId: logFolder }]);
+    exec(success, error, 'Logger', 'copyLogToBackup', [{ userId: logFolder }]);
 };
 
 /**
@@ -81,7 +81,7 @@ exports.logDebug = function (sourceClass, sourceMethod, message, success, error)
         if (error) error('Message is required');
         return;
     }
-    exec(success, error, 'UnviredLogger', 'logDebug', [{ 
+    exec(success, error, 'Logger', 'logDebug', [{ 
         userId: logFolder, 
         level: exports.LogLevel.Debug,
         message: message, 
@@ -95,7 +95,7 @@ exports.logInfo = function (sourceClass, sourceMethod, message, success, error)
         if (error) error('Message is required');
         return;
     }
-    exec(success, error, 'UnviredLogger', 'logInfo', [{ 
+    exec(success, error, 'Logger', 'logInfo', [{ 
         userId: logFolder, 
         level: exports.LogLevel.Info,
         message: message, 
@@ -109,7 +109,7 @@ exports.logError = function (sourceClass, sourceMethod, message, success, error)
         if (error) error('Message is required');
         return;
     }
-    exec(success, error, 'UnviredLogger', 'logError', [{ 
+    exec(success, error, 'Logger', 'logError', [{ 
         userId: logFolder, 
         level: exports.LogLevel.Error,
         message: message, 
@@ -119,13 +119,13 @@ exports.logError = function (sourceClass, sourceMethod, message, success, error)
 };
 
 exports.getLogFileURL = function (success, error) {
-    exec(success, error, 'UnviredLogger', 'getLogFileURL', [{ userId: logFolder }]);
+    exec(success, error, 'Logger', 'getLogFileURL', [{ userId: logFolder }]);
 };
 
 exports.getBackupLogFileURL = function (success, error) {
-    exec(success, error, 'UnviredLogger', 'getBackupLogFileURL', [{ userId: logFolder }]);
+    exec(success, error, 'Logger', 'getBackupLogFileURL', [{ userId: logFolder }]);
 };
 
 exports.getLogLevel = function (success, error) {
-    exec(success, error, 'UnviredLogger', 'getLogLevel', []);
+    exec(success, error, 'Logger', 'getLogLevel', []);
 };