1use std::error::Error as StdError;
2
3use crate::request::ConnectionMeta;
4use crate::sentinel::Sentry;
5use crate::util::Formatter;
6use crate::{route, Catcher, Config, Error, Request, Response, Route};
7use crate::error::ErrorKind;
8
9use figment::Figment;
10use rocket::http::Header;
11use tracing::Level;
12
13pub trait Trace {
14 fn trace(&self, level: Level);
15
16 #[inline(always)] fn trace_info(&self) { self.trace(Level::INFO) }
17 #[inline(always)] fn trace_warn(&self) { self.trace(Level::WARN) }
18 #[inline(always)] fn trace_error(&self) { self.trace(Level::ERROR) }
19 #[inline(always)] fn trace_debug(&self) { self.trace(Level::DEBUG) }
20 #[inline(always)] fn trace_trace(&self) { self.trace(Level::TRACE) }
21}
22
23pub trait TraceAll: Sized {
24 fn trace_all(self, level: Level);
25
26 #[inline(always)] fn trace_all_info(self) { self.trace_all(Level::INFO) }
27 #[inline(always)] fn trace_all_warn(self) { self.trace_all(Level::WARN) }
28 #[inline(always)] fn trace_all_error(self) { self.trace_all(Level::ERROR) }
29 #[inline(always)] fn trace_all_debug(self) { self.trace_all(Level::DEBUG) }
30 #[inline(always)] fn trace_all_trace(self) { self.trace_all(Level::TRACE) }
31}
32
33impl<T: Trace, I: IntoIterator<Item = T>> TraceAll for I {
34 fn trace_all(self, level: Level) {
35 self.into_iter().for_each(|i| i.trace(level))
36 }
37}
38
39impl<T: Trace> Trace for &T {
40 #[inline(always)]
41 fn trace(&self, level: Level) {
42 T::trace(self, level)
43 }
44}
45
46impl Trace for Figment {
47 fn trace(&self, level: Level) {
48 for param in Config::PARAMETERS {
49 if let Some(source) = self.find_metadata(param) {
50 if param.contains("secret") {
51 continue;
52 }
53
54 event! { level, "figment",
55 param,
56 %source.name,
57 source.source = source.source.as_ref().map(display),
58 value = self.find_value(param).ok().map(debug),
59 }
60 }
61 }
62
63 for (key, replacement) in Config::DEPRECATED_KEYS {
65 if let Some(source) = self.find_metadata(key) {
66 event! { Level::WARN, "deprecated",
67 key,
68 replacement,
69 %source.name,
70 source.source = source.source.as_ref().map(display),
71 "config key `{key}` is deprecated and has no meaning"
72 }
73 }
74 }
75 }
76}
77
78impl Trace for Config {
79 fn trace(&self, level: Level) {
80 event! { level, "config",
81 http2 = cfg!(feature = "http2"),
82 log_level = self.log_level.map(|l| l.as_str()),
83 log_format = ?self.log_format,
84 cli_colors = %self.cli_colors,
85 workers = self.workers,
86 max_blocking = self.max_blocking,
87 wake_interval = (self.wake_interval != 0).then_some(self.wake_interval),
88 ident = %self.ident,
89 ip_header = self.ip_header.as_ref().map(|s| s.as_str()),
90 proxy_proto_header = self.proxy_proto_header.as_ref().map(|s| s.as_str()),
91 limits = %Formatter(|f| f.debug_map()
92 .entries(self.limits.limits.iter().map(|(k, v)| (k.as_str(), display(v))))
93 .finish()),
94 temp_dir = %self.temp_dir.relative().display(),
95 keep_alive = (self.keep_alive != 0).then_some(self.keep_alive),
96 linger = (self.linger != 0).then_some(self.linger),
97 shutdown.ctrlc = self.shutdown.ctrlc,
98 shutdown.signals = %{
99 #[cfg(not(unix))] {
100 "disabled (not unix)"
101 }
102
103 #[cfg(unix)] {
104 Formatter(|f| f.debug_set()
105 .entries(self.shutdown.signals.iter().map(|s| s.as_str()))
106 .finish())
107 }
108 },
109 shutdown.grace = self.shutdown.grace,
110 shutdown.mercy = self.shutdown.mercy,
111 shutdown.force = self.shutdown.force,
112 }
113
114 #[cfg(feature = "secrets")] {
115 if !self.secret_key.is_provided() {
116 warn! {
117 name: "volatile_secret_key",
118 "secrets enabled without configuring a stable `secret_key`\n\
119 private/signed cookies will become unreadable after restarting\n\
120 disable the `secrets` feature or configure a `secret_key`\n\
121 this becomes a hard error in non-debug profiles",
122 }
123 }
124
125 let secret_key_is_known = Config::KNOWN_SECRET_KEYS.iter().any(|&key_str| {
126 let value = figment::value::Value::from(key_str);
127 self.secret_key == value.deserialize().expect("known key is valid")
128 });
129
130 if secret_key_is_known {
131 warn! {
132 name: "insecure_secret_key",
133 "The configured `secret_key` is exposed and insecure. \
134 The configured key is publicly published and thus insecure. \
135 Try generating a new key with `head -c64 /dev/urandom | base64`."
136 }
137 }
138 }
139 }
140}
141
142impl Trace for Route {
143 fn trace(&self, level: Level) {
144 event! { level, "route",
145 name = self.name.as_ref().map(|n| &**n),
146 rank = self.rank,
147 method = %Formatter(|f| match self.method {
148 Some(method) => write!(f, "{}", method),
149 None => write!(f, "[any]"),
150 }),
151 uri = %self.uri,
152 uri.base = %self.uri.base(),
153 uri.unmounted = %self.uri.unmounted(),
154 format = self.format.as_ref().map(display),
155 location = self.location.as_ref()
156 .map(|(file, line, _)| Formatter(move |f| write!(f, "{file}:{line}")))
157 .map(display),
158 }
159
160 event! { Level::DEBUG, "sentinels",
161 route = self.name.as_ref().map(|n| &**n),
162 sentinels = %Formatter(|f| {
163 f.debug_set()
164 .entries(self.sentinels.iter().filter(|s| s.specialized).map(|s| s.type_name))
165 .finish()
166 })
167 }
168 }
169}
170
171impl Trace for Catcher {
172 fn trace(&self, level: Level) {
173 event! { level, "catcher",
174 name = self.name.as_ref().map(|n| &**n),
175 code = %Formatter(|f| match self.code {
176 Some(code) => write!(f, "{}", code),
177 None => write!(f, "default"),
178 }),
179 rank = self.rank,
180 uri.base = %self.base(),
181 location = self.location.as_ref()
182 .map(|(file, line, _)| Formatter(move |f| write!(f, "{file}:{line}")))
183 .map(display),
184 }
185 }
186}
187
188impl Trace for &dyn crate::fairing::Fairing {
189 fn trace(&self, level: Level) {
190 self.info().trace(level)
191 }
192}
193
194impl Trace for crate::fairing::Info {
195 fn trace(&self, level: Level) {
196 event!(level, "fairing", name = self.name, kind = %self.kind)
197 }
198}
199
200impl Trace for figment::error::Kind {
201 fn trace(&self, _: Level) {
202 use figment::error::{OneOf as V, Kind::*};
203
204 match self {
205 Message(message) => error!(message),
206 InvalidType(actual, expected) => error!(%actual, expected, "invalid type"),
207 InvalidValue(actual, expected) => error!(%actual, expected, "invalid value"),
208 InvalidLength(actual, expected) => error!(%actual, expected, "invalid length"),
209 UnknownVariant(actual, v) => error!(actual, expected = %V(v), "unknown variant"),
210 UnknownField(actual, v) => error!(actual, expected = %V(v), "unknown field"),
211 UnsupportedKey(actual, v) => error!(%actual, expected = &**v, "unsupported key"),
212 MissingField(value) => error!(value = &**value, "missing field"),
213 DuplicateField(value) => error!(value, "duplicate field"),
214 ISizeOutOfRange(value) => error!(value, "out of range signed integer"),
215 USizeOutOfRange(value) => error!(value, "out of range unsigned integer"),
216 Unsupported(value) => error!(%value, "unsupported type"),
217 }
218 }
219}
220
221impl Trace for figment::Error {
222 fn trace(&self, _: Level) {
223 for e in self.clone() {
224 span_error!("config",
225 key = (!e.path.is_empty()).then_some(&e.path).and_then(|path| {
226 let (profile, metadata) = (e.profile.as_ref()?, e.metadata.as_ref()?);
227 Some(metadata.interpolate(profile, path))
228 }),
229 source.name = e.metadata.as_ref().map(|m| &*m.name),
230 source.source = e.metadata.as_ref().and_then(|m| m.source.as_ref()).map(display)
231 => e.kind.trace_error());
232 }
233 }
234}
235
236impl Trace for Header<'_> {
237 fn trace(&self, level: Level) {
238 event!(level, "header", name = self.name().as_str(), value = self.value());
239 }
240}
241
242impl Trace for route::Outcome<'_> {
243 fn trace(&self, level: Level) {
244 event!(level, "outcome",
245 outcome = match self {
246 Self::Success(..) => "success",
247 Self::Error(..) => "error",
248 Self::Forward(..) => "forward",
249 },
250 status = match self {
251 Self::Success(r) => r.status().code,
252 Self::Error(s) => s.code,
253 Self::Forward((_, s)) => s.code,
254 },
255 )
256 }
257}
258
259impl Trace for Response<'_> {
260 fn trace(&self, level: Level) {
261 event!(level, "response", status = self.status().code);
262 }
263}
264
265impl Trace for Error {
266 fn trace(&self, level: Level) {
267 self.kind.trace(level);
268 }
269}
270
271impl Trace for Sentry {
272 fn trace(&self, level: Level) {
273 let (file, line, col) = self.location;
274 event!(level, "sentry",
275 type_name = self.type_name,
276 location = %Formatter(|f| write!(f, "{file}:{line}:{col}"))
277 );
278 }
279}
280
281impl Trace for Request<'_> {
282 fn trace(&self, level: Level) {
283 event!(level, "request", method = %self.method(), uri = %self.uri())
284 }
285}
286
287impl Trace for ConnectionMeta {
288 fn trace(&self, level: Level) {
289 event!(level, "connection",
290 endpoint = self.peer_endpoint.as_ref().map(display),
291 certs = self.peer_certs.is_some(),
292 )
293 }
294}
295
296impl Trace for ErrorKind {
297 fn trace(&self, level: Level) {
298 use ErrorKind::*;
299
300 fn try_downcast<'a, T>(error: &'a (dyn StdError + 'static)) -> Option<&'a T>
301 where T: StdError + 'static
302 {
303 error.downcast_ref().or_else(|| error.source()?.downcast_ref())
304 }
305
306 match self {
307 Bind(endpoint, error) => {
308 if let Some(e) = try_downcast::<crate::Error>(&**error) {
309 e.trace(level);
310 } else if let Some(e) = try_downcast::<figment::Error>(&**error) {
311 e.trace(level);
312 } else {
313 event!(level, "error::bind",
314 reason = %error,
315 endpoint = endpoint.as_ref().map(display),
316 "binding to network interface failed"
317 )
318 }
319 }
320 Io(reason) => event!(level, "error::io", %reason, "i/o error"),
321 Config(error) => error.trace(level),
322 Collisions { routes, catchers }=> {
323 span!(level, "collision",
324 route.pairs = routes.len(),
325 catcher.pairs = catchers.len(),
326 "colliding items detected"
327 ).in_scope(|| {
328 for (a, b) in routes {
329 span!(level, "colliding route pair").in_scope(|| {
330 a.trace(level);
331 b.trace(level);
332 })
333 }
334
335 for (a, b) in catchers {
336 span!(level, "colliding catcher pair").in_scope(|| {
337 a.trace(level);
338 b.trace(level);
339 })
340 }
341
342 span!(Level::INFO, "collisions can usually be resolved by ranking items");
343 });
344 }
345 FailedFairings(fairings) => {
346 let span = span!(level, "failed ignite fairings", count = fairings.len());
347 span.in_scope(|| fairings.iter().trace_all(level));
348 },
349 SentinelAborts(sentries) => {
350 let span = span!(level, "sentries", "sentry launch abort");
351 span.in_scope(|| sentries.iter().trace_all(level));
352 }
353 InsecureSecretKey(profile) => event!(level, "insecure_key", %profile,
354 "secrets enabled in a non-debug profile without a stable `secret_key`\n\
355 disable the `secrets` feature or configure a `secret_key`"
356 ),
357 Liftoff(_, reason) => event!(level, "panic", %reason, "liftoff fairing failed"),
358 Shutdown(_) => event!(level, "shutdown", "shutdown failed"),
359 }
360 }
361}