SigNoz — Open Source APM & Observability Platform

What SigNoz Does

• Distributed Tracing: End-to-end request tracing across microservices with flame graphs and Gantt charts
• Metrics Monitoring: Application and infrastructure metrics with custom dashboards
• Log Management: Structured and unstructured log aggregation with full-text search
• Alerts: Threshold and anomaly-based alerts with Slack, PagerDuty, and webhook notifications
• Service Maps: Auto-generated topology showing service dependencies and health
• Exception Tracking: Group and track application exceptions with stack traces
• OpenTelemetry Native: First-class support for OpenTelemetry — no proprietary agents

Architecture

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  Your Apps   │────▶│  OTel        │────▶│  SigNoz      │
│  (OTel SDK)  │     │  Collector   │     │  Query       │
└──────────────┘     └──────────────┘     │  Service     │
                                          └──────┬───────┘
┌──────────────┐                                 │
│  SigNoz UI   │◀────────────────────────────────┘
│  (React)     │                          ┌──────┴───────┐
└──────────────┘                          │  ClickHouse  │
                                          │  (Storage)   │
                                          └──────────────┘

Self-Hosting

Docker Compose

git clone https://github.com/SigNoz/signoz.git
cd signoz/deploy
docker compose -f docker/clickhouse-setup/docker-compose.yaml up -d

This starts: SigNoz frontend, query service, OTel collector, alert manager, and ClickHouse.

Kubernetes (Helm)

helm repo add signoz https://charts.signoz.io
helm install signoz signoz/signoz --namespace signoz --create-namespace

Instrumenting Your App

Python (Flask)

# pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(
    OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
))
trace.set_tracer_provider(provider)
tracer = trace.get_tracer(__name__)

@app.route("/api/users")
def get_users():
    with tracer.start_as_current_span("fetch-users"):
        users = db.query("SELECT * FROM users")
        return jsonify(users)

Node.js

// npm install @opentelemetry/api @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-grpc
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-grpc');

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'http://localhost:4317',
  }),
});
sdk.start();

Go

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
)

exporter, _ := otlptracegrpc.New(ctx,
    otlptracegrpc.WithEndpoint("localhost:4317"),
    otlptracegrpc.WithInsecure(),
)
// Set up tracer provider with exporter

Key Features

Distributed Tracing

Visualize request flow across services:

User Request → API Gateway (12ms)
  → Auth Service (5ms)
  → User Service (45ms)
    → PostgreSQL Query (30ms)
    → Redis Cache Set (2ms)
  → Response (62ms total)

Flame graph and Gantt chart views show exactly where time is spent.

Log Management

Query: service=api-gateway AND status>=500 AND latency>1000ms
  → Filter by time range, severity, service
  → Correlate logs with traces (click log → see trace)
  → Create alerts on log patterns

Dashboards

Pre-built dashboards for:

• Application: P99 latency, error rate, throughput (RED metrics)
• Infrastructure: CPU, memory, disk, network per host
• Database: Query latency, connection pool, slow queries
• Custom: Build with PromQL-compatible query builder

SigNoz vs Alternatives

FAQ

Q: How does SigNoz compare to Grafana + Prometheus + Loki + Tempo? A: The Grafana stack requires deploying and operating four separate components. SigNoz is a single platform where logs, traces, and metrics are natively correlated — simpler to deploy and run. Grafana's strengths are a more mature ecosystem and more flexible dashboards.

Q: How does the ClickHouse backend perform? A: ClickHouse is a columnar database ideally suited to time-series queries. SigNoz efficiently handles hundreds of thousands of span writes per second and returns queries over billions of rows in seconds — 3–5× more storage-efficient than Elasticsearch.

Q: Do I need to change my application code? A: You do need to add the OpenTelemetry SDK to instrument your app. Most frameworks have auto-instrumentation libraries — just a few lines of configuration. It's a standard practice and doesn't lock you into SigNoz.

Sources & Credits

• GitHub: SigNoz/signoz — 26.5K+ ⭐
• Website: signoz.io