feat: add tap handler, send span

Author: mario-launchdarkly

Sources/Client/InstrumentationManager.swift

@@ -4,6 +4,8 @@ import OpenTelemetrySdk
 import StdoutExporter
 import OpenTelemetryProtocolExporterHttp
 
+import UIKit.UIWindow
+
 import API
 import Interfaces
 import Common
@@ -26,6 +28,7 @@ public final class InstrumentationManager {
     private var cachedLongCounters = AtomicDictionary<String, LongCounter>()
     private var cachedHistograms = AtomicDictionary<String, DoubleHistogram>()
     private var cachedUpDownCounters = AtomicDictionary<String, DoubleUpDownCounter>()
+    private let lock: NSLock = NSLock()
 
     public init(sdkKey: String, options: Options, sessionManager: SessionManager) {
         self.sdkKey = sdkKey
@@ -143,8 +146,23 @@ public final class InstrumentationManager {
         self.otelMeter = OpenTelemetry.instance.meterProvider.get(
             name: options.serviceName
         )
+
+//        Task { @MainActor [weak self] in
+//            for await touchEvent in TapHandler.stream() {
+//                print("touch event: \(touchEvent)")
+//                var attributes = [String: AttributeValue]()
+//                attributes["screen.name"] = .string(touchEvent.viewName)
+//                attributes["target.id"] = .string(touchEvent.accessibilityIdentifier ?? touchEvent.viewName)
+//                // sending location in points (since it is preferred over pixels)
+//                attributes["position.x"] = .string(touchEvent.locationInPoints.x.toString())
+//                attributes["position.y"] = .string(touchEvent.locationInPoints.y.toString())
+//                self?.startSpan(name: "", attributes: attributes)
+//            }
+//        }
     }
 
+    // MARK: - Instrumentation
+    
     func recordMetric(metric: Metric) {
         var gauge = cachedGauges[metric.name]
         if gauge == nil {

Sources/Client/ObservabilityClient.swift

@@ -60,8 +60,27 @@ public final class ObservabilityClient: Observe {
             onWillEndSession: onWillEndSession,
             onDidStartSession: onDidStartSession
         )
+        
+        nonisolated(unsafe) let obj = self
+        
+        Task { @MainActor in
+            for await touchEvent in TapHandler.stream() {
+                print("touch event: \(touchEvent)")
+                var attributes = [String: AttributeValue]()
+                attributes["screen.name"] = .string(touchEvent.viewName)
+                attributes["target.id"] = .string(touchEvent.accessibilityIdentifier ?? touchEvent.viewName)
+                // sending location in points (since it is preferred over pixels)
+                attributes["position.x"] = .string(touchEvent.locationInPoints.x.toString())
+                attributes["position.y"] = .string(touchEvent.locationInPoints.y.toString())
+                obj
+                    .startSpan(name: "user.tap", attributes: attributes)
+                    .end()
+            }
+        }
     }
 
+    // MARK: - Instrumentation
+    
     public func recordMetric(metric: Metric) {
         instrumentationManager.recordMetric(metric: metric)
     }

Sources/Client/TapHandler.swift

@@ -0,0 +1,54 @@
+import UIKit.UIWindow
+import Common
+
+@MainActor public final class TapHandler {
+    private var startPoint: CGPoint?
+    
+    public init() {}
+    
+    public func handle(event: UIEvent, window: UIWindow, completion: (TouchEvent) -> Void) {
+        if let touches = event.allTouches, let touch = touches.first, let targetView = touch.view {
+            switch touch.phase {
+            case .began:
+                startPoint = touch.location(in: window)
+            case .ended:
+                if let startPoint {
+                    let endPoint = touch.location(in: window)
+                    let dx = endPoint.x - startPoint.x
+                    let dy = endPoint.y - startPoint.y
+                    if abs(dx) < 10 && abs(dy) < 10 {
+                        print("Tap")
+                        let accessibilityIdentifier = targetView.accessibilityIdentifier
+                        let targetClass = type(of: targetView)
+                        
+                        let viewName = accessibilityIdentifier ?? String(describing: targetClass)
+                        
+                        completion(
+                            .init(
+                                location: endPoint,
+                                viewName: viewName,
+                                accessibilityIdentifier: accessibilityIdentifier,
+                                scale: targetView.window?.screen.scale ?? UIScreen.main.scale)
+                        )
+                    }
+                }
+                startPoint = nil
+            default:
+                break
+            }
+        }
+    }
+}
+
+extension TapHandler {
+    public static func stream() -> AsyncStream<TouchEvent> {
+        AsyncStream<TouchEvent> { continuation in
+            let handler = TapHandler()
+            UIWindowSendEvent.inject { uiWindow, uiEvent in
+                handler.handle(event: uiEvent, window: uiWindow) { touchEvent in
+                    continuation.yield(touchEvent)
+                }
+            }
+        }
+    }
+}

Sources/Client/TouchEvent.swift

@@ -0,0 +1,20 @@
+import UIKit
+
+public struct TouchEvent: Sendable, CustomStringConvertible {
+    public let location: CGPoint
+    public let viewName: String
+    public let accessibilityIdentifier: String?
+    public let scale: CGFloat
+    
+    public var locationInPoints: CGPoint {
+        return location
+    }
+    
+    public var locationInPixels: CGPoint {
+        return CGPoint(x: Int((location.x * scale).rounded()), y: Int((location.y * scale).rounded()))
+    }
+    
+    public var description: String {
+        return "TouchEvent(\(location), \(viewName), \(accessibilityIdentifier ?? "nil"), \(scale)) coordinates In pixels: \(locationInPixels.x), \(locationInPixels.y)"
+    }
+}

Sources/Common/CGFloat+ToString.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+extension CGFloat {
+    public func toString() -> String {
+        String(format: "%.2f", self)
+    }
+}

Sources/Common/Swizzler.swift

@@ -0,0 +1,22 @@
+import Foundation
+
+public struct Swizzle<Signature, Block> {
+    private let baseClass: AnyClass
+ 
+    public init(baseClass: AnyClass) {
+        self.baseClass = baseClass
+    }
+    
+    public func swizzle(selector: Selector, block: (Signature) -> Block) {
+        guard let method = class_getInstanceMethod(baseClass, selector) else {
+            return
+        }
+        let existingImplementation = method_getImplementation(method)
+        let existingImplementationType = unsafeBitCast(
+            existingImplementation,
+            to: Signature.self)
+        let blockImplementation: Block = block(existingImplementationType)
+        let newImplementation = imp_implementationWithBlock(blockImplementation)
+        method_setImplementation(method, newImplementation)
+    }
+}

Sources/Common/UIWindowSendEvent.swift

@@ -0,0 +1,38 @@
+import UIKit.UIWindow
+
+public final class UIWindowSendEvent {
+    typealias SendEventRef = @convention(c) (UIWindow, Selector, UIEvent) -> Void
+    private static let sendEvenSelector = #selector(UIWindow.sendEvent(_:))
+    
+    public static func inject(
+        into subclasses: [UIWindow.Type] = [],
+        block: @escaping (UIWindow, UIEvent) -> Void
+    ) {
+        guard let originalMethod = class_getInstanceMethod(UIWindow.self, sendEvenSelector) else { return }
+    
+        var originalIMP = Optional<IMP>.none
+        
+        let swizzledSendEventBlock: @convention(block) (UIWindow, UIEvent) -> Void = { window, event in
+            if let originalIMP = originalIMP {
+                let castedIMP = unsafeBitCast(originalIMP, to: SendEventRef.self)
+                castedIMP(window, sendEvenSelector, event)
+            }
+
+            guard !subclasses.isEmpty else {
+                return block(window, event)
+            }
+            if UIWindowSendEvent.shouldInject(into: window, subclasses: subclasses) {
+                block(window, event)
+            }
+        }
+        
+        let swizzledIMP = imp_implementationWithBlock(unsafeBitCast(swizzledSendEventBlock, to: AnyObject.self))
+        originalIMP = method_setImplementation(originalMethod, swizzledIMP)
+    }
+    
+    private static func shouldInject(into receiver: Any, subclasses: [UIWindow.Type]) -> Bool {
+        let ids = subclasses.map { ObjectIdentifier($0) }
+        let receiverType = type(of: receiver)
+        return ids.contains(ObjectIdentifier(receiverType))
+    }
+}

Sources/CrashReporterLive/LaunchDarklyCrashFilter.swift

@@ -62,10 +62,13 @@ final class LaunchDarklyCrashFilter: NSObject, CrashReportFilter {
                 let reportSections = crashReportString.components(separatedBy: "\\n")
                 let incidentIdentifier = reportSections.first(where: { $0.contains(ReportSection.incidentIdentifier.rawValue) }) ?? ""
                 let exceptionType = reportSections.first(where: { $0.contains(ReportSection.exceptionType.rawValue) }) ?? ""
+                let exceptionCodes = reportSections.first(where: { $0.contains(ReportSection.exceptionCodes.rawValue) }) ?? ""
 
                 var attributes = [String: AttributeValue]()
                 attributes[SemanticAttributes.exceptionType.rawValue] = .string(exceptionType.replacingOccurrences(of: "\"", with: ""))
                 attributes[SemanticAttributes.exceptionStacktrace.rawValue] = .string(crashReportString)
+                attributes[SemanticAttributes.exceptionMessage.rawValue] = .string(exceptionCodes)
+                
                 logger?.logRecordBuilder()
                     .setAttributes(attributes)
                     .setBody(.string(incidentIdentifier.replacingOccurrences(of: "\"", with: "")))