dotTrace helps you locate performance bottlenecks in a variety of .NET applications: desktop applications, .NET Core, ASP.NET, ASP.NET Core applications hosted on IIS or IIS Express web servers, Silverlight, WCF services, Windows services, Universal Windows Platform applications, and unit tests.
Versatile profiling modes
Depending on your needs, you can choose between several modes of performance profiling: timeline, sampling, tracing, and line-by-line.
Unlike "classic" performance profiling that only lets you measure method call execution time, timeline profiling reveals how calls are distributed in time.
By virtue of binding method call data to a timeline, this profiling mode goes beyond plainly detecting the slowest method: it allows diagnosing performance issues where the order of events matters, such as UI freezes, excessive garbage collection, uneven workload distribution, inefficient file I/O, and more.
However, traditional profiling modes are still available in dotTrace. Sampling profiling is the easiest way to evaluate overall application performance, whereas tracing and line-by-line profiling modes are ideal when you need details on how a particular algorithm works inside.
Deep Visual Studio integration
You can launch profiling of your applications right from Visual Studio 2010, 2012, 2013, 2015, 2017, 2019, and 2022. If your solution is opened in Visual Studio during your profiling session, you can instantly navigate from dotTrace code preview area to the corresponding code file in Visual Studio.
Profile async calls
dotTrace allows you to easily analyze asynchronous code: All "parts" of an async call are shown in one place so that you don't need to search for them in different call stacks.
Profile static methods
dotTrace allows you to instantly profile any static method in your code. You can profile any part of your code in place, right after you've written it! No need to build your solution, run it under the profiler, perform a usage scenario that runs your new code, etc.
Local or remote profiling
Most of the time, you're profiling local applications. However, what if you're faced with a lagging application on a remote web server?
dotTrace can connect to a remote machine to profile a standalone or web application, or a Windows service. You don't even have to install dotTrace there — just copy a few files.
Connect to running applications
dotTrace can be attached to a running application for profiling and detached as soon as profiling data has been captured.
This minimizes overhead imposed by running an application under the profiler. More importantly, it **enables investigating performance issues in production environments **where you just can't afford to restart an application every time you need to profile it.
Profile unit tests
If you have ReSharper installed in Visual Studio, you can easily start profiling unit tests from the code editor or ReSharper's unit test runner.
Even if you don't have ReSharper installed, you can still profile a native unit test runner provided by NUnit, MSTest, or xUnit.
Profile SQL queries and HTTP requests
Use timeline profiling to analyze how each particular query affects application performance and why this query is running slow.
If you develop a web application, learn how it processes incoming HTTP requests. When analyzing timeline profiling snapshots, you can filter out time intervals where your web application processes incoming HTTP requests.
Profiling SDK allows you to control a profiling session right from your code: programmatically start and stop collecting profiling data, save collected snapshots and so on.
This enables two valuable usage scenarios. First, you can use the SDK to narrow down the profiling scope and choose which parts of your code to profile. The second usage scenario is self-profiled applications: you can collect statistics showing how your application behaves on end-user machines.
Continuous Integration support
dotTrace comes with command-line profiling tools that can be used to automate gathering profiling snapshots, which is essential if you want to make profiling a part of your Continuous Integration builds.
If you're using JetBrains TeamCity as your CI server, make sure to install dotTrace plugin to TeamCity. The plugin helps you prevent application performance regression by profiling integration tests. All you need is set a threshold for test execution time, and if it's exceeded, the plugin will automatically take performance snapshot and fail the test.
Estimation of performance gains
Sometimes, after hours of optimizing a time-consuming function, developers are forced to start profiling from scratch to see if their optimization actually worked.
This is not a problem anymore. dotTrace can recalculate all function timings in a snapshot instantly, based on a time adjustment that you set — without reprofiling your application. It's like asking the profiler: "what if I optimize this function by 40%?" Just specify the new time for a function or for all functions in a particular class. Time values for the entire snapshots will be recalculated.
dotTrace is able to compare any two performance snapshots of the same application. It generates a comparison snapshot which shows the difference in the number of calls and times consumed by each function. Comparison snapshots can be viewed and analyzed the same way as regular performance snapshots.