updates

Cargo.toml

@@ -6,37 +6,33 @@ edition = "2021"
 [dependencies]
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-tracing-opentelemetry = "0.27.0"
+tracing-opentelemetry = "0.29.0"
-opentelemetry = { version = "0.26.0" }
+opentelemetry = { version = "0.28.0" }
-opentelemetry_sdk = { version = "0.26.0", features = ["rt-tokio"] }
+opentelemetry_sdk = { version = "0.28.0", features = ["rt-tokio"] }
-opentelemetry-otlp = { version = "0.26.0", features = ["tls"] }
+opentelemetry-otlp = { version = "0.28.0", features = ["tls", "grpc-tonic"] }
 serde = { version = "1.0.203", features = ["derive"] }
-toml = "0.8.14"
+sqlx = { version = "0.8.3", features = ["postgres", "time", "runtime-tokio-rustls"] }
-sqlx = { version = "0.7.4", features = ["postgres", "time", "runtime-tokio-rustls"] }
+sea-query = { version = "0.32.3", features = ["backend-postgres", "with-time", "derive"] }
-sea-query = { version = "0.30.7", features = ["backend-postgres", "with-time", "derive"] }
+sea-query-binder = { version = "0.7.0", features = ["with-time", "sqlx-postgres"] }
-sea-query-binder = { version = "0.5.0", features = ["with-time", "sqlx-postgres"] }
+thiserror = "2.0.12"
-thiserror = "1.0.61"
 tokio = { version = "1.38.0", features = ["full"] }
-config = { version = "0.14.0", features = ["toml"] }
+config = { version = "0.15.11", features = ["toml"] }
 time = "0.3.36"
-maud = { version = "0.26.0", features = ["axum"] }
+maud = { version = "0.27.0", features = ["axum"] }
-axum = { version = "0.7.5", features = ["macros"] }
+axum = { version = "0.8.1", features = ["macros"] }
 hyper = "1.3.1"
 hyper-util = { version = "0.1.5", features = ["tokio", "server"] }
-axum-extra = { version = "0.9.3", features = ["typed-header", "cookie"] }
+axum-extra = { version = "0.10.0", features = ["typed-header", "cookie"] }
-tower-http = { version = "0.5.2", features = ["trace", "fs"] }
+tower-http = { version = "0.6.2", features = ["trace", "fs"] }
 steamid-ng = "1.0.0"
-itertools = "0.13.0"
+itertools = "0.14.0"
-const-fnv1a-hash = "1.1.0"
-const_base = "0.2.0"
-const-str = "0.5.7"
 steam-openid = "0.2.0"
 async-session = "3.0.0"
-quick-xml = { version = "0.36.2", features = ["serialize"] }
+quick-xml = { version = "0.37.2", features = ["serialize"] }
 reqwest = "0.12.4"
-rand = "0.8.5"
+rand = "0.9.0"
 demostf-build = { path = "./build", version = "*" }
 include_dir = "0.7.3"
-serde-env = "0.1.1"
+serde-env = "0.2.0"
 tonic = { version = "0.12.3", features = ["tls", "tls-webpki-roots"] }
 secretfile = "0.1.0"

src/data/steam_id.rs

@@ -1,7 +1,6 @@
 use maud::Render;
 use sea_query::Value;
 use serde::{de::Error, Deserialize, Deserializer, Serialize};
-use sqlx::database::HasValueRef;
 use sqlx::error::BoxDynError;
 use sqlx::{Database, Decode, Type};
 use std::borrow::Cow;
