Engineers at Polar Signals write about continuous profiling, eBPF, stack unwinding, and deterministic simulation testing in Rust and Go.
HN links it for profiling and testing techniques. Commenters discuss the Parca open source profiler, Python tracing with eBPF, and determinism in Rust versus Go.
The pervasive lack of frame pointers is the reason why we've developed a custom format derived from DWARF unwind information thanks to some insights: DWARF unwind information is incredible flexible, it supports many arches and allows restoring any arbitrary register. But we only need 3: the frame pointer, the stack pointer, and in non-x86 the return address.
In addition, this encoding doesn't use that many bytes, but unfortunately reading and parsing that information is quite expensive.
For that reason I've developed a new unwinder that uses custom unwind information derived from DWARF (https://www.polarsignals.com/blog/posts/2022/11/29/profiling-without-frame-pointers/, previously discussed in https://news.ycombinator.com/item?id=33788794) that runs in BPF. This new compact representation can be binary searched easily and each unwind row has a size of 16 bytes. I are currently working on reducing it down to ~10 bytes.
All the code is fully OSS (Apache 2.0 for userspace and GPL for BPF), and part of the Parca project (https://github.com/parca-dev/parca-agent).
We've also given some talks in FOSDEM going deeper into how we made it scale for many big processes.
I rarely come out and post on HN, but I couldn't resist.
First off, congratulations on the launch!
I am doing some work around Python tracing using eBPF tools and spending a lot time reading about CPython interpreter and runtime implementation. I came across this Polar Signals blog post[0] last week. Fantastic, fantastic work! I learned a ton about Python internals in just a few minutes that I had completely missed even after reading the code for days. This post also set a benchmark for technical writing for me.
Huge kudos for all the great work! And thank you for sharing all these out!
[0] https://www.polarsignals.com/blog/posts/2023/10/04/profiling-python-and-ruby-with-ebpf
> In addition to that we built a custom columnar database
I did some digging in your blog history and it seems that is referencing https://www.polarsignals.com/blog/posts/2022/07/22/frostdb-in-prometheus and digging into the "but why?" section <https://github.com/polarsignals/frostdb#why-you-should-use-frostdb> seems to imply you favored the embedded feature over having something standalone, but I would enjoy hearing (or reading a blog post!) about why you felt it was a better use of your engineering to make your own columar DB versus using one of the existing columanr dbs that I have seen referenced a ton in other Show HN announcements around both logging and metrics services
It is also easier to make your code deterministic with Rust vs with Go, which is incredibly useful if you need to perform deterministic simulation testing + property-based testing. I recently wrote a Postgres-to-Iceberg data mirroring tool [1] in Go, but I ported it to Rust because I wanted the ability perform DST without fighting Go's runtime [2]. But if the domain is not critical that warrants DST, I would still pick Go over Rust any day.
[1] https://github.com/polynya-dev/pg2iceberg
[2] https://www.polarsignals.com/blog/posts/2024/05/28/mostly-dst-in-go
This profiler is focused on kernel execution but we do scrape high level metrics (https://www.polarsignals.com/blog/posts/2025/06/04/latest-in-continuous-profiling-for-gpus which is based on https://github.com/polarsignals/gpu-metrics-agent). What performance counters in particular were you interested in?
It's pretty hard to tell from the website what this product does, and the submitted title ("Polar Signals Cloud Is Generally Available") doesn't explain anything, so I replaced it with a phrase from https://www.polarsignals.com/blog/posts/2023/10/10/polarsignals-cloud-ga that seems to say something.