Open-source project
parseablehq/parseable avatar
parseablehq/parseable

Parseable: the Makefile builds a server directory the tree does not contain

Parseable is an open source, unified infrastructure observability platform built in Rust on a data lake architecture. It tracks logs, metrics, traces, and events across apps, agents, and systems, reducing storage costs by up to 90% through columnar telemetry compression.

2,579 stars184 forksRustAGPL-3.0

At a glance

What is it?
Parseable is a Rust observability platform that keeps logs, metrics, traces and events as columnar data on object storage and ships as one binary. The install path is one line, and the default credentials sit in the quickstart in plain sight.
Who is it for?
Parseable fits a team that wants alerting, dashboards, anomaly detection, APM, PromQL and SQL from one binary with storage decoupled from compute, and that is willing to run an AGPL component. Before deploying it, three things are worth checking against your own setup.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • parseablehq/parseable2,579 ★ · +124
Star history
Repository2026-09-112026-11-15
parseablehq/parseable2.5k2.6k

124 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The quickstart publishes the default login in plain and encoded form

The ingest example that follows the installer is a complete request, and its authorization header carries the same pair the page names in prose:

bash
curl --location --request POST 'http://localhost:8000/api/v1/ingest' \
--header 'X-P-Stream: demo' \
--header 'Authorization: Basic YWRtaW46YWRtaW4=' \
--header 'Content-Type: application/json' \
--data-raw '[
    {
        "id": "434a5f5e-2f5f-11ed-a261-0242ac120002",
        "datetime": "24/Jun/2022:14:12:15 +0000",
        "host": "153.10.110.81"
    }
]'

The credential in that header is the base64 form of the administrator login, and the text below the block spells the same pair out and points the reader at the interface on port 8000. So the defaults are not merely implied by the example, they are printed on the page twice. The page does add that production deployments should follow the installation guide for hardening, which makes the order of operations the reader's problem: the sample is usable as written and the hardening note comes after it.

Both installers pipe a script from a short domain straight into a shell

Getting the binary is one line per platform:

bash
curl -fsSL https://logg.ing/install | bash
pwsh
powershell -c "irm https://logg.ing/install-windows | iex"

The Windows variant sits inside a collapsed section, and it fetches a differently named path from the same short domain. Neither route offers a checksum, a pinned version or an alternative such as a container image or a distribution package, so what a reader executes is whatever that host returns at the moment of the request. The only integrity mechanism described anywhere on the page applies after the download rather than to this step, and it is the subject of its own section below.

The Makefile points at a server directory and a chart the root does not have

The Makefile is small and every target names a path. The two Rust targets are:

code
fmt:
	cd server/src/ && cargo fmt

run:
	cd server && cargo run

The root listing has src, resources, scripts and systemd, and no server directory, so both of those targets change into a path the repository does not show. The two Helm targets have the same problem:

code
template:
	helm template parseable \
	helm/parseable \
	-f helm/parseable/values.yaml

upgrade:
	helm upgrade --install \
	parseable --namespace parseable \
	--create-namespace \
	helm/parseable \
	-f helm/parseable/values.yaml

A helm directory is not among the root entries either. Four of the four targets therefore reference locations that are not in the tree, which is the shape left behind when a monorepo is flattened and the build file is not updated with it.

The container builder runs Rust 1.96 while the manifest declares 1.94 as the floor

The manifest states the language floor and the build image states something higher:

code
rust-version = "1.94.0"
edition = "2024"
dockerfile
FROM rust:1.96.0-bookworm AS builder
WORKDIR /parseable
COPY . .
RUN cargo build --release

A gap between the two is not a conflict, since the image satisfies the floor, but it does mean a build on the declared minimum is never exercised by the container path. The runtime stage is a distroless Debian 12 image referenced by its moving tag, which means the base is not fixed by digest and two builds of the same commit are not guaranteed to produce the same filesystem. That image has no shell, so anything an operator expects to run inside the container has to come from elsewhere.

The maintainer address is one domain in the manifest and another in the image label

The two files disagree on the contact address. The manifest lists the authors as Parseable Team at an address on parseable.com, while the image carries labels setting the maintainer to Parseable Team at an address on parseable.io, with the vendor given as Parseable Inc and the licence declared as AGPL-3.0. Both are one word apart and neither is marked as a former address. The licence header at the top of the image also dates itself 2022 to 2025, which is a year behind the releases it ships, and the licence itself is the AGPL, matching the licence recorded for the repository and the licence file at the root.

