[opensourcedex]

Gigapipe is a free, open source monitoring & observability project written in Go and released under AGPL-3.0. It has 1,706 GitHub stars, 102 forks and 16 open issues, and was last pushed 7 hours ago. On this registry it ranks #86 of 97 tracked projects in Monitoring & Observability, with 5 head-to-head comparisons available. It gained 1 stars over the last 6 tracked days.

What is Gigapipe?

What it is

Gigapipe is an open-source observability warehouse written in Go under the AGPL-3.0 license. The project, formerly known as qryn, combines logs, metrics, traces, and profiling in one stack, and it presents itself as a lightweight, cloud-native, drop-in alternative to Grafana LGTMP.

The concrete problem it addresses is the need to collect and query multiple telemetry signals without assembling separate tools for each signal. Gigapipe implements popular observability standards, protocols, and query languages, so teams can ingest OpenTelemetry data or push data through native Loki, Prometheus, Tempo, Pyroscope, Influx, Datadog, and Elastic APIs while retaining control of data in ClickHouse, DuckDB, or GigAPI with S3 object storage.

Key capabilities

  • Gigapipe ingests logs, metrics, traces, and profiling data through OpenTelemetry and through native Loki, Prometheus, Tempo/Zipkin, Pyroscope, Influx, Datadog, and Elastic APIs.
  • It supports LogQL, PromQL, TempoQL, and TraceQL as query paths for data that arrives through compatible ingestion routes.
  • It implements the Loki API for transparent compatibility with LogQL clients, and the Grafana Loki datasource can browse logs and display extracted timeseries without plugins.
  • It provides an OTLP over gRPC receiver for traces, logs, metrics, and profiles, plus OTLP metrics ingestion at /v1/metrics and OTLP profiles ingestion at /v1development/profiles.
  • It stores telemetry in ClickHouse, DuckDB, or GigAPI with S3 object storage, and it includes a built-in Explorer and CLI alongside native Grafana datasource compatibility.
  • It exposes Loki index statistics at /loki/api/v1/index/stats, returning stream count, entry count, byte volume, and chunk count, and its Tail service supports limit and start parameters with dropped_entries in WebSocket responses.

Who uses it and how

  • Operators deploy Gigapipe on premises as a self-hosted observability warehouse for logs, metrics, traces, and profiling.
  • Teams already using Loki-compatible clients can point those clients at Gigapipe and query logs through LogQL or the Grafana Loki datasource.
  • Teams using OpenTelemetry instrumentation can send logs, traces, metrics, and profiles to Gigapipe without modifying the instrumentation.
  • Teams using Prometheus, Tempo, or Pyroscope can push data through native APIs and use the supported query languages, profiling endpoints, DOT export, and Graphviz visualization.
  • Teams without Grafana can use the built-in Explorer and CLI to inspect telemetry data.

Getting started

Users can deploy the open-source project through Docker using the documented environment variables, Docker quickstart, and cross-cluster setup, or they can try a free trial at gigapipe.com.

When to use it — and when not to

Gigapipe suits teams that want an open-source, self-hosted alternative to Grafana LGTMP and vendor controlled observability stacks, especially when they can operate ClickHouse, DuckDB, or GigAPI with S3 storage. The repository lists zero contributors, a zero-year age, and sixteen open issues, so teams that need a mature project profile may need to evaluate compatibility and operations carefully.

project readme (upstream, from github) — read inline

Gigapipe: All-In-One Polyglot Observability

formerly known as qryn

 

CI+CD CodeQL GitHub Repo stars

:rocket: Gigapipe is a lighweight, multi-standard, polyglot observability stack for Logs, Metrics, Traces and Profiling

  • Polyglot: All-in-one, drop-in compatible with Loki, Prometheus, Tempo, Pyroscope
  • Familiar: Use stable & popular LogQL, PromQL, TempoQL languages to query and visualize data
  • Voracious: Ingest using OpenTelemetry, Loki, Prometheus, Tempo, Influx, Datadog, Elastic + more
  • Versatile: Explore data with qryn's built-in Explorer and CLI or native Grafana datasource compatibility
  • Secure: Retain total control of data, using ClickHouse, DuckDB or GigAPI with S3 object storage
  • Independent: Open source, community powered, anti lock-in alternative to vendor controlled stacks

🚀 Get Started

  • Setup & Deploy gigapipe opensource and get help in our Matrix room :octocat:
  • Looking for a quick test before installing? Signup for a free trial at gigapipe.com

📚 Documentation

Features

💡 gigapipe independently implements popular observability standards, protocols and query languages

➡️ Ingestion

📚 OpenTelemetry

