TRUST-609 Add ability to clear logs for adapters (PR 43)

* Add clearLogs for the adapters

* Integrate clearLogs into testapp

* Fix test

* Update changelog

* Allow to clean netext logs on the fly

* On the fly logs cleanup for testapp

* Update CHANGELOG.md

---------

Co-authored-by: Sergey Fionov <sfionov@adguard.com>

Author: anyakushin

CHANGELOG.md

@@ -8,6 +8,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Added
 
+- Add `clearLogs` method for platform adapters.
+
 ### Changed
 
 ### Deprecated

platform/android/lib/src/main/java/com/adguard/trusttunnel/VpnService.kt

@@ -176,6 +176,16 @@ class VpnService : android.net.VpnService(), VpnClientListener {
 
             return fileLogger?.snapshotTo(exportDir) ?: emptyList()
         }
+
+        /**
+         * Delete all log files produced by the VPN service.
+         *
+         * Safe to call while the VPN is active.
+         */
+        fun clearLogs() {
+            if (!initialized) return
+            fileLogger?.clearLogs()
+        }
     }
 
     private var state = State.Stopped

platform/android/lib/src/main/java/com/adguard/trusttunnel/log/FileLogger.kt

@@ -86,6 +86,24 @@ class FileLogger(
         return future.get()
     }
 
+    /**
+     * Delete all log files managed by this logger and reopen a fresh current file.
+     *
+     * Safe to call without additional synchronization.
+     */
+    fun clearLogs() {
+        val future = writeExecutor.submit(Callable<Unit> {
+            closeFile()
+            for (idx in 0..archiveCount) {
+                val file = if (idx == 0) File(directory, "$baseName.log")
+                           else File(directory, "$baseName.$idx.log")
+                file.delete()
+            }
+            openOrCreateFile()
+        })
+        future.get()
+    }
+
     // ---- private ----
 
     /** Lock-free append (runs on single-thread executor). */

platform/android/lib/src/test/java/com/adguard/trusttunnel/log/FileLoggerTest.kt

@@ -3,6 +3,7 @@ package com.adguard.trusttunnel.log
 import com.adguard.trusttunnel.Logger
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
@@ -211,4 +212,60 @@ class FileLoggerTest {
         assertTrue("Should include current log", archiveNames.contains("snaparchive.log"))
         assertTrue("Should include archive log", archiveNames.contains("snaparchive.1.log"))
     }
+
+    // ---- clearLogs ----
+
+    @Test
+    fun clearLogs_removesCurrentAndArchiveFiles() {
+        val logger = FileLogger(logDir, "clear", maxFileSize = 200)
+        logger.install()
+        logger.snapshotTo(File(tempDir, "drain"))
+
+        // Trigger a rotation so both current and archive files exist.
+        repeat(5) {
+            Logger.dispatchNative(Logger.LogLevel.INFO, "line $it")
+        }
+        logger.snapshotTo(File(tempDir, "drain2"))
+
+        val current = File(logDir, "clear.log")
+        val archive = File(logDir, "clear.1.log")
+        assertTrue("Current file should exist before clear", current.exists())
+        assertTrue("Current file is not empty", current.length().toInt() != 0)
+        assertTrue("Archive file should exist before clear", archive.exists())
+        assertTrue("Archive file is not empty", archive.length().toInt() != 0)
+
+        logger.clearLogs()
+
+        // `clearLogs` reopens the file so logging could proceed after
+        assertTrue("Current file exists", current.exists())
+        assertEquals("Current file is empty (clean), ${current.length()}", current.length(), 0)
+        assertFalse("Archive file should be removed", archive.exists())
+    }
+
+    @Test
+    fun clearLogs_resetsWriterForNewOutput() {
+        val logger = FileLogger(logDir, "reset", maxFileSize = 200)
+        logger.install()
+        logger.snapshotTo(File(tempDir, "drain"))
+
+        repeat(5) {
+            Logger.dispatchNative(Logger.LogLevel.INFO, "before clear $it")
+        }
+        logger.snapshotTo(File(tempDir, "drain2"))
+
+        val current = File(logDir, "reset.log")
+        assertTrue("Current file should have content before clear", current.length() > 0)
+
+        logger.clearLogs()
+
+        // New writes must land in a freshly created (empty) file.
+        Logger.dispatchNative(Logger.LogLevel.INFO, "after clear")
+        logger.snapshotTo(File(tempDir, "drain3"))
+
+        assertTrue("Current file should exist after clear", current.exists())
+        val content = current.readText()
+        assertFalse("Old content should be gone", content.contains("before clear"))
+        assertTrue("New content should be present", content.contains("after clear"))
+        assertFalse("Archive should remain removed", File(logDir, "reset.1.log").exists())
+    }
 }

