Continuous profiling has become a cornerstone of modern observability, offering unparalleled insights into code performance. With the release of Pyroscope 2.0, Grafana Labs has rearchitected its open-source profiling database to be faster, cheaper, and fully compatible with the OpenTelemetry Protocol (OTLP). This Q&A covers everything from the basics of continuous profiling to the specific upgrades in Pyroscope 2.0.
What is continuous profiling and why is it important?
Continuous profiling is a method of constantly capturing detailed snapshots of where an application spends its CPU time, memory allocations, and other resources. Unlike metrics (which tell you that CPU is high) or logs (which show a slow request), profiling reveals which specific function and even which line of code is consuming resources. This level of granularity is crucial for modern, complex systems where understanding performance bottlenecks requires more than just aggregate numbers. By providing a continuous, historical record of resource usage, teams can track regressions over time and pinpoint inefficiencies that would otherwise remain invisible. As OpenTelemetry recently promoted its Profiles signal to alpha, profiling is solidifying its place as a first-class observability signal alongside traces and metrics.
How does continuous profiling help reduce cloud costs?
Cloud infrastructure costs—especially CPU and memory—are among the largest engineering expenses. Teams often overprovision because they lack fine-grained visibility into actual resource consumption. Continuous profiling changes that by giving you a function-level map of where your cloud budget is going. Instead of guessing which service needs more juice, you can see that a single function processOrder() is responsible for 30% of CPU usage across all replicas. With that data, you can optimize that function—for example, by caching a regex pattern or reducing allocation—and scale down your infrastructure accordingly. The result is targeted optimization rather than horizontal scaling, leading to direct cost savings. Many teams report cutting their cloud bills by 20–30% after adopting continuous profiling because they stop wasting money on overprovisioning and can confidently right-size their clusters.
How does continuous profiling speed up root cause analysis during incidents?
When an incident occurs, metrics and traces typically narrow the blast radius to a specific service or endpoint. But the hardest part is the last mile—identifying the exact code change that caused the regression. With continuous profiling, that last mile shrinks from hours to minutes. You can compare a profile taken just before the incident with one taken during the event, and the tool highlights the code paths that changed. No need to reproduce the issue in staging, add ad-hoc logging, or guess. For example, if a deployment introduced a new loop that burns CPU, the diff will show it immediately. This capability is especially valuable for intermittent or hard-to-reproduce issues, because the profile captures production behavior as it happens, not in a controlled environment.
How does profiling complement tracing for latency analysis?
Distributed tracing tells you where wall-clock time is spent across service boundaries—for instance, that the auth service added 200ms to a request. However, tracing doesn’t show you why that time was spent. Profiling fills the gap by revealing how the CPU actually used those 200 milliseconds. A trace might point to a slow endpoint, while a profile shows that 150ms of that latency was due to an expensive regex compilation that could be cached. Together, they close the observability loop. This is especially powerful for tail latency (p99 spikes), which are often caused by code-level inefficiencies that are invisible to traces alone. By capturing profiles during those spike moments, you can diagnose the root cause without relying on luck or debuggers.
How does Pyroscope 2.0 leverage OpenTelemetry for profiling?
Pyroscope 2.0 introduces native support for the OpenTelemetry Protocol (OTLP) for profiling. This means you can now send profiles using the emerging OTLP standard, just as you would for traces and metrics. This unification simplifies your observability pipeline—you no longer need separate agents or proprietary exporters for profiling. By adopting OTLP, Pyroscope ensures that profiling becomes a first-class citizen in the OpenTelemetry ecosystem. Whether you’re using the OpenTelemetry Collector or any OTLP-compatible agent, you can start ingesting profiles directly into Pyroscope. This aligns with the industry move toward a single, open standard for observability signals, reducing vendor lock-in and operational overhead.
What makes Pyroscope 2.0 more cost-effective than previous versions?
The original Pyroscope architecture was based on Cortex, which was not originally designed for the high-cardinality, high-churn nature of profiling data. Pyroscope 2.0 is a ground-up rearchitecture that optimizes storage and query performance specifically for continuous profiling. The new design reduces storage requirements by using more efficient encoding and compression tailored to stack traces. It also improves query speed, allowing you to run complex flamegraph comparisons without expensive queries. These improvements mean you can store more profiles for longer periods at a lower cost, and query them faster—making always-on profiling financially viable even for large-scale deployments. Early adopters report 50% reductions in storage costs compared to the previous version.
What are the key architectural changes in Pyroscope 2.0?
Pyroscope 2.0 moves away from the Cortex-based architecture to a purpose-built storage engine designed specifically for profiling data. This new engine handles high-cardinality labels (like service name, region, and user-defined tags) much more efficiently. It also introduces a new indexing system that accelerates queries across time and labels, making it possible to quickly filter profiles by attributes such as deployment version or environment. Additionally, the ingestion pipeline has been reworked to support unlimited concurrent writes without bottlenecks, enabling ingestion from thousands of agents simultaneously. Finally, the query layer was redesigned to support OTLP natively and to provide seamless integration with Grafana dashboards. These changes collectively make Pyroscope 2.0 faster, cheaper, and more scalable, aligning with the growing demand for continuous profiling in production.