⚡ gigapipe is officially integrated with OpenTelemetry supports any log, trace or metric format
Ingested data can be queried using any of the available gigapipe APIs (LogQL, PromQL, TraceQL)

💡 No modifications required to your OpenTelemetry instrumentation!

📚 Native APIs

gigapipe supports native ingestion for Loki, Prometheus, Tempo/Zipkin, Pyroscope and many other protocols
With gigapipe integrators can push and read data using any desired combination of APIs and formats

💡 No opentelemetry or any other middlewayre/proxy required!


⬅️ Query

📚 Loki + LogQL

Any Loki compatible client or application can be used with gigapipe out of the box

⚡ gigapipe implements the Loki API for transparent compatibility with LogQL clients

The Grafana Loki datasource can be used to natively browse and query logs and display extracted timeseries

:tada: No plugins needed
:eye: No Grafana? No problem! Use View

Index Stats & Enhanced Tail

Index statistics: Query stream metadata using /loki/api/v1/index/stats to retrieve stream count, entry count, byte volume, and chunk count. Supports LogQL stream selectors for filtering:

GET /loki/api/v1/index/stats?query={job="app"}&start=<ns>&end=<ns>

Enhanced live-tail: The Tail service now supports limit and start query parameters for controlling tail behavior. The limit parameter caps the number of entries returned, and start sets the starting timestamp (in nanoseconds). WebSocket responses include a dropped_entries field indicating when entries were dropped due to backpressure:

{
  "streams": [...],
  "dropped_entries": []
}

📈 Prometheus + PromQL

Any Prometheus compatible client or application can be used with gigapipe out of the box

⚡ gigapipe implements the Prometheus API for transparent PromQL compatibility using WASM 🏆

The Grafana Prometheus datasource can be used to natively to query metrics and display timeseries

:tada: No plugins needed
:eye: No Grafana? No problem! Use View


🕛 Tempo + TraceQL

⚡ gigapipe implements the Tempo API for transparent compatibility with TraceQL clients.

Any Tempo/OpenTelemetry compatible client or application can be used with gigapipe out of the box

The Tempo datasource can be used to natively query traces including TraceQL and supporting service graphs

:tada: No plugins needed
:eye: No Grafana? No problem! Use View

TraceQL Metrics

gigapipe supports TraceQL metrics endpoints for calculating metrics from trace data. Calculate error rates, latency distributions, and throughput directly from traces using TraceQL queries.

Metrics endpoints:

  • /api/metrics/query_range - range queries over a time window
  • /api/metrics/query - instant queries at a specific time

Parameters:

  • q or query - TraceQL query string (required)
  • start - start timestamp (unix seconds, nanoseconds, or RFC3339)
  • end - end timestamp (same format as start)
  • since - relative time duration (e.g., "1h", "30m") - alternative to start/end
  • step - query resolution (e.g., "15s", "1m") - auto-calculated if not specified

Example:

GET /api/metrics/query_range?q={span.http.status_code=200}&since=1h&step=1m

This query calculates span counts for successful HTTP requests over the last hour with 1-minute resolution.


🔥 Pyroscope + Phlare

⚡ gigapipe implements the Pyroscope API for transparent compatibility with Pyroscope SDK clients.

Any Pyroscope SDK client or Pyroscope compatible agent can be used with gigapipe out of the box for continuous profiling

OTLP Profiles Ingestion

⚡ gigapipe also ingests the OpenTelemetry profiles signal (profiles/v1development) directly from OpenTelemetry collectors:

POST /v1development/profiles      Content-Type: application/x-protobuf

💡 No collector code changes required — point an otlphttp exporter at gigapipe and profiles flow in.

OTLP profiles land in the same ClickHouse profiles tables as Pyroscope data and are queryable through the existing Pyroscope-compatible API (flamegraph, series, stacktraces). See docs/otlp-profiles.md for details.

DOT Graph Rendering

The Render endpoint (/render?format=dot) generates Graphviz DOT format graphs for profiling visualization with enhanced readability:

Features:

  • maxNodes parameter: Limit the number of nodes displayed in DOT graphs (0 = unlimited). Use this to control graph complexity for large profiles.
    GET /render?query=...&from=...&until=...&format=dot&maxNodes=50
  • Human-readable values: Automatically formats values based on unit type (e.g., "1.23s" for durations, "1.23 MB" for memory)
  • Variable font sizes: Node font size scales from 8pt to 24pt

readme truncated — read the full docs on github

Frequently asked questions

Is Gigapipe free to use?

Gigapipe is open source under the AGPL-3.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 Gigapipe do?

All-in-one observability with unlimited data ingestion

What is Gigapipe written in?

Gigapipe is primarily written in Go. Its source is publicly available at https://github.com/metrico/gigapipe, and it has 1,706 GitHub stars.