signoz

SigNoz is an open-source observability platform native to OpenTelemetry with logs, traces and metrics in a single application. An open-source alternative to DataDog, NewRelic, etc. 🔥 🖥. 👉 Open source Application Performance Monitoring (APM) & Observability tool

18,859

1,227

18,859

1,270

View on GitHub

Top Related Projects

grafana

63,808

The open and composable observability and data visualization platform. Visualize metrics, logs, and traces from multiple sources like Prometheus, Loki, Elasticsearch, InfluxDB, Postgres and many more.

kibana

19,705

Your window into the Elastic Stack

prometheus

54,803

The Prometheus monitoring system and time series database.

jaeger

20,309

CNCF Jaeger, a Distributed Tracing Platform

skywalking

23,791

APM, Application Performance Monitoring System

Quick Overview

SigNoz is an open-source application performance monitoring (APM) and observability platform. It provides developers with a comprehensive solution for monitoring and troubleshooting their applications, offering features like distributed tracing, metrics, and logs management in a single, unified interface.

Pros

All-in-one solution for metrics, traces, and logs
User-friendly interface with customizable dashboards
Open-source and self-hosted, providing better data control and privacy
Compatible with OpenTelemetry, making it easy to integrate with existing systems

Cons

Relatively new project, may have fewer features compared to established commercial APM tools
Self-hosting requires more setup and maintenance compared to SaaS solutions
Limited community support and documentation compared to more mature projects
May require additional resources for deployment and scaling in large environments

Getting Started

To get started with SigNoz, follow these steps:

Clone the repository:

git clone https://github.com/SigNoz/signoz.git && cd signoz

Run the install script:

./deploy/docker/install.sh

Access the SigNoz UI at http://localhost:3301
To send data to SigNoz, instrument your application with OpenTelemetry. Here's an example for a Node.js application:

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const { Resource } = require('@opentelemetry/resources');
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');

const sdk = new NodeSDK({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'my-service',
  }),
  traceExporter: new OTLPTraceExporter({
    url: 'http://localhost:4318/v1/traces',
  }),
});

sdk.start();

For more detailed instructions and language-specific examples, refer to the SigNoz documentation.

Competitor Comparisons

grafana

63,808

Pros of Grafana

Extensive visualization options and customizable dashboards
Large ecosystem with numerous plugins and integrations
Mature project with a strong community and extensive documentation

Cons of Grafana

Steeper learning curve for complex configurations
Requires additional setup for full observability stack (e.g., Prometheus, Loki)

Code Comparison

Grafana (dashboard configuration):

{
  "panels": [
    {
      "type": "graph",
      "title": "CPU Usage",
      "datasource": "Prometheus",
      "targets": [
        { "expr": "node_cpu_usage_percent" }
      ]
    }
  ]
}

SigNoz (dashboard configuration):

{
  "panels": [
    {
      "type": "timeseries",
      "name": "CPU Usage",
      "query": "SELECT avg(cpu_usage_percent) FROM system_metrics"
    }
  ]
}

Summary

Grafana is a powerful and flexible visualization tool with a vast ecosystem, while SigNoz offers a more integrated, all-in-one observability solution. Grafana excels in customization and third-party integrations but may require more setup time. SigNoz provides a simpler, out-of-the-box experience for full-stack observability but may have fewer advanced features compared to Grafana's extensive plugin ecosystem.

kibana

19,705

Your window into the Elastic Stack

Pros of Kibana

Mature and widely adopted ecosystem with extensive documentation and community support
Powerful visualization capabilities and customizable dashboards
Seamless integration with other Elastic Stack components

Cons of Kibana

Steep learning curve and complex setup process
Resource-intensive, especially for large-scale deployments
Licensing costs for advanced features and enterprise support

Code Comparison

Kibana (JavaScript):

import { i18n } from '@kbn/i18n';
import { CoreSetup, CoreStart, Plugin } from '../../../core/public';
import { KibanaUsageCollectionSetup } from '../../../plugins/usage_collection/public';

export class MyPlugin implements Plugin {
  public setup(core: CoreSetup, plugins: { usageCollection?: KibanaUsageCollectionSetup }) {}
}

SigNoz (TypeScript):

import { Plugin, CoreSetup, CoreStart } from '../../../core/server';
import { PluginInitializerContext } from '../../../core/server';

export class SigNozPlugin implements Plugin {
  constructor(private readonly initializerContext: PluginInitializerContext) {}
  public async setup(core: CoreSetup) {}
}

Both repositories use similar plugin architectures, but SigNoz employs TypeScript for improved type safety. Kibana's codebase is more extensive due to its longer development history and broader feature set.

prometheus

54,803

The Prometheus monitoring system and time series database.

Pros of Prometheus

Mature and widely adopted monitoring system with extensive ecosystem support
Powerful query language (PromQL) for flexible data analysis
Built-in alerting capabilities

Cons of Prometheus

Steep learning curve for complex setups and configurations
Limited long-term storage options without additional components
Lacks built-in distributed tracing functionality

