Skip to main content

​
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

​
Documentation

Full API Documentation

View complete API reference on docs.rs

​
Minimum Rust Version

MSRV: 1.75.0

Build docs developers (and LLMs) love

Get started for freeTalk to us