Tracing preferences.

App/InjectionNext/ConfigStore.swift

@@ -319,6 +319,36 @@ final class ConfigStore: ObservableObject {
         client.writeCommand(InjectionCommand.setenv.rawValue,
                             with: INJECTION_BENCH)
         client.write(benchmarking ? "1" : unsetVar)
+        client.writeCommand(InjectionCommand.setenv.rawValue,
+                            with: INJECTION_TRACE_FILTER)
+        client.write(traceFilter != "" ? traceFilter : ".")
+        switch traceMode {
+        case .injected:
+            client.writeCommand(InjectionCommand.setenv.rawValue,
+                                with: INJECTION_TRACE)
+            client.write("1")
+        case .all:
+            client.writeCommand(InjectionCommand.setenv.rawValue,
+                                with: INJECTION_TRACE_ALL)
+            client.write("1")
+        case .off:
+            break
+        }
+        if traceFrameworks != "" {
+            client.writeCommand(InjectionCommand.setenv.rawValue,
+                                with: INJECTION_TRACE_FRAMEWORKS)
+            client.write(traceFrameworks)
+        }
+        if traceUIKit != "" {
+            client.writeCommand(InjectionCommand.setenv.rawValue,
+                                with: INJECTION_TRACE_UIKIT)
+            client.write(traceUIKit)
+        }
+        if traceLookup {
+            client.writeCommand(InjectionCommand.setenv.rawValue,
+                                with: INJECTION_TRACE_LOOKUP)
+            client.write(traceUIKit)
+        }
     }
 
     // MARK: - Devices
@@ -342,22 +372,22 @@ final class ConfigStore: ObservableObject {
     }
     @Published var availableIdentities: [String] = []
 
-    // MARK: - Tracing // difficult to implement as tracing happens early.
+    // MARK: - Tracing
 
     @Published var traceMode: TraceMode {
-        didSet { ud.set(traceMode.rawValue, forKey: "traceMode") }
+        didSet { ud.set(traceMode.rawValue, forKey: "traceMode"); updateEnvVars() }
     }
     @Published var traceFilter: String {
-        didSet { ud.set(traceFilter, forKey: "traceFilter") }
+        didSet { ud.set(traceFilter, forKey: "traceFilter"); updateEnvVars() }
     }
     @Published var traceFrameworks: String {
-        didSet { ud.set(traceFrameworks, forKey: "traceFrameworks") }
+        didSet { ud.set(traceFrameworks, forKey: "traceFrameworks"); updateEnvVars() }
     }
     @Published var traceLookup: Bool {
-        didSet { ud.set(traceLookup, forKey: "traceLookup") }
+        didSet { ud.set(traceLookup, forKey: "traceLookup"); updateEnvVars() }
     }
     @Published var traceUIKit: String {
-        didSet { ud.set(traceUIKit, forKey: "traceUIKit") }
+        didSet { ud.set(traceUIKit, forKey: "traceUIKit"); updateEnvVars() }
     }
 
     // MARK: - File Watcher

App/InjectionNext/Info.plist

@@ -19,7 +19,7 @@
 	<key>CFBundleShortVersionString</key>
 	<string>$(MARKETING_VERSION)</string>
 	<key>CFBundleVersion</key>
-	<string>14172</string>
+	<string>14181</string>
 	<key>LSApplicationCategoryType</key>
 	<string>public.app-category.developer-tools</string>
 	<key>LSMinimumSystemVersion</key>

Sources/InjectionNext/InjectionNext.swift

@@ -114,10 +114,15 @@ open class InjectionNext: SimpleSocket {
         log("Connection lost, disconnecting.")
     }
 
