Observability, Configuration and Deployment

tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }

use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};

pub fn init_tracing() {
    let filter = EnvFilter::try_from_default_env() // RUST_LOG=info,my_service=debug,tower_http=debug,sqlx=warn
        .unwrap_or_else(|_| EnvFilter::new("info,tower_http=info,sqlx=warn"));
    let json = std::env::var("LOG_FORMAT").is_ok_and(|v| v == "json");
    let registry = tracing_subscriber::registry().with(filter);
    if json {
        registry
            .with(fmt::layer().json().with_current_span(true).with_span_list(false))
            .init();
    } else {
        registry.with(fmt::layer().with_target(false)).init();
    }
}

use tracing::instrument;

#[instrument(skip(state, body), fields(tenant = %tenant, order_id))]
async fn create_order(state: &AppState, tenant: String, body: NewOrder) -> Result<Order, AppError> {
    let order = state.repo.insert(&tenant, &body).await?;
    tracing::Span::current().record("order_id", order.id); // fill a declared-empty field later
    Ok(order)
}

#[instrument(level = "debug", skip_all, err)] // err: record Err(e) as an error event (needs Display)
async fn charge(gateway: &Gateway, amount_cents: i64) -> Result<(), PaymentError> {
    gateway.charge(amount_cents).await
}

use std::time::Duration;
use axum::{extract::{MatchedPath, Request}, response::Response};
use tower_http::trace::TraceLayer;
use tracing::Span;

pub fn trace_layer() -> TraceLayer<
    tower_http::classify::SharedClassifier<tower_http::classify::ServerErrorsAsFailures>,
    impl Fn(&Request) -> Span + Clone,
    tower_http::trace::DefaultOnRequest,
    impl Fn(&Response, Duration, &Span) + Clone,
> {
    TraceLayer::new_for_http()
        .make_span_with(|req: &Request| {
            let route = req.extensions().get::<MatchedPath>().map(|p| p.as_str().to_owned());
            let request_id = req.headers().get("x-request-id").and_then(|v| v.to_str().ok()).unwrap_or("-");
            tracing::info_span!(
                "http",
                method = %req.method(),
                route = route.as_deref().unwrap_or("unmatched"), // low-cardinality: "/orders/{id}"
                request_id,
                status = tracing::field::Empty,
            )
        })
        .on_response(|res: &Response, latency: Duration, span: &Span| {
            span.record("status", res.status().as_u16());
            tracing::info!(latency_ms = latency.as_millis() as u64, "response");
        })
}

1. Build an OTLP span exporter (tonic/gRPC to :4317 or HTTP to :4318).
2. Build an SdkTracerProvider with a batch processor and a Resource { service.name, service.version, env }.
3. tracer = provider.tracer("my-service")
4. registry().with(EnvFilter).with(fmt::layer()).with(tracing_opentelemetry::layer().with_tracer(tracer)).init()
5. Propagate context: extract W3C `traceparent` from incoming headers into the request span; inject it into
   outgoing reqwest calls (a reqwest middleware or manual header injection).
6. On shutdown: provider.shutdown() so buffered spans are flushed.

[dependencies]
console-subscriber = "0.4"
tokio = { version = "1", features = ["full", "tracing"] }

fn main() {
    console_subscriber::init(); // instead of your normal subscriber, or add console_subscriber::spawn() as a layer
    // build the runtime / #[tokio::main] as usual
}

RUSTFLAGS="--cfg tokio_unstable" cargo run      # instrumentation requires tokio_unstable
cargo install --locked tokio-console
tokio-console                                    # connects to 127.0.0.1:6669

use std::{net::SocketAddr, time::Duration};

#[derive(Clone, Debug)]
pub struct Config {
    pub addr: SocketAddr,
    pub database_url: String,
    pub request_timeout: Duration,
    pub max_db_connections: u32,
}

impl Config {
    pub fn from_env() -> anyhow::Result<Self> {
        use anyhow::Context;
        let var = |k: &str| std::env::var(k).with_context(|| format!("missing env var {k}"));
        Ok(Self {
            addr: std::env::var("ADDR").unwrap_or_else(|_| "0.0.0.0:3000".into()).parse()?,
            database_url: var("DATABASE_URL")?,
            request_timeout: Duration::from_secs(
                std::env::var("REQUEST_TIMEOUT_SECS").ok().and_then(|v| v.parse().ok()).unwrap_or(10),
            ),
            max_db_connections: std::env::var("MAX_DB_CONNECTIONS").ok().and_then(|v| v.parse().ok()).unwrap_or(20),
        })
    }
}

use figment::{Figment, providers::{Env, Format, Serialized, Toml}};

#[derive(Debug, serde::Deserialize, serde::Serialize)]
pub struct Settings {
    pub port: u16,
    pub database_url: String,
    pub log_format: String,
}

impl Default for Settings {
    fn default() -> Self {
        Self { port: 3000, database_url: String::new(), log_format: "text".into() }
    }
}

pub fn load() -> Result<Settings, figment::Error> {
    Figment::from(Serialized::defaults(Settings::default()))
        .merge(Toml::file("App.toml"))   // optional: missing file is ignored
        .merge(Env::prefixed("APP_"))    // APP_PORT=8080, APP_DATABASE_URL=...
        .extract()
}

#[derive(Debug, serde::Deserialize)]
pub struct Settings {
    pub port: u16,
    pub database: Database,
}

#[derive(Debug, serde::Deserialize)]
pub struct Database {
    pub url: String,
    pub max_connections: u32,
}

pub fn load() -> Result<Settings, config::ConfigError> {
    config::Config::builder()
        .set_default("port", 3000)?
        .add_source(config::File::with_name("config/default").required(false))
        .add_source(config::Environment::with_prefix("APP").separator("__")) // APP_DATABASE__URL
        .build()?
        .try_deserialize()
}

# syntax=docker/dockerfile:1
FROM lukemathwalker/cargo-chef:latest-rust-1 AS chef
WORKDIR /app

FROM chef AS planner
COPY . .
RUN cargo chef prepare --recipe-path recipe.json

FROM chef AS builder
COPY --from=planner /app/recipe.json recipe.json
# Dependencies only: this layer is cached until Cargo.toml/Cargo.lock change
RUN cargo chef cook --release --recipe-path recipe.json
COPY . .
ENV SQLX_OFFLINE=true
RUN cargo build --release --locked --bin orders-api

FROM gcr.io/distroless/cc-debian12:nonroot AS runtime
COPY --from=builder /app/target/release/orders-api /usr/local/bin/orders-api
EXPOSE 3000
ENTRYPOINT ["/usr/local/bin/orders-api"]

readinessProbe:
  httpGet: { path: /readyz, port: 3000 }
  periodSeconds: 5
  failureThreshold: 2
livenessProbe:
  httpGet: { path: /healthz, port: 3000 }
  periodSeconds: 10
  failureThreshold: 3
lifecycle:
  preStop:
    exec: { command: ["/usr/local/bin/orders-api", "--sleep", "5"] }  # distroless has no `sleep`; or use the in-app delay
terminationGracePeriodSeconds: 30