RUM-8415 Add SwiftUI view auto-instrumentation

Author: mariedm

Datadog/Datadog.xcodeproj/project.pbxproj

@@ -28,8 +28,6 @@
  * SOFTWARE.
  */
 
-#if DEBUG
-
 // swiftlint:disable function_default_parameter_at_end
 
 import Foundation
@@ -49,7 +47,7 @@ import Foundation
 ///     components. The default is `Int.max`.
 /// - Returns: The instance passed as `value`.
 @discardableResult
-internal func customDump<T>(
+public func customDump<T>(
     _ value: T,
     name: String? = nil,
     indent: Int = 0,
@@ -550,7 +548,18 @@ public struct FileHandlerOutputStream: TextOutputStream {
         }
     }
 }
-
 // swiftlint:enable function_default_parameter_at_end
 
+#if DEBUG
+/// Dumps the given value's contents in a file.
+public func dump<T>(_ value: T, filename: String) throws {
+    let manager = FileManager.default
+    let url = manager.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent(filename) //swiftlint:disable:this force_unwrapping
+    manager.createFile(atPath: url.path, contents: nil, attributes: nil)
+    let handle = try FileHandle(forWritingTo: url)
+    var stream = FileHandlerOutputStream(handle)
+    customDump(value, to: &stream)
+    print("Dump:", url)
+    handle.closeFile()
+}
 #endif

DatadogInternal/Sources/Utils/CustomDump.swift

@@ -0,0 +1,31 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+/// Protocol for dumping objects to a text stream.
+///
+/// The `Dumper` protocol provides a standard interface for converting objects to string
+/// representations and writing them to a text output stream.
+public protocol Dumper {
+    func dump<T, TargetStream>(_ value: T, to target: inout TargetStream) where TargetStream: TextOutputStream
+}
+
+/// Default implementation of the `Dumper` protocol that uses `customDump` to generate string representations.
+///
+/// This implementation provides structured output for complex Swift objects by leveraging
+/// the `customDump` functionality, which creates more readable output than the standard
+/// `print` or `description` approaches.
+public class DefaultDumper: Dumper {
+    public init() {}
+
+    /// Dumps the value to the target stream using `customDump`.
+    ///
+    /// - Parameters:
+    ///   - value: The value to dump.
+    ///   - target: The stream to write the dump to.
+    public func dump<T, TargetStream>(_ value: T, to target: inout TargetStream) where TargetStream: TextOutputStream {
+        customDump(value, to: &target)
+    }
+}

DatadogInternal/Sources/Utils/Dumper.swift

