opentelemetry-stdout

Debug exporter that prints telemetry to stdout

opentelemetry-stdout

Version: 0.31.0

The opentelemetry-stdout crate provides exporters that print telemetry data (traces, metrics, and logs) to standard output. This is primarily intended for debugging, learning, and development purposes.

Not for production use. This exporter is designed for debugging and educational purposes only. The output format is not optimized for performance and may change without notice.

Installation

[dependencies]
opentelemetry-stdout = { version = "0.31", features = ["trace", "metrics", "logs"] }

Feature Flags

• trace: Include trace span exporter (enabled by default)
• metrics: Include metrics exporter (enabled by default)
• logs: Include log exporter (enabled by default)

Quick Start

Trace Export

use opentelemetry::trace::Tracer;
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry_stdout::SpanExporter;

let exporter = SpanExporter::default();
let provider = SdkTracerProvider::builder()
    .with_simple_exporter(exporter)
    .build();

let tracer = provider.tracer("my_service");
tracer.in_span("example_span", |cx| {
    // Your traced logic
});

Metrics Export

use opentelemetry::metrics::MeterProvider;
use opentelemetry_sdk::metrics::SdkMeterProvider;
use opentelemetry_stdout::MetricExporter;

let exporter = MetricExporter::default();
let provider = SdkMeterProvider::builder()
    .with_periodic_exporter(exporter)
    .build();

let meter = provider.meter("my_service");
let counter = meter.u64_counter("requests").build();
counter.add(1, &[]);

Logs Export

use opentelemetry_sdk::logs::SdkLoggerProvider;
use opentelemetry_stdout::LogExporter;

let exporter = LogExporter::default();
let provider = SdkLoggerProvider::builder()
    .with_simple_exporter(exporter)
    .build();

Exporters

SpanExporter

SpanExporter · struct

Prints trace spans to stdout with human-readable formatting

use opentelemetry_stdout::SpanExporter;

let exporter = SpanExporter::default();

// Output example:
// Span {
//   name: "my_span",
//   trace_id: "0123456789abcdef0123456789abcdef",
//   span_id: "0123456789abcdef",
//   parent_span_id: None,
//   start_time: "2024-01-15T10:30:00Z",
//   end_time: "2024-01-15T10:30:01Z",
//   ...
// }

MetricExporter

MetricExporter · struct

Prints aggregated metrics to stdout

use opentelemetry_stdout::MetricExporter;

let exporter = MetricExporter::default();

// Output example:
// Metric {
//   name: "http.server.duration",
//   description: "HTTP request duration",
//   unit: "ms",
//   data: Histogram { ... }
// }

LogExporter

LogExporter · struct

Prints log records to stdout

use opentelemetry_stdout::LogExporter;

let exporter = LogExporter::default();

// Output example:
// LogRecord {
//   timestamp: "2024-01-15T10:30:00Z",
//   severity: "INFO",
//   body: "Application started",
//   ...
// }

Complete Example

use opentelemetry::trace::{Tracer, Span};
use opentelemetry::{Context, KeyValue};
use opentelemetry::metrics::MeterProvider;
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry_sdk::metrics::SdkMeterProvider;
use opentelemetry_sdk::logs::SdkLoggerProvider;
use opentelemetry_stdout::{SpanExporter, MetricExporter, LogExporter};

fn main() {
    // Initialize trace provider
    let trace_exporter = SpanExporter::default();
    let tracer_provider = SdkTracerProvider::builder()
        .with_simple_exporter(trace_exporter)
        .build();

    // Initialize metrics provider
    let metrics_exporter = MetricExporter::default();
    let meter_provider = SdkMeterProvider::builder()
        .with_periodic_exporter(metrics_exporter)
        .build();

    // Initialize logs provider
    let log_exporter = LogExporter::default();
    let logger_provider = SdkLoggerProvider::builder()
        .with_simple_exporter(log_exporter)
        .build();

    // Use them
    let tracer = tracer_provider.tracer("example");
    let meter = meter_provider.meter("example");

    tracer.in_span("main", |cx| {
        let counter = meter.u64_counter("operations").build();
        counter.add(1, &[KeyValue::new("operation", "example")]);
    });
}

Output Format

The exporters use Rust’s Debug formatting to print telemetry data. The output includes:

For Traces:

• Span name and IDs
• Start and end times
• Attributes
• Events
• Links
• Status

For Metrics:

• Metric name and description
• Unit
• Data points with values and attributes
• Aggregation type

For Logs:

• Timestamp
• Severity level
• Body/message
• Attributes
• Trace context (if available)

Use Cases

Learning

Understand how OpenTelemetry structures telemetry data

Debugging

Verify instrumentation is working correctly

Testing

Validate telemetry in unit and integration tests

Development

Quick local debugging without backend setup

Limitations

• Performance: Not optimized for high-throughput scenarios
• Format stability: Output format may change between versions
• Production use: Not recommended for production environments
• Buffering: Uses simple synchronous I/O

Related Crates

• opentelemetry - Core API
• opentelemetry-sdk - SDK implementation
• opentelemetry-otlp - Production-ready OTLP exporter

Documentation

Full API Documentation

View complete API reference on docs.rs

Minimum Rust Version

MSRV: 1.75.0