parca: Open Source Monitoring & Observability

parca

“Continuous profiling for analysis of CPU and memory usage, down to the line number and throughout time. Saving infrastructure cost, improving performance, and i”

Continuous profiling for analysis of CPU and memory usage, down to the line number and throughout time. Saving infrastructure cost, improving performance, and increasing reliability.

maintainer? embed the star badge

get the markdown →

What is parca?

Parca is an open-source continuous profiling system that records CPU and memory usage down to the line number and across time, built for platform, SRE, and performance engineers who run production workloads on Kubernetes or systemd.

What it is

Parca is a continuous profiler for cloud-native infrastructure. It ships an eBPF-based profiler agent that automatically discovers profiling targets from Kubernetes or systemd across an entire fleet, collects CPU and memory profiles with very low overhead, and stores them so that they can be queried by label rather than inspected one process at a time. It sits in the Infrastructure & Operations / Monitoring & Observability space alongside the rest of the observability stack, and it speaks pprof as its interchange format on both the producing and the ingesting side.

The concrete problem it solves is the cost of profiling at scale. Traditional profiling requires instrumenting each application, attaching to a process on demand, or accepting sampling gaps that make results statistically weak. Parca's agent aims to lower that entry bar to zero instrumentation: deploy it across the infrastructure and profiles begin arriving. Because profiles are retained over time and indexed by labels, an operator can aggregate data infrastructure-wide, open a single profile at a point in time, or compare any dimension such as deploy, version, or region. That turns questions like "what changed in this release" or "where is this memory leak" into queries instead of one-off debugging sessions.

Key capabilities

eBPF profiler that automatically discovers targets from Kubernetes or systemd across the whole infrastructure, with support for C, C++, Rust, Go, and more.
pprof interoperability: the agent produces pprof-formatted profiles, and Parca ingests any pprof-formatted profile, so existing language tooling keeps working.
Label-based search over stored profiles, allowing slicing and dicing of profiling data by any dimension while retaining the raw data.
Comparison of profiles across label dimensions such as deploys, versions, and regions to attribute differences to a specific change.
parca.yaml configuration for scrape targets; by default Parca scrapes its own pprof endpoints so profiles appear shortly after first run.
--mode flag selecting all (every component) or scraper (scraper only, shipping to a remote gRPC endpoint), plus --http-address defaulting to :7070.
OTLP trace export through --otlp-address with a grpc or HTTP exporter and an --otlp-insecure option that disables TLS.

Who uses it and how

Platform teams that need infrastructure-wide profiling without asking every service owner to add instrumentation, since the agent requires none.
Kubernetes operators who want automatic target discovery instead of hand-maintained scrape lists per cluster.
Cost-optimisation efforts: the README notes that many organisations waste 20-30% of resources on easily optimised code paths, and positions the agent as the low-friction way to find them.
Incident responders investigating memory leaks or momentary CPU and I/O spikes, where continuous data over time is the deciding evidence.
Teams that already emit pprof profiles and want a storage and query layer rather than another collector.

Getting started

Build from source with make build, which requires Go, Node, and Pnpm installed and produces the binary at bin/parca; run it with ./bin/parca and open the web UI at http://localhost:7070/. Detailed installation guides live on the project website at parca.dev.

How it compares

Parca stands alone in this registry: the facts provide no list of paid products it replaces, and name no directly comparable profiling tool, so no licence, cost-model, or self-hosting contrast can be drawn from the record.

When to use it — and when not to

A self-hoster must build the project from source with a Go, Node, and Pnpm toolchain, then operate the storage and query components and maintain a parca.yaml scrape configuration. The README is deliberately thin on installation, delegating it to the website, and the repository carries 206 open issues, so teams wanting a turnkey, fully documented appliance should weigh that. It is also the wrong pick if workloads fall outside Kubernetes or systemd target discovery, or if the organisation has no appetite for running another stateful observability component.

project readme (upstream, from github) — read inline

Discord contributors

Continuous profiling for analysis of CPU, memory usage over time, and down to the line number. Saving infrastructure cost, improving performance, and increasing reliability.

Features

eBPF Profiler: A single profiler, using eBPF, automatically discovering targets from Kubernetes or systemd across the entire infrastructure with very low overhead. Supports C, C++, Rust, Go, and more!
Open Standards: Both producing pprof formatted profiles with the eBPF based profiler, and ingesting any pprof formatted profiles allowing for wide language adoption and interoperability with existing tooling.
Optimized Storage & Querying: Efficiently storing profiling data while retaining raw data and allowing slicing and dicing of data through a label-based search. Aggregate profiling data infrastructure wide, view single profiles in time or compare on any dimension.

Why?

Save Money: Many organizations have 20-30% of resources wasted with easily optimized code paths. The Parca Agent aims to lower the entry bar by requiring 0 instrumentation for the whole infrastructure. Deploy in your infrastructure and get started!
Improve Performance: Using profiling data collected over time, Parca can with confidence and statistical significance determine hot paths to optimize. Additionally, it can show differences between any label dimension, such as deploys, versions, and regions.
Understand Incidents: Profiling data provides unique insight and depth into what a process executed over time. Memory leaks, but also momentary spikes in CPU or I/O causing unexpected behavior, is traditionally difficult to troubleshoot are a breeze with continuous profiling.

