Pull request #1403: Feature/AG-13082

Merge in ADGUARD-IOS/adguard-ios from feature/AG-13082 to master

* commit 'e350ac6a6f05d2fa9dd5dff87132f3598f4b8cec': (22 commits)
  🦞 Fix: Issues from review
  🧹 Refactor: remove reference to old loggerFile in project
  🧹 Refactor: delete old logger-class
  🧹 Refactor: delete "SUPERmegaTEST"-log
  🧹 Refactor: fix logs' messages
  🧹 Refactor: fix loggerManager in Services
  Refactor: Change messages in some logs
  fix name in some LOG-files; add some debug-logs in SupportService; change initialisation in 'ServiceInitializer'; delete unused classes
  Test fixes
  TODO fix
  delete old init logger-files
  💉 Enhance: Implement logger for old ObjC classes; Refactoring
  Fix supportService; delete old logger files
  TODO marks
  build crash fix
  comment old logger init; add targets to LoggerManager
  Correction of the message in LOG
  Revert "Refactor: Zxc refactor"
  Refactor: Zxc refactor
  Bug fix with type 'result'; Change old 'Logger.' to 'LOG.'
  ...

AdGuardSDK/AdGuardSDK/DNS/DnsProtection/DnsProtection+BackgroundFetch.swift

@@ -18,15 +18,17 @@
 
 import SharedAdGuardSDK
 
+private let LOG = LoggerFactory.getLoggerWrapper(DnsProtection.self)
+
 extension DnsProtection {
     public func updateFiltersInBackground(onFiltersUpdate: @escaping ((_ error: Error?) -> Void)) {
         workingQueue.async { [weak self] in
             self?.dnsFiltersManager.updateAllFilters { result in
                 if result.unupdatedFiltersIds.isEmpty {
-                    Logger.logInfo("(DnsProtection+BackgroundFetch) - updateFiltersInBackground; Filters with id = \(result.updatedFiltersIds) were updated")
+                    LOG.info("Filters with id = \(result.updatedFiltersIds) were updated")
                     self?.completionQueue.async { onFiltersUpdate(nil) }
                 } else {
-                    Logger.logError("(DnsProtection+BackgroundFetch) - updateFiltersInBackground; Some filters with id = \(result.unupdatedFiltersIds) were not updated")
+                    LOG.error("Some filters with id = \(result.unupdatedFiltersIds) were not updated")
                     self?.completionQueue.async { onFiltersUpdate(CommonError.error(message: "Some filters were not updated")) }
                 }
             }

AdGuardSDK/AdGuardSDK/DNS/DnsProtection/DnsProtection+Configuration.swift

@@ -48,6 +48,8 @@ public protocol DnsProtectionConfigurationProtocol {
     func updateConfig(with newConfig: DnsConfigurationProtocol)
 }
 
+private let LOG = LoggerFactory.getLoggerWrapper("DnsProtection+Configuration")
+
 extension DnsProtection {
     public var proStatus: Bool {
         return workingQueue.sync { return configuration.proStatus }
@@ -91,7 +93,7 @@ extension DnsProtection {
 
     public func updateConfig(with newConfig: DnsConfigurationProtocol) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+Configuration) - updateConfig;")
+            LOG.info("updateConfig")
             self.configuration.updateConfig(with: newConfig)
         }
     }

AdGuardSDK/AdGuardSDK/DNS/DnsProtection/DnsProtection+Filters.swift

@@ -78,6 +78,8 @@ public protocol DnsProtectionFiltersProtocol {
     func updateAllFilters(onFilterUpdated: @escaping (_ result: DnsFiltersUpdateResult) -> Void)
 }
 
+private let LOG = LoggerFactory.getLoggerWrapper("DnsProtection+Filters")
+
 extension DnsProtection {
 
     public var filters: [DnsFilter] {
@@ -103,41 +105,41 @@ extension DnsProtection {
     public func setFilter(withId id: Int, to enabled: Bool) throws {
         try workingQueue.sync {
             try dnsFiltersManager.setFilter(withId: id, to: enabled)
-            Logger.logInfo("(DnsProtection+Filters - setFilter; Enabled state for filter with id = \(id) is = \(enabled)")
+            LOG.info("Enabled state for filter with id = \(id) is = \(enabled)")
         }
     }
 
     public func renameFilter(withId id: Int, to name: String) throws {
         try workingQueue.sync {
             try dnsFiltersManager.renameFilter(withId: id, to: name)
-            Logger.logInfo("(DnsProtection+Filters - renameFilter; Filter with id = \(id) was renamed to \(name)")
+            LOG.info("Filter with id = \(id) was renamed to \(name)")
         }
     }
 
     public func addFilter(withName name: String, url: URL, isEnabled: Bool, onFilterAdded: @escaping (Error?) -> Void) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+Filters - addFilter; Start add filter with name = \(name), url = \(url), is enabled = \(isEnabled)")
+            LOG.info("Start add filter with name = \(name), url = \(url), is enabled = \(isEnabled)")
             dnsFiltersManager.addFilter(withName: name, url: url, isEnabled: isEnabled, onFilterAdded: onFilterAdded)
         }
     }
 
     public func removeFilter(withId id: Int) throws {
         try workingQueue.sync {
             try dnsFiltersManager.removeFilter(withId: id)
-            Logger.logInfo("(DnsProtection+Filters - removeFilter; Filter with id = \(id) was removed")
+            LOG.info("Filter with id = \(id) was removed")
         }
     }
 
     public func updateFilter(withId id: Int, onFilterUpdated: @escaping (_ error: Error?) -> Void) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+Filters) - updateFilter; Start updating filter with id = \(id)")
+            LOG.info("Start updating filter with id = \(id)")
             dnsFiltersManager.updateFilter(withId: id, onFilterUpdated: onFilterUpdated)
         }
     }
 
     public func updateAllFilters(onFilterUpdated: @escaping (_ result: DnsFiltersUpdateResult) -> Void) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+Filters) - updateAllFilters; Start updating all filters")
