Re-export Hyper types used in public API

Foundations uses Hyper types in it's public API for
`TelemetryServerRoute` which means any users will need to add an
explicit dependency on the same version of hyper and ensure it stays
matching. Re-exporting the types will allow users to explicitly use the
same types as foundations is using.

For simplicity, we re-export the entire `hyper` crate under a new
`foundations::telemetry::reexports` module.

Author: Thea Heinen

foundations/src/telemetry/mod.rs

@@ -132,9 +132,15 @@ pub use self::memory_profiler::MemoryProfiler;
 
 #[cfg(feature = "telemetry-server")]
 pub use self::server::{
-    BoxError, TelemetryRouteHandler, TelemetryRouteHandlerFuture, TelemetryServerRoute,
+    TelemetryRouteBody, TelemetryRouteHandler, TelemetryRouteHandlerFuture, TelemetryServerRoute,
 };
 
+#[cfg(feature = "telemetry-server")]
+/// Re-exported crates which are used in public `telemetry` APIs.
+pub mod reexports {
+    pub use hyper;
+}
+
 pub use self::telemetry_context::{
     TelemetryContext, WithTelemetryContext, WithTelemetryContextLocal,
 };

foundations/src/telemetry/server/mod.rs

@@ -131,7 +131,7 @@ impl TelemetryListener {
 }
 
 pub use router::{
-    BoxError, TelemetryRouteHandler, TelemetryRouteHandlerFuture, TelemetryServerRoute,
+    TelemetryRouteBody, TelemetryRouteHandler, TelemetryRouteHandlerFuture, TelemetryServerRoute,
 };
 
 pub(super) struct TelemetryServerFuture {

foundations/src/telemetry/server/router.rs

@@ -16,12 +16,12 @@ use std::collections::HashMap;
 use std::convert::Infallible;
 use std::sync::Arc;
 
+/// Body type used in [`TelemetryServerRoute`] responses.
+pub type TelemetryRouteBody = BoxBody<Bytes, crate::Error>;
+
 /// Future returned by [`TelemetryServerRoute::handler`].
 pub type TelemetryRouteHandlerFuture =
-    BoxFuture<'static, std::result::Result<Response<BoxBody<Bytes, BoxError>>, Infallible>>;
-
-/// Error type returned by [`TelemetryRouteHandlerFuture`].
-pub type BoxError = Box<dyn std::error::Error + Send + Sync>;
+    BoxFuture<'static, Result<Response<TelemetryRouteBody>, Infallible>>;
 
 /// Telemetry route handler.
 pub type TelemetryRouteHandler = Box<
@@ -156,7 +156,7 @@ impl Router {
         }
     }
 
-    async fn handle_request(&self, req: Request<Incoming>) -> Response<BoxBody<Bytes, BoxError>> {
+    async fn handle_request(&self, req: Request<Incoming>) -> Response<TelemetryRouteBody> {
         let res = Response::builder();
 
         let Ok(path) = percent_decode_str(req.uri().path()).decode_utf8() else {
@@ -188,7 +188,7 @@ impl Router {
 }
 
 impl Service<Request<Incoming>> for Router {
-    type Response = Response<BoxBody<Bytes, BoxError>>;
+    type Response = Response<TelemetryRouteBody>;
     type Error = Infallible;
     type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
 
@@ -202,7 +202,7 @@ impl Service<Request<Incoming>> for Router {
 fn into_response(
     content_type: &str,
     res: crate::Result<impl Into<Full<Bytes>>>,
-) -> std::result::Result<Response<BoxBody<Bytes, BoxError>>, Infallible> {
+) -> Result<Response<TelemetryRouteBody>, Infallible> {
     Ok(match res {
         Ok(data) => Response::builder()
             .header(header::CONTENT_TYPE, content_type)

foundations/tests/telemetry_server.rs

@@ -1,11 +1,12 @@
 use foundations::telemetry::settings::{
     LivenessTrackingSettings, TelemetryServerSettings, TelemetrySettings, TracingSettings,
 };
-use foundations::telemetry::{TelemetryConfig, TelemetryContext, TelemetryServerRoute};
+use foundations::telemetry::{
+    reexports::hyper::{Method, Response},
+    TelemetryConfig, TelemetryContext, TelemetryRouteBody, TelemetryServerRoute,
+};
 use futures_util::FutureExt;
-use http_body_util::combinators::BoxBody;
 use http_body_util::{BodyExt, Full};
-use hyper::{Method, Response};
 use std::future::IntoFuture;
 use std::net::{Ipv4Addr, SocketAddr};
 
@@ -56,7 +57,7 @@ async fn telemetry_server() {
                 methods: vec![Method::GET],
                 handler: Box::new(|_, _| {
                     async {
-                        Ok(Response::new(BoxBody::new(
+                        Ok(Response::new(TelemetryRouteBody::new(
                             Full::from("Hello").map_err(Into::into),
                         )))
                     }