Request Tracing

[dependencies]
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["fmt"] }
tracing-opentelemetry = "0.32"
opentelemetry = "0.31"
opentelemetry_sdk = "0.31"
opentelemetry-otlp = { version = "0.31", features = ["grpc-tonic"] }

use std::time::Duration;
use couchbase::authenticator::PasswordAuthenticator;
use couchbase::cluster::Cluster;
use couchbase::options::cluster_options::ClusterOptions;
use opentelemetry::KeyValue;
use opentelemetry::trace::TracerProvider;
use opentelemetry_sdk::{
    trace::{BatchSpanProcessor, Sampler, SdkTracerProvider},
    Resource,
};
use opentelemetry_otlp::{Protocol, SpanExporter, WithExportConfig};
use tracing::instrument::WithSubscriber;
use tracing_subscriber::{layer::SubscriberExt, Registry};
use tracing_opentelemetry::OpenTelemetryLayer;

#[tokio::main]
async fn main() {
    let tracer_provider = setup_otel_tracer_provider();
    let tracer = tracer_provider.tracer("my-app");

    let subscriber = Registry::default()
        .with(OpenTelemetryLayer::new(tracer))
        .with(tracing_subscriber::fmt::layer()); // Add any other layers you want

    // Scope the subscriber to your SDK calls.
    // Alternatively, register it globally with:
    //   tracing::subscriber::set_global_default(subscriber)
    // Note: with a global subscriber, all spans in the process will share the same
    // instrumentation scope name.
    your_couchbase_sdk_calls()
        .with_subscriber(subscriber)
        .await;
}

fn setup_otel_tracer_provider() -> SdkTracerProvider {
    // This exporter exports traces on the OTLP protocol over GRPC to localhost:4317.
    let exporter = SpanExporter::builder()
        .with_tonic()
        .with_protocol(Protocol::Grpc)
        .with_endpoint("http://localhost:4317")
        .build()
        .expect("failed to build OTLP exporter");

    let resource = Resource::builder()
        // An OpenTelemetry service name generally reflects the name of your microservice,
        // e.g. "shopping-cart-service".
        .with_attributes([
            KeyValue::new("service.name", "YOUR_SERVICE_NAME_HERE"),
        ])
        .build();

    let tracer_provider = SdkTracerProvider::builder()
        .with_resource(resource)
        // Export every trace: this may be too heavy for production.
        // An alternative is `.with_sampler(Sampler::TraceIdRatioBased(0.01))`
        .with_sampler(Sampler::AlwaysOn)
        // The BatchSpanProcessor will efficiently batch traces and periodically export them.
        .with_span_processor(
            BatchSpanProcessor::builder(exporter)
                .with_batch_config(
                    opentelemetry_sdk::trace::BatchConfigBuilder::default()
                        .with_scheduled_delay(Duration::from_millis(5000))
                        .build(),
                )
                .build(),
        )
        .build();

    tracer_provider
}

async fn your_couchbase_sdk_calls() {
    // Your Couchbase SDK calls here, e.g.:
    let opts = ClusterOptions::new(PasswordAuthenticator::new("username", "password").into());
    let cluster = Cluster::connect("couchbase://localhost", opts).await.unwrap();
    let bucket = cluster.bucket("my_bucket");
    let collection = bucket.default_collection();
    collection.insert("my_key", "my_value", None).await.unwrap();
}