> ## 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 Rust SDK

> Instrument, generate, collect, and export telemetry data (metrics, logs, and traces) for your Rust applications

OpenTelemetry is a collection of tools, APIs, and SDKs used to instrument, generate, collect, and export telemetry data (metrics, logs, and traces) for analysis in order to understand your software's performance and behavior.

## Why OpenTelemetry Rust?

The Rust implementation of OpenTelemetry provides a performant, type-safe SDK for instrumenting your applications with observability capabilities. Export and analyze telemetry data using Prometheus, Jaeger, and other observability tools.

**Key capabilities:**

* **Traces** - Distributed tracing to track requests across services
* **Metrics** - Counters, histograms, gauges, and observable instruments
* **Logs** - Structured logging with context propagation
* **Exporters** - OTLP, Prometheus, Jaeger, Zipkin, and stdout
* **Context propagation** - W3C Trace Context, baggage, and custom propagators

## Signal status

| Signal/Component        | Status |
| ----------------------- | ------ |
| Context                 | Beta   |
| Baggage                 | RC     |
| Propagators             | Beta   |
| Logs API                | Stable |
| Logs SDK                | Stable |
| Logs OTLP Exporter      | RC     |
| Logs Appender (Tracing) | Stable |
| Metrics API             | Stable |
| Metrics SDK             | Stable |
| Metrics OTLP Exporter   | RC     |
| Traces API              | Beta   |
| Traces SDK              | Beta   |
| Traces OTLP Exporter    | Beta   |

## Getting started

<CardGroup cols={2}>
  <Card title="Installation" icon="download" href="/installation">
    Add OpenTelemetry to your Rust project with Cargo
  </Card>

  <Card title="Quickstart" icon="bolt" href="/quickstart">
    Get up and running with a working example in minutes
  </Card>

  <Card title="API Reference" icon="book" href="https://docs.rs/opentelemetry">
    Explore the complete API documentation on docs.rs
  </Card>

  <Card title="Examples" icon="code" href="https://github.com/open-telemetry/opentelemetry-rust/tree/main/examples">
    Browse real-world examples for traces, metrics, and logs
  </Card>
</CardGroup>

## Core crates

The OpenTelemetry Rust implementation is distributed across several crates:

<CardGroup cols={2}>
  <Card title="opentelemetry" icon="cube">
    Core API crate containing Context, Baggage, Propagators, and APIs for Logging, Metrics, and Tracing
  </Card>

  <Card title="opentelemetry-sdk" icon="box">
    Official SDK implementation with Logging SDK, Metrics SDK, Tracing SDK, and propagator implementations
  </Card>

  <Card title="opentelemetry-otlp" icon="arrow-right-arrow-left">
    Export telemetry in OTLP format to collectors, backends like Jaeger and Prometheus, or vendor endpoints
  </Card>

  <Card title="opentelemetry-stdout" icon="terminal">
    Export logs, metrics, and traces to stdout for learning and debugging
  </Card>
</CardGroup>

### Appenders and integrations

<Note>
  OpenTelemetry Rust does not provide a new logging API. Instead, it bridges existing logging libraries to the OpenTelemetry log data model.
</Note>

Available log appenders:

* **`opentelemetry-appender-tracing`** - Bridge for the [tracing](https://github.com/tokio-rs/tracing) crate (recommended for new projects)
* **`opentelemetry-appender-log`** - Bridge for the [log](https://docs.rs/log/latest/log/) crate

Additional exporters and propagators:

* **`opentelemetry-prometheus`** - Prometheus metrics exporter
* **`opentelemetry-zipkin`** - Zipkin trace exporter
* **`opentelemetry-jaeger-propagator`** - Jaeger propagation format
* **`opentelemetry-semantic-conventions`** - Standard names and semantic conventions

## Supported Rust versions

<Warning>
  Minimum supported Rust version: **1.75**
</Warning>

OpenTelemetry is built against the latest stable release. The current stable Rust compiler and the three most recent minor versions before it will always be supported.

For example, if the current stable compiler version is 1.49, the minimum supported version will not be increased past 1.46. Increasing the minimum supported compiler version is not considered a semver breaking change.

## Community

Join the OpenTelemetry Rust community:

* **Slack**: [#otel-rust](https://cloud-native.slack.com/archives/C03GDP0H023) on CNCF Slack
* **SIG Meetings**: Alternating weeks between Tuesday 9:00 AM PT and Wednesday 8:00 AM PT
* **Meeting Notes**: [Google Doc](https://docs.google.com/document/d/12upOzNk8c3SFTjsL6IRohCWMgzLKoknSCOOdMakbWo4/edit)
* **GitHub**: [opentelemetry-rust](https://github.com/open-telemetry/opentelemetry-rust)

The meeting is open to all, regardless of experience level. Everyone is welcome to participate!

## Next steps

<Steps>
  <Step title="Install OpenTelemetry">
    Follow the [installation guide](/installation) to add the necessary crates to your project
  </Step>

  <Step title="Try the quickstart">
    Get hands-on with a [complete working example](/quickstart) that demonstrates traces, metrics, or logs
  </Step>

  <Step title="Choose your exporter">
    Select an exporter based on your observability backend (OTLP, Prometheus, Jaeger, etc.)
  </Step>

  <Step title="Instrument your code">
    Add instrumentation to your application code to emit telemetry signals
  </Step>
</Steps>