@@ -83,7 +82,7 @@ where
     DB: Database,
     &'r str: Decode<'r, DB>,
 {
-    fn decode(value: <DB as HasValueRef<'r>>::ValueRef) -> Result<Self, BoxDynError> {
+    fn decode(value: DB::ValueRef<'r>) -> Result<Self, BoxDynError> {
         let str = <&str as Decode<DB>>::decode(value)?;
         Ok(str.parse().unwrap())
     }

src/data/user.rs

@@ -1,7 +1,7 @@
 use crate::data::steam_id::SteamId;
 use crate::{Error, Result};
 use maud::Render;
-use rand::distributions::Alphanumeric;
+use rand::distr::Alphanumeric;
 use rand::Rng;
 use reqwest::get;
 use serde::{Deserialize, Serialize};
@@ -79,7 +79,7 @@ impl User {
             })
         } else {
             let profile = Self::fetch(&steam_id).await?;
-            let token: String = rand::thread_rng()
+            let token: String = rand::rng()
                 .sample_iter(&Alphanumeric)
                 .take(64)
                 .map(char::from)

src/error.rs

@@ -2,6 +2,7 @@ use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 use config::ConfigError;
 use opentelemetry::trace::TraceError;
+use opentelemetry_sdk::logs::LogError;
 use secretfile::SecretError;
 use tracing_subscriber::util::TryInitError;
 
@@ -34,6 +35,8 @@ pub enum SetupError {
     #[error(transparent)]
     Tracing(#[from] TraceError),
     #[error(transparent)]
+    Log(#[from] LogError),
+    #[error(transparent)]
     TracingSubscriber(#[from] TryInitError),
     #[error(transparent)]
     Config(#[from] ConfigError),

src/main.rs

@@ -46,8 +46,9 @@ use include_dir::{include_dir, Dir};
 use maud::{Markup, Render};
 use opentelemetry::trace::TracerProvider;
 use opentelemetry::KeyValue;
-use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_otlp::{SpanExporter, WithExportConfig, WithTonicConfig};
-use opentelemetry_sdk::{runtime, trace, Resource};
+use opentelemetry_sdk::trace::SdkTracerProvider;
+use opentelemetry_sdk::Resource;
 use secretfile::load;
 use sqlx::PgPool;
 use std::convert::Infallible;
@@ -104,8 +105,8 @@ fn setup() -> Result<Config, SetupError> {
     {
         let mut tls_config = ClientTlsConfig::new().with_webpki_roots();
 
-        let mut otlp_exporter = opentelemetry_otlp::new_exporter()
+        let mut otlp_exporter = SpanExporter::builder()
-            .tonic()
+            .with_tonic()
             .with_endpoint(&tracing_cfg.endpoint);
 
         if let Some(tracing_ident) = tracing_cfg.tls.as_ref().map(|tracing_tls_cfg| {
@@ -117,13 +118,14 @@ fn setup() -> Result<Config, SetupError> {
         }
         otlp_exporter = otlp_exporter.with_tls_config(tls_config);
 
-        let tracer = opentelemetry_otlp::new_pipeline()
+        let tracer = SdkTracerProvider::builder()
-            .tracing()
+            .with_resource(
-            .with_exporter(otlp_exporter)
+                Resource::builder()
-            .with_trace_config(trace::Config::default().with_resource(Resource::new(vec![
+                    .with_attribute(KeyValue::new("service.name", "demos.tf"))
-                KeyValue::new("service.name", "demos.tf"),
+                    .build(),
-            ])))
+            )
-            .install_batch(runtime::Tokio)?
+            .with_batch_exporter(otlp_exporter.build()?)
+            .build()
             .tracer("demos.tf");
         Some(tracing_opentelemetry::layer().with_tracer(tracer))
     } else {
@@ -164,8 +166,8 @@ async fn main() -> Result<()> {
 
     let app = Router::new()
         .route("/", get(index))
-        .route("/uploads/:uploader", get(uploads))
+        .route("/uploads/{uploader}", get(uploads))
-        .route("/profiles/:uploader", get(profiles))
+        .route("/profiles/{uploader}", get(profiles))
         .route(GlobalStyle::route(), get(serve_asset::<GlobalStyle>))
         .route(
             ClassIconsStyle::route(),
@@ -198,9 +200,9 @@ async fn main() -> Result<()> {
         .route("/upload", get(upload))
         .route("/viewer", get(viewer))
         .route("/edit", get(edit))
-        .route("/viewer/:id", get(viewer))
+        .route("/viewer/{id}", get(viewer))
-        .route("/:id", get(demo))
+        .route("/{id}", get(demo))
-        .route("/images/kill_icons/:icon", get(kill_icons))
+        .route("/images/kill_icons/{icon}", get(kill_icons))
         .layer(
             TraceLayer::new_for_http().make_span_with(|request: &Request<_>| {
                 let matched_path = request
@@ -298,12 +300,12 @@ async fn main() -> Result<()> {
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn index(
     State(app): State<Arc<App>>,
     session: SessionData,
-    filter: Option<Query<Filter>>,
+    Query(filter): Query<Filter>,
 ) -> Result<Markup> {
-    let filter = filter.map(|filter| filter.0).unwrap_or_default();
     let demos = ListDemo::list(&app.connection, filter).await?;
     Ok(render(
         Index {
@@ -316,6 +318,7 @@ async fn index(
 }
 
 #[instrument(skip(_app))]
+#[axum::debug_handler]
 async fn about(State(_app): State<Arc<App>>, session: SessionData) -> Result<Markup> {
     Ok(render(
         AboutPage {
@@ -326,6 +329,7 @@ async fn about(State(_app): State<Arc<App>>, session: SessionData) -> Result<Mar
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn api(State(app): State<Arc<App>>, session: SessionData) -> Result<Markup> {
     Ok(render(
         ApiPage {
@@ -337,6 +341,7 @@ async fn api(State(app): State<Arc<App>>, session: SessionData) -> Result<Markup
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn demo(
     State(app): State<Arc<App>>,
     Path(id): Path<String>,
@@ -349,6 +354,7 @@ async fn demo(
     Ok(render(DemoPage { demo }, session))
 }
 
+#[axum::debug_handler]
 async fn login_callback(
     State(app): State<Arc<App>>,
     RawQuery(query): RawQuery,
@@ -387,6 +393,7 @@ async fn login_callback(
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn login(State(app): State<Arc<App>>) -> impl IntoResponse {
     (
         StatusCode::FOUND,
@@ -398,6 +405,7 @@ async fn login(State(app): State<Arc<App>>) -> impl IntoResponse {
 }
 
 #[instrument(skip(app, cookie))]
+#[axum::debug_handler]
 async fn logout(
     State(app): State<Arc<App>>,
     cookie: Option<TypedHeader<Cookie>>,
@@ -424,6 +432,7 @@ async fn logout(
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn upload(State(app): State<Arc<App>>, session: SessionData) -> impl IntoResponse {
     if let Some(token) = session.token() {
         render(
@@ -444,20 +453,20 @@ async fn upload(State(app): State<Arc<App>>, session: SessionData) -> impl IntoR
 }
 
 #[instrument(skip(app))]
-async fn demo_list(State(app): State<Arc<App>>, filter: Option<Query<Filter>>) -> Result<Markup> {
+#[axum::debug_handler]
-    let filter = filter.map(|filter| filter.0).unwrap_or_default();
+async fn demo_list(State(app): State<Arc<App>>, Query(filter): Query<Filter>) -> Result<Markup> {
     let demos = ListDemo::list(&app.connection, filter).await?;
     Ok(DemoList { demos: &demos }.render())
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn uploads(
     State(app): State<Arc<App>>,
     session: SessionData,
-    filter: Option<Query<Filter>>,
+    Query(mut filter): Query<Filter>,
     Path(uploader): Path<SteamId>,
 ) -> Result<Markup> {
-    let mut filter = filter.map(|filter| filter.0).unwrap_or_default();
     filter.uploader = Some(uploader.clone());
 
     let demos = ListDemo::list(&app.connection, filter).await?;
@@ -476,13 +485,13 @@ async fn uploads(
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn profiles(
     State(app): State<Arc<App>>,
     session: SessionData,
-    filter: Option<Query<Filter>>,
+    Query(mut filter): Query<Filter>,
     Path(profile): Path<SteamId>,
 ) -> Result<Markup> {
-    let mut filter = filter.map(|filter| filter.0).unwrap_or_default();
     filter.players.push(profile.clone());
 
     let demos = ListDemo::list(&app.connection, filter).await?;
@@ -501,6 +510,7 @@ async fn profiles(
 }
 
 #[instrument(skip(app))]
+#[axum::debug_handler]
 async fn viewer(
     State(app): State<Arc<App>>,
     id: Option<Path<String>>,
@@ -526,14 +536,17 @@ async fn viewer(
     ))
 }
 
-async fn edit(session: SessionData) -> Result<Markup> {
+#[axum::debug_handler]
+async fn edit(State(_app): State<Arc<App>>, session: SessionData) -> Result<Markup> {
     Ok(render(EditorPage, session))
 }
 
+#[axum::debug_handler]
 async fn handler_404() -> impl IntoResponse {
     Error::NotFound
 }
 
+#[axum::debug_handler]
 pub async fn kill_icons(path: Path<String>) -> impl IntoResponse {
     let path = path.as_str();
     match KILL_ICONS.get_file(path) {

src/session.rs

@@ -4,11 +4,11 @@ use crate::{App, Result};
 use async_session::SessionStore as _;
 use axum::extract::{FromRef, FromRequestParts};
 use axum::http::request::Parts;
-use axum::{async_trait, RequestPartsExt};
+use axum::RequestPartsExt;
-use std::convert::Infallible;
-use std::sync::Arc;
 use axum_extra::headers::Cookie;
 use axum_extra::TypedHeader;
+use std::convert::Infallible;
+use std::sync::Arc;
 use tracing::debug;
 
 pub const COOKIE_NAME: &str = "tf_session";
@@ -34,7 +34,6 @@ impl SessionData {
     }
 }
 
-#[async_trait]
 impl<S> FromRequestParts<S> for SessionData
 where
     Arc<App>: FromRef<S>,