Operations | Monitoring | ITSM | DevOps | Cloud

Coroot already does eBPF-based CPU profiling for Java. It catches CPU hotspots well, but that's all it can do. Every time we looked at a GC pressure issue or a latency spike caused by lock contention, we could see something was wrong but not what. We wanted memory allocation and lock contention profiling. So we decided to add async-profiler support to coroot-node-agent. The goal: memory allocation and lock contention profiles for any HotSpot JVM, with zero code changes. Here's how we got there.

Continuous profiling offers deep visibility into production environments, revealing exactly how applications consume CPU and memory. It’s the go-to observability practice for directly connecting system behavior and performance to specific lines of code. But when teams consider deploying continuous profiling more broadly, a common question comes up: what’s the overhead? Is it safe to run continuous profiling on my production services 24/7, or does the cost outweigh the benefits?

Backend systems rarely fail in obvious ways. More often, they degrade over time. CPU usage slowly increases, request latency creeps up, and costs rise without a clear explanation. Metrics tell you something is wrong, traces show where requests go, but neither explains why your code behaves the way it does under real load. Continuous profiling fills that gap. Atatus continuous profiling runs automatically in production with minimal overhead.

Continuous profiling has established itself as core observability practice, so much so that we’ve referred to it as the fourth pillar of observability. But despite the capabilities and growing adoption of continuous profiling, it can still be confusing to approach profiling as a newcomer and correctly apply it to different troubleshooting scenarios.

At Coralogix, we’re constantly looking to evolve the measurements we take to better understand the efficiency of our infrastructure. We constantly assess and investigate sources of cost in our cloud infrastructure, to ensure we’re getting the best return on investment. This activity, often referred to as FinOps, is becoming a cornerstone of engineering teams.

Developers have long used profilers to diagnose performance bottlenecks and improve the efficiency of their code. But a modern version of profiling, continuous profiling, is quietly redefining what profiling is and what it can do. By running nonstop in production with very low overhead, continuous profilers give teams always-on visibility into how their code behaves in the real world.

Modern code profilers gather performance data that is highly useful for developers, but the traditional presentation of that data can be challenging to interpret for engineers who are new to profiling. For the Continuous Profiler team at Datadog, our guiding mission is to make profiling a standard practice for all developers by flattening its learning curve and helping teams quickly gain insights into application performance.