Code Comparison

Prometheus configuration (prometheus.yml):

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'example'
    static_configs:
      - targets: ['localhost:8080']

SigNoz configuration (docker-compose.yml):

version: '3'
services:
  clickhouse:
    image: clickhouse/clickhouse-server:22.8.8
  otel-collector:
    image: signoz/otel-collector:0.76.1
  query-service:
    image: signoz/query-service:0.25.0
  frontend:
    image: signoz/frontend:0.25.0

SigNoz offers a more integrated approach with distributed tracing and metrics in a single platform, while Prometheus focuses primarily on metrics monitoring. Prometheus has a larger community and ecosystem, but SigNoz provides an easier setup for full-stack observability. Both have their strengths, and the choice depends on specific monitoring requirements and infrastructure complexity.

jaeger

20,309

CNCF Jaeger, a Distributed Tracing Platform

Pros of Jaeger

More mature and widely adopted in the industry
Supports multiple storage backends (Cassandra, Elasticsearch, etc.)
Extensive documentation and community support

Cons of Jaeger

Requires additional components for a complete observability stack
Steeper learning curve for beginners
Limited built-in analytics and visualization capabilities

Code Comparison

Jaeger (Go):

tracer, closer := jaeger.NewTracer(
    "my-service",
    jaeger.NewConstSampler(true),
    jaeger.NewInMemoryReporter(),
)
defer closer.Close()

SigNoz (JavaScript):

const tracer = new opentelemetry.NodeTracerProvider({
  resource: new opentelemetry.Resource({
    [opentelemetry.SemanticResourceAttributes.SERVICE_NAME]: 'my-service',
  }),
});
tracer.register();

Both Jaeger and SigNoz are open-source distributed tracing systems, but they differ in their approach and features. Jaeger is a more established project with broader adoption and flexibility in storage options. However, it may require additional setup for a complete observability solution.

SigNoz, on the other hand, aims to provide a more comprehensive out-of-the-box experience with integrated metrics, traces, and logs. It offers a user-friendly interface and built-in analytics, making it easier for beginners to get started. However, it may have fewer storage options and a smaller community compared to Jaeger.

The code examples show the initialization of tracers in both systems, highlighting the different approaches and languages used (Go for Jaeger, JavaScript for SigNoz).

skywalking

23,791

APM, Application Performance Monitoring System

Pros of Skywalking

More mature project with a larger community and ecosystem
Supports a wider range of programming languages and frameworks
Offers more advanced features like service mesh observability and continuous profiling

Cons of Skywalking

Steeper learning curve and more complex setup process
Requires more resources to run and maintain
UI can be overwhelming for beginners due to its extensive features

Code Comparison

SigNoz (JavaScript):

const { trace } = require('@opentelemetry/api');
const tracer = trace.getTracer('my-service');

tracer.startActiveSpan('my-operation', (span) => {
  // Your code here
  span.end();
});

Skywalking (Java):

import org.apache.skywalking.apm.toolkit.trace.ActiveSpan;
import org.apache.skywalking.apm.toolkit.trace.TraceContext;

ActiveSpan.tag("key", "value");
String traceId = TraceContext.traceId();
ActiveSpan.error(new RuntimeException("Something wrong"));

Both SigNoz and Skywalking are open-source application performance monitoring (APM) tools. SigNoz focuses on simplicity and ease of use, making it a good choice for smaller teams or those new to observability. Skywalking offers more advanced features and broader language support, suitable for larger enterprises with complex infrastructures. The code examples show how to create and manage spans in each system, with Skywalking providing more built-in functionality for tagging and error handling.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

SigNoz

All your logs, metrics, and traces in one place. Monitor your application, spot issues before they occur and troubleshoot downtime quickly with rich context. SigNoz is a cost-effective open-source alternative to Datadog and New Relic. Visit signoz.io for the full documentation, tutorials, and guide.

Downloads GitHub issues

Documentation • ReadMe in Chinese • ReadMe in German • ReadMe in Portuguese • Slack Community • Twitter

Features

Application Performance Monitoring

Use SigNoz APM to monitor your applications and services. It comes with out-of-box charts for key application metrics like p99 latency, error rate, Apdex and operations per second. You can also monitor the database and external calls made from your application. Read more.

You can instrument your application with OpenTelemetry to get started.

apm-cover

Logs Management

SigNoz can be used as a centralized log management solution. We use ClickHouse (used by likes of Uber & Cloudflare) as a datastore, â¯ an extremely fast and highly optimized storage for logs data. Instantly search through all your logs using quick filters and a powerful query builder.

You can also create charts on your logs and monitor them with customized dashboards. Read more.

logs-management-cover

Distributed Tracing

Distributed Tracing is essential to troubleshoot issues in microservices applications. Powered by OpenTelemetry, distributed tracing in SigNoz can help you track user requests across services to help you identify performance bottlenecks.

See user requests in a detailed breakdown with the help of Flamegraphs and Gantt Charts. Click on any span to see the entire trace represented beautifully, which will help you make sense of where issues actually occurred in the flow of requests.

