cordova-plugin-unvired-logger 0.0.10 → 0.0.12

package/README.md

@@ -200,12 +200,12 @@ testLogger();
 ## Platform-Specific Details
 
 ### Android
-- Logs are stored in the app's internal storage: `/data/data/[package]/files/[userId]/AppLogs/`
+- Logs are stored in the app's internal storage: `/data/data/[package]/files/[userId]/`
 - Requires storage permissions for external storage access
 - Automatic log rotation when file size exceeds 5MB
 
 ### iOS
-- Logs are stored in the app's Documents directory: `Documents/[userId]/AppLogs/`
+- Logs are stored in the app's Documents directory: `Documents/[userId]/`
 - Uses native Swift implementation for optimal performance
 - Automatic log rotation when file size exceeds 5MB
 
@@ -230,14 +230,13 @@ testLogger();
 
 Logs are stored in the following structure:
 ```
-{userDataPath}/{userId}/AppLogs/log.txt
-{userDataPath}/{userId}/AppLogs/log_backup.txt
+{userDataPath}/{userId}/log.txt
+{userDataPath}/{userId}/log_backup.txt
 ```
 
 Where:
 - `userDataPath` is the Electron app's user data directory
-- `userId` is the user identifier you provide
-- `AppLogs` is the log folder name
+- `userId` is the log folder name
 - `log.txt` is the current log file
 - `log_backup.txt` is the backup file (created during rotation)
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cordova-plugin-unvired-logger",
-    "version": "0.0.10",
+    "version": "0.0.12",
     "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.12"
         xmlns="http://apache.org/cordova/ns/plugins/1.0"
         xmlns:android="http://schemas.android.com/apk/res/android">
 

package/src/android/Logger.java

@@ -16,12 +16,11 @@ import java.util.Locale;
 
 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 +110,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;
     }
 
@@ -203,7 +202,7 @@ public class Logger extends CordovaPlugin {
 
     private File getUserLogDir(String userId) {
         Context ctx = cordova.getActivity().getApplicationContext();
-        File userDir = new File(ctx.getFilesDir(), userId + File.separator + LOG_FOLDER_NAME);
+        File userDir = new File(ctx.getFilesDir(), userId);
         if (!userDir.exists()) userDir.mkdirs();
         return userDir;
     }
@@ -229,7 +228,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

@@ -1,4 +1,3 @@
-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
@@ -6,7 +5,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 +28,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,14 +3,42 @@ const path = require('path');
 const fs = require('fs');
 const fsPromises = fs.promises;
 
-const LOG_FOLDER_NAME = 'log';
+// --- 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_FILE_NAME = 'log.txt';
 const BACKUP_LOG_FILE_NAME = 'log_backup.txt';
 
 const LogLevel = {
     Debug: 'debug',
     Error: 'error',
-    Info: 'info',
+    Info: 'important',
 };
 
 let defaultLogLevel = LogLevel.Info;
@@ -29,15 +57,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 +92,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 +121,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}`;
     });
 }
 
@@ -173,7 +182,7 @@ function getLogDirectory(args) {
     }
     const userId = args[0].userId;
     const userDataPath = app.getPath('userData');
-    const userPath = path.join(userDataPath, userId, LOG_FOLDER_NAME);
+    const userPath = path.join(userDataPath, userId);
     if (!fs.existsSync(userPath)) {
         fs.mkdirSync(userPath, { recursive: true });
     }
@@ -190,21 +199,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

@@ -3,12 +3,11 @@ import UIKit
 
 @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 +192,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
@@ -214,7 +213,7 @@ import UIKit
     
     private func getUserLogDir(userId: String) throws -> URL {
         let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
-        let userDir = documentsPath.appendingPathComponent(userId).appendingPathComponent(LOG_FOLDER_NAME)
+        let userDir = documentsPath.appendingPathComponent(userId)
         
         if !FileManager.default.fileExists(atPath: userDir.path) {
             try FileManager.default.createDirectory(at: userDir, withIntermediateDirectories: true, attributes: nil)
@@ -251,7 +250,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 ""
@@ -259,6 +258,11 @@ import UIKit
     }
     
     private func appendToFile(file: URL, data: String) throws {
+        let fileManager = FileManager.default
+        if !fileManager.fileExists(atPath: file.path) {
+            // Create the file if it doesn't exist
+            fileManager.createFile(atPath: file.path, contents: nil, attributes: nil)
+        }
         let fileHandle = try FileHandle(forWritingTo: file)
         fileHandle.seekToEndOfFile()
         fileHandle.write(data.data(using: .utf8)!)

package/www/logger.js

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