Skip to main content

rocket/trace/
traceable.rs

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        // Check for now deprecated config values.
64        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}