Softpedia >Windows >Programming >Other Programming Files >JetBrains dotTrace >  Changelog

JetBrains dotTrace Changelog

What's new in JetBrains dotTrace 2023.3 Build 2023.3.0.4 EAP 4

Oct 23, 2023
  • dotTrace:
  • This build introduces new advanced options to the Timeline profiling mode:
  • Sampling rate configuration
  • Sampling for native allocations
  • Parallel download of native symbol files, including the option to download them in the background
  • dotTrace now also supports System.Data.SqlClient for applications targeting the .NET and .NET Core frameworks.

New in JetBrains dotTrace 2023.2.1 Build 2023.2.1.65536 (Aug 25, 2023)

  • SWEA Razor: Ambiguous Invocation
  • CSHTML inspection false positive
  • Escape pasted text - broken for raw string literals
  • Unexpected token in valid .cshtml view
  • Slow Project Saving
  • One or more errors occurred. (Entity Framework SourceType/TargetType mismatch.

New in JetBrains dotTrace 2023.2 Build 2023.2.0.65536 (Aug 3, 2023)

  • Grouping by a thread for sampling, tracing, and line-by-line snapshots:
  • Now, the Call Tree inside Rider and the standalone dotTrace application lets you group call stacks by individual threads, allowing deeper insight into thread-specific performance issues.
  • 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.

New in JetBrains dotTrace 2023.1.1 Build 2023.1.20230421.170358 (Apr 30, 2023)

  • We have fixed a bug that blocked dotTrace’s ability to open a snapshot if the profiler was an x64 version run on an ARM64 processor (DTRC-29667).

New in JetBrains dotTrace 2023.1 Build 2023.1.0.65536 (Apr 5, 2023)

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

New in JetBrains dotTrace 2022.3 Build 2022-12-07 (Dec 7, 2022)

  • Support for 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 the more modern Timeline Viewer. This worsened the overall user experience, since the viewers have different user interfaces and approaches to snapshot analysis.
  • Now we’re getting rid of the Performance Viewer in favor of the dotTrace Viewer (formerly the Timeline Viewer). dotTrace will use it to open snapshots of all types. However, you may continue to use the discontinued Performance Viewer if you’d like. If you opt to stick with the Performance Viewer, we would love to hear your reasons for doing so. Your feedback is greatly appreciated!
  • Improvements in snapshot analysis:
  • As the dotTrace Viewer now opens snapshots of all types, you can use all of its powerful features when comparing performance snapshots:
  • The new “comparison as a filter” concept makes it easier to compare sampling, tracing, and line-by-line snapshots.
  • Now you can filter subsystems in sampling, tracing, and line-by-line snapshots.
  • The dotTrace Viewer now has a Plain List view. It’s available for sampling, tracing, and line-by-line snapshots, and also for timeline snapshots.

New in JetBrains dotTrace 2022.2.2 Build 2022-08-22 (Aug 22, 2022)

  • Improved support for native system calls 2022.2:
  • dotTrace now provides more details for native system calls in the Timeline Call Tree, including Windows kernel calls (ntoskrnl.exe), device driver calls (*.sys), and more.
  • Improvements to dotTrace in JetBrains Rider 2022.2:
  • 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.

New in JetBrains dotTrace 2022.2.1 Build 2022-08-08 (Aug 10, 2022)

  • Improved support for native system calls:
  • dotTrace now provides more details for native system calls in the Timeline Call Tree, including Windows kernel calls (ntoskrnl.exe), device driver calls (*.sys), and more.
  • Improvements to dotTrace in JetBrains Rider:
  • 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.

New in JetBrains dotTrace 2021.3 Build 2021.3.0.65536 (Dec 8, 2021)

  • Support for Apple silicon processors 2021.3:
  • The dotTrace command-line tool now works on computers with Apple silicon processors. You can use it to profile .NET 6 applications (native mode) and .NET 5 applications (Rosetta 2 mode).
  • Performance improvements 2021.3:
  • We reduced the performance overhead of Timeline profiling for applications that heavily use async calls.
  • We improved the performance of opening and filtering in Timeline snapshots.
  • Saving UI state for Timeline snapshots 2021.3:
  • When you close a Timeline snapshot, dotTrace saves the state of the user interface, including selected time intervals, applied filters, and so on. Next time you open the snapshot, dotTrace will restore the UI to the same state.

New in JetBrains dotTrace 2021.2.2 (Oct 13, 2021)

  • Native profiling:
  • It’s now possible to profile native applications on Windows. When starting a profiling session, you have the option to download native source symbol files from remote servers. Native profiling is only available for the Timeline profiling type.

New in JetBrains dotTrace 2021.1 (Apr 8, 2021)

  • New Home Screen:
  • We’ve completely reworked the dotTrace Home screen. 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:
  • You can install and use the dotTrace command-line profiler as a dotnet global tool: dotnet tool install --global JetBrains.dotTrace.GlobalTools --version 2021.1.0

New in JetBrains dotTrace 2020.3 (Dec 14, 2020)

  • .NET 5 support 2020.3:
  • 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 2020.3:
  • 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 2020.3:
  • 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.
  • Other Updates 2020.3:
  • 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.
  • Multiple bugfixes.

New in JetBrains dotTrace 2020.2 (Aug 13, 2020)

  • Native profiling of Mono and Unity applications:
  • Both standalone dotTrace and dotTrace in Rider can profile the native part of Mono/Unity applications on Windows. Start a session with the ‘Enable native profiling’ option selected, and you’ll see both native and managed call stacks in the 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.
  • Other improvements:
  • The profiler lets you control the profiling session (take snapshots, detach from the profiled process, and so on) by sending commands to stdin or 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.

New in JetBrains dotTrace 2020.1.4 (Jul 9, 2020)

  • 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.

New in JetBrains dotTrace 2019.3 (Dec 11, 2019)

  • 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.

New in JetBrains dotTrace 2019.2 (Aug 8, 2019)

  • You can set environment variables for any application type.
  • ASP.NET Core support in Visual Studio is improved: different hosting models are correctly supported, browser settings and Enable SSL are taken into account when starting a profiling session, and more.
  • Profiling API gets the ability to detach from the profiled process.
  • Silverlight and WebDev applications are no longer supported.

New in JetBrains dotTrace 2019.1 (Apr 30, 2019)

  • Support for macOS and Linux in JetBrains Rider:
  • If you use JetBrains Rider, you can run dotTrace on macOS and Linux to profile Mono and Unity applications.
  • Profiling Mono and Unity applications:
  • dotTrace lets you profile Mono 5.10 or later and Unity 2018.3 or later applications on Windows, macOS, and Linux.
  • New profiling API:
  • As you might know, dotTrace includes the profiling API that is used to control profiling sessions right from the code of your application. In 2019.1, we have rewritten this API from scratch to make it more user-friendly:
  • We got rid of the state machine.
  • We reduced a number of methods you have to use. Thus, to start profiling, simply call MeasureProfiler.StartCollectingData(). To stop collecting data and save a snapshot, call MeasureProfiler.SaveData().
  • The API is available as a NuGet package.
  • Command-line profiler improvements:
  • The dotTrace command-line profiling tools get improved:
  • 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 in JetBrains dotTrace 2018.3 (Dec 19, 2018)

  • JetBrains Rider integration:
  • In addition to Visual Studio, now dotTrace is a part of the JetBrains Rider IDE on Windows. You can configure and run profiling sessions, get snapshots, and analyze them in the built-in viewer.
  • 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.
  • Improved 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.
  • Visual Studio 2019 Preview 1 support:
  • dotTrace 2018.3, along with other products of the ReSharper Ultimate family, can now be installed into Visual Studio 2019 Preview 1.

New in JetBrains dotTrace 2018.2 (Aug 22, 2018)

  • .NET process filter:
  • Though, this release was mainly focused on improving dotTrace performance, we've also improved profiling of arbitrary .NET processes. Now, when configuring a profiling session, you are able to set an include filter: dotTrace will attach only to a process that matches the filter.

New in JetBrains dotTrace 2018.1 (Apr 16, 2018)

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

New in JetBrains dotTrace 2017.3.3 (Mar 2, 2018)

  • Support for async calls:
  • The downside of asynchronous code is it's extremely difficult to profile 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:
  • Do you remember the "performance forecasting" feature in the Performance Viewer? Now, you can do the same thing in the Timeline Viewer. Simply exclude a particular method from the Call Tree, and dotTrace will recalculate the entire snapshot as if there is no such method.
  • Backtraces in Methods and Subsystems:
  • When examining a list of top methods in Methods and Subsystems, it may be helpful to quickly view backtraces (an inverted call tree) of a particular method to identify its origin. Now, you can do this right in Methods and Subsystems without switching to the Call Tree.
  • Marking user assemblies as system ones:
  • Sometimes, you may want dotTrace to treat particular user modules/assemblies as system ones. This may be helpful, for example, in case the user modules provide some core functionality and are not supposed to be optimized.
  • After you mark a user module as a system module, 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.

New in JetBrains dotTrace 2017.3.2 (Mar 2, 2018)

  • Navigation path in Call Tree:
  • When navigating a call tree, it's always been tough to understand how you ended up at a particular function. Not anymore with dotTrace 2017.2: 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.
  • It's also worth noting that dotTrace command-line tools are now available as a NuGet package.

New in JetBrains dotTrace 2017.3.1 (Jan 24, 2018)

  • Support for async/await:
  • The most important update in dotTrace 2017.3 is its support for asynchronous code. The details can be found in a separate article, so here we’ll only give an overview of the key idea.
  • You can now quickly find all “parts” of an asynchronous call in one place. dotTrace marks all async call nodes in the Call Tree and groups the corresponding await time and continuation code under those nodes.
  • Forecasting performance in Timeline Viewer:
  • If you’re a long-term dotTrace user, you probably know that the “classic” dotTrace Performance Viewer lets you remove particular functions from the snapshot. This helps answer the question, “What if there were no such function?”, or “Is it worth optimizing this function?”.
  • The exact same feature is now available in the Timeline Viewer. Right-click the function in the Call Tree and choose either Exclude This Call Path (to exclude this particular function call) or Exclude Method (to exclude all calls to that function) from the context menu.
  • Backtraces in Methods and Subsystems (Timeline Viewer):
  • Backtraces is an awesome feature that allows you to track the origin of a particular call. In this mode, the call tree is inverted so that you see all of the parent calls.
  • Before 2017.3, the only option to view backtraces was to use the Call Tree. This was not very convenient if you examined the list of top methods in Methods and Subsystems and wanted to get more details about a method: no one likes to switch contexts. Now, you can view backtraces right in Methods and Subsystems. Simply hover the mouse over the method you’re interested in and click the arrow symbol on the left.
  • Marking user assemblies as system assemblies:
  • Sometimes, you want dotTrace to treat particular user modules/assemblies as system assemblies. This may be helpful, for example, if the user modules/assemblies provide some core functionality and are not supposed to be optimized.
  • In dotTrace 2017.3, you have the option to mark a user assembly as a system one. After you do this, two things will happen. First, the execution time (shown in Methods and Subsystems) of methods belonging to this assembly will be calculated as if it was a system assembly. Second, all calls (of methods belonging to this assembly) will be folded in the Call Tree as if they were system calls, i.e. a group of calls will be collapsed into a single node so as not to distract you.
  • To mark a user assembly as a system assembly, simply right-click a method that belongs to the assembly you want to mark as a system one, and then select Mark all Functions from Assembly ‘MyAssembly’ as System (where ‘MyAssembly’ is the name of the assembly you want to mark as a system one).

New in JetBrains dotTrace 2017.2.1 (Sep 29, 2017)

  • Navigation path in Call Tree:
  • When navigating a call tree, it's always been tough to understand how you ended up at a particular function. Not anymore with dotTrace 2017.2: 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.
  • It's also worth noting that dotTrace command-line tools are now available as a NuGet package.
  • Profile child processes in unit tests:
  • You can now enable profiling of child processes in unit tests with a simple checkbox. Complex profiling configurations are no longer required

New in JetBrains dotTrace 2016.1.2 (Jul 7, 2016)

  • Timeline in Visual Studio with smart tooltips 2016.1:
  • Before dotTrace 2016.1, the main drawback of the integrated viewer compared to its standalone counterpart was the absence of the Threads diagram. Now, the integrated viewer gets exactly the same diagram, which you can use to select threads, time range, and of course, view thread activity and filtered time intervals.
  • In addition, Threads diagram in both standalone and Visual Studio viewer gets smart tooltips. Hold the mouse over a specific time point on the timeline to display a tooltip showing the current thread state, executed method, and more useful info.
  • Tooltips are context-sensitive. This means that if some filter is applied, the tooltip will contain additional data on the filtered event. For example, when the File I/O filter is selected, the tooltip additionally shows info about file operation, file name, and data size.

New in JetBrains dotTrace 5.5.0 Build 0.11568 (Jul 23, 2013)

  • dotTrace 5.5 Performance introduces Subsystems, Bookmarks and new Overview page, integrates with Visual Studio 2012 and ReSharper 8, supports .NET Framework 4.5 and Windows 8, enables attaching to and detaching from running processes and supports Windows Store applications profiling.
  • Subsystems:
  • dotTrace Performance 5.5 comes with a new way to analyze snapshots in terms of Subsystems. Discover your code bottlenecks faster without digging deep into callstacks. With Subsystems view you get a quick overview of where a possible bottleneck may originate.
  • Visual Studio 2012 integration:
  • dotTrace 5.3 Performance adds integration with Visual Studio 2012. You can launch profiling sessions from within Visual Studio 2012 and navigate from a snapshot to the corresponding source code in the latest version of the Microsoft IDE. Visual Studio 2005, 2008, and 2010 are still supported, too.
  • Improved remote profiling:
  • You have been able to profile .NET applications on remote machines for a while using dotTrace Performance. With version 5, remote profiling experience is substantially improved.
  • To start off, HTTP is now used for remote profiling instead of a custom protocol, which allows profiling over VPNs and simplifies configuring firewall rules. Also, both IPv4 and IPv6 are now supported for remote profiling.
  • enlarge
  • We have also removed passphrase exchange between dotTrace and its remote agent, making remote profiling easier in restricted environments. In addition, dotTrace profiling agent can now be run either as a regular application or an ASP.NET Web Service.
  • Last but not least, you can finally attach to running remote processes, which is crucial in discovering bottlenecks in mission-critical production .NET applications.
  • Support for IIS Express:
  • As IIS Express was gaining popularity among web developers, we've been receiving requests to enable profiling web applications running under this server, and here we go: dotTrace 5 Performance introduces official support for IIS Express that complements existing support for the full-fledged IIS and ASP.NET Development Server.
  • Refined stack walking mechanism:
  • Our improved stack walking algorithm allows you to see detailed call stacks of profiled applications in more scenarios than before. Instead of the ambiguous [Native or optimized code] label, you're now able to see an expanded list of your application or CLR functions that were called during execution under profiling where it's possible.
  • Improvements in Plain List View:
  • We've put a lot of effort to make Plain List a better place to examine application behavior. You can now choose to show or hide system functions from the Plain List View, and group functions by assembly in addition to class and namespace groupings.
  • As a bonus, Plain List is now constructed a lot faster with large snapshots, displaying up to 20x performance improvement in certain scenarios.
  • .NET 4.5 and Windows 8 Support:
  • Starting from version 5.2 dotTrace Performance provides support for .NET 4.5 applications and Windows 8. It is possible to profile .NET 4.5 applications using dotTrace Performance standalone.
  • Refined Overview page:
  • With dotTrace 5.5 Performance comes new refined overview tab. You can now see all the significant information about your application performance and session parameters at one screen.
  • Profiling Windows Store applications:
  • With version 5.3 comes support for profiling Windows Store applications including Windows Store test projects.
  • New filters in Hot Spots view:
  • You can filter out system functions or event-waiting trees in the Hot Spots view to concentrate on the functions you need to investigate in a more comfortable way.
  • Attaching to running processes:
  • Arguably the greatest new feature in dotTrace 5 Performance is the ability to attach the profiler to an existing .NET Framework 4.0+ process and run sampling performance analysis on it.
  • Oftentimes, an application that you want to optimize takes long hours or even days before it starts to display any performance issues. Previously, you would have to run it under profiling from the very start, which added another layer of performance overhead. Now, this is no longer required: with the ability to attach to a running process, you only involve the profiler when you really need it.
  • Integration with ReSharper 8:
  • With dotTrace Performance, you can easily start profiling unit tests from Visual Studio code editor, Solution Explorer or ReSharper's unit test runner. Starting from version 5.5, dotTrace Performance supports ReSharper 8. Needless to say, it integrates with previous ReSharper versions as well.
  • Integrated decompiler:
  • Following ReSharper and dotPeek, JetBrains .NET assembly decompiling technology has arrived in dotTrace. While profiling an application, if you need to dig further into the code but you don't have source code or symbol information at hand, dotTrace 5 Performance will decompile it for you and present decompiled code in its source preview area for quick review.
  • Easier estimation of performance gains:
  • The Adjust Time functionality that is used to estimate how optimizing a certain function affects timings of the entire snapshot has been improved as well.
  • Specifically, you can now clear all time adjustments on all functions visible in the current view in one step — previously you would have to navigate between adjusted functions and set them back to their actual timings one by one. We have also enabled management of time adjustments in the Overview view.
  • Enhancements and additions for supported frameworks:
  • dotTrace 5 Performance ensures seamless profiling of applications that contain code targeting different CLR versions. For example, if you have a .NET Framework 4.0 application that is dependent on external libraries targeting CLR 2, this application can now be perfectly profiled.

New in JetBrains dotTrace 5.3.2 Build 1114.138 (May 15, 2013)

  • dotTrace 5.3.2 Performance now supports the latest CLR 4.5, so if you have installed this update or plan to do it, we would recommend to use the newest version of the profiler.

New in JetBrains dotTrace 5.3.1. Build 1114.66 (Feb 21, 2013)

  • dotTrace 5.3.1 Performance fixes fetching PDB files required for code preview, and improves installation in certain scenarios.

New in JetBrains dotTrace 5.3.1114.16 (Dec 18, 2012)

  • Integration with Visual Studio 2012 and ReSharper 7.1.x.
  • Profiling Windows Store applications, including Windows Store test projects.
  • New filters in Hot Spots view: "Filter system functions" and "Filter event-waiting trees".
  • New measurement method, Thread Cycle Time, in addition to wall time and thread time methods.
  • An updated Welcome screen that includes Attach To Process button and more cosmetic improvements for a comfortable profiling experience.

New in JetBrains dotTrace 5.2.1100.84 (Aug 2, 2012)

  • Improved remote profiling
  • Attaching to running processes
  • Support for IIS Express
  • Integration with ReSharper 7
  • Refined stack walking mechanism
  • Integrated decompiler
  • Improvements in Plain List View
  • Easier estimation of performance gains
  • .NET 4.5 and Windows 8 Support
  • Enhancements and additions for supported frameworks

New in JetBrains dotTrace 5.1.1056.26 (Jul 4, 2012)

  • Updated and improved stack walker. Our new algorithm helps you get deeper into call stacks of your application or CLR, providing more opportunities to detect bottlenecks.
  • Integration with ReSharper 7. If you're using pre-release builds of ReSharper 7, add dotTrace 5.1 Performance to enable profiling unit tests right from Visual Studio code editor, Solution Explorer or ReSharper 7 unit test runner.

New in JetBrains dotTrace 5.0.1045.2 (Apr 11, 2012)

  • Improved remote profiling:
  • You have been able to profile .NET applications on remote machines for a while using dotTrace Performance. With version 5, remote profiling experience is substantially improved.
  • To start off, HTTP is now used for remote profiling instead of a custom protocol, which allows profiling over VPNs and simplifies configuring firewall rules. Also, both IPv4 and IPv6 are now supported for remote profiling.
  • We have also removed passphrase exchange between dotTrace and its remote agent, making remote profiling easier in restricted environments. In addition, dotTrace profiling agent can now be run either as a regular service or an ASP.NET Web Service.
  • Last but not least, you can finally attach to running remote processes, which is crucial in discovering bottlenecks in mission-critical production .NET applications.
  • Support for IIS Express:
  • As IIS Express was gaining popularity among web developers, we've been receiving requests to enable profiling web applications running under this server, and here we go: dotTrace 5 Performance introduces official support for IIS Express that complements existing support for the full-fledged IIS and ASP.NET Development Server.
  • Improvements in Plain List View:
  • We've put a lot of effort to make Plain List a better place to examine application behavior. You can now choose to show or hide system functions from the Plain List View, and group functions by assembly in addition to class and namespace groupings.
  • As a bonus, Plain List is now constructed a lot faster with large snapshots, displaying up to 20x performance improvement in certain scenarios.
  • Attaching to running processes:
  • Arguably the greatest new feature in dotTrace 5 Performance is the ability to attach the profiler to an existing .NET Framework 4.0+ process and run sampling performance analysis on it.
  • Oftentimes, an application that you want to optimize takes long hours or even days before it starts to display any performance issues. Previously, you would have to run it under profiling from the very start, which added another layer of performance overhead. Now, this is no longer required: with the ability to attach to a running process, you only involve the profiler when you really need it.
  • Integrated decompiler:
  • Following ReSharper and dotPeek, JetBrains .NET assembly decompiling technology has arrived in dotTrace. While profiling an application, if you need to dig further into the code but you don't have source code or symbol information at hand, dotTrace 5 Performance will decompile it for you instantly and present decompiled code in its source preview area for quick review.
  • Easier estimation of performance gains:
  • The Adjust Time functionality that is used to estimate how optimizing a certain function affects timings of the entire snapshot has been improved as well.
  • Specifically, you can now clear all time adjustments on all functions visible in the current view in one step — previously you would have to navigate between adjusted functions and set them back to their actual timings one by one. We have also enabled management of time adjustments in the Overview view.
  • Enhancements and additions for supported frameworks:
  • dotTrace 5 Performance ensures seamless profiling of applications that contain code targeting different CLR versions. For example, if you have a .NET Framework 4.0 application that is dependent on external libraries targeting CLR 2, this application can now be perfectly profiled.

New in JetBrains dotTrace 4.5.950.32 (Dec 22, 2011)

  • 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 in JetBrains dotTrace 4.0 (Dec 22, 2011)

  • 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