@onekeyfe/react-native-native-logger 1.1.27 → 1.1.29

package/android/src/main/java/com/margelo/nitro/nativelogger/NativeLogger.kt

@@ -3,6 +3,7 @@ package com.margelo.nitro.nativelogger
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.Promise
 import java.io.File
+import java.io.RandomAccessFile
 
 @DoNotStrip
 class NativeLogger : HybridNativeLoggerSpec() {
@@ -24,24 +25,6 @@ class NativeLogger : HybridNativeLoggerSpec() {
             Regex("(?:eyJ|AAAA)[A-Za-z0-9+/=]{40,}"),
         )
 
-        /** Rate limiting: max messages per second */
-        private const val MAX_MESSAGES_PER_SECOND = 100
-        @Volatile private var messageCount = 0
-        @Volatile private var windowStartMs = System.currentTimeMillis()
-        private val rateLimitLock = Any()
-
-        private fun isRateLimited(): Boolean {
-            synchronized(rateLimitLock) {
-                val now = System.currentTimeMillis()
-                if (now - windowStartMs >= 1000L) {
-                    windowStartMs = now
-                    messageCount = 0
-                }
-                messageCount++
-                return messageCount > MAX_MESSAGES_PER_SECOND
-            }
-        }
-
         fun sanitize(message: String): String {
             var result = message
             for (pattern in sensitivePatterns) {
@@ -54,7 +37,6 @@ class NativeLogger : HybridNativeLoggerSpec() {
     }
 
     override fun write(level: Double, msg: String) {
-        if (isRateLimited()) return
         val sanitized = sanitize(msg)
         when (level.toInt()) {
             0 -> OneKeyLog.debug("JS", sanitized)
@@ -88,6 +70,7 @@ class NativeLogger : HybridNativeLoggerSpec() {
 
     override fun deleteLogFiles(): Promise<Unit> {
         return Promise.async {
+            OneKeyLog.flush()
             val dir = OneKeyLog.logsDirectory
             if (dir.isEmpty()) return@async
             val files = File(dir).listFiles { _, name -> name.endsWith(".log") }
@@ -95,9 +78,16 @@ class NativeLogger : HybridNativeLoggerSpec() {
                 OneKeyLog.warn("NativeLogger", "Failed to list log directory for deletion")
                 return@async
             }
-            // Skip the active log file to avoid breaking logback's open file handle
-            files.filter { it.name != "app-latest.log" }.forEach { file ->
-                if (!file.delete()) {
+            files.forEach { file ->
+                try {
+                    if (file.name == "app-latest.log") {
+                        RandomAccessFile(file, "rw").use { raf ->
+                            raf.setLength(0L)
+                        }
+                    } else if (!file.delete()) {
+                        OneKeyLog.warn("NativeLogger", "Failed to delete log file")
+                    }
+                } catch (_: Exception) {
                     OneKeyLog.warn("NativeLogger", "Failed to delete log file")
                 }
             }

package/android/src/main/java/com/margelo/nitro/nativelogger/OneKeyLog.kt

@@ -23,10 +23,48 @@ object OneKeyLog {
     private const val MAX_FILE_SIZE = 20L * 1024 * 1024       // 20 MB
     private const val MAX_HISTORY = 6
     private const val TOTAL_SIZE_CAP = MAX_FILE_SIZE * MAX_HISTORY
+    private const val DEBUG_INFO_RATE_PER_SECOND = 400.0
+    private const val DEBUG_INFO_BURST = 2000.0
+    private const val WARN_RATE_PER_SECOND = 1000.0
+    private const val WARN_BURST = 2000.0
 
     // Cached value; empty string means context was not yet available (will retry)
     @Volatile
     private var cachedLogsDir: String? = null
+    private data class TokenBucket(
+        val ratePerSecond: Double,
+        val burstCapacity: Double,
+        var tokens: Double,
+        var lastRefillAtMs: Long,
+    ) {
+        fun allow(nowMs: Long): Boolean {
+            val elapsedMs = (nowMs - lastRefillAtMs).coerceAtLeast(0L)
+            if (elapsedMs > 0L) {
+                val refill = (elapsedMs.toDouble() / 1000.0) * ratePerSecond
+                tokens = minOf(burstCapacity, tokens + refill)
+                lastRefillAtMs = nowMs
+            }
+            if (tokens < 1.0) return false
+            tokens -= 1.0
+            return true
+        }
+    }
+
+    private val rateLimitBuckets: MutableMap<String, TokenBucket> = mutableMapOf(
+        "DEBUG" to TokenBucket(
+            DEBUG_INFO_RATE_PER_SECOND, DEBUG_INFO_BURST, DEBUG_INFO_BURST, System.currentTimeMillis()
+        ),
+        "INFO" to TokenBucket(
+            DEBUG_INFO_RATE_PER_SECOND, DEBUG_INFO_BURST, DEBUG_INFO_BURST, System.currentTimeMillis()
+        ),
+        "WARN" to TokenBucket(
+            WARN_RATE_PER_SECOND, WARN_BURST, WARN_BURST, System.currentTimeMillis()
+        ),
+    )
+    private val droppedCounts: MutableMap<String, Int> = mutableMapOf()
+    @Volatile
+    private var lastDropReportMs = System.currentTimeMillis()
+    private val rateLimitLock = Any()
 
     /**
      * Initialise OneKeyLog with an Android Context before NitroModules is ready.
@@ -154,7 +192,61 @@ object OneKeyLog {
         return truncate("$time | $level : [$safeTag] $safeMessage")
     }
 
+    private fun buildDropReportLocked(nowMs: Long): String? {
+        if (nowMs - lastDropReportMs < 1000L) return null
+        if (droppedCounts.isEmpty()) {
+            lastDropReportMs = nowMs
+            return null
+        }
+        val ordered = listOf("DEBUG", "INFO", "WARN")
+        val parts = ordered.mapNotNull { level ->
+            val count = droppedCounts[level] ?: 0
+            if (count > 0) "$level=$count" else null
+        }
+        droppedCounts.clear()
+        lastDropReportMs = nowMs
+        if (parts.isEmpty()) return null
+        return "[OneKeyLog] Rate-limited logs (last 1s): ${parts.joinToString(", ")}"
+    }
+
+    private data class RateLimitDecision(val drop: Boolean, val report: String?)
+
+    private fun evaluateRateLimit(level: String): RateLimitDecision {
+        synchronized(rateLimitLock) {
+            val nowMs = System.currentTimeMillis()
+            var report = buildDropReportLocked(nowMs)
+
+            // Never limit error logs.
+            if (level == "ERROR") {
+                return RateLimitDecision(drop = false, report = report)
+            }
+
+            val bucket = rateLimitBuckets[level]
+            if (bucket == null) {
+                return RateLimitDecision(drop = false, report = report)
+            }
+            if (bucket.allow(nowMs)) {
+                return RateLimitDecision(drop = false, report = report)
+            }
+            droppedCounts[level] = (droppedCounts[level] ?: 0) + 1
+            report = buildDropReportLocked(nowMs) ?: report
+            return RateLimitDecision(drop = true, report = report)
+        }
+    }
+
+    private fun emitRateLimitReport(report: String) {
+        val l = logger
+        if (l != null) {
+            l.warn(report)
+        } else {
+            android.util.Log.w("OneKeyLog", report)
+        }
+    }
+
     private fun log(tag: String, level: String, message: String, androidLogLevel: Int) {
+        val decision = evaluateRateLimit(level)
+        decision.report?.let { emitRateLimitReport(it) }
+        if (decision.drop) return
         val formatted = formatMessage(tag, level, message)
         val l = logger
         if (l != null) {

package/ios/NativeLogger.swift

@@ -22,24 +22,6 @@ class NativeLogger: HybridNativeLoggerSpec {
         return patterns.compactMap { try? NSRegularExpression(pattern: $0) }
     }()
 
-    /// Rate limiting: max messages per second
-    private static let maxMessagesPerSecond = 100
-    private static var messageCount = 0
-    private static var windowStart = Date()
-    private static let rateLimitLock = NSLock()
-
-    private static func isRateLimited() -> Bool {
-        rateLimitLock.lock()
-        defer { rateLimitLock.unlock() }
-        let now = Date()
-        if now.timeIntervalSince(windowStart) >= 1.0 {
-            windowStart = now
-            messageCount = 0
-        }
-        messageCount += 1
-        return messageCount > maxMessagesPerSecond
-    }
-
     private static func sanitize(_ message: String) -> String {
         var result = message
         for regex in sensitivePatterns {
@@ -55,8 +37,24 @@ class NativeLogger: HybridNativeLoggerSpec {
         return result
     }
 
+    private static func truncateFile(atPath path: String) throws {
+        guard FileManager.default.fileExists(atPath: path) else { return }
+        let handle = try FileHandle(forWritingTo: URL(fileURLWithPath: path))
+        defer {
+            if #available(iOS 13.0, *) {
+                try? handle.close()
+            } else {
+                handle.closeFile()
+            }
+        }
+        if #available(iOS 13.0, *) {
+            try handle.truncate(atOffset: 0)
+        } else {
+            handle.truncateFile(atOffset: 0)
+        }
+    }
+
     func write(level: Double, msg: String) {
-        if NativeLogger.isRateLimited() { return }
         let sanitized = NativeLogger.sanitize(msg)
         switch Int(level) {
         case 0: OneKeyLog.debug("JS", sanitized)
@@ -93,6 +91,7 @@ class NativeLogger: HybridNativeLoggerSpec {
 
     func deleteLogFiles() throws -> Promise<Void> {
         return Promise.async {
+            DDLog.flushLog()
             let dir = OneKeyLog.logsDirectory
             let fm = FileManager.default
             let files: [String]
@@ -102,10 +101,14 @@ class NativeLogger: HybridNativeLoggerSpec {
                 OneKeyLog.warn("NativeLogger", "Failed to list log directory for deletion")
                 return
             }
-            // Skip the active log file to avoid breaking CocoaLumberjack's open file handle
-            for file in files where file.hasSuffix(".log") && file != "app-latest.log" {
+            for file in files where file.hasSuffix(".log") {
+                let path = "\(dir)/\(file)"
                 do {
-                    try fm.removeItem(atPath: "\(dir)/\(file)")
+                    if file == "app-latest.log" {
+                        try NativeLogger.truncateFile(atPath: path)
+                    } else {
+                        try fm.removeItem(atPath: path)
+                    }
                 } catch {
                     OneKeyLog.warn("NativeLogger", "Failed to delete log file")
                 }

package/ios/OneKeyLog.swift

@@ -6,6 +6,7 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
     private static let logPrefix = "app"
     private static let latestFileName = "\(logPrefix)-latest.log"
     private static let dateFormatterLock = NSLock()
+    private static let archiveLock = NSLock()
     private static let _dateFormatter: DateFormatter = {
         let fmt = DateFormatter()
         fmt.dateFormat = "yyyy-MM-dd"
@@ -30,8 +31,11 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
 
     /// When rolled, rename app-latest.log → app-{yyyy-MM-dd}.{i}.log (matches Android pattern)
     override func didArchiveLogFile(atPath logFilePath: String, wasRolled: Bool) {
+        Self.archiveLock.lock()
+        defer { Self.archiveLock.unlock() }
+
         guard wasRolled else {
-            super.didArchiveLogFile(atPath: logFilePath, wasRolled: wasRolled)
+            runCleanup()
             return
         }
 
@@ -53,16 +57,37 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
                 try fm.moveItem(atPath: logFilePath, toPath: archivedPath)
                 moved = true
             } catch {
-                // Another thread may have created this file; try next index
-                index += 1
+                // Another callback may have already moved the source file.
+                if !fm.fileExists(atPath: logFilePath) {
+                    break
+                }
+                let nsError = error as NSError
+                // Retry only for recoverable "target exists" collisions.
+                if nsError.domain == NSCocoaErrorDomain &&
+                    nsError.code == NSFileWriteFileExistsError {
+                    index += 1
+                    continue
+                }
+                NSLog(
+                    "[OneKeyLog] Failed to archive log file move (%@:%ld): %@",
+                    nsError.domain,
+                    nsError.code,
+                    nsError.localizedDescription
+                )
+                break
             }
         }
         if !moved {
             NSLog("[OneKeyLog] Failed to archive log file after 1000 attempts: %@", logFilePath)
-            super.didArchiveLogFile(atPath: logFilePath, wasRolled: wasRolled)
-        } else {
-            // Pass the new path so the super class can find the file for cleanup
-            super.didArchiveLogFile(atPath: archivedPath, wasRolled: wasRolled)
+        }
+        runCleanup()
+    }
+
+    private func runCleanup() {
+        do {
+            try cleanupLogFiles()
+        } catch {
+            NSLog("[OneKeyLog] Failed to cleanup log files: %@", (error as NSError).localizedDescription)
         }
     }
 }
@@ -71,6 +96,56 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
 
     private static let maxMessageLength = 4096
 
+    private struct TokenBucket {
+        let ratePerSecond: Double
+        let burstCapacity: Double
+        var tokens: Double
+        var lastRefillAt: TimeInterval
+
+        mutating func allow(at now: TimeInterval) -> Bool {
+            let elapsed = max(0, now - lastRefillAt)
+            if elapsed > 0 {
+                tokens = min(burstCapacity, tokens + elapsed * ratePerSecond)
+                lastRefillAt = now
+            }
+            guard tokens >= 1 else { return false }
+            tokens -= 1
+            return true
+        }
+    }
+
+    private static let debugInfoRatePerSecond = 400.0
+    private static let debugInfoBurst = 2000.0
+    private static let warnRatePerSecond = 1000.0
+    private static let warnBurst = 2000.0
+
+    private static var rateLimitBuckets: [String: TokenBucket] = {
+        let now = Date().timeIntervalSinceReferenceDate
+        return [
+            "DEBUG": TokenBucket(
+                ratePerSecond: debugInfoRatePerSecond,
+                burstCapacity: debugInfoBurst,
+                tokens: debugInfoBurst,
+                lastRefillAt: now
+            ),
+            "INFO": TokenBucket(
+                ratePerSecond: debugInfoRatePerSecond,
+                burstCapacity: debugInfoBurst,
+                tokens: debugInfoBurst,
+                lastRefillAt: now
+            ),
+            "WARN": TokenBucket(
+                ratePerSecond: warnRatePerSecond,
+                burstCapacity: warnBurst,
+                tokens: warnBurst,
+                lastRefillAt: now
+            ),
+        ]
+    }()
+    private static var droppedCounts: [String: Int] = [:]
+    private static var lastDropReportAt = Date().timeIntervalSinceReferenceDate
+    private static let rateLimitLock = NSLock()
+
     private static let configured: Bool = {
         let logsDir = logsDirectory
 
@@ -115,6 +190,63 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
         return _timeFormatter.string(from: date)
     }
 
+    private static func rateLimitReportLocked(now: TimeInterval) -> String? {
+        guard now - lastDropReportAt >= 1.0 else { return nil }
+        guard !droppedCounts.isEmpty else {
+            lastDropReportAt = now
+            return nil
+        }
+        let ordered = ["DEBUG", "INFO", "WARN"]
+        let parts = ordered.compactMap { level -> String? in
+            guard let count = droppedCounts[level], count > 0 else { return nil }
+            return "\(level)=\(count)"
+        }
+        droppedCounts.removeAll()
+        lastDropReportAt = now
+        guard !parts.isEmpty else { return nil }
+        return "[OneKeyLog] Rate-limited logs (last 1s): \(parts.joined(separator: ", "))"
+    }
+
+    private static func evaluateRateLimit(for level: String) -> (drop: Bool, report: String?) {
+        rateLimitLock.lock()
+        defer { rateLimitLock.unlock() }
+
+        let now = Date().timeIntervalSinceReferenceDate
+        var report = rateLimitReportLocked(now: now)
+
+        // Never limit error logs.
+        if level == "ERROR" {
+            return (false, report)
+        }
+
+        guard var bucket = rateLimitBuckets[level] else {
+            return (false, report)
+        }
+        let allowed = bucket.allow(at: now)
+        rateLimitBuckets[level] = bucket
+        if allowed {
+            return (false, report)
+        }
+        droppedCounts[level, default: 0] += 1
+        report = rateLimitReportLocked(now: now) ?? report
+        return (true, report)
+    }
+
+    private static func log(
+        _ level: String,
+        _ tag: String,
+        _ message: String,
+        writer: (String) -> Void
+    ) {
+        _ = configured
+        let decision = evaluateRateLimit(for: level)
+        if let report = decision.report {
+            DDLogWarn(report)
+        }
+        if decision.drop { return }
+        writer(formatMessage(tag, level, message))
+    }
+
     private static func truncate(_ message: String) -> String {
         if message.count > maxMessageLength {
             return String(message.prefix(maxMessageLength)) + "...(truncated)"
@@ -163,23 +295,19 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
     }
 
     @objc public static func debug(_ tag: String, _ message: String) {
-        _ = configured
-        DDLogDebug(formatMessage(tag, "DEBUG", message))
+        log("DEBUG", tag, message) { DDLogDebug($0) }
     }
 
     @objc public static func info(_ tag: String, _ message: String) {
-        _ = configured
-        DDLogInfo(formatMessage(tag, "INFO", message))
+        log("INFO", tag, message) { DDLogInfo($0) }
     }
 
     @objc public static func warn(_ tag: String, _ message: String) {
-        _ = configured
-        DDLogWarn(formatMessage(tag, "WARN", message))
+        log("WARN", tag, message) { DDLogWarn($0) }
     }
 
     @objc public static func error(_ tag: String, _ message: String) {
-        _ = configured
-        DDLogError(formatMessage(tag, "ERROR", message))
+        log("ERROR", tag, message) { DDLogError($0) }
     }
 
     /// Returns the logs directory path (for getLogFilePaths / deleteLogFiles)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-native-logger",
-  "version": "1.1.27",
+  "version": "1.1.29",
   "description": "react-native-native-logger",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",