cors and tracing

Cargo.lock

···
  "atrium-oauth",
  "clap",
  "ctrlc",
- "env_logger",
  "foyer",
  "hickory-resolver",
  "jetstream",
···
  "time",
  "tokio",
  "tokio-util",
+ "tracing-subscriber",
  "url",
 ]
 

slingshot/Cargo.toml

···
 atrium-oauth = "0.1.3"
 clap = { version = "4.5.41", features = ["derive"] }
 ctrlc = "3.4.7"
-env_logger = "0.11.8"
 foyer = { version = "0.18.0", features = ["serde"] }
 hickory-resolver = "0.25.2"
 jetstream = { path = "../jetstream", features = ["metrics"] }
···
 time = { version = "0.3.41", features = ["serde"] }
 tokio = { version = "1.47.0", features = ["full"] }
 tokio-util = "0.7.15"
+tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 url = "2.5.4"

slingshot/src/main.rs

···
 
 #[tokio::main]
 async fn main() -> Result<(), String> {
-    env_logger::init();
+    tracing_subscriber::fmt::init();
 
     let shutdown = CancellationToken::new();
 

slingshot/src/server.rs

···
 use tokio_util::sync::CancellationToken;
 
 use poem::{
-    Endpoint, Route, Server,
+    Endpoint, EndpointExt, Route, Server,
     endpoint::make_sync,
+    http::Method,
     listener::{
         Listener, TcpListener,
         acme::{AutoCert, LETS_ENCRYPT_PRODUCTION},
     },
+    middleware::{Cors, Tracing},
 };
 use poem_openapi::{
     ApiResponse, Object, OpenApi, OpenApiService, param::Query, payload::Json, types::Example,
···
             .server("http://localhost:3000")
             .url_prefix("/xrpc");
 
-    let app = Route::new()
+    let mut app = Route::new()
         .nest("/", api_service.scalar())
         .nest("/openapi.json", api_service.spec_endpoint())
         .nest("/xrpc/", api_service);
···
             .install_default()
             .expect("alskfjalksdjf");
 
-        let app = app.at("/.well-known/did.json", get_did_doc(&host));
+        app = app
+            .at("/.well-known/did.json", get_did_doc(&host));
 
         let auto_cert = AutoCert::builder()
             .directory_url(LETS_ENCRYPT_PRODUCTION)
···
             .build()
             .map_err(ServerError::AcmeBuildError)?;
 
-        Server::new(TcpListener::bind("0.0.0.0:443").acme(auto_cert))
-            .name("slingshot")
-            .run(app)
-            .await
-            .map_err(ServerError::ServerExited)
+        run(TcpListener::bind("0.0.0.0:443").acme(auto_cert), app).await
     } else {
-        Server::new(TcpListener::bind("127.0.0.1:3000"))
-            .name("slingshot")
-            .run(app)
-            .await
-            .map_err(ServerError::ServerExited)
+        run(TcpListener::bind("127.0.0.1:3000"), app).await
     }
 }
+
+async fn run<L>(listener: L, app: Route) -> Result<(), ServerError>
+where
+    L: Listener + 'static
+{
+    let app = app
+        .with(Cors::new()
+            .allow_method(Method::GET)
+            .allow_credentials(false))
+        .with(Tracing);
+    Server::new(listener)
+        .name("slingshot")
+        .run(app)
+        .await
+        .map_err(ServerError::ServerExited)
+}