open-telemetry/opentelemetry-go
Opentelemetry Go
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 without requiring changes to application source code.
The library covers several high-level observability domains, including distributed tracing to track request paths across service boundaries and performance metrics collection for monitoring system health. It supports both manual instrumentation for business logic and automatic instrumentation for frameworks and HTTP servers, while using context propagation to correlate signals across distributed network messages.
Features
- Distributed Tracing - Provides a framework for collecting and analyzing telemetry data across distributed service architectures to identify bottlenecks and failures.
- Distributed Tracing - Provides a full framework for tracking requests across distributed systems using unique identifiers to analyze performance and execution flow.
- OTLP Exporters - Implements standard utilities for transmitting telemetry data using the OpenTelemetry Protocol (OTLP).
- Tracing Context Propagation - Implements mechanisms for injecting and extracting distributed tracing headers across network boundaries to maintain request correlation.
- Contextual Metadata Propagation - Implements mechanisms for automatically attaching and propagating request-scoped metadata and trace identifiers through application flows.
- Application Metric Tracking - Enables the collection of custom application-level performance counters and histograms to monitor specific business logic.
- Application Observability - Provides a framework for monitoring, tracing, and debugging the execution flow and performance of Go applications.
- Application Performance Monitoring - Gathers numerical metrics and timing data from Go code to monitor system health and performance bottlenecks.
- Automatic Framework Instrumentation - Provides tools to automatically inject telemetry collection into software frameworks and libraries without manual code changes.
- Data Export Pipelines - Provides a configurable pipeline architecture for streaming telemetry and performance data to external analysis backends.
- Telemetry Exporters - Provides a pluggable system for pushing internal performance metrics and logs to third-party observability platforms.
- Instrumentation APIs - Provides a standardized set of interfaces for adding manual and automatic observability markers to Go application code.
- Metric Collection - Gathers quantitative time-series performance data to monitor system health and resource usage.
- Observability Pipelines - Ships a configurable pipeline for collecting, formatting, and routing telemetry signals to centralized monitoring platforms.
- OpenTelemetry Exporters - Provides components for exporting telemetry data in compliance with OpenTelemetry standards to external backends.
- OpenTelemetry SDKs - Provides the standardized software development kit for generating and exporting distributed traces, metrics, and logs in Go.
- Binary Serialization Formats - Uses a compact binary serialization format via the OpenTelemetry Protocol for efficient transport of telemetry signals.
- Trace Samplers - Implements configurable samplers to control the volume of recorded and exported spans via probabilistic or rule-based logic.
- Telemetry Signal Processors - Provides an ordered chain of processors to filter, batch, and modify telemetry signals before they reach the exporter.
- SDK-API Separation - Separates the public instrumentation API from the SDK implementation, allowing multiple SDKs to coexist behind the same interface.
- Observability Signal Abstractions - Models traces, metrics, and logs as distinct signal types through a unified API for shared context and configuration.
- Custom Logic Spans - Offers APIs to define manual instrumentation points for monitoring internal application logic via structured metadata.
- HTTP Server Instrumentation - Captures inbound and outbound HTTP request telemetry to track network traffic and service dependencies.
- Telemetry Processing Engines - Implements a processing engine to filter, enrich, and route observability signals before they are exported.
- Structured Logging - Generates machine-readable key-value pairs for application events to enable efficient historical analysis.
- Telemetry Resource Attributes - Attaches static metadata labels to telemetry data to identify services, versions, and environments.
- Cross-Signal Correlations - Links traces, metrics, and logs with shared context to enable cross-signal correlation of application behavior.
- Trace Sampling - Controls the volume of recorded and exported traces through sampling strategies to manage operational costs.
- Observability and Monitoring - Go API and SDK for telemetry instrumentation.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
