What's New in dotTrace

.NET 6 support

dotTrace now lets you profile .NET 6 applications on Windows, macOS, and Linux. Note that to profile applications on Linux and macOS, you should use either JetBrains Rider or dotTrace command-line profiler.

Support for Apple M1

Now, the dotTrace command-line tool can work on computers with Apple M1 processors. The tool supports profiling of .NET 6 applications (native mode) and .NET 5 applications (Rosetta 2 mode).

Saving UI state for Timeline snapshots

When you close a Timeline snapshot, dotTrace saves the user interface state: selected time intervals, applied filters, and so on. Next time you open the snapshot, dotTrace will restore the UI state back.

Performance improvements

We reduced performance overhead of the Timeline profiling for applications that heavily use async calls. Improved performance of opening and filtering in Timeline snapshots.

Support for TPL events on macOS and Linux

Now, the dotTrace command-line tool and dotTrace in Rider let you collect data on asynchronous calls on macOS and Linux. To get this data, use the Timeline profiling mode. dotTrace provides full support for TPL events in .NET 5+ applications: The Call Tree shows async calls including awaits and continuations. For .NET 3.1 apps, only the Task API is supported: The Call Tree shows separate nodes for task scheduling and execution but no data on async/await calls.

Improved support for child processes on macOS and Linux

Now, the dotTrace command-line tool and dotTrace in Rider can profile child processes of applications on macOS and Linux in the Timeline profiling mode. The support is available only for .NET 5+ applications.

Native profiling

Now, it's possible to profile native applications on Windows. When starting a profiling session, you have an option to download native source symbol files from remote servers. Native profiling is available only for the Timeline profiling type.

Timeline profiling on macOS and Linux

Now, you can profile .NET Core and .NET applications on macOS and Linux using the Timeline profiling type.

New Home screen

We completely reworked the dotTrace Home screen. Now, it's much easier to configure and start new profiling sessions, work with snapshots, and perform other basic operations.

Command-line profiler as a .NET global tool

Now, you can install and use the dotTrace command-line profiler as a .NET global tool.

.NET 5 support

dotTrace now lets you profile .NET 5 applications on Windows, macOS, and Linux. Note that to profile applications on Linux and macOS, you should use either JetBrains Rider or dotTrace command-line profiler.

Call Tree as a flame graph in Rider

In Rider, you can switch the call tree to the flame graph mode. The graph helps you quickly identify the slowest methods in the current scope.

Call Tree folding in Rider

dotTrace for Rider gets the call tree folding feature (earlier it was available only in the standalone version of dotTrace). It helps simplify call tree analysis by folding chains of calls that do not belong to user modules and assemblies.

Various improvements

• You can hide native threads in the Threads list in Rider.

• The File I/O timeline filter now includes the FileIOCreate events.

• You can hide the Top Methods list in Rider.

Native profiling of Mono and Unity applications

Both standalone dotTrace and dotTrace in Rider are able to profile the native part of Mono/Unity applications on Windows. Start a session with the Enable native profiling option, and you'll see both native and managed call stacks in performance snapshots.

Support for ARM64 architecture

The dotTrace command-line profiler for Linux (any distribution with GLIBC_2.23 or later) lets you profile applications on ARM64 systems.

The command-line profiler lets you control the profiling session (take snapshots, detach from the profiled process, and so on) by sending commands to stdin or to a file.

The new self-profiling API (the API that lets applications initialize and start a profiling session by themselves) is much easier to use. The self-profiling API is distributed as a NuGet package.

Improved Linux and macOS support

• Now, you can profile .NET Core applications on macOS and Linux using the Tracing profiling mode. To do this, you should use either JetBrains Rider or dotTrace command-line profiler.

• Now, you can attach the profiler to running processes on Linux.

Next Important Call

Now, you can navigate through Call Tree using the Next Important Call action. Press Ctrl+Shift+Right and dotTrace will navigate you to a node that is most relevant for further analysis (for example, a node with high own execution time).

The feature is available in dotTrace Standalone (both Performance Viewer and Timeline Viewer), in Visual Studio, and JetBrains Rider.

.NET Core support on macOS and Linux

dotTrace 2019.3 supports sampling profiling of .NET Core projects on Linux and macOS. Note that only projects targeting .NET Core 3.1 are fully supported. Because of some .NET Core limitations, profiling of projects targeting .NET Core 3.0 or earlier may have some issues: in rare cases, the profiled application may hang or crash. To profile .NET Core applications on Linux and macOS, you should use JetBrains Rider or dotTrace command-line tools.

Command-line profiler on macOS and Linux

The command-line profiler finally comes to macOS and Linux. dotTrace.sh has the same functionality as its Windows counterpart and is distributed as a .tar.gz archive and as a NuGet package.

Call tree flame graph

