What's New in dotTrace

Improved performance

All versions of dotTrace receive several performance improvements, including faster processing of timeline snapshots and data on the Call Tree and Hotspots views.

Other improvements and bugfixes

• Now, dotTrace Viewer on all platforms uses the same new rendering engine. If you experience issues with the updated viewer, remove Use new cross-platform dotTrace Viewer by default in dotTrace Home | Settings.

• The standalone version of dotTrace for macOS and Linux gets the Options window.

• We fixed the issue with missing kernel events on Windows: Kernel sampling events were missing in Timeline snapshots due to interference from Windows Defender.

• Various minor improvements and bugfixes.

Support for MAUI applications

Now, you can profile applications based on the MAUI framework. Currently, dotTrace supports:

• macOS – Mac Catalyst applications targeting .NET 7.0+. Timeline profiling only.

• Windows – WinUI applications targeting .NET 7.0+. All profiling types are supported. Attaching to already running applications is available only for the Timeline and Sampling types.

The support is available for dotTrace standalone and dotTrace integrated into Rider and ReSharper.

Improved support for Unreal Engine

dotTrace makes it easier to profile Unreal Engine applications: you can now select the Unreal Engine application type when configuring a profiling target. This will predefine the profiling settings that are relevant to Unreal Engine applications.

Profiling presets

dotTrace now includes user interface (UI) presets. The presets adjust the UI to show only the profiling settings relevant to specific applications: General (all application types), Unity developer, and Unreal Engine developer.

Improved support for macOS

We improved profiling on macOS:

• Now, the standalone version of dotTrace lets you specify application bundles (.app) instead of executable files.

• dotTrace in Rider can profile macOS run configurations. The following target frameworks are supported: net7.0-macos, net8.0-macos, net7.0-maccatalyst, net8.0-maccatalyst, Xamarin.Mac.

Improved configuration of the Timeline profiling mode on Windows

Now, when configuring a Timeline profiling session on Windows, you can specify the following advanced options:

• Sampling rate – lets you find the optimal balance between data accuracy and the snapshot size. Fast sampling mode for game development is also supported.

• Sample allocations every ... KB for native allocations – lets you improve the performance of snapshot analysis by reducing the amount of collected data, i.e., snapshot size.

• Download in background for native symbol files – downloads symbol files during the profiling session to reduce the time it takes to take a snapshot.

Profiling data in the Source view

Instead of analyzing the Call Tree, you can now view performance profiling data right in the source code. The Source view displays time distribution for particular lines of code. As for now, this feature is available for timeline snapshots taken on Windows.

Flame graph chart on Linux and macOS

Now, dotTrace on Linux and macOS can show the call tree as a flame graph chart for Timeline snapshots.

Improved native code analysis

• Source code for native methods can now be viewed for timeline snapshots taken on Windows.

• Native threads are now displayed by default if there are no managed threads.

Other improvements

• The timeline profiling mode now supports the System.Data.SqlClient data provider for the .NET and .NET Core frameworks. You can view the corresponding events in the SQL Queries filter.

• You can now view performance metrics inside the search window in the dotTrace viewer.

• Support for integration with third-party tools is now available on Linux and macOS.

• Starting with the version 2023.3, dotTrace no longer supports remote profiling. Use the command-line profiler instead.

Grouping by a thread for sampling, tracing, and line-by-line snapshots

Now, Call Tree lets you group call stacks by individual threads, allowing deeper insight into thread-specific performance issues.

Source View tool window on Linux and macOS

The standalone version of dotTrace on Linux and macOS gets the Source View window. After you select a call in Call Tree, Source View will show you the source code of the corresponding method.

Other improvements and bug fixes

• For Timeline snapshots, dotTrace Viewer now shows the names of native threads instead of showing them all as Native. This feature will benefit Unity developers, letting them distinguish specific Unity threads. Available only on Windows.

• The Source View window in dotTrace Viewer now shows the number of invocations for each line of code.

dotTrace Standalone on Linux and macOS

The standalone version of dotTrace is now available on Linux and macOS. Now, you can perform the full profiling workflow on these operating systems, including collecting and analyzing performance snapshots.

.NET 7 support

dotTrace now lets you profile .NET 7 applications on Windows, macOS, and Linux.

Note that you might face the following issues:

• If your application creates dynamic assemblies, the profiler won't show data (method names) from these assemblies. They will be shown as Unresolved.

• If you profile the application by attaching the profiler to it, the application may crash during the session.

Both issues will be fixed in the upcoming .NET 7 bugfix release.

Improved ARM CPUs support

• Linux arm32  – Now, you can run the dotTrace command-line profiler on arm32 CPUs on Linux. Supported frameworks: .NET Core 3.1, .NET 5.0 - 7.0. Note that the timeline profiling type is supported only for .NET 6.0+ applications.

• Windows arm64  – Now, you can use dotTrace on arm64 CPUs on Windows. This applies to all versions: dotTrace standalone, dotTrace in Rider, dotTrace in Visual Studio, and the dotTrace command-line tool.

Discarding the Performance Viewer

