Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/asaaki/opentelemetry-tide

🔭🌊 OpenTelemetry integration for Tide
https://github.com/asaaki/opentelemetry-tide

metrics opentelemetry opentelemetry-rust opentelemetry-tide otel rust tracing

Last synced: 2 months ago
JSON representation

🔭🌊 OpenTelemetry integration for Tide

Awesome Lists containing this project

README

        



opentelemetry-tide


[OpenTelemetry] integration for [Tide]





Crates.io version



docs.rs docs




CI status



Download

Add OpenTelemetry tracing and metrics support to your tide application.
Be part of the new observability movement!

## Notes

* It only implements very basic request tracing on the middleware layer.
If you need spans for your executed code, you need to add them yourself.
* It provides basic prometheus metrics, based on the [RED method].
* This project got inspired by .
* You probably do not want to use it in production. 🤷

## How to use

```sh
# Run jaeger in background
docker run -d \
-p6831:6831/udp -p6832:6832/udp -p16686:16686 -p14268:14268 \
jaegertracing/all-in-one:latest

# Run server example with tracing middleware
cargo run --example server

# Make a request or two ...
curl http://localhost:3000/

# Open browser and view the traces
firefox http://localhost:16686/

# Check the prometheus metrics endpoint
curl http://localhost:3000/metrics
```

## Example

### `Cargo.toml`

```toml
# ...

[dependencies]
async-std = { version = "1.10", features = ["attributes"] }
opentelemetry = { version = "0.17.0", features = ["rt-async-std"] }
opentelemetry-jaeger = { version = "0.16.0", features = ["rt-async-std"] }
opentelemetry-tide = "0.12"
tide = "0.16"
```

### `server.rs`

```rust
use opentelemetry::{global, KeyValue, runtime};
use opentelemetry_semantic_conventions::resource;
use opentelemetry_tide::TideExt; // import trait

const VERSION: &'static str = env!("CARGO_PKG_VERSION");

#[async_std::main]
async fn main() -> Result<(), Box> {
tide::log::with_level(tide::log::LevelFilter::Warn);

let tags = [resource::SERVICE_VERSION.string(VERSION)];

let _tracer = opentelemetry_jaeger::new_pipeline()
.with_tags(tags.iter().map(ToOwned::to_owned))
.install_batch(runtime::AsyncStd)
.expect("pipeline install failure");
let tracer = global::tracer("example-server");

let metrics_kvs = vec![KeyValue::new("K", "V")];

let mut app = tide::new();

// use the trait
app.with_middlewares(tracer, Some(metrics_kvs));

app.at("/").get(|_| async move {
Ok("Hello, OpenTelemetry!")
});

app.listen("0.0.0.0:3000").await?;

global::shutdown_tracer_provider();

Ok(())
}
```

## Cargo Features

| flag | description |
| --------: | :---------- |
| `trace` | enables **tracing** middleware; enabled by default
| `metrics` | enables **metrics** middleware; enabled by default

## Safety

This crate uses ``#![forbid(unsafe_code)]`` to ensure everything is implemented in 100% Safe Rust.

## License


Licensed under either of
Apache License, Version 2.0 or
MIT license
at your option.



Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
be dual licensed as above, without any additional terms or conditions.

[OpenTelemetry]: https://crates.io/crates/opentelemetry
[Tide]: https://crates.io/crates/tide
[RED method]: https://www.weave.works/blog/the-red-method-key-metrics-for-microservices-architecture/