Automatically Logging Errors to the Server Console

[NCura]

Hello,

I created a new project using cargo leptos new --git leptos-rs/start-axum and modified the app.rs with some code from the leptos/examples/action-form-error-handling:

/// Renders the home page of your application.
#[component]
fn HomePage() -> impl IntoView {
    let do_something_action = Action::<DoSomething, _>::server();
    let value = Signal::derive(move || {
        do_something_action
            .value()
            .get()
            .unwrap_or_else(|| Ok(String::new()))
    });

    Effect::new_isomorphic(move |_| {
        logging::log!("Got value = {:?}", value.get());
    });

    view! {
        <h1>"Test the action form!"</h1>
        <ErrorBoundary fallback=move |error| {
            format!("{:#?}", error.get().into_iter().next().unwrap().1.into_inner().to_string())
        }>
            {value} <ActionForm action=do_something_action class="form">
                <label>Should error: <input type="checkbox" name="should_error"/></label>
                <button type="submit">Submit</button>
            </ActionForm>
        </ErrorBoundary>
    }
}

#[server]
async fn do_something(
    should_error: Option<String>,
) -> Result<String, ServerFnError> {
    if should_error.is_none() {
        Ok(String::from("Successful submit"))
    } else {
        Err(ServerFnError::ServerError(String::from(
            "You got an error!",
        )))
    }
}

When I run cargo leptos watch and navigate to the home page, I see:

Got value = Ok("")
listening on http://127.0.0.1:3000
Got value = Ok("")

printed in the server console. Then if I toggle the "Should error" checkbox and submit the form, the page shows the error display, and the console shows a 500 Server Error with the message "You got an error!". But there is nothing in the server console.

My question is how to make the server console show the error automatically as well.

One option is to add a logging::log!("You got an error!"); before returning the server error:

#[server]
async fn do_something(
    should_error: Option<String>,
) -> Result<String, ServerFnError> {
    if should_error.is_none() {
        Ok(String::from("Successful submit"))
    } else {
        logging::log!("You got an error!");
        Err(ServerFnError::ServerError(String::from(
            "You got an error!",
        )))
    }
}

but I would like it to be automatic.

I considered creating my own Error type and returning that instead, with a log in the Display implementation of the error:

#[derive(Clone, Debug )]
pub enum Error {
    ErrorVariant1
}

impl std::error::Error for Error {}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> core::result::Result<(), std::fmt::Error> {
        log!("{self:?}");
        write!(f, "{self:?}")
    }
}

#[server]
async fn do_something(
    should_error: Option<String>,
) -> Result<String, ServerFnError> {
    if should_error.is_none() {
        Ok(String::from("Successful submit"))
    } else {
        Err(Error::ErrorVariant1)?
    }
}

Is this the best approach, or is there a simpler way to have errors displayed in the server console automatically?

[benwis]

As far as Error handling goes, this is working as designed. A server function returns an error, and then the user has a choice of how to handle it on the frontend. <ErrorBoundary> components let you choose how to display it in the UI. If the error is on the server, as a 500 is, it can be handled by tracing or printed or whatever the user prefers.

If you look in the actual Response in the browser inspector, you will most likely see the Display trait message in the response. That's how I usually debug things with 500s on the server

I'm open to suggestions, perhaps it would be a good idea to automatically print the display error in the console in debug mode.

[aschweig]

Maybe another approach is to use tracing::instrument, e.g.,

#[tracing::instrument(err)]
#[server]
async fn do_something(
    should_error: Option<String>,
) -> Result<String, ServerFnError> {
    if should_error.is_none() {
        Ok(String::from("Successful submit"))
    } else {
        Err(ServerFnError::ServerError(String::from(
            "You got an error!",
        )))
    }
}

I'm returning exceptions like Err(ServerFnError::new("Authentication required")) -- but perhaps having ServerFnError enum variants that automatically came back as HTTP Status 400, 401, and 404 would be more semantically consistent.