Before this release, sampling, tracing, and line-by-line performance snapshots had to be opened in the legacy Performance Viewer, while timeline snapshots were opened in a more modern Timeline Viewer. This worsened the overall user experience since the two viewers have different user interfaces and approaches to snapshot analysis. Now, we're getting rid of Performance Viewer in favor of dotTrace Viewer (former Timeline Viewer). dotTrace will use it to open snapshots of all types. Nevertheless, if you want to continue using the discarded Performance Viewer, you still have such an option.

Improvements in snapshot analysis

As dotTrace Viewer (former Timeline Viewer) now opens all types of snapshots, you can use all its powerful features for performance snapshots:

• Comparing sampling, tracing, and line-by-line snapshots is easier due to the new "comparison as a filter" concept.

• Now, you can filter subsystems in sampling, tracing, and line-by-line snapshots.

• dotTrace Viewer gets the Plain List view. Moreover, it's available not only for sampling, tracing, and line-by-line snapshots but also for timeline snapshots.

Improved support for native system calls

Now, dotTrace shows more details for native system calls in the Timeline call tree, including Windows kernel calls (ntoskrnl.exe), device driver calls (*.sys), and so on.

Note that native profiling is supported only in Windows by all dotTrace versions: standalone, the command-line tool, as well as dotTrace integrated in ReSharper and Rider.

dotTrace in JetBrains Rider improvements

You no longer have to restart the Unity Editor to launch the profiling process. The profiler can now attach to and detach from running Unity processes.

Support for musl-based Linux distributions

The dotTrace command-line tool now supports Alpine versions 3.13–3.15. The following CPUs and frameworks are supported:

• x64: .NET Core 3.1, .NET 5.0–6.0.

• arm64: .NET 5.0–6.0.

Support for the .NET Core NetTrace file format

You can now open NetTrace files collected with dotnet-trace collect: from the dotTrace Home menu, click Open Snapshot and choose a .nettrace file.

Improved support for SQL Server events

Now dotTrace supports SQL Server events from the Microsoft.Data.SqlClient provider on Windows (.NET Core, .NET 5+), as well as macOS and Linux (.NET Core 3.0+, .NET 5+).

Keyboard navigation in dotTrace Home

You can now navigate the dotTrace Home window using only keyboard combinations. No mouse is needed. Each UI element is assigned to a key or key sequence. There are two ways to view the assigned keys and interact with UI elements:

• Hold Alt and press a key or key sequence (default).

• Press the mode-toggle key, then press a key or key sequence.

You can choose which to use in dotTrace Home | Settings.

Attaching to applications with drag and drop

You can now attach the profiler to an already running application by simply dragging the special icon onto the application window.

Improved Snapshots page in the dotTrace Home window

• You can now edit the names of snapshots.

• You can now open snapshots by dragging the corresponding files onto the dotTrace Home window.

• The snapshots list now preserves the sorting state between dotTrace launches.

• The snapshots list now uses the system date format.

Other improvements

• You can now disable snapshot auto-saving. If you do, when you close the Timeline or Performance Viewer, dotTrace will ask you whether you want to save the collected snapshots.

• It’s now possible to pin threads in the Threads filter in the Timeline Viewer.

• The Configuration2Xml tool now uses the same UI as the dotTrace Home window.

Improved profiling of child processes

Suppose you profile a root process that creates a number of managed child processes you want to profile. The root process itself is excluded from profiling for some reason (for example, it may be a shell script, a native process, or you simply exclude it with process filters).

Before: The profiler starts profiling any child process that matches the filter. Once a child process is finished, the profiler waits for one second. If no new child processes are started within this time, the profiler finishes the profiling session. This could be a problem if the root process starts child processes with a longer delay.

Now: While the root process is running, the profiler doesn't stop the profiling session. Once the root process stops working, the profiler switches to the one-second-delay approach. (edited)

.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 Hotspots (Timeline Viewer). Now, you can quickly view backtraces of a particular method right in the Hotspots 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 Hotspots 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 Hotspots (Timeline Viewer). Now, you can quickly view backtraces of a particular method right in the Hotspots 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 Hotspots 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. Hover over 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

New performance profiling capabilities:

• Profiling .NET Framework 4.0 applications.

• Profiling Windows Mobile applications built with .NET Compact Framework 3.5.

• Profiling Silverlight 4 applications.

• Profiling web applications deployed under IIS 7 or IIS 7.5.

• Profiling any .NET processes.

• Profiling applications remotely.

• Profiling applications line-by-line.

• A new way to measure execution time: wall time (performance counter).

• High Accuracy option to account for the time spent inside the profiler.

• Merging threads with identical names.

Improvements in working with performance snapshots:

• Handling snapshots of up to several hundred gigabytes in size.

• A new presentation view: Overview.

• Improved speed of search and navigation including name matching.

• Improved navigation between found function calls.

• Performance forecasting

• Adding textual annotations to functions.

• Advanced filtering.

• Selective line-by-line profiling for functions or classes that you'd like to zoom into.

• Improved source code preview.

Integration with Microsoft Visual Studio:

• Integration with Visual Studio 2005, 2008, and 2010.

• Support for more application types when you profile from Visual Studio.

• Profiling unit tests using Visual Studio, JetBrains ReSharper and dotTrace.

Editioning:

• Two editions: Standard and Professional.