feat: update SKBackTrace.backTraceInfoEntity return value.

Xcoder1011 · Xcoder1011 · commit c5dffe85a1e8 · 2022-10-31T17:07:35.000+08:00
diff --git a/SKApmTools/Classes/ANR/SKANRMonitor.swift b/SKApmTools/Classes/ANR/SKANRMonitor.swift
@@ -20,9 +20,13 @@ open class SKANRMonitor: NSObject{
     fileprivate var semaphore: DispatchSemaphore?
     
     fileprivate var underObserving: Bool = false
-    // 卡顿次数记录
+    /// 卡顿次数记录
     fileprivate var count: Int = 0
     
+    fileprivate var pendingEntitys: [SKBacktraceEntity] = []
+    
+    fileprivate var pendingEntityDict: [String: SKBacktraceEntity] = [:]
+    
     @objc public func start() {
         if nil == self.observer {
             underObserving = true
@@ -37,16 +41,22 @@ open class SKANRMonitor: NSObject{
                         SKANRMonitor.sharedInstance.logActivity(activity)
                         let result = semaphore.wait(timeout: DispatchTime.now() + .milliseconds(self.singleTime))
                         if result == .timedOut {
+                            if self.observer == nil {
+                                return
+                            }
                             if activity == .beforeSources || activity == .afterWaiting {
-                                let stackSize = Thread.main.stackSize
                                 print("监测到卡顿")
-//                                let callStackSymbols = Thread.callStackSymbols
-//                                for (index, symbol) in callStackSymbols.enumerated() {
-//                                    print("symbol【\(index)】: \(symbol)")
-//                                }
-                                let traces = SKBackTrace.backTrace(of: Thread.main)
-                                for (index, symbol) in traces.enumerated() {
-                                    print("symbol【\(index)】: \(symbol.info)")
+                                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("相同的卡顿只记录一次")
                                 }
                             }
                         } else {
diff --git a/SKApmTools/Classes/BackTrace/SKBackTrace.swift b/SKApmTools/Classes/BackTrace/SKBackTrace.swift
@@ -11,33 +11,43 @@ import MachO
 public class SKBackTrace {
     
     /// 获取指定线程的堆栈信息
-    public static func backTrace(of thread: Thread) -> [SKStackSymbol] {
+    public static func backTraceInfoEntity(of thread: Thread) -> SKBacktraceEntity {
         let mach_thread = _machThread(from: thread)
-        var symbols : [SKStackSymbol] = []
         let stackSize : UInt32 = 128
         let addrs = UnsafeMutablePointer<UnsafeMutableRawPointer?>.allocate(capacity: Int(stackSize))
         defer { addrs.deallocate() }
         let frameCount = mach_back_trace(mach_thread, stack: addrs, maxSymbols: Int32(stackSize))
         let buf = UnsafeBufferPointer(start: addrs, count: Int(frameCount))
+        var validAddress = "", validFunction = "", traceContent = ""
+        var symbols : [SKStackSymbol] = []
+        let bundleName = Bundle.main.infoDictionary?["CFBundleName"] // like SKApmTools_Example
         /// 解析堆栈地址
         for (index, addr) in buf.enumerated() {
             guard let addr = addr else { continue }
             let address = UInt(bitPattern: addr)
-            let symbol: SKStackSymbol
-            symbol = mach_O_parseSymbol(with: address, index: index)
+            let symbol = mach_O_parseSymbol(with: address, index: index)
+            traceContent.append("\(symbol.info)")
             symbols.append(symbol)
+            if let bundleName = bundleName, validAddress.count == 0,  bundleName as! String == symbol.baseAddress {
+                validAddress = symbol.formatAddress
+                validFunction = symbol.demangledSymbol
+            }
+        }
+        if validAddress.count == 0 {
+            validAddress = symbols.first?.formatAddress ?? ""
+            validFunction = symbols.first?.demangledSymbol ?? ""
         }
-        return symbols
+        let entity = SKBacktraceEntity(threadId: UInt(mach_thread), validAddress: validAddress, validFunction: validFunction, traceContent: traceContent, traceSymbols: symbols)
+        return entity
     }
     
-    /// Thread to mach thread
     /// 获取线程对应的线程标识
     private static func _machThread(from thread: Thread) -> thread_t {
         guard let (threads, count) = _machAllThread() else {
             return mach_thread_self()
         }
         
-        // 判断目标 thread, 如果是主线程，直接返回对应标识
+        /// 判断目标 thread, 如果是主线程，直接返回对应标识
         if thread.isMainThread {
             return get_main_thread_id()
         }
@@ -83,8 +93,8 @@ public class SKBackTrace {
 
 @_silgen_name("mach_backtrace")
 public func mach_back_trace(_ thread: thread_t,
-                             stack: UnsafeMutablePointer<UnsafeMutableRawPointer?>,
-                             maxSymbols: Int32) -> Int32
+                            stack: UnsafeMutablePointer<UnsafeMutableRawPointer?>,
+                            maxSymbols: Int32) -> Int32
 
 extension Character {
     var isAscii: Bool {
diff --git a/SKApmTools/Classes/BackTrace/SKStackSymbol.swift b/SKApmTools/Classes/BackTrace/SKStackSymbol.swift
@@ -20,17 +20,41 @@ public struct SKStackSymbol {
         return _stdlib_demangleName(symbol)
     }
     
+    public var baseAddress: String {
+        return image.utf8CString.withUnsafeBufferPointer { (imageBuffer: UnsafeBufferPointer<CChar>) -> String in
+            return String(format: "%s", UInt(bitPattern: imageBuffer.baseAddress))
+        }
+    }
+    
+    public var formatAddress: String {
+#if arch(x86_64) || arch(arm64)
+        return String(format: "0x%016llx", address)
+#else
+        return String(format: "0x%08lx", address)
+#endif
+    }
+    
     public var info: String {
         return image.utf8CString.withUnsafeBufferPointer { (imageBuffer: UnsafeBufferPointer<CChar>) -> String in
+            let add = UInt(bitPattern: imageBuffer.baseAddress)
 #if arch(x86_64) || arch(arm64)
-            return String(format: "%-4ld%-35s 0x%016llx %@ + %ld \n", index, UInt(bitPattern: imageBuffer.baseAddress), address, demangledSymbol, offset)
+            return String(format: "%-4ld%-35s 0x%016llx  %@ + %ld \n", index, add, address, demangledSymbol, offset)
 #else
-            return String(format: "%-4d%-35s 0x%08lx %@ + %d \n", index, UInt(bitPattern: imageBuffer.baseAddress), address, demangledSymbol, offset)
+            return String(format: "%-4d%-35s 0x%08lx  %@ + %d \n", index, add, address, demangledSymbol, offset)
 #endif
         }
     }
 }
 
+
+public struct SKBacktraceEntity {
+    public let threadId: UInt  // 259
+    public let validAddress: String // address
+    public let validFunction: String // function
+    public let traceContent: String
+    public let traceSymbols: [SKStackSymbol]
+}
+
 public struct SKBacktraceEntry: Codable {
     public let `class`: String
     public let name: String
@@ -50,7 +74,7 @@ func _stdlib_demangleImpl(
     flags: UInt32
 ) -> UnsafeMutablePointer<CChar>?
 
-// Swift方法名还原
+/// Swift方法名还原
 private func _stdlib_demangleName(_ mangledName: String) -> String {
     return mangledName.utf8CString.withUnsafeBufferPointer {
         (mangledNameUTF8CStr) in
