objectstore_server/web/
app.rs1use std::net::SocketAddr;
2
3use anyhow::Result;
4use axum::ServiceExt;
5use axum::extract::Request;
6use objectstore_log::{Level, tracing};
7use sentry::integrations::tower::{NewSentryLayer, SentryHttpLayer};
8use tokio::net::TcpListener;
9use tower::ServiceBuilder;
10use tower_http::catch_panic::CatchPanicLayer;
11use tower_http::trace::{DefaultOnFailure, TraceLayer};
12
13use crate::endpoints;
14use crate::state::ServiceState;
15use crate::web::middleware as m;
16
17#[derive(Debug)]
19pub struct App {
20 router: axum::Router,
21 graceful_shutdown: bool,
22}
23
24impl App {
25 pub fn new(state: ServiceState) -> Self {
30 let middleware = ServiceBuilder::new()
35 .layer(axum::middleware::from_fn(m::capture_request_time))
36 .layer(NewSentryLayer::new_from_top())
37 .layer(SentryHttpLayer::new().enable_transaction())
38 .layer(axum::middleware::from_fn(m::emit_request_metrics))
39 .layer(axum::middleware::from_fn(m::bind_sentry_body))
40 .layer(axum::middleware::from_fn_with_state(
41 state.request_counter.clone(),
42 m::limit_web_concurrency,
43 ))
44 .layer(state.request_counter.layer())
45 .layer(CatchPanicLayer::custom(m::handle_panic))
46 .layer(m::set_server_header())
47 .layer(
48 TraceLayer::new_for_http()
49 .make_span_with(tracing::Span::none())
50 .on_failure(DefaultOnFailure::new().level(Level::DEBUG)),
51 );
52
53 let router = endpoints::routes()
54 .layer(middleware)
55 .with_state(state.clone());
56
57 App {
58 router,
59 graceful_shutdown: false,
60 }
61 }
62
63 pub fn graceful_shutdown(mut self, enable: bool) -> Self {
67 self.graceful_shutdown = enable;
68 self
69 }
70
71 pub async fn serve(self, listener: TcpListener) -> Result<()> {
76 let Self {
77 router,
78 graceful_shutdown,
79 } = self;
80
81 let service =
82 ServiceExt::<Request>::into_make_service_with_connect_info::<SocketAddr>(router);
83
84 if graceful_shutdown {
85 let guard = elegant_departure::get_shutdown_guard();
86 axum::serve(listener, service)
87 .with_graceful_shutdown(guard.wait_owned())
88 .await?;
89 } else {
90 axum::serve(listener, service).await?;
91 }
92
93 Ok(())
94 }
95}
96
97#[cfg(test)]
98mod tests {
99 use axum::body::{Body, to_bytes};
100 use axum::http::StatusCode;
101 use objectstore_service::backend::local_fs::FileSystemConfig;
102 use sentry::protocol::{Context, EnvelopeItem, TraceContext, Transaction};
103 use tower::ServiceExt;
104 use tracing_subscriber::prelude::*;
105
106 use super::*;
107 use crate::config::{AuthZ, Config, StorageConfig};
108 use crate::state::Services;
109
110 fn trace<'a>(transaction: &'a Transaction<'_>) -> &'a TraceContext {
111 let Some(Context::Trace(trace)) = transaction.contexts.get("trace") else {
112 panic!("transaction is missing its trace context");
113 };
114 trace
115 }
116
117 #[test]
118 fn body_task_preserves_sentry_context() {
119 let runtime = tokio::runtime::Builder::new_current_thread()
120 .enable_all()
121 .build()
122 .unwrap();
123 let _subscriber = tracing_subscriber::registry()
124 .with(
125 sentry::integrations::tracing::SpanLayer::new()
126 .with_filter(tracing_subscriber::filter::LevelFilter::DEBUG),
127 )
128 .set_default();
129 let trace_id = "11111111111111111111111111111111";
130 let caller_span = "aaaaaaaaaaaaaaaa";
131 let envelopes = sentry::test::with_captured_envelopes_options(
132 || {
133 runtime.block_on(async {
134 let directory = tempfile::tempdir().unwrap();
135 let state = Services::spawn(Config {
136 storage: StorageConfig::FileSystem(FileSystemConfig {
137 path: directory.path().into(),
138 cogs: None,
139 }),
140 auth: AuthZ {
141 enforce: false,
142 ..Default::default()
143 },
144 ..Default::default()
145 })
146 .await
147 .unwrap();
148 let request = Request::builder()
149 .method("POST")
150 .uri("/v1/objects:batch/test/org=1/")
151 .header("sentry-trace", format!("{trace_id}-{caller_span}-1"))
152 .header("content-type", "multipart/form-data; boundary=boundary")
153 .body(Body::from(concat!(
154 "--boundary\r\n",
155 "x-sn-batch-operation-key: missing\r\n",
156 "x-sn-batch-operation-kind: head\r\n",
157 "\r\n\r\n--boundary--\r\n",
158 )))
159 .unwrap();
160 let response = App::new(state).router.oneshot(request).await.unwrap();
161 assert_eq!(response.status(), StatusCode::OK);
162 let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();
164 assert!(String::from_utf8_lossy(&body).contains("404 Not Found"));
165 })
166 },
167 sentry::ClientOptions::new().traces_sample_rate(1.0),
168 );
169 let transactions: Vec<_> = envelopes
170 .iter()
171 .flat_map(|envelope| envelope.items())
172 .filter_map(|item| match item {
173 EnvelopeItem::Transaction(transaction) => Some(transaction),
174 _ => None,
175 })
176 .collect();
177 let [http, task] = transactions.as_slice() else {
178 panic!("expected exactly one HTTP and one task transaction");
179 };
180 assert_eq!(trace(http).op.as_deref(), Some("http.server"));
181 assert_eq!(trace(task).op.as_deref(), Some("tokio.task"));
182 assert_eq!(task.name.as_deref(), Some("head"));
183 assert_eq!(trace(http).parent_span_id.unwrap().to_string(), caller_span);
184 assert_eq!(
185 trace(task).parent_span_id,
186 Some(trace(http).span_id),
187 "task parent must be the emitted HTTP span"
188 );
189 for transaction in transactions {
190 assert_eq!(trace(transaction).trace_id.to_string(), trace_id);
191 assert_eq!(
192 transaction.tags.get("usecase").map(String::as_str),
193 Some("test")
194 );
195 assert_eq!(
196 transaction.tags.get("scope.org").map(String::as_str),
197 Some("1")
198 );
199 }
200 }
201}