.NET Continuous Profiler: CPU and wall time profiling | Datadog (opens in new tab)

Datadog’s Continuous Profiler timeline view offers a granular look at application performance by mapping code execution directly to a temporal axis. This allows engineers to move beyond aggregate flame graphs to understand exactly when and why specific bottlenecks occur during a request’s lifecycle. By correlating traces with detailed profile data, teams can effectively isolate the root causes of latency spikes and resource exhaustion in live production environments.

Bridging the Gap Between Tracing and Profiling

• While distributed tracing identifies which service or span is slow, profiling explains the "why" by showing execution at the method and line level.
• The timeline view integrates profile data with specific trace spans, allowing users to zoom into the exact millisecond a performance degradation began.
• By toggling between CPU time and wall time, developers can distinguish between active computation and passive waiting, providing a clearer picture of thread state.

Visualizing CPU-Bound Inefficiencies

• The tool identifies "hot" methods that consume excessive CPU cycles, such as inefficient regular expressions, heavy JSON serialization, or intensive cryptographic operations.
• It detects transient CPU spikes that might be averaged out or hidden in traditional 60-second aggregate profiles.
• Engineers can correlate CPU usage with specific threads to identify background tasks or "noisy neighbor" processes that impact the responsiveness of the main application logic.

Diagnosing Wall Time and Runtime Overhead

• Wall time analysis reveals where threads are blocked by external factors like I/O operations, database wait times, or mutex lock contention.
• The view surfaces runtime-specific issues such as Garbage Collection (GC) pauses and Safepoint intervals that halt execution across the entire virtual machine.
• This visibility is critical for troubleshooting synchronization issues where a thread is idle and waiting for a resource, a scenario that often causes high latency without showing up in CPU-only profiles.

To maintain high availability and performance, organizations should integrate continuous profiling into their standard troubleshooting workflows, enabling a seamless transition from detecting a slow trace to identifying the offending line of code or runtime event.