Upgrade Axum to 0.7, tower to 0.5, opentelemetry to 0.23, and hyper to 1.0 (#183)

* refactor(deps): Upgrade deps to support axum 0.7, tower 0.5, opentelemetry 0.23, and hyper 1.0

* style: Run rustfmt on code changes

* build: Upgrade minimum rust version to 1.75, required by the updated zip library

* build: Fix a few more lints
- Allow unused for HeaderValue
- Use identity function in map
- Dont use default for unit struct
- Fix doc indents
- tokio-unstable config

* build: fix warnings and allow mpl for webpki-roots

* refactor: Cleanup differences between axum::http::StatusCode and http::StatusCode

* refactor(deps): Upgrade dependency versions for reqwest, reqwest middleware, reqwest retry, reqwest telemetry, etc

Author: jeckhart

rust+wasm/.github/workflows/tests_and_checks.yml

@@ -21,7 +21,7 @@ jobs:
           - stable
           - nightly
           # minimum version
-          - 1.67
+          - "1.75"
     steps:{% if axum %}
       - name: Install Protoc
         uses: arduino/setup-protoc@v1

rust+wasm/deny.toml

@@ -118,6 +118,7 @@ exceptions = [
     # this is not a problem for us. See https://github.com/dtolnay/unicode-ident/pull/9/files
     { allow = ["Unicode-DFS-2016"], name = "unicode-ident", version = "*"},
     { allow = ["OpenSSL"], name = "ring", version = "*" },
+    { allow = ["MPL-2.0"], name = "webpki-roots", version = "*"},
 ]
 
 # Some crates don't have (easily) machine readable licensing information,

rust+wasm/{{project-name}}/Cargo.axum.toml

@@ -40,35 +40,37 @@ bench = false
 ansi_term = { version = "0.12", optional = true, default-features = false }
 anyhow = { version = "1.0", features = ["backtrace"] }
 async-trait = "0.1"
-axum = { version = "0.6", features = ["headers"] }
-axum-tracing-opentelemetry = { version = "0.10", features = ["otlp"] }
+axum = { version = "0.7" }
+axum-extra = { version = "0.9", features = ["typed-header"] }
+axum-tracing-opentelemetry = { version = "0.19" }
 base64 = "0.21"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 config = "0.13"
 console-subscriber = { version = "0.1", default-features = false, features = [ "parking_lot" ], optional = true }
 const_format = "0.2"
 futures = "0.3"
-headers = "0.3"
-http = "0.2"
-http-serde = "1.1"
-hyper = "0.14"
+headers = "0.4"
+http = "1.1"
+http-serde = "2.1"
+hyper = "1.0.1"
 metrics = "0.20"
 metrics-exporter-prometheus = "0.11"
 metrics-util = { version = "0.14", default-features = true }
 mime = "0.3"
 num_cpus = "1.0"
 once_cell = "1.14"
 openssl = { version = "0.10", features = ["vendored"], default-features = false }
-opentelemetry = { version = "0.18", features = ["rt-tokio", "trace"] }
-opentelemetry-otlp = { version = "0.11", features = ["metrics", "grpc-tonic", "tls-roots"], default-features = false }
-opentelemetry-semantic-conventions = "0.10"
+opentelemetry = { version = "0.23" }
+opentelemetry-otlp = { version = "0.16", features = ["metrics", "grpc-tonic", "tls-roots", "trace"], default-features = false }
+opentelemetry-semantic-conventions = "0.15"
+opentelemetry_sdk = { version = "0.23", features = ["rt-tokio", "trace"] }
 parking_lot = "0.12"{% if bench %}
 proptest = { version = "1.1", optional = true }{% endif %}
-reqwest = { version = "0.11", features = ["json"] }
-reqwest-middleware = "0.2"
-reqwest-retry = "0.2"
-reqwest-tracing = { version = "0.4", features = ["opentelemetry_0_17"] }
-retry-policies = "0.1"
+reqwest = { version = "0.12", features = ["json"] }
+reqwest-middleware = "0.3"
+reqwest-retry = "0.6"
+reqwest-tracing = { version = "0.5", features = ["opentelemetry_0_23"] }
+retry-policies = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_path_to_error = "0.1"
@@ -79,17 +81,17 @@ thiserror = "1.0"
 time = { version = "0.3", features = ["serde-well-known", "serde-human-readable"] }
 tokio = { version = "1.26", features = ["full", "parking_lot"] }
 ## Tied to opentelemetry-otlp dependency
-tonic = { version = "0.8" }
+tonic = { version = "0.11" }
 tower = "0.4"
-tower-http = { version = "0.4", features = ["catch-panic", "request-id", "sensitive-headers", "timeout", "trace", "util"] }
+tower-http = { version = "0.5", features = ["catch-panic", "request-id", "sensitive-headers", "timeout", "trace", "util"] }
 tracing = "0.1"
 tracing-appender = "0.2"
-tracing-opentelemetry = "0.18"
+tracing-opentelemetry = "0.24"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json", "parking_lot", "registry"] }
 ulid = { version = "1.0", features = ["serde"] }
 url = "2.3"
-utoipa = { version = "3.3", features = ["uuid", "axum_extras"] }
-utoipa-swagger-ui = { version = "3.1", features = ["axum"] }
+utoipa = { version = "4.2.3", features = ["uuid", "axum_extras"] }
+utoipa-swagger-ui = { version = "7.1.0", features = ["axum"] }
 
 [dev-dependencies]
 assert-json-diff = "2.0"{% if bench %}

rust+wasm/{{project-name}}/src.axum/error.rs

@@ -5,7 +5,6 @@ use axum::{
     response::{IntoResponse, Response},
     Json,
 };
-
 use serde::{Deserialize, Serialize};
 use tracing::warn;
 use ulid::Ulid;
@@ -84,8 +83,8 @@ impl From<AppError> for (StatusCode, Json<ErrorResponse>) {
 
 impl IntoResponse for AppError {
     fn into_response(self) -> Response {
-        let error_response: (StatusCode, Json<ErrorResponse>) = self.into();
-        error_response.into_response()
+        let resp: (StatusCode, Json<ErrorResponse>) = self.into();
+        resp.into_response()
     }
 }
 
@@ -115,7 +114,7 @@ impl From<anyhow::Error> for AppError {
 ///
 /// We could have used http_serde, but it encodes the status code as a NUMBER.
 pub mod serde_status_code {
-    use http::StatusCode;
+    use axum::http::StatusCode;
     use serde::{de::Unexpected, Deserialize, Deserializer, Serialize, Serializer};
 
     /// Serialize [StatusCode]s.
@@ -148,7 +147,9 @@ impl std::fmt::Display for AppError {
 #[cfg(test)]
 /// Parse the app error out of the json body
 pub async fn parse_error(response: Response) -> AppError {
-    let body_bytes = hyper::body::to_bytes(response.into_body()).await.unwrap();
+    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
+        .await
+        .unwrap();
     let mut err_response: ErrorResponse = serde_json::from_slice(&body_bytes).unwrap();
     err_response.errors.remove(0)
 }

rust+wasm/{{project-name}}/src.axum/extract/json.rs

@@ -2,15 +2,12 @@
 
 use async_trait::async_trait;
 use axum::{
-    body::{Bytes, HttpBody},
-    extract::FromRequest,
+    body::Bytes,
+    extract::{FromRequest, Request},
+    http::{header, StatusCode},
     response::{IntoResponse, Response},
-    BoxError,
-};
-use http::{
-    header::{self, HeaderMap, HeaderValue},
-    Request, StatusCode,
 };
+use axum_extra::headers::{HeaderMap, HeaderValue};
 use serde::{de::DeserializeOwned, Serialize};
 use std::ops::{Deref, DerefMut};
 use tracing::warn;
@@ -38,6 +35,7 @@ use crate::error::AppError;
 /// # Extractor example
 ///
 /// ```rust,no_run
+/// use std::net::SocketAddr;
 /// use axum::{
 ///     response,
 ///     routing::post,
@@ -46,6 +44,8 @@ use crate::error::AppError;
 /// use {{crate_name}}::extract;
 /// use serde::Deserialize;
 ///
+/// use tokio::net::TcpListener;
+///
 /// #[derive(Deserialize)]
 /// struct CreateUser {
 ///     email: String,
@@ -58,24 +58,25 @@ use crate::error::AppError;
 ///
 /// let app = Router::new().route("/users", post(create_user));
 /// # async {
-/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
+/// # let port = 3000;
+/// # let listener = TcpListener::bind(format!("0.0.0.0:{port}")).await.unwrap();
+/// #     axum::serve(listener, app.into_make_service_with_connect_info::<SocketAddr>())
+/// #         .await
+/// #         .unwrap();
 /// # };
 /// ```
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Json<T>(pub T);
 
 #[async_trait]
-impl<T, S, B> FromRequest<S, B> for Json<T>
+impl<T, S> FromRequest<S> for Json<T>
 where
     T: DeserializeOwned,
-    B: HttpBody + Send + 'static,
-    B::Data: Send,
-    B::Error: Into<BoxError>,
     S: Send + Sync,
 {
     type Rejection = AppError;
 
-    async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
+    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
         if json_content_type(req.headers()) {
             let bytes = Bytes::from_request(req, state).await.map_err(|err| {
                 warn!(
@@ -202,9 +203,11 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use axum::routing::{get, Router};
-    use http::Request;
-    use hyper::Body;
+    use axum::{
+        body::Body,
+        http::Request,
+        routing::{get, Router},
+    };
     use serde::Deserialize;
     use tower::ServiceExt;
 
@@ -232,7 +235,9 @@ mod tests {
             .await
             .unwrap();
 
-        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+            .await
+            .unwrap();
         let body_text = std::str::from_utf8(&body[..]).unwrap();
         dbg!(body_text);
         assert_eq!(body_text, "bar");

rust+wasm/{{project-name}}/src.axum/headers/header.rs

@@ -1,13 +1,13 @@
-use axum::{extract::TypedHeader, headers::Header};
+use axum_extra::{headers::Header, TypedHeader};
 
 /// Generate String-focused, generic, custom typed [`Header`]'s.
 #[allow(unused)]
 macro_rules! header {
     ($tname:ident, $hname:ident, $sname:expr) => {
-        static $hname: once_cell::sync::Lazy<axum::headers::HeaderName> =
-            once_cell::sync::Lazy::new(|| axum::headers::HeaderName::from_static($sname));
+        static $hname: once_cell::sync::Lazy<axum_extra::headers::HeaderName> =
+            once_cell::sync::Lazy::new(|| axum_extra::headers::HeaderName::from_static($sname));
 
-        #[doc = "Generated custom [`axum::headers::Header`] for "]
+        #[doc = "Generated custom [`axum_extra::headers::Header`] for "]
         #[doc = $sname]
         #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
         pub(crate) struct $tname(pub(crate) String);
@@ -24,27 +24,27 @@ macro_rules! header {
             }
         }
 
-        impl axum::headers::Header for $tname {
-            fn name() -> &'static axum::headers::HeaderName {
+        impl axum_extra::headers::Header for $tname {
+            fn name() -> &'static axum_extra::headers::HeaderName {
                 &$hname
             }
 
-            fn decode<'i, I>(values: &mut I) -> Result<Self, axum::headers::Error>
+            fn decode<'i, I>(values: &mut I) -> Result<Self, axum_extra::headers::Error>
             where
-                I: Iterator<Item = &'i axum::headers::HeaderValue>,
+                I: Iterator<Item = &'i axum_extra::headers::HeaderValue>,
             {
                 values
                     .next()
                     .and_then(|v| v.to_str().ok())
                     .map(|x| $tname(x.to_string()))
-                    .ok_or_else(axum::headers::Error::invalid)
+                    .ok_or_else(axum_extra::headers::Error::invalid)
             }
 
             fn encode<E>(&self, values: &mut E)
             where
-                E: Extend<axum::headers::HeaderValue>,
+                E: Extend<axum_extra::headers::HeaderValue>,
             {
-                if let Ok(value) = axum::headers::HeaderValue::from_str(&self.0) {
+                if let Ok(value) = axum_extra::headers::HeaderValue::from_str(&self.0) {
                     values.extend(std::iter::once(value));
                 }
             }
@@ -79,10 +79,8 @@ where
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use axum::{
-        headers::{Header, HeaderMapExt},
-        http,
-    };
+    use axum::http;
+    use axum_extra::headers::{Header, HeaderMapExt};
 
     header!(XDummyId, XDUMMY_ID, "x-dummy-id");
 

rust+wasm/{{project-name}}/src.axum/main.rs

@@ -1,19 +1,14 @@
 //! {{project-name}}
 
 use anyhow::Result;
-use axum::{extract::Extension, headers::HeaderName, routing::get, Router};
-use axum_tracing_opentelemetry::{opentelemetry_tracing_layer, response_with_trace_layer};
+use axum::{extract::Extension, routing::get, Router};
+use axum_tracing_opentelemetry::middleware::{OtelAxumLayer, OtelInResponseLayer};
+use headers::HeaderName;
 use http::header;
-use std::{
-    future::ready,
-    io,
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-    time::Duration,
-};
-use tokio::signal::{
-    self,
-    unix::{signal, SignalKind},
-};
+use std::{future::ready, io, iter::once, net::SocketAddr, time::Duration};
+#[cfg(unix)]
+use tokio::signal::unix::{signal, SignalKind};
+use tokio::{net::TcpListener, signal};
 use tower::ServiceBuilder;
 use tower_http::{
     catch_panic::CatchPanicLayer, sensitive_headers::SetSensitiveHeadersLayer,
@@ -83,11 +78,11 @@ async fn main() -> Result<()> {
             .route_layer(axum::middleware::from_fn(middleware::metrics::track))
             .layer(Extension(env))
             // Include trace context as header into the response.
-            .layer(response_with_trace_layer())
+            .layer(OtelInResponseLayer)
             // Opentelemetry tracing middleware.
             // This returns a `TraceLayer` configured to use
             // OpenTelemetry’s conventional span field names.
-            .layer(opentelemetry_tracing_layer())
+            .layer(OtelAxumLayer::default())
             // Set and propagate "request_id" (as a ulid) per request.
             .layer(
                 ServiceBuilder::new()
@@ -103,7 +98,9 @@ async fn main() -> Result<()> {
             // `500 Internal Server` responses.
             .layer(CatchPanicLayer::custom(runtime::catch_panic))
             // Mark headers as sensitive on both requests and responses.
-            .layer(SetSensitiveHeadersLayer::new([header::AUTHORIZATION]))
+            .layer(SetSensitiveHeadersLayer::new(once(
+                HeaderName::from_static(header::AUTHORIZATION.as_str()),
+            )))
             .merge(SwaggerUi::new("/swagger-ui").url("/api-doc/openapi.json", ApiDoc::openapi()));
 
         serve("Application", router, settings.server().port).await
@@ -114,19 +111,23 @@ async fn main() -> Result<()> {
 }
 
 async fn serve(name: &str, app: Router, port: u16) -> Result<()> {
-    let bind_addr: SocketAddr = SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port);
+    // let bind_addr: SocketAddr = SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port);
+    let listener = TcpListener::bind(format!("0.0.0.0:{port}")).await.unwrap();
     info!(
         subject = "app_start",
         category = "init",
         "{} server listening on {}",
         name,
-        bind_addr
+        port
     );
 
-    axum::Server::bind(&bind_addr)
-        .serve(app.into_make_service_with_connect_info::<SocketAddr>())
-        .with_graceful_shutdown(shutdown())
-        .await?;
+    axum::serve(
+        listener,
+        app.into_make_service_with_connect_info::<SocketAddr>(),
+    )
+    .with_graceful_shutdown(shutdown())
+    .await
+    .unwrap();
 
     Ok(())
 }

rust+wasm/{{project-name}}/src.axum/middleware/client/metrics.rs

@@ -1,8 +1,8 @@
 //! Middleware for tracking metrics on each client [reqwest::Request].
 
+use http::Extensions;
 use reqwest_middleware::Middleware as ReqwestMiddleware;
 use std::time::Instant;
-use task_local_extensions::Extensions;
 
 const OK: &str = "ok";
 const ERROR: &str = "error";