Feedback & Support

If you have any feedback, please open a discussion in the GitHub Discussions of this project. We would love to learn what you think!

Installation & Documentation

Check Parca's website for updated and in-depth installation guides and documentation!

parca.dev

Development

You need to have Go, Node and Pnpm installed.

Clone the project

git clone https://github.com/parca-dev/parca.git

Go to the project directory

cd parca

Build the UI and compile the Go binaries

make build

Running the compiled Parca binary

The binary was compiled to bin/parca .

./bin/parca

Now Parca is running locally and its web UI is available on http://localhost:7070/.

By default, Parca is scraping it's own pprof endpoints and you should see profiles show up over time. The scrape configuration can be changed in the parca.yaml in the root of the repository.

Configuration

Flags:

Usage: parca [flags]

Flags:
  -h, --help                     Show context-sensitive help.
      --config-path="parca.yaml"
                                 Path to config file.
      --mode="all"               Scraper only runs a scraper that sends to a
                                 remote gRPC endpoint. All runs all components.
      --http-address=":7070"     Address to bind HTTP server to.
      --http-read-timeout=5s     Timeout duration for HTTP server to read
                                 request body.
      --http-write-timeout=1m    Timeout duration for HTTP server to write
                                 response body.
      --port=""                  (DEPRECATED) Use http-address instead.
      --log-level="info"         Log level.
      --log-format="logfmt"      Configure if structured logging as JSON or as
                                 logfmt
      --otlp-address=STRING      The endpoint to send OTLP traces to.
      --otlp-exporter="grpc"     The OTLP exporter to use.
      --otlp-insecure            If true, disables TLS for OTLP exporters (both
                                 gRPC and HTTP).
      --cors-allowed-origins=CORS-ALLOWED-ORIGINS,...
                                 Allowed CORS origins.
      --version                  Show application version.
      --path-prefix=""           Path prefix for the UI
      --mutex-profile-fraction=0
                                 Fraction of mutex profile samples to collect.
      --block-profile-rate=0     Sample rate for block profile.
      --enable-persistence       Turn on persistent storage for the metastore
                                 and profile storage.
      --storage-active-memory=536870912
                                 Amount of memory to use for active storage.
                                 Defaults to 512MB.
      --storage-path="data"      Path to storage directory.
      --storage-enable-wal       Enables write ahead log for profile storage.
      --storage-snapshot-trigger-size=134217728
                                 Number of bytes to trigger a snapshot. Defaults
                                 to 1/4 of active memory. This is only used if
                                 enable-wal is set.
      --storage-row-group-size=8192
                                 Number of rows in each row group during
                                 compaction and persistence. Setting to <= 0
                                 results in a single row group per file.
      --storage-index-on-disk    Whether to store the index on disk instead
                                 of in memory. Useful to reduce the memory
                                 footprint of the store.
      --symbolizer-demangle-mode="simple"
                                 Mode to demangle C++ symbols. Default mode
                                 is simplified: no parameters, no templates,
                                 no return type
      --symbolizer-external-addr-2-line-path=""
                                 Path to addr2line utility, to be used for
                                 symbolization instead of native implementation
      --symbolizer-number-of-tries=3
                                 Number of tries to attempt to symbolize an
                                 unsybolized location
      --debuginfo-cache-dir="/tmp"
                                 Path to directory where debuginfo is cached.
      --debuginfo-upload-max-size=1000000000
                                 Maximum size of debuginfo upload in bytes.
      --debuginfo-upload-max-duration=15m
                                 Maximum duration of debuginfo upload.
      --debuginfo-uploads-signed-url
                                 Whether to use signed URLs for debuginfo
                                 uploads.
      --debuginfod-upstream-servers=debuginfod.elfutils.org,...
                                 Upstream debuginfod servers. Defaults to
                                 debuginfod.elfutils.org. It is an ordered
                                 list of servers to try. Learn more at
                                 https://sourceware.org/elfutils/Debuginfod.html
      --debuginfod-http-request-timeout=5m
                                 Timeout duration for HTTP request to upstream
                                 debuginfod server. Defaults to 5m
      --profile-share-server="api.pprof.me:443"
                                 gRPC address to send share profile requests to.
      --store-address=STRING     gRPC address to send profiles and symbols to.
      --bearer-token=STRING      Bearer token to authenticate with store
                                 ($PARCA_BEARER_TOKEN).
      --bearer-token-file=STRING
                                 File to read bearer token from to authenticate
                                 with store.
      --insecure                 Send gRPC requests via plaintext instead of
                                 TLS.
      --insecure-skip-verify     Skip TLS certificate verification.
      --external-label=KEY=VALUE;...
                                 Label(s) to attach to all profiles in
                                 scraper-only mode.
      --grpc-headers=KEY

Frequently asked questions

Is parca free to use?

parca is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does parca do?

Continuous profiling for analysis of CPU and memory usage, down to the line number and throughout time. Saving infrastructure cost, improving performance, and i

What is parca written in?

parca is primarily written in TypeScript. Its source is publicly available at https://github.com/parca-dev/parca, and it has 4,971 GitHub stars.