Open-source alternatives to Opentelemetry Dotnet

OpenTelemetry Go is a framework for generating and collecting distributed traces, metrics, and logs from Go applications. It provides a standardized telemetry instrumentation API for adding observability markers to code and a corresponding SDK for processing and emitting these signals. The project utilizes a configurable observability pipeline to sample and export telemetry data to external backends using the OTLP wire protocol. It features a pluggable export system and a separation between the public API and the SDK implementation, allowing telemetry to be routed to third-party platforms wit

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

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

This project provides a collection of extensions for the OpenTelemetry Go software development kit, serving as a toolkit for automated instrumentation, context propagation, and telemetry pipeline management. It enables the capture of traces, metrics, and logs across distributed systems by providing unified interfaces that decouple data collection from specific backend storage or analysis platforms. The project distinguishes itself through its ability to inject telemetry collection into popular frameworks and libraries without requiring manual source code modifications. It maintains request co

GreptimeDB is a distributed, open-source time-series database built for unified observability. It stores and queries metrics, logs, and traces together in a single columnar engine, supporting both SQL and PromQL for analysis. The database is designed as a Kubernetes-native operator with a decoupled compute and storage architecture, enabling horizontal scaling and multi-region deployment. What distinguishes GreptimeDB is its role as a multi-protocol ingestion gateway, accepting data through OpenTelemetry, Prometheus Remote Write, InfluxDB, Loki, Elasticsearch, Kafka, and MQTT protocols without

OpenCensus-go is an observability instrumentation library designed to capture and export telemetry data from distributed systems. It functions as a framework for application performance monitoring and distributed request tracing, allowing developers to track system health, latency, and the progression of requests across service boundaries. The project distinguishes itself through a modular architecture that decouples data collection from storage. By utilizing a pluggable exporter interface, it enables the transmission of metrics and trace data to a variety of external monitoring and analysis

The Datadog Agent is an infrastructure monitoring agent and host telemetry collector. It functions as a background process that gathers system metrics and application health data to send to a centralized monitoring platform. The project operates as a plugin-based metric collector, using a modular system of independent check scripts to gather data from various third-party services and applications. It serves as a remote telemetry transmitter, providing a pipeline to stream infrastructure and system information to a remote analysis and alerting backend. Its capabilities cover application perfo

The OpenTelemetry Collector is a vendor-agnostic proxy and observability data pipeline that receives, processes, and exports traces, metrics, and logs. It functions as a telemetry ingestion gateway and multi-backend monitoring agent, translating various data formats into a standardized internal representation for consistent processing. The project distinguishes itself through a plugin-based component model, allowing the integration of custom receivers, processors, and exporters without modifying the core codebase. It utilizes a configurable pipeline system where telemetry flows through a sequ

OpenTelemetry PHP is a standard-compliant observability framework designed to instrument applications for the collection and export of telemetry data. It provides a comprehensive suite of tools for capturing traces, metrics, and logs, enabling developers to monitor operational behavior and system performance in real time. The project distinguishes itself through an interface-driven plugin architecture that allows for the modular configuration of exporters, processors, and samplers. To maintain performance in production environments, it supports the use of native binary extensions for data ser

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

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 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

This project is a Node.js binary distribution repository and Linux package repository. It provides a hosted set of pre-compiled JavaScript runtime binaries for various Linux distributions to simplify installation and version management through native package managers. The project includes a Node.js observability toolset and security policy manager. These components enable the gathering of runtime telemetry to monitor application health and performance via diagnostic dashboards, while providing a resource restriction layer that intercepts system calls to prevent unauthorized modules from acces

This project provides a collection of implementation kits, guides, and source code designed to teach containerized application development and cluster management. It serves as a learning path for packaging applications with Docker and orchestrating workloads within Kubernetes. The repository includes practical walkthroughs for building automated delivery pipelines using containerized runners and build agents. It also provides a suite of guides for implementing cloud-native observability, deploying service meshes, and managing Kubernetes cluster configurations. The material covers a broad ran

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