Find slowest methods in just a glance with the call tree flame graph. Note that the graph is available only in the Timeline Viewer.

Timeline filters in Rider.

dotTrace in Rider becomes more mature: Now, it gets the full set of Timeline filters making it easier to analyze Timeline profiling snapshots in place.

.NET Core 3.0 full support.

dotTrace is now able to attach to the .NET Core 3.0 Preview 7 processes.

Improved support for ASP.NET Core applications in Visual Studio:

• different hosting models are correctly supported,

• browser settings and Enable SSL are taken into account when starting a profiling session,

• ASP.NET Core 3.0 Preview 7 is supported,

• and other improvements...

Profiling API gets the ability to detach from the profiled process.

Silverlight and WebDev applications are no longer supported.

Mono and Mono Unity applications support:

• Standalone dotTrace: Windows only.

• dotTrace integrated into JetBrains Rider: Windows, macOS, and Linux.

Command-line profiler improvements:

• The start and attach commands now accept advanced profiling parameters, like time measurement type and others.

• The Reporter.exe tool accepts the --save-signature argument that allows you to distinguish overloaded methods in the final report.

New profiling API. We have significantly updated the profiling API:

• we got rid of the state machine. Now, you can call any API method regardless of the controller state.

• we have reduced the number of available methods, thereby simplifying the use of the API.

• now, we distribute the API as a NuGet package.

JetBrains Rider integration. You can configure and run profiling sessions, get snapshots, and analyze them in the built-in viewer. Note that currently the viewer cannot show distribution of events on a timeline. That's why timeline snapshots are opened as simple sampling snapshots.

Improved .NET Memory Allocations filter. Timeline Viewer gets a new subfilter that allows you to analyze how the allocated memory is distributed between the objects of a certain type.

Reworked IIS Express profiling settings. Now, the default way to profile a web app hosted on IIS Express is to provide dotTrace a applicationhost.config file.

Improved performance and stability.

Include filters for .NET processes. When configuring profiling of an arbitrary .NET process, you are able to set an include filter: dotTrace will attach only to the process that matches the filter.

Improved performance. This release of dotTrace was mainly focused on improving stability and performance.

Support for async calls. The downside of asynchronous code is it's extremely difficult to profile it and analyze its performance. dotTrace 2017.3 dramatically simplifies the analysis of asynchronous code. It marks all async call nodes in the Call Tree and groups the corresponding await time and continuation code under that node. This means that you can quickly find all "parts" of an asynchronous call in one place instead of searching in different call stacks.

Forecasting performance in Timeline Viewer. Now, you can "forecast" application performance in the Timeline Viewer. Simply, exclude a particular method from the Call Tree and dotTrace will recalculate the entire snapshot as if there were no such a method.

Backtraces in Methods and Subsystems (Timeline Viewer). Now, you can quickly view backtraces of a particular method right in the Methods and Subsystems without switching to the Call Tree.

Marking user assemblies as system ones. You can mark particular user assemblies as the system ones. After that, all rules that are applied to methods from system modules will be applied to methods from this user assembly as well: e.g. the way the methods' time is calculated in Methods and Subsystems and system calls folding.

Support for async calls. The downside of asynchronous code is it's extremely difficult to profile it and analyze its performance. dotTrace 2017.3 dramatically simplifies the analysis of asynchronous code. It marks all async call nodes in the Call Tree and groups the corresponding await time and continuation code under that node. This means that you can quickly find all "parts" of an asynchronous call in one place instead of searching in different call stacks.

Forecasting performance in Timeline Viewer. Now, you can "forecast" application performance in the Timeline Viewer. Simply, exclude a particular method from the Call Tree and dotTrace will recalculate the entire snapshot as if there were no such a method.

Backtraces in Methods and Subsystems (Timeline Viewer). Now, you can quickly view backtraces of a particular method right in the Methods and Subsystems without switching to the Call Tree.

Marking user assemblies as system ones. You can mark particular user assemblies as the system ones. After that, all rules that are applied to methods from system modules will be applied to methods from this user assembly as well: e.g. the way the methods' time is calculated in Methods and Subsystems and system calls folding.

Navigation path in Call Tree. When navigating a call tree, there was always a problem to understand how did you get to a particular function. With dotTrace 2017.2 the problem is solved: the Call Tree view shows all your transitions in the left gutter.

Timeline profiling from the command line. The command-line profiler finally supports the Timeline profiling type.

Profile child processes in unit tests.

Now, you can enable profiling of child processes in unit tests with a simple checkbox. Complex profiling configurations are no longer needed!

Clear cache files. Now, you can forcibly delete snapshot-cache files using the button in dotTrace Home Preferences. This will result in slower loading of existing snapshots but will free you some disk space.

Visual Studio 2017 support.

Attach via drag and drop. Now, you can attach the profiler to running applications using drag and drop. Simply, drop a special icon onto the application window you want to profile.

