How to distinguish body errors and when a peer resets a connection with hyper::Error?

[beroal]

let conn = http1::Builder::new()
    .serve_connection(io, service_fn(move |req| service(cs.clone(), req)));
let watched_conn = graceful.watch(conn);
tokio::task::spawn(async move {
    if let Err(error) = watched_conn.await {
        dbg!(error);
    }
});

“Cargo.toml”:

hyper = { version = "1.6.0", features = ["server", "http1"] }

When a peer resets the connection, error is
hyper::Error(Io, Os { code: 104, kind: ConnectionReset, message: "Connection reset by peer" }). I suppose that error in the code above may be also an error returned by my implementation of the hyper::body::Body trait. I would like to distinguish body errors and when a peer resets a connection to log these error with different log levels.
However, all is_* methods of hyper::Error return false. Shouldn't one of the below methods

• is_body_write_aborted
• is_canceled
• is_closed

return true?

[Maxaubert]

None of the is_* helpers cover these two cases directly, because both get folded into internal Kind variants that don't have their own dedicated accessor (Kind::Io for the reset, Kind::User(User::Body) for your Body impl's error). But is_user() already does what you need for the body-error half, and the reset can be recovered through source().

Body errors

When your Body::poll_frame returns Err(e), hyper wraps it with Error::new_user_body(e):

hyper/src/proto/h1/dispatch.rs

Lines 372 to 378 in 621d8e4

	let item = ready!(body.as_mut().poll_frame(cx));
	if let Some(item) = item {
	let frame = item.map_err(|e| {
	*clear_body = true;
	crate::Error::new_user_body(e)
	})?;

which sets Kind::User(User::Body):

hyper/src/error.rs

Lines 394 to 396 in 621d8e4

	pub(super) fn new_user_body<E: Into<Cause>>(cause: E) -> Error {
	Error::new_user(User::Body).with(cause)
	}

and is_user() returns true for any Kind::User(_):

hyper/src/error.rs

Lines 193 to 195 in 621d8e4

	pub fn is_user(&self) -> bool {
	matches!(self.inner.kind, Kind::User(_))
	}

Peer reset

An I/O failure on the socket (reset, broken pipe, etc.) goes through Error::new_io(io_err):

hyper/src/error.rs

Lines 316 to 318 in 621d8e4

	pub(super) fn new_io(cause: std::io::Error) -> Error {
	Error::new(Kind::Io).with(cause)
	}

That's just Kind::Io with the original std::io::Error stashed as the source(). There is no is_io(), but Error implements source():

hyper/src/error.rs

Lines 536 to 542 in 621d8e4

	impl StdError for Error {
	fn source(&self) -> Option<&(dyn StdError + 'static)> {
	self.inner
	.cause
	.as_ref()
	.map(|cause| &**cause as &(dyn StdError + 'static))
	}

so you can downcast it back to std::io::Error and check the ErrorKind:

use std::error::Error as _;

fn log_conn_error(error: &hyper::Error) {
    if error.is_user() {
        // came from your Body impl (is_user() also covers Service etc.,
        // but in a serve_connection future this is effectively "your Body")
        warn!("body error: {error}");
        return;
    }

    if let Some(io_err) = error.source().and_then(|s| s.downcast_ref::<std::io::Error>()) {
        if io_err.kind() == std::io::ErrorKind::ConnectionReset {
            debug!("peer reset the connection");
            return;
        }
    }

    warn!("connection error: {error}");
}

is_user() is true for the whole User family (body, service, header misuse, etc.), not only for your Body, so if you need finer granularity than "user code vs transport" you'd have to downcast source() to your own body-error type instead of relying on a hyper method, since hyper doesn't expose is_user_body().