distributed-tracing-cover

Metrics and Dashboards

Ingest metrics from your infrastructure or applications and create customized dashboards to monitor them. Create visualization that suits your needs with a variety of panel types like pie chart, time-series, bar chart, etc.

Create queries on your metrics data quickly with an easy-to-use metrics query builder. Add multiple queries and combine those queries with formulae to create really complex queries quickly.

metrics-n-dashboards-cover

Alerts

Use alerts in SigNoz to get notified when anything unusual happens in your application. You can set alerts on any type of telemetry signal (logs, metrics, traces), create thresholds and set up a notification channel to get notified. Advanced features like alert history and anomaly detection can help you create smarter alerts.

Alerts in SigNoz help you identify issues proactively so that you can address them before they reach your customers.

alerts-cover

Exceptions Monitoring

Monitor exceptions automatically in Python, Java, Ruby, and Javascript. For other languages, just drop in a few lines of code and start monitoring exceptions.

See the detailed stack trace for all exceptions caught in your application. You can also log in custom attributes to add more context to your exceptions. For example, you can add attributes to identify users for which exceptions occurred.

exceptions-cover

Why SigNoz?

SigNoz is a single tool for all your monitoring and observability needs. Here are a few reasons why you should choose SigNoz:

Single tool for observability(logs, metrics, and traces)
Built on top of OpenTelemetry, the open-source standard which frees you from any type of vendor lock-in
Correlated logs, metrics and traces for much richer context while debugging
Uses ClickHouse (used by likes of Uber & Cloudflare) as datastore - an extremely fast and highly optimized storage for observability data
DIY Query builder, PromQL, and ClickHouse queries to fulfill all your use-cases around querying observability data
Open-Source - you can use open-source, our cloud service or a mix of both based on your use case

Getting Started

Create a SigNoz Cloud Account

SigNoz cloud is the easiest way to get started with SigNoz. Our cloud service is for those users who want to spend more time in getting insights for their application performance without worrying about maintenance.

Get started for free

Deploy using Docker(self-hosted)

Please follow the steps listed here to install using docker

The troubleshooting instructions may be helpful if you face any issues.

Deploy in Kubernetes using Helm(self-hosted)

Please follow the steps listed here to install using helm charts

We also offer managed services in your infra. Check our pricing plans for all details.

Join our Slack community

Come say Hi to us on Slack ð

Languages supported:

SigNoz supports all major programming languages for monitoring. Any framework and language supported by OpenTelemetry is supported by SigNoz. Find instructions for instrumenting different languages below:

You can find our entire documentation here.

Comparisons to Familiar Tools

SigNoz vs Prometheus

Prometheus is good if you want to do just metrics. But if you want to have a seamless experience between metrics, logs and traces, then current experience of stitching together Prometheus & other tools is not great.

SigNoz is a one-stop solution for metrics and other telemetry signals. And because you will use the same standard(OpenTelemetry) to collect all telemetry signals, you can also correlate these signals to troubleshoot quickly.

For example, if you see that there are issues with infrastructure metrics of your k8s cluster at a timestamp, you can jump to other signals like logs and traces to understand the issue quickly.

SigNoz vs Jaeger

Jaeger only does distributed tracing. SigNoz supports metrics, traces and logs - all the 3 pillars of observability.

Moreover, SigNoz has few more advanced features wrt Jaeger:

Jaegar UI doesnât show any metrics on traces or on filtered traces
Jaeger canât get aggregates on filtered traces. For example, p99 latency of requests which have tag - customer_type='premium'. This can be done easily on SigNoz
You can also go from traces to logs easily in SigNoz

SigNoz vs Elastic

SigNoz Logs management are based on ClickHouse, a columnar OLAP datastore which makes aggregate log analytics queries much more efficient
50% lower resource requirement compared to Elastic during ingestion

We have published benchmarks comparing Elastic with SigNoz. Check it out here

SigNoz vs Loki

SigNoz supports aggregations on high-cardinality data over a huge volume while loki doesnât.
SigNoz supports indexes over high cardinality data and has no limitations on the number of indexes, while Loki reaches max streams with a few indexes added to it.
Searching over a huge volume of data is difficult and slow in Loki compared to SigNoz

We have published benchmarks comparing Loki with SigNoz. Check it out here

Contributing

We â¤ï¸ contributions big or small. Please read CONTRIBUTING.md to get started with making contributions to SigNoz.

Not sure how to get started? Just ping us on #contributing in our slack community

Project maintainers

Backend

Frontend

DevOps

Documentation

You can find docs at https://signoz.io/docs/. If you need any clarification or find something missing, feel free to raise a GitHub issue with the label documentation or reach out to us at the community slack channel.

Community

Join the slack community to know more about distributed tracing, observability, or SigNoz and to connect with other users and contributors.

If you have any ideas, questions, or any feedback, please share on our Github Discussions

As always, thanks to our amazing contributors!

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot