Concise logging when matching Result - rust

Question

I am working on a large project in Rust with many moving pieces. One of my agendas is to log an error if something goes wrong in any part so I can debug later.
However, it seems for every function call the conciseness has vanished, plausibly due to my naivete.
How can I make this more concise? I looked at this question which essentially asks to use a match to capture both OK() and Err.
fn pathway_1(x: &str, y: &str) -> Option<Vec<String>> {
let unique_numbers = match query_unique_numbers(&x, &y) {
Ok(r) => r
Err(e) => {
log::error!(target: "normal", "Could not query unique numbers. Err {e}");
return None;
}
}
let unique_people = match query_unique_people(&unique_numbers, &y) {
Ok(r) => r
Err(e) => {
log::error!(target: "normal", "Could not query unique people. Err {e}");
return None;
}
}
let relevant_things_by_people = match query_relevant_things(&unique_people, &y) {
Ok(r) => r
Err(e) => {
log::error!(target: "normal", "Could not query relevant things. Err {e}");
return None;
}
}
/// Many such function calls below.
Some(vector_of_strings)
}

Answer 1

You can use .ok() to convert a Result into an Option and then use ? to propagate it.
Logging on each result could be achieved with .map_err() to apply a "transformation" to the error. It may be slightly better to use .inspect_err() (when stabilized) or .tap_err() (from the tap crate), though since the error is not used after logging, it doesn't really matter:
fn pathway_1(x: &str, y: &str) -> Option<Vec<String>> {
let unique_numbers = query_unique_numbers(&x, &y)
.map_err(|e| { log::error!(target: "normal", "Could not query unique numbers. Err {e}"); })
.ok()?;
let unique_people = query_unique_people(&unique_numbers, &y)
.map_err(|e| { log::error!(target: "normal", "Could not query unique people. Err {e}"); })
.ok()?;
let relevant_things_by_people = query_relevant_things(&unique_people, &y)
.map_err(|e| { log::error!(target: "normal", "Could not query relevant things. Err {e}"); })
.ok()?;
/// Many such function calls below.
Some(vector_of_strings)
}
However, I would not do it like this. You seem to be using Option in the return type to indicate failure. If that is the case, you should return a Result. And if you do that, you can create a proper encompassing error type that can express what step failed, with what original error, and the display logic (using something like the thiserror crate):
use thiserror::Error;
#[derive(Error, Debug)]
enum QueryError {
#[error("Could not query unique numbers. Err {0}")]
UniqueNumbers(SomeError),
#[error("Could not query unique people. Err {0}")]
UniquePeople(SomeError),
#[error("Could not query relevant things. Err {0}")]
RelevantThings(SomeError),
}
fn pathway_1(x: &str, y: &str) -> Result<Vec<String>, QueryError> {
let unique_numbers = query_unique_numbers(&x, &y)
.map_err(QueryError::UniqueNumbers)?;
let unique_people = query_unique_people(&unique_numbers, &y)
.map_err(QueryError::UniquePeople)?;
let relevant_things_by_people = query_relevant_things(&unique_people, &y)
.map_err(QueryError::RelevantThings)?;
/// Many such function calls below.
Ok(vector_of_strings)
}
Then you can handle all errors in one place in the caller. For example:
match pathway_1(x, y) {
Ok(vector_of_strings) => {
// do something
}
Err(e) => {
log::error!(target: "normal", "{e}");
}
}

Answer 2

You can create a custom method on Result, log(), that logs the error with context:
trait ResultExt<T> {
fn log(self, context: &str) -> Option<T>;
}
impl<T, E: std::fmt::Display> ResultExt<T> for Result<T, E> {
fn log(self, context: &str) -> Option<T> {
match self {
Ok(v) => Some(v),
Err(err) => {
log::error!(target: "normal", "{context}. Err {err}");
None
}
}
}
}
fn pathway_1(x: &str, y: &str) -> Option<Vec<String>> {
let unique_numbers = query_unique_numbers(&x, &y).log("Could not query unique numbers")?;
let unique_people =
query_unique_people(&unique_numbers, &y).log("Could not query unique people")?;
let relevant_things_by_people =
query_relevant_things(&unique_people, &y).log("Could not query relevant things")?;
/// Many such function calls below.
Some(vector_of_strings)
}