opentelemetry-rust

Introduction to OpenTelemetry Rust

OpenTelemetry Rust is a key implementation of the OpenTelemetry project designed specifically for the Rust programming language. OpenTelemetry is an observability framework that enables developers to capture data on an application's behavior and performance through metrics, logs, and traces. This information can then be exported for analysis using popular observability tools like Prometheus and Jaeger.

Overview

OpenTelemetry integrates a set of APIs, SDKs, and tools that provide a comprehensive approach to telemetry data collection. The Rust implementation provides a framework for instrumenting Rust applications to collect telemetry data which can be processed and exported. This framework supports Rust compiler version 1.70 and above.

Project Status

The OpenTelemetry Rust project is active and divided into several components, each with different maturity statuses:

• Log-related APIs and SDKs are in Beta, meaning they are relatively stable and ready for public testing.
• Metrics components are in Alpha, indicating ongoing development and potential for significant changes.
• Trace-related components are also in Beta.

The project is geared towards integrating existing logging libraries into the OpenTelemetry model via Log Bridge API, without offering a new logging API. Users can utilize available log appenders to route logs to OpenTelemetry.

Getting Started

To start using OpenTelemetry in Rust, developers can follow the sample code provided that sets up a tracing pipeline and uses a simple exporter to output traces to the console:

use opentelemetry::{
    global,
    trace::{Tracer, TracerProvider as _},
};
use opentelemetry_sdk::trace::TracerProvider;

fn main() {
    let provider = TracerProvider::builder()
        .with_simple_exporter(opentelemetry_stdout::SpanExporter::default())
        .build();
    let tracer = provider.tracer("readme_example");

    tracer.in_span("doing_work", |cx| {
        // Traced app logic here...
    });

    global::shutdown_tracer_provider();
}

Developers need to include the relevant dependencies in their Cargo.toml file to use these features.

Key Crates

The OpenTelemetry Rust project comprises several crates, each serving different purposes:

• opentelemetry: The core API crate needed for instrumenting applications, featuring APIs for context, baggage, logging, metrics, and tracing.
• opentelemetry-sdk: Offers the official OpenTelemetry SDK implementation, including SDKs for logging, metrics, and tracing.
• opentelemetry-otlp: Used for exporting telemetry data in the OTLP format to suitable endpoints.
• opentelemetry-stdout: Enables sending telemetry data to the console for debugging and learning purposes.
• opentelemetry-http: Contains utilities for exporting telemetry over HTTP.
• Additional amenders and propagators are available for integrating with other systems like Jaeger, Prometheus, and Zipkin.

Supported Rust Versions

The project supports the current stable release of Rust and the three preceding versions. The minimum compatible version is 1.70, ensuring compatibility with modern Rust development environments.

Community and Contribution

The OpenTelemetry Rust community is active and open to contributions from developers of all skill levels. Regular meetings are held to discuss project progress and invite collaboration. Interested contributors can find more information on joining these discussions through the OpenTelemetry community calendar and Slack channel.

Maintainers and Approvers

The project is backed by a team of dedicated maintainers and approvers, ensuring its continual development and support. Contributions from the wider community are appreciated and acknowledged, highlighting the collaborative spirit of the project.

With its robust framework, flexible architecture, and active community, OpenTelemetry Rust is a valuable tool for developers looking to enhance their applications with comprehensive observability capabilities.