cordova-plugin-unvired-logger 0.0.1

package/README.md

@@ -0,0 +1,272 @@
+# Cordova Plugin Unvired Logger
+
+A comprehensive Cordova plugin that provides advanced logging functionality with log levels, file management, and user-specific log organization. Supports Android, iOS, Electron, and Browser platforms.
+
+## Installation
+
+```bash
+cordova plugin add cordova-plugin-unvired-logger
+```
+
+## Usage
+
+### Basic Logging
+
+```javascript
+// Info log
+Logger.logInfo("user123", "AuthService", "login", "User login successful",
+    function(success) {
+        console.log("Log saved:", success);
+    },
+    function(error) {
+        console.error("Logging failed:", error);
+    }
+);
+
+// Debug log
+Logger.logDebug("user123", "UserService", "getUserData", "Fetching user data from API",
+    function(success) {
+        console.log("Debug log saved:", success);
+    },
+    function(error) {
+        console.error("Debug logging failed:", error);
+    }
+);
+
+// Error log
+Logger.logError("user123", "UserService", "getUserData", "Failed to fetch user data: Network error",
+    function(success) {
+        console.log("Error log saved:", success);
+    },
+    function(error) {
+        console.error("Error logging failed:", error);
+    }
+);
+```
+
+### Advanced Logging with Level
+
+```javascript
+Logger.loggerWithLevel("user123", "debug", "MyClass", "myMethod", "This is a debug message",
+    function(success) {
+        console.log("Log saved:", success);
+    },
+    function(error) {
+        console.error("Logging failed:", error);
+    }
+);
+```
+
+### Log Level Management
+
+```javascript
+// Set log level to control which messages are logged
+Logger.setLogLevel("debug", // Logs all levels
+    function(success) {
+        console.log("Log level set to Debug");
+    },
+    function(error) {
+        console.error("Failed to set log level:", error);
+    }
+);
+
+Logger.setLogLevel("info", // Logs Info and Error only
+    function(success) {
+        console.log("Log level set to Info");
+    },
+    function(error) {
+        console.error("Failed to set log level:", error);
+    }
+);
+
+Logger.setLogLevel("error", // Logs Error only
+    function(success) {
+        console.log("Log level set to Error");
+    },
+    function(error) {
+        console.error("Failed to set log level:", error);
+    }
+);
+```
+
+### Log File Management
+
+```javascript
+// Get log file content
+Logger.getLogFileContent("user123",
+    function(content) {
+        console.log("Log file content:", content);
+    },
+    function(error) {
+        console.error("Failed to read log file:", error);
+    }
+);
+
+// Clear log file
+Logger.clearLogFile("user123",
+    function(success) {
+        console.log("Log file cleared successfully");
+    },
+    function(error) {
+        console.error("Failed to clear log file:", error);
+    }
+);
+
+// Get backup log file content (when log rotation occurs)
+Logger.getBackupLogFileContent("user123",
+    function(content) {
+        console.log("Backup log file content:", content);
+    },
+    function(error) {
+        console.error("Failed to read backup log file:", error);
+    }
+);
+```
+
+### Complete Test Example
+
+```javascript
+function testLogger() {
+    if (window && Logger) {
+        console.log("Testing UnviredLogger plugin...");
+        
+        // Test basic logging
+        Logger.logInfo("testuser", "AuthService", "login", "User login successful",
+            function(success) {
+                console.log("Basic log success:", success);
+                
+                // Test log level setting
+                Logger.setLogLevel("debug",
+                    function() {
+                        console.log("Log level set to Debug");
+                        
+                        // Test convenience methods
+                        Logger.logDebug("testuser", "TestClass", "testMethod", "Debug message test",
+                            function() {
+                                console.log("Debug log successful");
+                                
+                                // Test reading log content
+                                Logger.getLogFileContent("testuser",
+                                    function(content) {
+                                        console.log("Log file content:", content);
+                                    },
+                                    function(error) {
+                                        console.error("Failed to read log:", error);
+                                    }
+                                );
+                            },
+                            function(error) {
+                                console.error("Debug log failed:", error);
+                            }
+                        );
+                    },
+                    function(error) {
+                        console.error("Failed to set log level:", error);
+                    }
+                );
+            },
+            function(error) {
+                console.error("Basic log failed:", error);
+            }
+        );
+    } else {
+        console.warn("UnviredLogger not available.");
+    }
+}
+
+// Call the test function
+testLogger();
+```
+
+## Supported Platforms
+
+- **Android**: Native Java implementation with file system access
+- **iOS**: Native Swift implementation with file system access
+- **Electron**: Node.js implementation with file system access
+- **Browser**: JavaScript implementation using localStorage
+
+## Features
+
+- **Advanced logging**: Log messages with class, method, and log level information
+- **Log levels**: Debug, Info, and Error levels with filtering
+- **User-specific logging**: Logs are organized by user ID
+- **Automatic file creation**: Log files and directories are created automatically
+- **Log rotation**: Automatic backup when log file exceeds 5MB
+- **Timestamped entries**: Each log entry includes local and UTC timestamps
+- **File management**: Read, clear, and backup log files
+- **Cross-platform**: Consistent API across all supported platforms
+- **Convenience methods**: Easy-to-use methods for different log levels
+
+## Platform-Specific Details
+
+### Android
+- Logs are stored in the app's internal storage: `/data/data/[package]/files/[userId]/AppLogs/`
+- 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/`
+- Uses native Swift implementation for optimal performance
+- Automatic log rotation when file size exceeds 5MB
+
+### Electron
+- Logs are stored in the app's user data directory: `[userData]/[userId]/log/`
+- Uses Node.js file system APIs
+- Automatic log rotation when file size exceeds 5MB
+
+### Browser
+- Logs are stored in browser's localStorage with keys: `unvired_logger_[userId]_log.txt`
+- Fallback implementation when Cordova is not available
+- Automatic content truncation when size exceeds 5MB
+- Console logging for debugging purposes
+
+## Log Levels
+
+- **Debug**: Detailed information for debugging (only logged when level is set to Debug)
+- **Info**: General information about application flow (logged when level is Info or Debug)
+- **Error**: Error messages and exceptions (always logged)
+
+## File Structure
+
+Logs are stored in the following structure:
+```
+{userDataPath}/{userId}/AppLogs/log.txt
+{userDataPath}/{userId}/AppLogs/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
+- `log.txt` is the current log file
+- `log_backup.txt` is the backup file (created during rotation)
+
+## API Reference
+
+### Core Methods
+- `log(userId, message, sourceClass?, sourceMethod?, level?, success, error)` - Log a message
+- `setLogLevel(level, success, error)` - Set the logging level
+- `getLogFileContent(userId, success, error)` - Get log file content
+- `clearLogFile(userId, success, error)` - Clear the log file
+- `getBackupLogFileContent(userId, success, error)` - Get backup log file content
+
+### Convenience Methods
+- `logDebug(userId, sourceClass, sourceMethod, message, success, error)` - Log debug message
+- `logInfo(userId, sourceClass, sourceMethod, message, success, error)` - Log info message
+- `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
+
+## Requirements
+
+- Cordova 9.0.0 or higher
+- cordova-electron 1.0.0 or higher
+- Electron 20.0.0 or higher
+- Node.js 14.0.0 or higher
+
+## License
+
+MIT 

package/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "cordova-plugin-unvired-logger",
+    "version": "0.0.1",
+    "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",
+        "platforms": [
+            "electron",
+            "android",
+            "browser",
+            "ios"
+        ]
+    },
+    "keywords": [
+        "cordova",
+        "electron",
+        "android",
+        "plugin",
+        "logger"
+    ],
+    "author": "Unvired Inc.",
+    "license": "MIT",
+    "dependencies": {
+        "fs": "^0.0.1-security"
+    }
+}

package/plugin.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin id="cordova-plugin-unvired-logger" version="0.0.1"
+        xmlns="http://apache.org/cordova/ns/plugins/1.0"
+        xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <name>UnviredLogger</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">
+        <clobbers target="Logger" />
+    </js-module>
+
+    <platform name="electron">
+        <framework src="src/electron"/>
+    </platform>
+
+    <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>
+        </config-file>
+        
+        <source-file src="src/android/UnviredLogger.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" />
+        <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    </platform>
+
+    <platform name="ios">
+        <config-file target="config.xml" parent="/*">
+            <feature name="UnviredLogger">
+                <param name="ios-package" value="UnviredLogger" />
+            </feature>
+        </config-file>
+        
+        <source-file src="src/ios/UnviredLogger.swift" />
+        
+        <framework src="Foundation.framework" />
+        <framework src="UIKit.framework" />
+    </platform>
+
+    <platform name="browser">
+        <js-module src="src/browser/Logger.js" name="UnviredLoggerBrowser">
+            <clobbers target="UnviredLoggerBrowser" />
+        </js-module>
+    </platform>
+</plugin>

package/src/android/UnviredLogger.java

@@ -0,0 +1,265 @@
+package cordova.plugin.unvired.logger;
+
+import android.content.Context;
+import android.os.Environment;
+
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CallbackContext;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.*;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+public class UnviredLogger 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";
+
+    @Override
+    public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
+        try {
+            switch (action) {
+                case "logDebug":
+                case "logInfo":
+                case "logError":
+                case "loggerWithLevel":
+                    logWithLevel(args, callbackContext);
+                    return true;
+                case "setLogLevel":
+                    setLogLevel(args, callbackContext);
+                    return true;
+                case "getLogLevel":
+                    callbackContext.success(defaultLogLevel);
+                    return true;
+                case "getLogFileContent":
+                    getLogFileContent(args, callbackContext);
+                    return true;
+                case "clearLogFile":
+                    clearLogFile(args, callbackContext);
+                    return true;
+                case "getBackupLogFileContent":
+                    getBackupLogFileContent(args, callbackContext);
+                    return true;
+                case "copyLogToBackup":
+                    copyLogToBackup(args, callbackContext);
+                    return true;
+                case "getLogFileURL":
+                    getLogFileURL(args, callbackContext);
+                    return true;
+                case "getBackupLogFileURL":
+                    getBackupLogFileURL(args, callbackContext);
+                    return true;
+                default:
+                    return false;
+            }
+        } catch (Exception e) {
+            callbackContext.error("Error: " + e.getMessage());
+            return false;
+        }
+    }
+
+    private void setLogLevel(JSONArray args, CallbackContext callbackContext) {
+        try {
+            String level = args.getString(0);
+            defaultLogLevel = level;
+            callbackContext.success();
+        } catch (Exception e) {
+            callbackContext.error("Failed to set log level: " + e.getMessage());
+        }
+    }
+
+    private void logWithLevel(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject arg = args.getJSONObject(0);
+            String userId = arg.optString("userId");
+            String level = arg.optString("level");
+            String sourceClass = arg.optString("sourceClass", "");
+            String sourceMethod = arg.optString("sourceMethod", "");
+            String message = arg.optString("message");
+
+            if (userId.isEmpty() || level.isEmpty() || message.isEmpty()) {
+                callbackContext.error("userId, level, and message are required");
+                return;
+            }
+
+            // Log level filtering
+            if (shouldSkipLog(level)) {
+                callbackContext.success();
+                return;
+            }
+
+            File logFile = getLogFile(userId);
+            checkAndRotateLogFile(logFile, userId);
+
+            String logEntry = formatLogEntry(level, sourceClass, sourceMethod, message);
+            appendToFile(logFile, logEntry);
+
+            callbackContext.success("Logged to " + logFile.getAbsolutePath());
+        } catch (Exception e) {
+            callbackContext.error("Logging failed: " + e.getMessage());
+        }
+    }
+
+    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;
+        return false;
+    }
+
+    private void getLogFileContent(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject arg = args.getJSONObject(0);
+            String userId = arg.optString("userId");
+            File logFile = getLogFile(userId);
+            String content = readFile(logFile);
+            callbackContext.success(content);
+        } catch (Exception e) {
+            callbackContext.error("Failed to read log file: " + e.getMessage());
+        }
+    }
+
+    private void clearLogFile(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject arg = args.getJSONObject(0);
+            String userId = arg.optString("userId");
+            File logFile = getLogFile(userId);
+            new FileOutputStream(logFile).close();
+            callbackContext.success();
+        } catch (Exception e) {
+            callbackContext.error("Failed to clear log file: " + e.getMessage());
+        }
+    }
+
+    private void getBackupLogFileContent(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject arg = args.getJSONObject(0);
+            String userId = arg.optString("userId");
+            File backupFile = getBackupLogFile(userId);
+            String content = readFile(backupFile);
+            callbackContext.success(content);
+        } catch (Exception e) {
+            callbackContext.error("Failed to read backup log file: " + e.getMessage());
+        }
+    }
+
+    private void copyLogToBackup(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject arg = args.getJSONObject(0);
+            String userId = arg.optString("userId");
+            File logFile = getLogFile(userId);
+            File backupFile = getBackupLogFile(userId);
+            copyFile(logFile, backupFile);
+            callbackContext.success();
+        } catch (Exception e) {
+            callbackContext.error("Failed to copy log file to backup: " + e.getMessage());
+        }
+    }
+
+    private void getLogFileURL(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject arg = args.getJSONObject(0);
+            String userId = arg.optString("userId");
+            File logFile = getLogFile(userId);
+            callbackContext.success(logFile.getAbsolutePath());
+        } catch (Exception e) {
+            callbackContext.error("Failed to get log file URL: " + e.getMessage());
+        }
+    }
+
+    private void getBackupLogFileURL(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject arg = args.getJSONObject(0);
+            String userId = arg.optString("userId");
+            File backupFile = getBackupLogFile(userId);
+            callbackContext.success(backupFile.getAbsolutePath());
+        } catch (Exception e) {
+            callbackContext.error("Failed to get backup log file URL: " + e.getMessage());
+        }
+    }
+
+    // --- Helper methods ---
+
+    private File getLogFile(String userId) {
+        File dir = getUserLogDir(userId);
+        if (!dir.exists()) dir.mkdirs();
+        return new File(dir, LOG_FILE_NAME);
+    }
+
+    private File getBackupLogFile(String userId) {
+        File dir = getUserLogDir(userId);
+        if (!dir.exists()) dir.mkdirs();
+        return new File(dir, BACKUP_LOG_FILE_NAME);
+    }
+
+    private File getUserLogDir(String userId) {
+        Context ctx = cordova.getActivity().getApplicationContext();
+        File userDir = new File(ctx.getFilesDir(), userId + File.separator + LOG_FOLDER_NAME);
+        if (!userDir.exists()) userDir.mkdirs();
+        return userDir;
+    }
+
+    private void checkAndRotateLogFile(File logFile, String userId) throws IOException {
+        if (logFile.exists() && logFile.length() > MAX_LOG_SIZE) {
+            File backupFile = getBackupLogFile(userId);
+            copyFile(logFile, backupFile);
+            new FileOutputStream(logFile).close();
+        }
+    }
+
+    private String formatLogEntry(String level, String sourceClass, String sourceMethod, String message) {
+        SimpleDateFormat localFormat = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss", Locale.getDefault());
+        SimpleDateFormat utcFormat = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss", Locale.US);
+        utcFormat.setTimeZone(java.util.TimeZone.getTimeZone("UTC"));
+        Date now = new Date();
+        String local = localFormat.format(now);
+        String utc = utcFormat.format(now);
+        String prefix = level.equalsIgnoreCase("error") ? "⭕️⭕️⭕️ " : "";
+        return prefix + local + " | UTC:" + utc + " | " + getStringFromLevel(level) + " | " + sourceClass + " | " + sourceMethod + " | " + message + "\n";
+    }
+
+    private String getStringFromLevel(String level) {
+        switch (level.toLowerCase()) {
+            case "info": return "IMPORTANT";
+            case "error": return "ERROR";
+            case "debug": return "DEBUG";
+            default: return "";
+        }
+    }
+
+    private void appendToFile(File file, String data) throws IOException {
+        FileWriter fw = new FileWriter(file, true);
+        fw.write(data);
+        fw.close();
+    }
+
+    private String readFile(File file) throws IOException {
+        if (!file.exists()) return "";
+        StringBuilder sb = new StringBuilder();
+        BufferedReader br = new BufferedReader(new FileReader(file));
+        String line;
+        while ((line = br.readLine()) != null) sb.append(line).append("\n");
+        br.close();
+        return sb.toString();
+    }
+
+    private void copyFile(File src, File dest) throws IOException {
+        if (!src.exists()) return;
+        FileInputStream in = new FileInputStream(src);
+        FileOutputStream out = new FileOutputStream(dest);
+        byte[] buf = new byte[1024];
+        int len;
+        while ((len = in.read(buf)) > 0) out.write(buf, 0, len);
+        in.close();
+        out.close();
+    }
+}