+            LOG.info("Start updating all filters")
             dnsFiltersManager.updateAllFilters(onFilterUpdated: onFilterUpdated)
         }
     }

AdGuardSDK/AdGuardSDK/DNS/DnsProtection/DnsProtection+UserRules.swift

@@ -121,58 +121,60 @@ public protocol DnsProtectionUserRulesManagerProtocol {
     func checkEnabledRuleExists(_ rule: String, for type: DnsUserRuleType)->Bool
 }
 
+private let LOG = LoggerFactory.getLoggerWrapper("DnsProtection+UserRules")
+
 extension DnsProtection {
     public func rulesString(for type: DnsUserRuleType) -> String {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - rulesString; Returning rules string for type=\(type)")
+            LOG.info("Returning rules string for type=\(type)")
             let manager = getManager(for: type)
             return manager.rulesString
         }
     }
 
     public func allRules(for type: DnsUserRuleType) -> [UserRule] {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - allRules; Returning all rules for type=\(type)")
+            LOG.info("Returning all rules for type=\(type)")
             let manager = getManager(for: type)
             return manager.allRules
         }
     }
 
     public func add(rule: UserRule, override: Bool, for type: DnsUserRuleType) throws {
         try workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - addRule; Adding rule: \(rule); for type=\(type); override=\(override)")
+            LOG.info("Adding rule: \(rule); for type=\(type); override=\(override)")
             let manager = getManager(for: type)
             try manager.add(rule: rule, override: override)
         }
     }
 
     public func add(rules: [UserRule], override: Bool, for type: DnsUserRuleType) throws {
         try workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - addRules; Adding \(rules.count) rules; for type=\(type); override=\(override)")
+            LOG.info("Adding \(rules.count) rules; for type=\(type); override=\(override)")
             let manager = getManager(for: type)
             try manager.add(rules: rules, override: override)
         }
     }
 
     public func set(rules: [String], for type: DnsUserRuleType) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - setRules; Setting \(rules.count) rules; for type=\(type)")
+            LOG.info("Setting \(rules.count) rules; for type=\(type)")
             let manager = getManager(for: type)
             manager.set(rules: rules)
         }
     }
 
     public func modifyRule(_ oldRuleText: String, _ newRule: UserRule, for type: DnsUserRuleType) throws {
         try workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - modifyRule; Modifying old rule=\(oldRuleText) to new rule=\(newRule)")
+            LOG.info("Modifying old rule=\(oldRuleText) to new rule=\(newRule)")
             let manager = getManager(for: type)
             try manager.modifyRule(oldRuleText, newRule)
         }
     }
 
     public func turnRules(_ rules: [String], on: Bool, for type: DnsUserRuleType) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - turnRules; Turning \(rules.count) rules on=\(on) for type=\(type)")