Mastra is an orchestration framework designed for building, deploying, and managing autonomous AI agents and multi-agent systems. It provides a comprehensive suite of primitives for creating resilient AI applications, including durable workflow orchestration, event-driven agent loops, and semantic memory management. By integrating these core components, the platform enables developers to build complex, multi-step processes that can reason about goals and execute tasks without manual intervention. The framework distinguishes itself through its focus on observability and secure, isolated execut

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

DeepOps is a full-stack observability platform and application performance monitoring tool. It serves as a distributed service observability suite designed to track response times, resource usage, and service health across diverse infrastructure layers. The platform functions as a cross-stack telemetry aggregator, unifying metrics and logs into a single data stream. It incorporates a heuristic anomaly detection system that analyzes performance baselines to identify statistical outliers and predict operational failures. The system covers a broad range of monitoring capabilities, including rea

This library provides a toolkit for instrumenting Go applications with performance metrics, enabling the tracking of counters, gauges, and timers. It serves as a foundational framework for recording application behavior and resource usage, offering thread-safe primitives to manage the lifecycle of these instruments within a central registry. The system distinguishes itself through a high-performance design that utilizes atomic operations to track event frequencies, avoiding the overhead of mutex locks during execution. It employs snapshot-based sampling to capture point-in-time data, ensuring

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

This project is a unified observability framework for Rust applications, designed to capture, aggregate, and report performance telemetry. It provides a comprehensive toolkit for instrumenting code to track counters, gauges, and histograms, enabling developers to monitor application health and operational performance through a standardized interface. The library distinguishes itself by decoupling instrumentation sites from specific backend implementations through a global registry and trait-based abstractions. This architecture allows developers to swap telemetry exporters at runtime without

Fluent Bit is a cloud-native log shipper and unified telemetry collector designed as a resource-efficient data pipeline. It ingests logs, metrics, and traces from multiple sources, processing them in real-time before routing the data to external storage backends. The project functions as a real-time stream processor and OpenTelemetry log processor, capable of transforming and filtering data using SQL and conditional logic. It also acts as a distributed tracing agent that can sample traces to reduce data volume while preserving full request paths. The system provides reliable data delivery th

Netdata is a real-time infrastructure monitoring tool and multi-node observability platform. It functions as a high-resolution monitoring agent, log and metric aggregator, and time-series database designed to provide full-stack visibility into server health. The system is distinguished by its per-second metric sampling and zero-configuration auto-discovery, which allows for immediate infrastructure tracking upon installation. It utilizes edge-based machine learning and unsupervised models to detect system anomalies and abnormal metric patterns locally on each node. For distributed environment

This is a Prometheus Python client library used for instrumenting Python applications. It provides the tools necessary to record counters, gauges, and histograms within a process to monitor application health and expose that data as a Prometheus exposition format provider. The library enables cloud native observability by allowing developers to define custom telemetry and track internal application events. It transforms internal application data into a standardized text format required by Prometheus scrapers for collection. The project covers a variety of monitoring and observability capabil

Alloy is a clustered telemetry collector and observability data pipeline that functions as an OpenTelemetry collector distribution. It acts as a declarative configuration engine for collecting and routing metrics, logs, traces, and profiles from various sources to monitoring backends. The system distinguishes itself through a distributed architecture that uses consistent hashing to balance scraping targets and collection workloads across multiple nodes. It manages fleet-wide settings via remote configuration fetching and a modular system for importing reusable pipeline patterns. As a Kubernet

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

Boto3 is the AWS SDK for Python, providing a programmatic interface for managing and automating AWS cloud infrastructure and services. It serves as a cloud management API client and resource manager for provisioning, configuring, and scaling virtual servers, databases, and storage. The library enables the implementation of infrastructure-as-code through declarative templates and scripts, allowing for the deployment of identical resource stacks across multiple accounts and geographic regions. It also provides a framework for coordinating distributed workflows, serverless functions, and contain