platform/apple/TrustTunnelClient/FileLogger.swift

@@ -65,6 +65,19 @@ public final class FileLogger {
         }
     }
 
+    /// Clear this logger's own log files and resume writing to a fresh file.
+    ///
+    /// Runs on the serial `queue` and closes/reopens the handle around the
+    /// delete, so pending appends drain first and new ones land in a fresh
+    /// file — nothing is dropped.
+    public func clearLogs() {
+        queue.sync {
+            closeFile()
+            Self.clearLogs(directory: directory, baseName: baseName, archiveCount: archiveCount)
+            openOrCreateFile()
+        }
+    }
+
     /// Produce point-in-time copies of the `<baseName>.log` family in
     /// `directory` into `destDir`, without needing a live `FileLogger`
     /// instance for them.
@@ -114,6 +127,44 @@ public final class FileLogger {
         return result
     }
 
+    /// Delete the `baseName`.log / `baseName`.{1…n}.log files in `directory`.
+    ///
+    /// - Note: Does not synchronize cross-process reads/writes. A process
+    ///   holding the file open keeps writing to the deleted (unlinked) file.
+    ///   For files this process is writing, use the instance `clearLogs()`.
+    public static func clearLogs(directory: URL,
+                                 baseName: String,
+                                 archiveCount: Int = 1) {
+        let fileManager = FileManager.default
+        let fileCoordinator = NSFileCoordinator(filePresenter: nil)
+
+        let candidates = (0 ... archiveCount).map { idx -> URL in
+            idx == 0
+                ? directory.appendingPathComponent("\(baseName).log")
+                : directory.appendingPathComponent("\(baseName).\(idx).log")
+        }
+
+        for url in candidates {
+            var coordinatorError: NSError?
+            fileCoordinator.coordinate(writingItemAt: url,
+                                       options: .forDeleting,
+                                       error: &coordinatorError)
+            { (actualURL) in
+                do {
+                    try fileManager.removeItem(at: actualURL)
+                } catch let error as NSError where error.code == NSFileNoSuchFileError {
+                    // A missing file is expected (e.g. a process that never ran).
+                } catch {
+                    // Surface genuinely unexpected failures.
+                    Self.fallbackLogger.debug("FileLogger clearLogs skipped \(url.lastPathComponent): \(error.localizedDescription)")
+                }
+            }
+            if let error = coordinatorError {
+                Self.fallbackLogger.debug("FileLogger clearLogs skipped \(url.lastPathComponent): \(error.localizedDescription)")
+            }
+        }
+    }
+
     /// Resolve the `logs/` directory inside the App Group container.
     ///
     /// Returns `nil` if the app group identifier yields no container URL.

platform/apple/TrustTunnelClient/PacketTunnelProvider.swift

@@ -47,6 +47,10 @@ open class AGPacketTunnelProvider: NEPacketTunnelProvider {
         } else {
             self.fileLogger = nil
         }