+            LOG.info("Turning \(rules.count) rules on=\(on) for type=\(type)")
             let manager = getManager(for: type)
             rules.forEach {
                 try? manager.modifyRule($0, UserRule(ruleText: $0, isEnabled: on))
@@ -182,15 +184,15 @@ extension DnsProtection {
 
     public func removeRule(withText ruleText: String, for type: DnsUserRuleType) throws {
         try workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - removeRule; Removing rule=\(ruleText) for type=\(type)")
+            LOG.info("Removing rule=\(ruleText) for type=\(type)")
             let manager = getManager(for: type)
             try manager.removeRule(withText: ruleText)
         }
     }
 
     public func removeRules(_ rules: [String], for type: DnsUserRuleType) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - removeRules; Removing \(rules.count) rules for type=\(type)")
+            LOG.info("Removing \(rules.count) rules for type=\(type)")
             let manager = getManager(for: type)
             rules.forEach {
                 try? manager.removeRule(withText: $0)
@@ -200,7 +202,7 @@ extension DnsProtection {
 
     public func removeAllRules(for type: DnsUserRuleType) {
         workingQueue.sync {
-            Logger.logInfo("(DnsProtection+UserRules) - removeAllRules; Removing all rules for type=\(type)")
+            LOG.info("Removing all rules for type=\(type)")
             let manager = getManager(for: type)
             manager.removeAllRules()
         }

AdGuardSDK/AdGuardSDK/DNS/DnsProviders/DnsProvidersManager/DnsProvidersManager.swift

@@ -78,6 +78,8 @@ public protocol DnsProvidersManagerProtocol: ResetableSyncProtocol {
     func removeCustomProvider(withId id: Int) throws
 }
 
+private let LOG = LoggerFactory.getLoggerWrapper(DnsProvidersManager.self)
+
 final public class DnsProvidersManager: DnsProvidersManagerProtocol {
 
     // MARK: - Internal variables
@@ -120,7 +122,7 @@ final public class DnsProvidersManager: DnsProvidersManagerProtocol {
          userDefaults: UserDefaultsStorageProtocol,
          customProvidersStorage: CustomDnsProvidersStorageProtocol,
          predefinedProviders: PredefinedDnsProvidersDecoderProtocol) {
-        Logger.logInfo("(DnsProvidersManager) - init start")
+        LOG.info("Init start")
         self.configuration = configuration
         self.userDefaults = userDefaults
         self.customProvidersStorage = customProvidersStorage
@@ -132,19 +134,19 @@ final public class DnsProvidersManager: DnsProvidersManagerProtocol {
         self.customProviders = providersWithState.custom
         self.activeDnsProvider = providersWithState.activeDnsProvider
         self.activeDnsServer = providersWithState.activeDnsServer
-        Logger.logInfo("(DnsProvidersManager) - init end")
+        LOG.info("Init end")
     }
 
     // MARK: - Public methods
 
     public func update(dnsImplementation: DnsImplementation) {
-        Logger.logInfo("(DnsProvidersManager) - updateDnsImplementation; Changed to \(dnsImplementation)")
+        LOG.info("Changed to \(dnsImplementation)")
         configuration.dnsImplementation = dnsImplementation
         reinitializeProviders()
     }
 
     public func selectProvider(withId id: Int, serverId: Int) throws {
-        Logger.logInfo("(DnsProvidersManager) - selectProvider; Selecting provider with id=\(id) serverId=\(serverId)")
+        LOG.info("Selecting provider with id=\(id) serverId=\(serverId)")
 
         guard let provider = allProviders.first(where: { $0.providerId == id }) else {
             throw DnsProviderError.invalidProvider(providerId: id)
@@ -158,13 +160,13 @@ final public class DnsProvidersManager: DnsProvidersManagerProtocol {
         userDefaults.activeDnsInfo = newActiveDnsInfo
         reinitializeProviders()
 
-        Logger.logInfo("(DnsProvidersManager) - selectProvider; Selected provider with id=\(id) serverId=\(serverId)")
+        LOG.info("Selected provider with id=\(id) serverId=\(serverId)")
     }
 
     // TODO: - It's a crutch, should be refactored
     /// isMigration parameter is a crutch to quickly migrate custom DNS providers without checking their upstreams
     public func addCustomProvider(name: String, upstreams: [String], selectAsCurrent: Bool, isMigration: Bool) throws {
-        Logger.logInfo("(DnsProvidersManager) - addCustomProvider; Trying to add custom provider with name=\(name), upstreams=\(upstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
+        LOG.info("Trying to add custom provider with name=\(name), upstreams=\(upstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
 
         // check server exists
         let servers = customProvidersStorage.providers.map { $0.server }
@@ -183,11 +185,11 @@ final public class DnsProvidersManager: DnsProvidersManagerProtocol {
         reinitializeProviders()
 
 
-        Logger.logInfo("(DnsProvidersManager) - addCustomProvider; Added custom provider with name=\(name), upstreams=\(upstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
+        LOG.info("Added custom provider with name=\(name), upstreams=\(upstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
     }
 
     public func updateCustomProvider(withId id: Int, newName: String, newUpstreams: [String], selectAsCurrent: Bool) throws {
-        Logger.logInfo("(DnsProvidersManager) - updateCustomProvider; Trying to update custom provider with id=\(id) name=\(newName), upstreams=\(newUpstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
+        LOG.info("Trying to update custom provider with id=\(id) name=\(newName), upstreams=\(newUpstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
 
         // check another server with given upstream exists
         let servers = customProvidersStorage.providers.compactMap {
@@ -208,11 +210,11 @@ final public class DnsProvidersManager: DnsProvidersManagerProtocol {
         }
         reinitializeProviders()
 
-        Logger.logInfo("(DnsProvidersManager) - updateCustomProvider; Updated custom provider with id=\(id) name=\(newName), upstreams=\(newUpstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
+        LOG.info("Updated custom provider with id=\(id) name=\(newName), upstreams=\(newUpstreams.joined(separator: "; ")) selectAsCurrent=\(selectAsCurrent)")
     }
 
     public func removeCustomProvider(withId id: Int) throws {
-        Logger.logInfo("(DnsProvidersManager) - removeCustomProvider; Trying to remove provider with id=\(id)")
+        LOG.info("Trying to remove provider with id=\(id)")
 
         try customProvidersStorage.removeCustomProvider(withId: id)
 
@@ -224,11 +226,11 @@ final public class DnsProvidersManager: DnsProvidersManagerProtocol {
         }
         reinitializeProviders()
 
-        Logger.logInfo("(DnsProvidersManager) - removeCustomProvider; Removed provider with id=\(id)")
+        LOG.info("Removed provider with id=\(id)")
     }
 
     public func reset() throws {
-        Logger.logInfo("(DnsProvidersManager) - reset; Start")
+        LOG.info("Start resettings")
 
         let defaultProviderId = PredefinedDnsProvider.systemDefaultProviderId
         let defaultServerId = PredefinedDnsServer.systemDefaultServerId
@@ -237,7 +239,7 @@ final public class DnsProvidersManager: DnsProvidersManagerProtocol {
         try! customProvidersStorage.reset()
         reinitializeProviders()
 
-        Logger.logInfo("(DnsProvidersManager) - reset; Finish")
+        LOG.info("Finish resettings")
     }
 
     // MARK: - Private methods

AdGuardSDK/AdGuardSDK/DNS/DnsProviders/Predefined/PredefinedDnsProvidersDecoder.swift

@@ -22,6 +22,8 @@ protocol PredefinedDnsProvidersDecoderProtocol {
     var providers: [PredefinedDnsProvider] { get }
 }
 
+private let LOG = LoggerFactory.getLoggerWrapper(PredefinedDnsProvidersDecoder.self)
+
 /**
  Decodes **providers.json** and **providers_i18n.json** and returns their data as an object
  File **providers.json** contains JSON with information about predefined DNS providers
@@ -119,7 +121,7 @@ struct PredefinedDnsProvidersDecoder: PredefinedDnsProvidersDecoderProtocol {
     /* Returns json Data from file name */
     private func getData(forFileName fileName: String) throws -> Data {
         guard let pathString = bundle.path(forResource: fileName, ofType: "json") else {
-            Logger.logError("(DnsProvidersDecoder) - getData; Failed to get \(fileName).json path")
+            LOG.error("Failed to get \(fileName).json path")
             throw CommonError.missingFile(filename: "\(fileName).json")
         }
         let pathUrl = URL(fileURLWithPath: pathString)