When this skill is activated, always start your first response with the 🧢 emoji.

SigNoz

SigNoz is an open-source observability platform that unifies traces, metrics, and logs in a single backend powered by ClickHouse. Built natively on OpenTelemetry, it provides APM dashboards, distributed tracing with flamegraphs, log management with pipelines, custom metrics, alerting across all signals, and exception monitoring - all without vendor lock-in. SigNoz is available as a managed cloud service or self-hosted via Docker or Kubernetes.

When to use this skill

Trigger this skill when the user:

• Wants to set up or configure SigNoz (cloud or self-hosted)
• Needs to instrument an application to send traces, logs, or metrics to SigNoz
• Asks about OpenTelemetry Collector configuration for SigNoz
• Wants to create dashboards, panels, or visualizations in SigNoz
• Needs to configure alerts (metric, log, trace, or anomaly-based) in SigNoz
• Asks about SigNoz query builder syntax, aggregations, or filters
• Wants to monitor exceptions or correlate traces with logs in SigNoz
• Is migrating from Datadog, Grafana, New Relic, or ELK to SigNoz

Do NOT trigger this skill for:

• General observability concepts without SigNoz context (use the observability skill)
• OpenTelemetry instrumentation not targeting SigNoz as the backend

Setup & authentication

SigNoz Cloud

Sign up at https://signoz.io/teams/ to get a cloud instance. You will receive:

• A region endpoint (e.g. ingest.us.signoz.cloud:443)
• A SIGNOZ_INGESTION_KEY for authenticating data

Self-hosted deployment

# Docker Standalone (quickest for local/dev)
git clone -b main https://github.com/SigNoz/signoz.git && cd signoz/deploy/
docker compose -f docker/clickhouse-setup/docker-compose.yaml up -d

# Kubernetes via Helm
helm repo add signoz https://charts.signoz.io
helm install my-release signoz/signoz

Self-hosted supports Docker Standalone, Docker Swarm, Kubernetes (AWS/GCP/Azure/ DigitalOcean/OpenShift), and native Linux installation.

Environment variables

# For cloud - set these in your OTel Collector or SDK exporter config
SIGNOZ_INGESTION_KEY=your-ingestion-key
OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.<region>.signoz.cloud:443
OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key=<your-ingestion-key>

Core concepts

SigNoz uses OpenTelemetry as its sole data ingestion layer. All telemetry (traces, metrics, logs) flows through an OTel Collector which receives data via OTLP (gRPC on port 4317, HTTP on 4318), processes it with batching and resource detection, and exports it to SigNoz's ClickHouse storage backend.

The data model has three pillars:

• Traces - Distributed request flows visualized as flamegraphs and Gantt charts. Each trace contains spans with attributes, events, and status codes.
• Metrics - Time-series data from application instrumentation (p99 latency, error rates, Apdex) and infrastructure (CPU, memory, disk, network via hostmetrics receiver).
• Logs - Structured log records ingested via OTel SDKs, FluentBit, Logstash, or file-based collection. Processed through log pipelines for parsing and enrichment.

All three signals correlate - traces link to logs via trace IDs, and exceptions embed in spans. The Query Builder provides a unified interface for filtering, aggregating, and visualizing across all signal types.

Common tasks

Instrument a Node.js app

npm install @opentelemetry/api \
  @opentelemetry/sdk-node \
  @opentelemetry/auto-instrumentations-node \
  @opentelemetry/exporter-trace-otlp-grpc

const { NodeSDK } = require("@opentelemetry/sdk-node");
const { getNodeAutoInstrumentations } = require("@opentelemetry/auto-instrumentations-node");
const { OTLPTraceExporter } = require("@opentelemetry/exporter-trace-otlp-grpc");

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4317",
  }),
  instrumentations: [getNodeAutoInstrumentations()],
});

sdk.start();

Supported languages: Java, Python, Go, .NET, Ruby, PHP, Rust, Elixir, C++, Deno, Swift, plus mobile (React Native, Android, iOS, Flutter) and frontend.

Configure the OTel Collector for SigNoz

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
  hostmetrics:
    collection_interval: 60s
    scrapers:
      cpu: {}
      memory: {}
      disk: {}
      load: {}
      network: {}
      filesystem: {}

processors:
  batch:
    send_batch_size: 1000
    timeout: 10s
  resourcedetection:
    detectors: [env, system]
    system:
      hostname_sources: [os]

exporters:
  otlp:
    endpoint: "ingest.<region>.signoz.cloud:443"
    tls:
      insecure: false
    headers:
      signoz-ingestion-key: "${SIGNOZ_INGESTION_KEY}"

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch, resourcedetection]
      exporters: [otlp]
    metrics:
      receivers: [otlp, hostmetrics]
      processors: [batch, resourcedetection]
      exporters: [otlp]
    logs:
      receivers: [otlp]
      processors: [batch, resourcedetection]
      exporters: [otlp]

For self-hosted, replace the endpoint with your SigNoz instance URL and remove the headers section.

Send logs to SigNoz

Three approaches:

1. OTel SDK - Instrument application code directly with OpenTelemetry logging SDK
2. File-based - Use FluentBit or Logstash to tail log files and forward via OTLP
3. Stdout/collector - Pipe container stdout to the OTel Collector's filelog receiver

# FluentBit output to SigNoz via OTLP
[OUTPUT]
    Name        opentelemetry
    Match       *
    Host        ingest.<region>.signoz.cloud
    Port        443
    Header      signoz-ingestion-key <your-key>
    Tls         On
    Tls.verify  On

Log pipelines in SigNoz can parse, transform, enrich, drop unwanted logs, and scrub PII before storage.

Create dashboards and panels

Navigate to Dashboards > New Dashboard. Add panels using the Query Builder:

1. Select signal type (metrics, logs, or traces)
2. Add filters (e.g. service.name = my-app)
3. Choose aggregation (Count, Avg, P99, Rate, etc.)
4. Group by attributes (e.g. method, status_code)
5. Set visualization type (time series, bar, pie chart, table)

Use {{attributeName}} in legend format for dynamic labels. Multiple queries can be combined with mathematical functions (log, sqrt, exp, time shift).

SigNoz provides pre-built dashboard JSON templates on GitHub that can be imported.

Configure alerts

SigNoz supports six alert types:

• Metrics-based - threshold on any metric
• Log-based - patterns, counts, or attribute values
• Trace-based - latency or error rate thresholds
• Anomaly-based - automatic anomaly detection
• Exceptions-based - exception count or type thresholds
• Apdex alerts - application performance index

Notification channels include Slack, PagerDuty, email, and webhooks. Alerts support routing policies and planned maintenance windows. A Terraform provider is available for infrastructure-as-code alert management.

Monitor exceptions

Exceptions are auto-recorded for Python, Java, Ruby, and JavaScript. For other languages, record manually:

from opentelemetry import trace

tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("operation") as span:
    try:
        risky_operation()
    except Exception as ex:
        span.record_exception(ex)
        span.set_status(trace.StatusCode.ERROR, str(ex))
        raise

Exceptions group by service name, type, and message. Enable low_cardinal_exception_grouping in the clickhousetraces exporter to group only by service and type (reduces high cardinality from dynamic messages).

Query with the Query Builder

# Filter: service.name = demo-a