-    func tracingOptions() {
+    lazy var setupTraceAdjustments: Void = {
         SwiftTrace.injectableSymbol = Reloader.injectableSymbol
         SwiftTrace.defaultMethodExclusions += // CoreFoundation
             #"|\[NS(Method|Tagged|Array|\w*Dict|Date|Data|Timer)|allocWithZone:|__unurl|_trueSelf"#
+          + #"|InjectionBundle.|fast_dl"#
+    }()
+
+    func tracingOptions() {
+        _ = setupTraceAdjustments
         /// Custom type lookup on tracing.
         if let exclude = getenv(INJECTION_TRACE_LOOKUP) {
             if exclude[0] == UInt8(ascii: "|") {
@@ -126,8 +131,7 @@ open class InjectionNext: SimpleSocket {
             SwiftTrace.typeLookup = true
         }
         if let filter = getenv(INJECTION_TRACE_FILTER) {
-            SwiftTrace.inclusionRegexp =
-                NSRegularExpression(regexp: String(cString: filter))
+            SwiftTrace.traceFilterInclude = String(cString: filter)
         }
         /// Entire App bundle tracing.
         if let exclude = getenv(INJECTION_TRACE_ALL) {
@@ -281,10 +285,66 @@ open class InjectionNext: SimpleSocket {
                 }
             case .setenv:
                 if let name = readString(), let value = readString() {
-                    if value != "0" {
-                        setenv(name, value, 1)
-                    } else {
+                    if value == "0" {
                         unsetenv(name)
+                    } else {
+                        _ = setupTraceAdjustments
+                        if name == INJECTION_TRACE_FILTER {
+                            SwiftTrace.traceFilterInclude = value
+                        } else if getenv(name) == nil {
+                            switch name {
+                            case INJECTION_TRACE_LOOKUP:
+                                if value.hasPrefix("|") {
+                                    SwiftTrace.defaultLookupExclusions += value
+                                }
+                                SwiftTrace.typeLookup = true
+                            case INJECTION_TRACE_ALL:
+                                SwiftTrace.interposeEclusions = SwiftTrace.exclusionRegexp
+                                appBundleImages { imageName, _, _ in
+                                    if SwiftTrace.interposeMethods(inBundlePath: imageName) == 0,
+                                       strstr(imageName, "XCT") == nil {
+                                        self.error("""
+                                        Unable to interpose to trace image \
+                                        \(String(cString: imageName)), have you added \
+                                        "Other Linker Flags" -Xlinker -interposable
+                                        """)
+                                    }
+                                    SwiftTrace.trace(bundlePath: imageName)
+                                }
+                            case INJECTION_TRACE_FRAMEWORKS:
+                                var frmwks = value
+                                if frmwks == "" || frmwks == "1" { frmwks = "SwiftUI,SwiftUICore" }
+                                for frmwk in frmwks.components(separatedBy: ",") {
+                                    if let dylib = DLKit.imageMap[frmwk] {
+                                        Self.target = dylib
+                                        appBundleImages { path, header, slide in
+                                            rebind_symbols_trace(autoBitCast(header), slide, Self.tracer)
+                                        }
+                                    } else {
+                                        error("Invalid trace framework \(frmwk)")
+                                    }
+                                }
+                            case INJECTION_TRACE_UIKIT:
+                                var frmwks = value
+                                if frmwks == "" || frmwks == "1" { frmwks = "UIKitCore" }
+                                for frmwk in frmwks.components(separatedBy: ",") {
+                                    if let bundle = DLKit.imageMap[frmwk]?.imageName {
+                                        SwiftTrace.trace(bundlePath: bundle)
+                                    } else {
+                                        error("Invalid swizzle framework \(frmwk)")
+                                    }
+                                }
+                            case INJECTION_TRACE:
+                                Reloader.traceHook = { (injected, name) in
+                                    let name = SwiftMeta.demangle(symbol: name) ?? String(cString: name)
+                                    detail("SwiftTracing \(name)")
+                                    return autoBitCast(SwiftTrace.trace(name: name, original: injected)) ?? injected
+                                }
+                            default:
+                                break
+                            }
+                        }
+                        setenv(name, value, 1)
                     }
                 }
             case .EOF: