awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

Self-Hosted-Backends für Distributed Tracing

Ranking aktualisiert am 30. Juni 2026

For selbstgehostetes System für Distributed Tracing, the strongest matches are grafana/tempo (Grafana Tempo is a self-hostable distributed tracing backend that), jaegertracing/jaeger (Jaeger is a mature, self-hostable distributed tracing platform that) and signoz/signoz (SigNoz is a self-hostable full-stack observability platform that collects). uptrace/uptrace and openzipkin/zipkin round out the shortlist. Each is ranked by relevance to your query, popularity and recent activity.

Open-Source-Plattformen zum Sammeln, Speichern und Visualisieren von verteilten Trace-Daten in der eigenen Infrastruktur.

Self-Hosted-Backends für Distributed Tracing

Finde die besten Repos mit KI.Wir suchen mit KI nach den am besten passenden Repositories.
  • grafana/tempoAvatar von grafana

    grafana/tempo

    5,079Auf GitHub ansehen↗

    Grafana Tempo is a high-scale distributed tracing backend and columnar trace database. It serves as an observability data store that persists and queries spans and traces using OpenTelemetry standards, allowing for the analysis of request flows across microservices. The system distinguishes itself by using an object-store based backend with columnar Parquet storage. This architecture enables efficient attribute searching and large-scale data retrieval through dedicated attribute columnization and block-based data partitioning. It includes a specialized TraceQL query engine for filtering trace

    Grafana Tempo is a self-hostable distributed tracing backend that ingests and stores traces via OpenTelemetry, provides a TraceQL query engine for trace analysis, and integrates with Grafana for service dependencies and sampling, making it a comprehensive fit for collecting and querying distributed traces from microservices.

    GoOpenTelemetry ComplianceTrace QueryingDistributed Tracing Backends
    Auf GitHub ansehen↗5,079
  • jaegertracing/jaegerAvatar von jaegertracing

    jaegertracing/jaeger

    22,890Auf GitHub ansehen↗

    Jaeger is a distributed tracing platform used for collecting, storing, and visualizing request flows across microservices. It identifies performance bottlenecks and errors by tracking requests as they move through multiple service boundaries. The system includes telemetry collectors, a multi-tenant backend, and a trace visualizer. The platform provides a multi-tenant tracing infrastructure that isolates data and queries by tenant to support shared environments. It supports standardized telemetry ingestion via the OpenTelemetry Protocol over gRPC and HTTP. To manage storage costs and overhead,

    Jaeger is a mature, self-hostable distributed tracing platform that collects, stores, and queries traces via OpenTelemetry Protocol, with built-in service dependency graphs, adaptive sampling, and multi-tenant support — covering every feature this search requires.

    GoTrace SamplingAdaptive SamplingDistributed Tracing Backends
    Auf GitHub ansehen↗22,890
  • signoz/signozAvatar von SigNoz

    SigNoz/signoz

    27,355Auf GitHub ansehen↗

    SigNoz is a full-stack observability platform designed to collect, store, and visualize metrics, logs, and distributed traces in a unified environment. It leverages OpenTelemetry-based data collection to ingest telemetry from diverse sources using vendor-neutral protocols, ensuring interoperability across complex microservices architectures. The platform utilizes a high-performance columnar storage engine to enable rapid aggregation and filtering, providing a centralized backend for monitoring application health and performance. What distinguishes the platform is its focus on automated instru

    SigNoz is a self-hostable full-stack observability platform that collects, stores, and visualizes distributed traces via OpenTelemetry, directly matching your need for a trace backend with support for service dependency mapping and multi-language instrumentation.

    TypeScriptService Dependency MappingDistributed Tracing BackendsLanguage-Specific Instrumentation
    Auf GitHub ansehen↗27,355
  • uptrace/uptraceAvatar von uptrace

    uptrace/uptrace

    4,098Auf GitHub ansehen↗

    Uptrace is an OpenTelemetry-based observability platform designed to collect, store, and analyze distributed traces, metrics, and logs. It functions as a centralized logging backend, a distributed tracing system, and a metrics engine to monitor application performance and system health. The platform is distinguished by AI-powered operational capabilities, allowing users to query telemetry data and manage monitoring dashboards using natural language. It specifically includes specialized monitoring for generative AI pipelines, tracking token usage and response quality for LLM interactions and r

    Uptrace is a self-hostable, OpenTelemetry-native observability platform that provides distributed trace collection, storage, and querying along with service dependency graphs and multi-language support, making it an excellent fit for a self-hosted distributed tracing backend.

    GoOpenTelemetry IngestionOTLP IngestionService Dependency Mapping
    Auf GitHub ansehen↗4,098
  • openzipkin/zipkinAvatar von openzipkin

    openzipkin/zipkin

    17,431Auf GitHub ansehen↗

    Zipkin is an open-source distributed tracing system designed to collect, store, and visualize timing data across complex service architectures. It provides a platform for monitoring request lifecycles, enabling developers to identify latency bottlenecks and performance issues by tracking operations as they move through heterogeneous service environments. The system distinguishes itself through a standardized data model and a pluggable storage architecture that supports various backend databases. It utilizes sampling strategies to manage telemetry volume and employs asynchronous collection met

    Zipkin is a self-hostable distributed tracing backend that collects, stores, and visualizes traces with dependency graphs and sampling controls, but it does not natively support OpenTelemetry Protocol ingestion—instead accepting spans in its own Zipkin format, which may need an adapter for full OTel integration.

    JavaService Dependency MappingTrace QueryingTrace Sampling
    Auf GitHub ansehen↗17,431
  • apache/incubator-skywalkingAvatar von apache

    apache/incubator-skywalking

    24,832Auf GitHub ansehen↗

    SkyWalking is a comprehensive observability stack and application performance monitoring platform. It functions as a distributed tracing system and an AI application monitor, providing a centralized suite for collecting and analyzing logs, metrics, and traces to maintain the health of containerized architectures. The platform distinguishes itself through a service topology visualizer that renders interactive maps of infrastructure dependencies and communication patterns. It also includes specialized capabilities for generative AI workflow observation to track the execution flow and performanc

    SkyWalking is a full-featured self-hostable distributed tracing backend that supports OpenTelemetry ingestion, trace storage and querying, service topology mapping, sampling controls, and multi-language agents, making it an excellent match for your requirements.

    JavaService Dependency Mapping
    Auf GitHub ansehen↗24,832
  • hyperdxio/hyperdxAvatar von hyperdxio

    hyperdxio/hyperdx

    9,324Auf GitHub ansehen↗

    HyperDX is an OpenTelemetry observability platform that provides centralized log management, distributed tracing, and a self-hosted monitoring stack. It functions as a unified system for collecting, indexing, and visualizing logs, metrics, and traces from cloud and container environments. The platform distinguishes itself with specialized tooling for large language model monitoring and session replay, allowing user interactions in the browser to be linked to backend telemetry. It employs schema-less JSON parsing to index structured logs dynamically and uses source maps to resolve minified sta

    HyperDX is a self-hosted OpenTelemetry observability platform that includes distributed trace collection, storage, and querying, along with a full monitoring stack covering logs, metrics, and session replay — directly fitting the need for a self-hostable backend with OpenTelemetry protocol support and multi-language instrumentation.

    TypeScriptOpenTelemetry IngestionSelf-Hosted Deployment Platforms
    Auf GitHub ansehen↗9,324
  • apache/skywalkingAvatar von apache

    apache/skywalking

    24,839Auf GitHub ansehen↗

    SkyWalking is an application performance monitoring system and observability platform designed to collect and analyze metrics, traces, and logs from distributed microservices. It functions as a distributed tracing platform and a telemetry data pipeline that ingests and aggregates observability data from various language agents. The project features an AI-powered anomaly detector that uses machine learning to calculate metric baselines and identify irregular URI patterns. It includes an eBPF performance profiler for diagnosing CPU and network bottlenecks at the kernel level and generates inter

    Apache SkyWalking is a self-hostable distributed tracing backend and observability platform that natively supports OpenTelemetry, provides trace storage and querying with service dependency graphs, sampling controls, and multi-language instrumentation agents, making it an ideal fit for collecting and analyzing distributed traces.

    JavaService Dependency Mapping
    Auf GitHub ansehen↗24,839
  • quickwit-oss/quickwitAvatar von quickwit-oss

    quickwit-oss/quickwit

    11,345Auf GitHub ansehen↗

    Quickwit is a cloud-native, distributed search engine designed for observability data such as logs, traces, and metrics. It functions as an observability backend that decouples compute from storage by persisting indices directly in S3-compatible cloud object stores. The system is distinguished by its compatibility with the Elasticsearch REST API, allowing it to integrate with existing clients and log shippers without reconfiguration. It also serves as an OpenTelemetry data indexer, ingesting technical data via the OpenTelemetry Protocol using gRPC and HTTP. The engine utilizes a hybrid of co

    Quickwit is a self-hostable observability backend that ingests traces via the OpenTelemetry protocol and supports trace storage and querying, aligning with your need for a distributed tracing backend, though it lacks prominent built-in service dependency graphs and sampling controls, and its broader focus on logs and metrics means it is not a dedicated tracing-only system.

    RustOpenTelemetry IngestionOTLP Ingestion
    Auf GitHub ansehen↗11,345
  • pinpoint-apm/pinpointAvatar von pinpoint-apm

    pinpoint-apm/pinpoint

    13,830Auf GitHub ansehen↗

    Pinpoint is a distributed application performance management tool designed to trace requests and monitor metrics across large-scale distributed architectures. It functions as a request tracer, topology mapper, and JVM application monitor, providing a backend capable of collecting and visualizing trace data from OpenTelemetry compatible sources. The system distinguishes itself through a combination of bytecode-based instrumentation via a Java agent and topology-based visualization that renders live maps of service interconnections. It captures execution flow across asynchronous boundaries, suc

    Pinpoint is a self-hostable distributed tracing backend that collects, stores, and queries traces via OpenTelemetry, provides a service dependency graph, and includes sampling controls—directly matching the intent.

    JavaDistributed Tracing Backends
    Auf GitHub ansehen↗13,830
  • getsentry/sentryAvatar von getsentry

    getsentry/sentry

    44,108Auf GitHub ansehen↗

    This project is a comprehensive software observability suite and application performance monitoring platform designed to track runtime errors, performance bottlenecks, and system health. It functions as a centralized diagnostic service that aggregates and categorizes exceptions, providing the infrastructure necessary to visualize complex execution paths across distributed systems and microservices. The platform distinguishes itself through a high-throughput distributed event ingestion pipeline and a columnar storage analytics engine that enables rapid aggregation of large-scale performance me

    Sentry is a self-hostable observability platform that ingests OpenTelemetry traces, stores them for querying, and provides service maps and sampling controls, making it a comprehensive distributed tracing backend that covers every feature you listed.

    PythonApplication Performance MonitoringApplication Performance Monitoring PlatformsIncident Management Systems
    Auf GitHub ansehen↗44,108
  • coroot/corootAvatar von coroot

    coroot/coroot

    7,400Auf GitHub ansehen↗

    Coroot is an observability platform and Kubernetes performance monitor that utilizes eBPF to automatically collect metrics, logs, and traces without requiring manual code instrumentation. It functions as an OpenTelemetry trace analyzer and an LLM observability gateway, exposing system health data to large language models through the Model Context Protocol. The platform differentiates itself by combining automated root cause analysis and AI-driven diagnostics to investigate performance regressions. It also includes a cloud cost monitoring tool that attributes infrastructure spending to specifi

    Coroot is a self-hostable observability platform that collects, stores, and queries distributed traces via eBPF and OpenTelemetry, with service maps and built-in analytics—exactly the backend system this search asks for.

    GoAutomated Root Cause AnalysiseBPF-Based CollectionObservability Platforms
    Auf GitHub ansehen↗7,400
  • naver/pinpointAvatar von naver

    naver/pinpoint

    13,833Auf GitHub ansehen↗

    Pinpoint is a distributed application performance monitoring and tracing system. It functions as an application performance monitor and topology visualizer designed to analyze the execution behavior of large-scale distributed applications. The system uses bytecode instrumentation to monitor applications without requiring changes to the original source code. It captures call stacks and request flows across interconnected services to visualize system dependencies and generate real-time architectural maps of communication patterns. The platform covers a broad range of observability capabilities

    Pinpoint is a self-hostable distributed tracing and APM system that stores and queries traces with service dependency graphs, but its primary Java bytecode instrumentation and lack of explicit OpenTelemetry support mean it covers only some of the listed features.

    JavaService Dependency Mapping
    Auf GitHub ansehen↗13,833
  • openobserve/openobserveAvatar von openobserve

    openobserve/openobserve

    17,937Auf GitHub ansehen↗

    OpenObserve is a unified observability data platform designed to ingest, store, and analyze logs, metrics, and traces. It functions as a cloud-native monitoring tool that centralizes telemetry from diverse sources, including standard collectors and cloud service providers, into a single, scalable system. By utilizing a columnar storage engine backed by object storage, the platform enables efficient long-term data retention and high-performance analytical querying. The platform distinguishes itself through deep integration with artificial intelligence, allowing users to query data using natura

    OpenObserve is a self-hostable unified observability platform that ingests OpenTelemetry traces, stores them, and supports querying with service dependency mapping, making it a solid fit for your distributed tracing backend needs, though explicit sampling controls are not highlighted in its description.

    TypeScriptService Dependency MappingSelf-Hosted Deployment Platforms
    Auf GitHub ansehen↗17,937
  • highlight/highlightAvatar von highlight

    highlight/highlight

    9,303Auf GitHub ansehen↗

    Highlight is a full-stack observability platform and monitoring system that aggregates logs, errors, and distributed traces to provide a unified view of application health. It functions as a distributed tracing system, an error monitoring service, and a session replay tool. The platform is available as a dockerized monitoring stack for self-hosted deployments on Linux. It distinguishes itself by combining backend observability with a visual recording system that captures document object model changes and network requests to replay user interactions. The system covers several core capability

    Highlight is a self-hostable full-stack observability platform that includes distributed tracing, making it a fitting backend for collecting and querying traces, though the description does not explicitly confirm OpenTelemetry support or a dedicated dependency graph.

    TypeScriptDistributed Tracing SystemsCentralized Logging SystemsDistributed Request Tracing
    Auf GitHub ansehen↗9,303
  • dianping/catAvatar von dianping

    dianping/cat

    18,944Auf GitHub ansehen↗

    Cat is a distributed application performance monitoring tool and tracing framework designed to track transactions, latency, and health across distributed services. It functions as a Kubernetes-native monitoring stack that utilizes multi-language monitoring clients and a real-time alerting system to maintain system visibility. The system provides monitoring clients for Java, Go, Python, Node.js, and C++ to collect performance metrics and trace data. It distinguishes itself by sampling request flows to record call chains and identify bottlenecks, while using a monitoring engine to trigger immed

    Cat is a distributed tracing and APM framework that collects, stores, and visualizes trace data from multi-language services — it fits the self-hostable tracing backend need, though it may not natively support the OpenTelemetry protocol.

    JavaApplication Performance MonitoringDistributed TracingAlerting Systems
    Auf GitHub ansehen↗18,944
Die Top 10 auf einen Blick vergleichen
RepositoryStarsSpracheLizenzLetzter Push
grafana/tempo5.1KGoagpl-3.020. Feb. 2026
jaegertracing/jaeger22.9KGoApache-2.016. Juni 2026
signoz/signoz27.4KTypeScriptNOASSERTION16. Juni 2026
uptrace/uptrace4.1KGoagpl-3.021. Jan. 2026
openzipkin/zipkin17.4KJavaApache-2.08. Apr. 2026
apache/incubator-skywalking24.8KJavaApache-2.017. Juni 2026
hyperdxio/hyperdx9.3KTypeScriptmit21. Feb. 2026
apache/skywalking24.8KJavaApache-2.023. Juni 2026
quickwit-oss/quickwit11.3KRustApache-2.023. Juni 2026
pinpoint-apm/pinpoint13.8KJavaApache-2.016. Juni 2026

Related searches

  • ein verteiltes Tracing-System für Microservices
  • selbstgehostete APM-Plattform
  • eine Observability-Plattform für LLM-Anwendungen
  • selbstgehostete Alternative zu Datadog
  • an open source application performance monitoring tool
  • eine self-hosted Alternative zu Kafka
  • selbstgehostetes Tool für Error-Tracking
  • an open source platform for error tracking