Open snapshot files from dotTrace Home. Now, you can open .dtp and .dtt snapshot files right from the dotTrace Home window.

Visual Studio 2017 RC initial support.

Subsystems in Timeline Viewer. Timeline Viewer gets one of the greatest Performance Viewer's features: Subsystems. The mechanics of Subsystems are quite simple: in most cases, each subsystem just groups calls made within a certain namespace or assembly. It is extremely useful when you need to quickly evaluate how time in a particular call subtree is distributed among various components: user and system code, WPF, LINQ, collections, strings, and more.

Analyze native memory allocations. The Native Memory Allocation event filter allows you to see what methods are making the allocations and analyze all issues related to the native memory.

Analyze application's debug output. The Debug Output filter can be very helpful for advanced debugging: When selected, timeline will show you only events where your application writes to the debug output, e.g. with the Debug.Write system method.

Events window. The Events tool window simply shows you event log - a list of events occurred in the profiled application: file operations, JIT, SQL queries, and more.

Profiling of .NET Core applications. If you have .NET Core tools installed on your computer, you can profile .NET Core applications without any additional actions.

Multiple improvements in Call Stack window.

Folding recursive calls in Timeline Viewer. Simplify analysis of deep recursive call stacks by folding recursive calls into one node.

Threads diagram in Visual Studio.

dotTrace viewer integrated in Visual Studio gets exactly the same Threads diagram as its standalone counterpart, so, now you can use it to select threads, time range, and of course, view threads activity and filtered time intervals.

Smart tooltips in Threads diagram. Hold the mouse cursor on any thread in Threads diagram, and a tooltip will show you detailed information about what this thread was doing at this particular time point: what method was executed, with which file the thread worked with (in case of file I/O), and other data.

Copy entire plain list to clipboard in Performance Viewer. Now you can copy the entire content of plain list to clipboard.

Profiled process data in the reports generated by the Reporter.exe tool. The Reporter.exe tool used to get performance data from snapshots (e.g., for profiling automation and CI) now puts additional data in its XML reports. If you build a report with the enabled /add_process_info option, the report will include a path to the profiled process's executable. This information is extremely helpful when profiling applications with multiple child processes.

Integration in Visual Studio. Now, Visual Studio gets an integrated counterpart of Timeline Viewer with instant navigation from Call Tree to the source code.

Console profiler accepts configuration via command-line arguments. As an alternative to providing profiling configuration in an XML file, you can do this via command-line arguments.

Profiling of run configurations. dotTrace integrated in Visual Studio gets more profiling capabilities. Now, you can profile not only your startup project, but any 'run configuration' - a startup project, an arbitrary executable, or even any static method.

Incoming HTTP requests profiling. Timeline Viewer offers the new Incoming HTTP Requests filter. Now you can get the exact data on how long a particular HTTP request is processed.

Snapshot auto-deletion. It is possible to automatically delete old snapshots without having to manually take care of them each week or month.

Updated Configuration2Xml tool. Profiling via the command line is back!

SQL queries profiling. Timeline Viewer offers the new SQL Queries filter. Now you can get the exact data on how long a particular SQL query is executed as well as what method has run the query.

Redesigned dotTrace Controller. dotTrace Controller is more neat and takes less space on the screen.

Updated remote agent.

Improved performance in Timeline Viewer.

A completely new Timeline Profiling method that collects temporal call stack and thread state data about your application.

Redesigned UI. Now, dotTrace interface consists of the three main components: dotTrace Home window, Performance Viewer, Timeline Viewer.

Profiling sessions are configured and started in a new dotTrace Home window.

More flexible subsystems. You can specify how the subsystem time should be handled: should it be shown separately, included in calling subsystems time, or not taken into account at all.

Filtering child processes. You can specify what child processes of an application should not be profiled.

A new convenient way to search for bottlenecks via the Subsystems view

Bookmarks for quick navigation between points of interest in a snapshot

Improved filters

Redesigned Overview

Improvements in performance

Profiling Windows Store applications

Integration with Microsoft Visual Studio 2012 and ReSharper 7.1

New filters in Hot Spots

New time measurement method

Attaching to .NET process

Displaying decompiled code

Improved remote profiling

Simultaneous profiling of applications targeting CLR versions 2.0 and 4.0

Support for IIS Express

Profiling XBAP applications

Transparent integration with Typemock Isolator

More options in Plain List

Support for UNC paths

Improved Adjust Time functionality

Threads that do message pumping are marked with special icon

Profiling WCF applications

More filtering to hide irrelevant calls

Examining the performance of all public members of a specific class by opening them in a new tab

Previewing source code for .NET Framework assemblies using source server

Displaying IL code

Performance improvements when processing large snapshots (especially in Plain List and Hot Spots)

More options for performance forecasting

Improved floating license use policy

Improved Home tab