The dependency stack is Arrow and DataFusion with four cloud backends enabled

The storage and query layer is visible in the manifest. Every Arrow crate is required at 59.2.0, DataFusion and its proto crate at 55.0.0, and Parquet at 59.2.0, which is what a columnar telemetry store on object storage is built from. The object store crate is where the backends are chosen, and it is enabled with four feature groups at once:

code
object_store = { version = "0.13.2", features = [
    "cloud",
    "aws",
    "azure",
    "gcp",
] }

Serving is Actix with the rustls backend rather than a native TLS stack, and the gRPC side carries gzip and zstd alongside Arrow Flight with its own TLS features. Kafka support is optional and builds librdkafka from source with cmake-build and static zlib, with sasl2 vendored, and the MSK IAM signer sits beside it for token signing. Password hashing is argon2. A test compose file named for Google Cloud Storage exists at the root, which is the fourth backend exercised somewhere in the repository.

The storage saving figure sits in the repository description, not on the page

The repository description claims storage costs reduced by up to ninety percent through columnar telemetry compression. The page itself makes no such claim in prose. What it does instead is link onward, to separate pages for the architecture, the features, and a benchmarks section, so the figure has to be taken on the strength of a document this page does not reproduce. The other numbers on the page are smaller and checkable: a fourteen day trial of the hosted version with no credit card, and a set of release tags three patch releases apart. Three releases are listed within a single week, two of them named as bugfix releases and the newest carrying only its own version number.

Six compose files, five Dockerfiles and a proxy config share the root

The root is wide rather than deep. Five Dockerfiles sit at the top, covering the release build, a debug variant, a development variant and a Kafka-specific one. Six compose files accompany them: one for a local run, one plain test, one test with Kafka, and three distributed variants including one with Kafka and one pointed at Google Cloud Storage. A parseable-ingest-haproxy.cfg sits beside them, so load balancing in front of the ingest path is anticipated rather than left to a reverse proxy of the operator's choosing. Around those are Cross.toml for cross-compilation, a systemd directory for a unit file, a scripts directory, a resources directory, a static analysis configuration, a citation file and a USERS.md listing who runs it.

Editorial conclusion

Parseable fits a team that wants alerting, dashboards, anomaly detection, APM, PromQL and SQL from one binary with storage decoupled from compute, and that is willing to run an AGPL component. Before deploying it, three things are worth checking against your own setup. The quickstart credentials are the defaults, published in the page in both plain and encoded form, so hardening has to happen before anything else is exposed. The container image is built on a base pinned to a moving tag, which means two builds from the same commit are not the same artifact. And the Makefile points at a server directory and a helm chart that the repository root does not contain, so the build and chart targets cannot be taken at face value until someone confirms where those moved to.

Frequently asked questions

How do I install Parseable?

One line per platform: curl piped into bash on Unix, and a PowerShell command fetching a separate install-windows path on Windows. The page offers no checksum, pinned version, container route or distribution package at that step.

What are the default credentials for the Parseable interface?

The quickstart names the administrator login in prose and repeats it as a base64 Basic authorization header in its ingest example. The page points readers to the installation guide for production hardening.

How do I verify a Parseable download?

Builds are attested with the attest-build-provenance action, and verification needs the GitHub CLI: gh attestation verify against the parseablehq/parseable repository with the path to your binary.

Which telemetry can Parseable ingest?

Logs, metrics, traces and events, sent through logging agents, OpenTelemetry, Kafka or eBPF. OpenTelemetry support is described as native, with Parseable usable as a drop-in replacement for an existing collector setup.

Which object storage backends does Parseable support?

The object store dependency is enabled with cloud, aws, azure and gcp features together, and the repository ships a distributed test compose file pointed at Google Cloud Storage alongside ones for local and Kafka runs.

Official sources

  1. License: AGPL-3.0
  2. parseablehq/parseable on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/parseablehq-parseable.svg)](https://hysenlabs.com/projects/parseablehq-parseable)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/parseablehq-parseable.svg)](https://hysenlabs.com/projects/parseablehq-parseable)

Was this useful?