Fix: handle panic on Ws error

[0xMelkor]

Motivation

Some issues have been raised, reporting WsServer panics on upstream connection errors.
#1889 #1815

ethers-rs/ethers-providers/src/transports/ws.rs

Lines 250 to 256 in 4b68562

	Err(ClientError::UnexpectedClose) => {
	error!("{}", ClientError::UnexpectedClose);
	break
	}
	Err(e) => {
	panic!("WS Server panic: {}", e);
	}

Solution

In order to have a simpler and more predictable behavior, I believe the application should directly handle reconnections (also stated here), avoiding recovery mechanisms at the transport layer.

Instead of crashing the program, we gracefully close all active subscriptions. Clients will then observe the end of their streams and issue proper actions.

What do you guys think?

PR Checklist

• Added Tests
• Added Documentation
• Updated the changelog

[mattsse]

imo, it makes more sense to handle this gracefully and don't panic on the ws task.

needs changelog entry

[0xMelkor]

Hi @mattsse, changelog updated.

[gakonst]

LGTM - let's iterate on this @mattsse so we unblock @0xMelkor

[Tigranchick]

Sorry for the dumb question, but how can I catch this panic or error, i mean is there place to match it. I don't get messages from websocket often and it breaks with connection refused. Now I took one of the solutions with 2 loops and a timeout in tokio select! like there #1889 .

[0xMelkor]

Hi @Tigranchick,

this PR removed the panic! statement in ws.rs, in favor of a graceful teardown of active subscriptions. The effect is that your stream reaches the last element and you are up to handle reconnections.

    // This loop iterates over WebSocket disconnections
    'connection: loop {

        let client = Provider::<Ws>::connect("wss://your-uri").await?;
        let client = Arc::new(client);
        let filter = Filter::new().event("Transfer(address,address,uint256)");

        let mut stream = client.subscribe_logs(&filter).await?;

        while let Some(log) = stream.next().await {
                 // Do some work
        }
       
        // If you get here, your subscription has been canceled => Iterate over the main loop to handle reconnection
   }

How can we improve ethers in my opinion

A cleaner approach would also propagate errors from Ws to the application.
This requires some library changes along the stack, and the subscription code would become like:

        // The stream now emits `Result`instead of `Log`
        while let Some(result) = stream.next().await {
                 match result {
                     Ok(log) => // Do some work
                     Err(e) => // Handle the error
                 }
        }

[Tigranchick]

@0xMelkor, thanks you to explanation!