generated from Patagia/template-nix
128 lines
3.8 KiB
Rust
128 lines
3.8 KiB
Rust
use anyhow::{anyhow, Result};
|
|
use clap::Parser;
|
|
use dropshot::endpoint;
|
|
use dropshot::ApiDescription;
|
|
use dropshot::ConfigDropshot;
|
|
use dropshot::HttpError;
|
|
use dropshot::HttpResponseOk;
|
|
use dropshot::RequestContext;
|
|
use dropshot::ServerBuilder;
|
|
use opentelemetry::{trace::TracerProvider as _, KeyValue};
|
|
use opentelemetry_otlp::WithExportConfig;
|
|
use opentelemetry_sdk::{
|
|
trace::{RandomIdGenerator, Sampler},
|
|
Resource,
|
|
};
|
|
use opentelemetry_semantic_conventions::{
|
|
attribute::{SERVICE_NAME, SERVICE_VERSION},
|
|
SCHEMA_URL,
|
|
};
|
|
use schemars::JsonSchema;
|
|
use serde::Serialize;
|
|
use slog::Drain;
|
|
use tracing_opentelemetry::OpenTelemetryLayer;
|
|
use tracing_slog::TracingSlogDrain;
|
|
use tracing_subscriber::prelude::*;
|
|
|
|
use std::net::SocketAddr;
|
|
use std::str::FromStr;
|
|
use std::sync::Arc;
|
|
|
|
#[derive(Parser, Debug)]
|
|
#[command(version, about, long_about = None)]
|
|
struct Cli {}
|
|
|
|
/// Represents a project in our API.
|
|
#[derive(Serialize, JsonSchema)]
|
|
struct VersionInfo {
|
|
name: String,
|
|
}
|
|
|
|
/// Fetch version info.
|
|
#[endpoint {
|
|
method = GET,
|
|
path = "/version",
|
|
}]
|
|
#[tracing::instrument(
|
|
skip(rqctx),
|
|
fields(
|
|
http.method=rqctx.request.method().as_str(),
|
|
http.path=rqctx.request.uri().path(),
|
|
http.remote_ip=rqctx.request.remote_addr().ip().to_string(),
|
|
request_id = rqctx.request_id,
|
|
),
|
|
err(Debug),
|
|
)]
|
|
async fn api_version(
|
|
rqctx: RequestContext<Arc<()>>,
|
|
) -> Result<HttpResponseOk<VersionInfo>, HttpError> {
|
|
let ver = VersionInfo {
|
|
name: String::from("patagia-controller"),
|
|
};
|
|
|
|
tracing::info!("Someone made a request to /version");
|
|
Ok(HttpResponseOk(ver))
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<()> {
|
|
let _args = Cli::parse();
|
|
let fmt_layer = tracing_subscriber::fmt::layer();
|
|
|
|
let mut config_dropshot = ConfigDropshot::default();
|
|
config_dropshot.bind_address = SocketAddr::from_str("0.0.0.0:9474").unwrap();
|
|
config_dropshot.request_body_max_bytes = 1024 * 1024;
|
|
|
|
// Adapt the Dropshot logger to tracing
|
|
let dropshot_logger = {
|
|
let level_drain = slog::LevelFilter(TracingSlogDrain, slog::Level::Debug).fuse();
|
|
let async_drain = slog_async::Async::new(level_drain).build().fuse();
|
|
slog::Logger::root(async_drain, slog::o!())
|
|
};
|
|
|
|
let otlp_exporter = opentelemetry_otlp::SpanExporter::builder()
|
|
.with_tonic()
|
|
.with_endpoint("https://localhost:4317")
|
|
.build()
|
|
.map_err(|e| anyhow!("Error creating OTLP exporter: {:?}", e))?;
|
|
|
|
let resource = Resource::from_schema_url(
|
|
[
|
|
KeyValue::new(SERVICE_NAME, env!("CARGO_PKG_NAME")),
|
|
KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
|
|
],
|
|
SCHEMA_URL,
|
|
);
|
|
|
|
let tracer_provider = opentelemetry_sdk::trace::TracerProvider::builder()
|
|
.with_config(
|
|
opentelemetry_sdk::trace::Config::default()
|
|
.with_sampler(Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(
|
|
1.0,
|
|
))))
|
|
.with_id_generator(RandomIdGenerator::default())
|
|
.with_resource(resource),
|
|
)
|
|
.with_batch_exporter(otlp_exporter, opentelemetry_sdk::runtime::Tokio)
|
|
.build();
|
|
|
|
let tracer = tracer_provider.tracer("patagia-controller");
|
|
|
|
tracing_subscriber::registry()
|
|
.with(tracing_subscriber::EnvFilter::from_default_env())
|
|
.with(fmt_layer)
|
|
.with(OpenTelemetryLayer::new(tracer))
|
|
.init();
|
|
|
|
tracing::info!("Patagia Controller");
|
|
|
|
let mut api = ApiDescription::new();
|
|
api.register(api_version).unwrap();
|
|
|
|
ServerBuilder::new(api, Arc::new(()), dropshot_logger)
|
|
.config(config_dropshot)
|
|
.start()
|
|
.map_err(|e| anyhow!("Error starting server: {:?}", e))?
|
|
.await
|
|
.map_err(|e| anyhow!(e))
|
|
}
|