@@ -63,7 +63,9 @@ internal final class RUMInstrumentation: RUMCommandPublisher {
         // and only swizzle `UIViewController` if UIKit instrumentation is configured:
         let viewsHandler = RUMViewsHandler(
             dateProvider: dateProvider,
-            predicate: uiKitRUMViewsPredicate,
+            uiKitPredicate: uiKitRUMViewsPredicate,
+            swiftUIPredicate: nil,
+            swiftUIViewNameExtractor: nil,
             notificationCenter: notificationCenter
         )
         let viewControllerSwizzler: UIViewControllerSwizzler? = {

DatadogRUM/Sources/Instrumentation/RUMInstrumentation.swift

@@ -0,0 +1,49 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+import DatadogInternal
+
+/// A description of the RUM View returned from the predicate.
+public struct RUMView {
+    /// The RUM View name, appearing as `VIEW NAME` in RUM Explorer.
+    public var name: String
+
+    /// The RUM View path, appearing as `VIEW PATH GROUP` / `VIEW URL` in RUM Explorer.
+    /// If set `nil`, the view controller class name will be used.
+    public var path: String?
+
+    /// Additional attributes to associate with the RUM View.
+    public var attributes: [AttributeKey: AttributeValue]
+
+    /// Whether this view is modal, but should not be tracked with `startView` and `stopView`
+    /// When this is `true`, the view previous to this one will be stopped, but this one will not be
+    /// started. When this view is dismissed, the previous view will be started.
+    public var isUntrackedModal: Bool
+
+    /// Initializes the RUM View description.
+    /// - Parameters:
+    ///   - path: the RUM View path, appearing as `PATH` in RUM Explorer.
+    ///   - attributes: additional attributes to associate with the RUM View.
+    @available(*, deprecated, message: "This initializer is renamed to `init(name:attributes:)`.")
+    public init(path: String, attributes: [AttributeKey: AttributeValue] = [:]) {
+        self.name = path
+        self.path = path
+        self.attributes = attributes
+        self.isUntrackedModal = false
+    }
+
+    /// Initializes the RUM View description.
+    /// - Parameters:
+    ///   - name: the RUM View name, appearing as `VIEW NAME` in RUM Explorer.
+    ///   - attributes: additional attributes to associate with the RUM View.
+    ///   - isUntrackedModal: true if this view is modal, but should not call startView / stopView.
+    public init(name: String, attributes: [AttributeKey: AttributeValue] = [:], isUntrackedModal: Bool = false) {
+        self.name = name
+        self.path = nil // the "VIEW URL" will default to view controller class name
+        self.attributes = attributes
+        self.isUntrackedModal = isUntrackedModal
+    }
+}

DatadogRUM/Sources/Instrumentation/Views/RUMView.swift

@@ -8,6 +8,7 @@ import Foundation
 import UIKit
 import DatadogInternal
 
+// MARK: - RUMViewsHandler
 internal final class RUMViewsHandler {
     /// RUM representation of a View.
     private struct View {
@@ -33,9 +34,17 @@ internal final class RUMViewsHandler {
     /// The current date provider.
     private let dateProvider: DateProvider
 
-    /// `UIKit` view predicate. `nil`, if `UIKit` auto-instrumentations is
+    /// `UIKit` view predicate. `nil` if `UIKit` auto-instrumentations is
     /// disabled.
-    private let predicate: UIKitRUMViewsPredicate?
+    private let uiKitPredicate: UIKitRUMViewsPredicate?
+
+    /// `SwiftUI` view predicate. `nil` if `SwiftUI` auto-instrumentations is
+    /// disabled.
+    private let swiftUIPredicate: SwiftUIRUMViewsPredicate?
+
+    /// `SwiftUI` view name extractor.
+    /// Extracts `SwiftUI` view name from view hierarchy.
+    private let swiftUIViewNameExtractor: SwiftUIViewNameExtractor?
 
     /// The notification center where this handler observes following `UIApplication` notifications:
     /// - `.didEnterBackgroundNotification`
@@ -64,11 +73,15 @@ internal final class RUMViewsHandler {
     ///    a set of `UIApplication` notifications.
     init(
         dateProvider: DateProvider,
-        predicate: UIKitRUMViewsPredicate?,
+        uiKitPredicate: UIKitRUMViewsPredicate?,
+        swiftUIPredicate: SwiftUIRUMViewsPredicate?,
+        swiftUIViewNameExtractor: SwiftUIViewNameExtractor?,
         notificationCenter: NotificationCenter
     ) {
         self.dateProvider = dateProvider
-        self.predicate = predicate
+        self.uiKitPredicate = uiKitPredicate
+        self.swiftUIPredicate = swiftUIPredicate
+        self.swiftUIViewNameExtractor = swiftUIViewNameExtractor
         self.notificationCenter = notificationCenter
 
         notificationCenter.addObserver(
@@ -196,14 +209,29 @@ internal final class RUMViewsHandler {
     }
 }
 
+// MARK: - UIViewControllerHandler
 extension RUMViewsHandler: UIViewControllerHandler {
     func notify_viewDidAppear(viewController: UIViewController, animated: Bool) {
         let identity = ViewIdentifier(viewController)
         if let view = stack.first(where: { $0.identity == identity }) {
             // If the stack already contains the view controller, just restarts the view.
             // This prevents from calling the predicate when unnecessary.
             add(view: view)
-        } else if let rumView = predicate?.rumView(for: viewController) {
+        } else if let rumView = uiKitPredicate?.rumView(for: viewController) {
+            add(
+                view: .init(
+                    identity: identity,
+                    name: rumView.name,
+                    path: rumView.path ?? viewController.canonicalClassName,
+                    isUntrackedModal: rumView.isUntrackedModal,
+                    attributes: rumView.attributes,
+                    instrumentationType: .uikit
+                )
+            )
+        } else if let swiftUIPredicate,
+                  let swiftUIViewNameExtractor,
+                  let rumViewName = swiftUIViewNameExtractor.extractName(from: viewController),
+                  let rumView = swiftUIPredicate.rumView(for: rumViewName) {
             add(
                 view: .init(
                     identity: identity,
@@ -233,6 +261,7 @@ extension RUMViewsHandler: UIViewControllerHandler {
     }
 }
 
+// MARK: - SwiftUIViewHandler
 extension RUMViewsHandler: SwiftUIViewHandler {
     /// Respond to a `SwiftUI.View.onAppear` event.
     ///

DatadogRUM/Sources/Instrumentation/Views/RUMViewsHandler.swift

@@ -0,0 +1,30 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+/// Protocol defining the predicate for SwiftUI view tracking in RUM.
+///
+/// The SDK uses this predicate to determine whether a detected SwiftUI view should be tracked as a RUM view.
+/// When a SwiftUI view is detected, the SDK first extracts its name,
+/// then passes that name to this predicate to convert it into RUM view parameters or filter it out.
+///
+/// Implement this protocol to customize which SwiftUI views are tracked and how they appear in the RUM Explorer.
+public protocol SwiftUIRUMViewsPredicate {
+    /// Converts an extracted SwiftUI view name into RUM view parameters, or filters it out.
+    ///
+    /// - Parameter extractedViewName: The name of the SwiftUI view detected by the SDK.
+    /// - Returns: RUM view parameters if the view should be tracked, or `nil` to ignore the view.
+    func rumView(for extractedViewName: String) -> RUMView?
+}
+
+/// Default implementation of `SwiftUIRUMViewsPredicate`.
+///
+/// This implementation tracks all detected SwiftUI views with their extracted names.
+/// The view name in RUM Explorer will match the name extracted from the SwiftUI view.
+public struct DefaultSwiftUIRUMViewsPredicate: SwiftUIRUMViewsPredicate {
+    public func rumView(for extractedViewName: String) -> RUMView? {
+        return RUMView(name: extractedViewName)
+    }
+}

DatadogRUM/Sources/Instrumentation/Views/SwiftUI/SwiftUIRUMViewsPredicate.swift

@@ -0,0 +1,65 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+import UIKit
+import DatadogInternal
+
+extension SwiftUIReflectionBasedViewNameExtractor {
+    // MARK: - Path Traversal
+    @usableFromInline
+    internal func extractHostingControllerPath(with reflector: ReflectorType) -> String? {
+        if let hostView = reflector.descendantIfPresent("host", "_rootView", "content", "storage", "view") {
+            var output = ""
+            dumper.dump(hostView, to: &output)
+            return output
+        }
+
+        if let hostView = reflector.descendantIfPresent("host", "_rootView") {
+            var output = ""
+            dumper.dump(hostView, to: &output)
+            return output
+        }
+        return nil
+    }
+
+    // MARK: - String Parsing
+    @usableFromInline
+    internal func extractViewNameFromHostingViewController(_ input: String) -> String? {
+        // First pattern: Extract from generic format with angle brackets
+        if let lastOpenBracket = input.lastIndex(of: "<"),
+           let closingBracket = input[lastOpenBracket...].firstIndex(of: ">"),
+           lastOpenBracket < closingBracket {
+            var betweenBrackets = input[input.index(after: lastOpenBracket)..<closingBracket]
+
+            // Handle generic parameters by taking the first part before comma
+            betweenBrackets = betweenBrackets.split(separator: ",").first ?? betweenBrackets
+
+            // Extract name after the first dot (to get the type name without namespace)
+            if let fristDotIndex = betweenBrackets.firstIndex(of: ".") {
+                let viewName = betweenBrackets[betweenBrackets.index(after: fristDotIndex)...]
+                return String(viewName)
+            }
+
+            // If no dots found, return the whole content between brackets
+            return String(betweenBrackets)
+        }
+
+        // Second pattern: Extract from format with parentheses at the end
+        // Example: "MyApp.(unknown context at $10cc64f58).(unknown context at $10cc64f64).HomeView()"
+        if input.hasSuffix("()") {
+            // Find the last component before the parentheses
+            let withoutParens = input.dropLast(2)
+
+            // Get the last component after a dot
+            if let lastDotIndex = withoutParens.lastIndex(of: ".") {
+                let viewName = withoutParens[withoutParens.index(after: lastDotIndex)...]
+                return String(viewName)
+            }
+        }
+
+        return nil
+    }
+}