How do I trace SwiftUI methods with SwiftTrace?

Use SwiftTrace.traceProtocolsInBundle, as shown in the README with UIHostingController, because SwiftUI relies on protocols, allowing interception via witness tables for internal calls.

SwiftTrace vs. traditional method swizzling: which is better?

SwiftTrace is more reliable with trampolines, reducing crash risks, but it has setup overhead and doesn't work on optimized code. Traditional swizzling is simpler but less stable for Swift.

Can SwiftTrace be used in production for logging?

It's possible but not recommended due to performance overhead and potential App Store review issues; it's better suited for development debugging and profiling scenarios.

How to modify method arguments using aspects in SwiftTrace?

In onEntry closures, access the stack to change arguments, e.g., set stack.intArg1 = 99. The README explains this with examples, but it requires understanding register usage.

What are the performance costs of using SwiftTrace?

Trampolines add minimal overhead per call, but tracing many methods can impact performance. Use benchmarking features to measure, and avoid in production for critical paths.

How to set up SwiftTrace with CocoaPods?

Add 'pod SwiftTrace' to your Podfile, rebuild, import SwiftTrace in your AppDelegate, and call tracing methods like SwiftTrace.traceBundle as shown in the README examples.

SwiftTrace — Swift & Objective-C Method Tracer

What is SwiftTrace?

SwiftTrace is a dynamic tracing library for Swift and Objective-C that intercepts and logs method invocations at runtime. It helps developers debug, profile, and monitor application behavior by providing visibility into method calls without modifying source code. The library also supports aspect-oriented programming, allowing injection of custom logic before or after method execution.

Target Audience

iOS and macOS developers working on complex applications who need advanced debugging, performance profiling, or runtime behavior analysis tools. It's particularly useful for those dealing with dynamic dispatch, framework integration, or aspect-oriented programming in Swift.

Value Proposition

Developers choose SwiftTrace for its reliable trampoline-based interception (vs. traditional swizzling), comprehensive tracing capabilities across Swift and Objective-C, and unique features like aspect injection and object lifetime tracking not found in standard debugging tools.

Trace Swift and Objective-C method invocations

Use Cases

Best For

Debugging complex method invocation flows in mixed Swift/Objective-C codebases
Profiling performance bottlenecks by tracing method execution times
Implementing aspect-oriented programming patterns in iOS/macOS apps
Monitoring object allocation/deallocation patterns for memory management
Dynamic runtime analysis of third-party frameworks or system libraries
Adding logging or instrumentation to production apps without recompilation

Not Ideal For

Projects that heavily use Swift's final classes or whole module optimization, as SwiftTrace cannot intercept methods with direct dispatch.
Teams deploying to production where runtime overhead must be minimized, since trampolines introduce performance penalties.
Developers needing simple, out-of-the-box debugging tools without configuring linker flags or understanding low-level details.
Apps subject to strict App Store policies that may restrict dynamic code injection techniques.

Pros & Cons

Pros

Reliable Trampoline Interception

Uses assembly-language trampolines instead of traditional swizzling, ensuring accurate method interception with minimal performance impact, as highlighted in the philosophy section.

Comprehensive Tracing Flexibility

Allows tracing of entire bundles, specific classes, instances, or protocols via regex patterns, enabling targeted debugging and profiling without source code changes.

Aspect-Oriented Programming Support

Enables adding closures before or after method execution to modify arguments or return values, facilitating runtime behavior modifications for debugging or instrumentation.

Built-in Benchmarking and Tracking

Provides methods to measure invocation counts and elapsed times for performance analysis, plus object lifetime tracking for monitoring allocations and deallocations.

Cons

Limited to Non-Final Methods

Cannot trace final classes or methods compiled with whole module optimization, restricting use in performance-optimized codebases, as admitted in the README.

Complex Setup and Configuration

Requires adding linker flags like '-Xlinker -interposable' for full functionality and involves low-level details for aspect programming, such as understanding register allocation.

Invocation API Limitations

The dynamic invocation API only supports a limited set of argument types (e.g., Double, Float, Int) and requires manual type conformances for custom structs, adding complexity.

Frequently Asked Questions

What is SwiftTrace?

Target Audience

Value Proposition

Use Cases

Best For

Debugging complex method invocation flows in mixed Swift/Objective-C codebases
Profiling performance bottlenecks by tracing method execution times
Implementing aspect-oriented programming patterns in iOS/macOS apps
Monitoring object allocation/deallocation patterns for memory management
Dynamic runtime analysis of third-party frameworks or system libraries
Adding logging or instrumentation to production apps without recompilation

Not Ideal For

Projects that heavily use Swift's final classes or whole module optimization, as SwiftTrace cannot intercept methods with direct dispatch.
Teams deploying to production where runtime overhead must be minimized, since trampolines introduce performance penalties.
Developers needing simple, out-of-the-box debugging tools without configuring linker flags or understanding low-level details.
Apps subject to strict App Store policies that may restrict dynamic code injection techniques.

Pros & Cons

Pros

Reliable Trampoline Interception

Uses assembly-language trampolines instead of traditional swizzling, ensuring accurate method interception with minimal performance impact, as highlighted in the philosophy section.

Comprehensive Tracing Flexibility

Allows tracing of entire bundles, specific classes, instances, or protocols via regex patterns, enabling targeted debugging and profiling without source code changes.

Aspect-Oriented Programming Support

Enables adding closures before or after method execution to modify arguments or return values, facilitating runtime behavior modifications for debugging or instrumentation.

Built-in Benchmarking and Tracking

Provides methods to measure invocation counts and elapsed times for performance analysis, plus object lifetime tracking for monitoring allocations and deallocations.

Cons

Limited to Non-Final Methods

Cannot trace final classes or methods compiled with whole module optimization, restricting use in performance-optimized codebases, as admitted in the README.

Complex Setup and Configuration

Requires adding linker flags like '-Xlinker -interposable' for full functionality and involves low-level details for aspect programming, such as understanding register allocation.

Invocation API Limitations

The dynamic invocation API only supports a limited set of argument types (e.g., Double, Float, Int) and requires manual type conformances for custom structs, adding complexity.

Frequently Asked Questions

SwiftTrace

What is SwiftTrace?

Overview

Use Cases

Best For

Not Ideal For

Pros & Cons

Pros

Cons

Frequently Asked Questions

Related Projects

Found a gem we're missing?

SwiftTrace

What is SwiftTrace?

Overview

Use Cases

Best For

Not Ideal For

Pros & Cons

Pros

Cons

Frequently Asked Questions

Related Projects

Found a gem we're missing?