+        // Register the app's clear-logs request handler.
+        if !self.bundleIdentifier.isEmpty {
+            self.setupClearLogsListener()
+        }
         if (config == nil) {
             completionHandler(TunnelError.parse_config_failed)
             return
@@ -152,6 +156,7 @@ open class AGPacketTunnelProvider: NEPacketTunnelProvider {
 
     open override func stopTunnel(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {
         self.clientQueue.async {
+            self.stopClearLogsListener()
             self.stopVpnClient()
             completionHandler()
         }
@@ -229,4 +234,48 @@ open class AGPacketTunnelProvider: NEPacketTunnelProvider {
         )
         logger.debug("notifyAppOnConnectionInfo done")
     }
+
+    // MARK: - Clear logs (App → Network Extension)
+
+    /// Registers a Darwin notification observer so the app can ask a running NE
+    /// to clear its own log file. Idempotent: removes any prior registration.
+    private func setupClearLogsListener() {
+        let center = CFNotificationCenterGetDarwinNotifyCenter()
+        let observer = Unmanaged.passUnretained(self).toOpaque()
+        let name = "\(bundleIdentifier).\(ClearLogsParams.notificationName)" as CFString
+
+        CFNotificationCenterRemoveObserver(center, observer, CFNotificationName(name), nil)
+
+        CFNotificationCenterAddObserver(
+            center,
+            observer,
+            { _, observer, _, _, _ in
+                guard let observer else { return }
+                let provider = Unmanaged<AGPacketTunnelProvider>.fromOpaque(observer).takeUnretainedValue()
+                provider.handleClearLogsNotification()
+            },
+            name,
+            nil,
+            .deliverImmediately
+        )
+    }
+
+    /// No-op if not registered.
+    private func stopClearLogsListener() {
+        let name = "\(bundleIdentifier).\(ClearLogsParams.notificationName)" as CFString
+        CFNotificationCenterRemoveObserver(
+            CFNotificationCenterGetDarwinNotifyCenter(),
+            Unmanaged.passUnretained(self).toOpaque(),
+            CFNotificationName(name),
+            nil
+        )
+    }
+
+    private func handleClearLogsNotification() {
+        fileLogger?.clearLogs()
+    }
+
+    deinit {
+        stopClearLogsListener()
+    }
 }

platform/apple/TrustTunnelClient/Utils.swift

@@ -6,6 +6,10 @@ internal struct ConnectionInfoParams {
     static let notificationName = "connection_info"
 }
 
+internal struct ClearLogsParams {
+    static let notificationName = "clear_logs"
+}
+
 func configureIPv4AndIPv6Settings(from config: TunConfig) -> (NEIPv4Settings, NEIPv6Settings) {
     let ipv4Settings = NEIPv4Settings(addresses: ["10.0.0.2"], subnetMasks: ["255.255.255.0"])
     let ipv6Settings = NEIPv6Settings(addresses: ["fd00::1"], networkPrefixLengths: [64])

platform/apple/TrustTunnelClient/VpnManager.swift

@@ -501,6 +501,39 @@ public final class VpnManager {
         return results.map { $0.path }
     }
 
+    /// Remove all log files from both the app and Network Extension processes.
+    /// Safe to call while the tunnel is running: the app clears `app.log`
+    /// through its live writer, and posts a Darwin notification so a running
+    /// NE clears its own open `extension.log` through its live writer. When the
+    /// NE is not running, its file is deleted directly.
+    public func clearLogs() -> Bool {
+        guard let logsDir = FileLogger.logsDirectory(appGroup: appGroup) else {
+            return false
+        }
+
+        // Own log — cleared through the live writer.
+        fileLogger?.clearLogs()
+
+        let manager = self.queue.sync { self.vpnManager }
+        let neRunning = manager != nil
+            && manager!.connection.status != .disconnected
+            && manager!.connection.status != .invalid
+
+        if neRunning {
+            // NE holds the file open — ask it to clear its own log.
+            let name = "\(bundleIdentifier).\(ClearLogsParams.notificationName)" as CFString
+            CFNotificationCenterPostNotification(
+                CFNotificationCenterGetDarwinNotifyCenter(),
+                CFNotificationName(name),
+                nil, nil, true
+            )
+        } else {
+            // NE not running — delete the files directly.
+            FileLogger.clearLogs(directory: logsDir, baseName: FileLogger.extensionBaseName)
+        }
+        return true
+    }
+
     // MARK: - exportLogs helpers
 
     private static let platformName: String = {

platform/testapp/android/app/src/main/kotlin/com/adguard/testapp/NativeCommunication.kt

@@ -69,6 +69,12 @@ interface NativeVpnInterface {
    * directory. The caller is responsible for cleaning up these files.
    */
   fun exportLogs(): List<String>
+  /**
+   * Clear all log files from the VPN process(es).
+   *
+   * On Apple, the VPN must be stopped before calling this.
+   */
+  fun clearLogs()
 
   companion object {
     /** The codec used by NativeVpnInterface. */
@@ -128,6 +134,22 @@ interface NativeVpnInterface {
           channel.setMessageHandler(null)
         }
       }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.com_adguard_testapp.NativeVpnInterface.clearLogs$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.clearLogs()
+              listOf(null)
+            } catch (exception: Throwable) {
+              NativeCommunicationPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
     }
   }
 }

platform/testapp/android/app/src/main/kotlin/com/adguard/testapp/NativeVpnImpl.kt

@@ -28,4 +28,8 @@ class NativeVpnImpl (
     override fun exportLogs(): List<String> {
         return VpnService.exportLogs(context)
     }
+
+    override fun clearLogs() {
+        VpnService.clearLogs()
+    }
 }