feat: pending data support disk cache.

Xcoder1011 · Xcoder1011 · commit 8f7bb4b250a5 · 2022-11-04T17:33:14.000+08:00
diff --git a/Example/SKApmTools/ViewController.swift b/Example/SKApmTools/ViewController.swift
@@ -25,11 +25,21 @@ class ViewController: UIViewController {
             btn.addTarget(self, action: #selector(btnClicked(_:)) , for: .touchUpInside)
             view.addSubview(btn)
         }
-        SKANRMonitor.sharedInstance.start()
+        
+        SKANRMonitor.start()
+        let datas = SKANRMonitor.getPendingEntities()
+        print("待处理的卡顿数据数目: \(datas.count)")
+        SKANRMonitor.monitorCallback { curEntity, allEntities in
+            print("监测到卡顿: \(curEntity.validFunction)")
+            print(curEntity.threadId)
+            print(curEntity.occurenceTime)
+            print(curEntity.validAddress)
+            print(curEntity.traceContent)
+        }
     }
     
     @objc func btnClicked(_ sender: UIButton) {
-        Thread.sleep(forTimeInterval: 2)
+        Thread.sleep(forTimeInterval: 1)
     }
 
     override func didReceiveMemoryWarning() {
diff --git a/SKApmTools/Classes/ANR/SKANRMonitor.swift b/SKApmTools/Classes/ANR/SKANRMonitor.swift
@@ -10,65 +10,147 @@ import Foundation
 open class SKANRMonitor: NSObject{
     
     @objc public static let sharedInstance = SKANRMonitor()
-    /// 单次耗时较长的卡顿阈值: 默认值为500ms，单位：毫秒
-    @objc public var singleTime: Int = 500
+    /// 单次耗时较长的卡顿阈值: 默认值为300ms，单位：毫秒
+    @objc public var singleTime: Int = 300
     
     fileprivate var observer: CFRunLoopObserver?
     
     fileprivate var activity: CFRunLoopActivity?
     
+    fileprivate var lock = os_unfair_lock()
+    
     fileprivate var semaphore: DispatchSemaphore?
     
     fileprivate var underObserving: Bool = false
     /// 卡顿次数记录
     fileprivate var count: Int = 0
     
-    fileprivate var pendingEntitys: [SKBacktraceEntity] = []
+    fileprivate var pendingEntities: [SKBacktraceEntity] = []
     
     fileprivate var pendingEntityDict: [String: SKBacktraceEntity] = [:]
     
-    @objc public func start() {
+    public typealias MonitorCallback = (_ curEntity: SKBacktraceEntity, _ allEntities: [SKBacktraceEntity]) -> Void
+    
+    fileprivate var callback: MonitorCallback?
+    
+    fileprivate var filePath: String? {
+        get {
+            let path = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true).first as NSString?
+            if let filePath = path?.appendingPathComponent("wd_apm_anr.archive") {
+                return filePath
+            }
+            return nil
+        }
+    }
+    
+    public override init() {
+        super.init()
+        readDataFromDisk()
+    }
+    
+    /// 开启监测
+    @objc public class func start() {
+        SKANRMonitor.sharedInstance.start()
+    }
+    /// 停止监测
+    @objc public class func stop() {
+        SKANRMonitor.sharedInstance.stop()
+    }
+    
+    /// 监测到一个卡顿回调
+    public class func monitorCallback(_ callback: @escaping MonitorCallback) {
+        SKANRMonitor.sharedInstance.callback = callback
+    }
+    
+    /// 获取卡顿数据
+    public class func getPendingEntities() -> [SKBacktraceEntity] {
+        return SKANRMonitor.sharedInstance.pendingEntities
+    }
+    
+    /// 清理卡顿数据
+    public class func clearPendingEntities() {
+        SKANRMonitor.sharedInstance._clearEntities()
+    }
+    
+    public func _clearEntities() {
+        os_unfair_lock_lock(&lock)
+        pendingEntities.removeAll()
+        pendingEntityDict.removeAll()
+        if let filePath = filePath {
+            if FileManager.default.fileExists(atPath: filePath) {
+                do {
+                    try FileManager.default.removeItem(atPath: filePath)
+                } catch {
+                    print("SKANRMonitor remove anr data from disk error = \(error.localizedDescription)")
+                }
+            }
+        }
+        os_unfair_lock_unlock(&lock)
+    }
+    
+    private func start() {
         if nil == self.observer {
             underObserving = true
             semaphore = DispatchSemaphore(value: 1)
             var context = CFRunLoopObserverContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
             self.observer = CFRunLoopObserverCreate(kCFAllocatorDefault, CFRunLoopActivity.allActivities.rawValue, true, 0, observerCallBack(), &context)
             CFRunLoopAddObserver(CFRunLoopGetMain(), observer, CFRunLoopMode.commonModes)
             
-            Thread.detachNewThread {
-                while(self.underObserving) {
-                    if let activity = self.activity, let semaphore = self.semaphore {
-                        SKANRMonitor.sharedInstance.logActivity(activity)
-                        let result = semaphore.wait(timeout: DispatchTime.now() + .milliseconds(self.singleTime))
+            Thread.detachNewThread { [self] in
+                while(underObserving) {
+                    if let activity = activity, let semaphore = semaphore {
+                        let result = semaphore.wait(timeout: DispatchTime.now() + .milliseconds(singleTime))
                         if result == .timedOut {
-                            if self.observer == nil {
+                            if observer == nil {
                                 return
                             }
                             if activity == .beforeSources || activity == .afterWaiting {
-                                print("监测到卡顿")
                                 let entity = SKBackTrace.backTraceInfoEntity(of: Thread.main)
-                                let key = "\(entity.validAddress)_\(entity.validFunction)"
-                                if !self.pendingEntityDict.keys.contains(key) {
-                                    self.pendingEntityDict.updateValue(entity, forKey: key)
-                                    self.pendingEntitys.append(entity)
-                                    print(entity.threadId)
-                                    print(entity.validAddress)
-                                    print(entity.validFunction)
-                                    print(entity.traceContent)
-                                } else {
-                                    print("相同的卡顿只记录一次")
-                                }
+                                handleEntity(entity)
                             }
                         } else {
-                            self.count = 0
+                            count = 0
                         }
                     }
                 }
             }
         }
     }
     
-    @objc public func stop() {
+    private func handleEntity(_ entity: SKBacktraceEntity) {
+        let key = "\(entity.validAddress)_\(entity.validFunction)"
+        if !self.pendingEntityDict.keys.contains(key) {
+            os_unfair_lock_lock(&lock)
+            // limit cache count 50
+            if (pendingEntities.count >= 50) {
+                let removeEntity = pendingEntities.removeLast()
+                let removeKey = "\(removeEntity.validAddress)_\(removeEntity.validFunction)"
+                self.pendingEntityDict.removeValue(forKey: removeKey)
+            }
+            self.pendingEntityDict.updateValue(entity, forKey: key)
+            self.pendingEntities.insert(entity, at: 0)
+            os_unfair_lock_unlock(&lock)
+            
+            if let filePath = filePath {
+                do {
+                    print("SKANRMonitor write data to filePath = \(filePath)")
+                    let data = try PropertyListEncoder().encode(self.pendingEntities)
+                    try data.write(to:  URL(fileURLWithPath: filePath))
+                }
+                catch {
+                    print("SKANRMonitor write data to filePath error = \(error.localizedDescription)")
+                }
+            }
+            
+            if let callback = self.callback {
+                callback(entity, self.pendingEntities)
+            }
+        } else {
+            print("SKANRMonitor 相同的卡顿只记录一次")
+        }
+    }
+    
+    private func stop() {
         if nil != self.observer  {
             underObserving = false
             CFRunLoopRemoveObserver(CFRunLoopGetMain(), self.observer, CFRunLoopMode.commonModes)
@@ -79,13 +161,31 @@ open class SKANRMonitor: NSObject{
     fileprivate func observerCallBack() -> CFRunLoopObserverCallBack {
         return {(observer, activity, pointer) in
             SKANRMonitor.sharedInstance.activity = activity
-            print("即将进入RunLoop")
             if let semaphore = SKANRMonitor.sharedInstance.semaphore {
                 semaphore.signal()
             }
         }
     }
     
+    private func readDataFromDisk() {
+        if let filePath = filePath, FileManager.default.fileExists(atPath: filePath) {
+            do {
+                let data = try Data(contentsOf: URL(fileURLWithPath: filePath))
+                let entities = try PropertyListDecoder().decode([SKBacktraceEntity].self, from: data)
+                os_unfair_lock_lock(&lock)
+                pendingEntities.append(contentsOf: entities)
+                entities.forEach { e in
+                    let key = "\(e.validAddress)_\(e.validFunction)"
+                    pendingEntityDict.updateValue(e, forKey: key)
+                }
+                os_unfair_lock_unlock(&lock)
+            }
+            catch {
+                print("SKANRMonitor read data from disk error = \(error.localizedDescription)")
+            }
+        }
+    }
+    
     fileprivate func logActivity(_ activity: CFRunLoopActivity) {
         switch activity {
         case .entry:
diff --git a/SKApmTools/Classes/BackTrace/SKBackTrace.swift b/SKApmTools/Classes/BackTrace/SKBackTrace.swift
@@ -37,7 +37,8 @@ public class SKBackTrace {
             validAddress = symbols.first?.formatAddress ?? ""
             validFunction = symbols.first?.demangledSymbol ?? ""
         }
-        let entity = SKBacktraceEntity(threadId: UInt(mach_thread), validAddress: validAddress, validFunction: validFunction, traceContent: traceContent, traceSymbols: symbols)
+        let time = Date.timeIntervalSinceReferenceDate
+        let entity = SKBacktraceEntity(threadId: UInt(mach_thread), validAddress: validAddress, validFunction: validFunction, traceContent: traceContent, traceSymbols: symbols, occurenceTime: time)
         return entity
     }
     
diff --git a/SKApmTools/Classes/BackTrace/SKStackSymbol.swift b/SKApmTools/Classes/BackTrace/SKStackSymbol.swift
@@ -7,7 +7,7 @@
 
 import Foundation
 
-public struct SKStackSymbol {
+public struct SKStackSymbol: Codable {
     public let symbol: String
     public let file: String
     public let address: UInt
@@ -47,12 +47,13 @@ public struct SKStackSymbol {
 }
 
 
-public struct SKBacktraceEntity {
+public struct SKBacktraceEntity: Codable {
     public let threadId: UInt  // 259
     public let validAddress: String // address
     public let validFunction: String // function
     public let traceContent: String
     public let traceSymbols: [SKStackSymbol]
+    public let occurenceTime: TimeInterval
 }
 
 public struct SKBacktraceEntry: Codable {

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,8 @@ public class SKBackTrace {`
`37`	`37`	`validAddress = symbols.first?.formatAddress ?? ""`
`38`	`38`	`validFunction = symbols.first?.demangledSymbol ?? ""`
`39`	`39`	`}`
`40`		`- let entity = SKBacktraceEntity(threadId: UInt(mach_thread), validAddress: validAddress, validFunction: validFunction, traceContent: traceContent, traceSymbols: symbols)`
	`40`	`+ let time = Date.timeIntervalSinceReferenceDate`
	`41`	`+ let entity = SKBacktraceEntity(threadId: UInt(mach_thread), validAddress: validAddress, validFunction: validFunction, traceContent: traceContent, traceSymbols: symbols, occurenceTime: time)`
`41`	`42`	`return entity`
`42`	`43`	`}`
`43`	`44`