> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/open-telemetry/opentelemetry-rust/llms.txt
> Use this file to discover all available pages before exploring further.

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

<Warning>
  **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.
</Warning>

## Installation

```toml theme={null}
[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

```rust theme={null}
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

```rust theme={null}
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

```rust theme={null}
use opentelemetry_sdk::logs::SdkLoggerProvider;
use opentelemetry_stdout::LogExporter;

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

## Exporters

### SpanExporter

<ParamField path="SpanExporter" type="struct">
  Prints trace spans to stdout with human-readable formatting
</ParamField>

```rust theme={null}
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

<ParamField path="MetricExporter" type="struct">
  Prints aggregated metrics to stdout
</ParamField>

```rust theme={null}
use opentelemetry_stdout::MetricExporter;

let exporter = MetricExporter::default();

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

### LogExporter

<ParamField path="LogExporter" type="struct">
  Prints log records to stdout
</ParamField>

```rust theme={null}
use opentelemetry_stdout::LogExporter;

let exporter = LogExporter::default();

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

## Complete Example

```rust theme={null}
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

<CardGroup cols={2}>
  <Card title="Learning" icon="graduation-cap">
    Understand how OpenTelemetry structures telemetry data
  </Card>

  <Card title="Debugging" icon="bug">
    Verify instrumentation is working correctly
  </Card>

  <Card title="Testing" icon="flask">
    Validate telemetry in unit and integration tests
  </Card>

  <Card title="Development" icon="code">
    Quick local debugging without backend setup
  </Card>
</CardGroup>

## Limitations

<Warning>
  * **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
</Warning>

## Related Crates

* **[opentelemetry](/api/opentelemetry)** - Core API
* **[opentelemetry-sdk](/api/opentelemetry-sdk)** - SDK implementation
* **[opentelemetry-otlp](/api/opentelemetry-otlp)** - Production-ready OTLP exporter

## Documentation

<Card title="Full API Documentation" icon="book" href="https://docs.rs/opentelemetry-stdout/0.31.0">
  View complete API reference on docs.rs
</Card>

## Minimum Rust Version

**MSRV:** 1.75.0