Server side events buffered until connection close?

[ericaltendorf]

Summary

I have an SSE handler that looks something like:

let (tx, rx) = mpsc::channel(100);
tokio::spawn(async move {
    ...some loops and delays {
        tx.send(Ok(Event::default().data(msg))).await.unwrap();
    }
});
let stream = ReceiverStream::new(rx);
Sse::new(stream).keep_alive(KeepAlive::default()) // return to client

I can verify the tx.send() messages are being added to the Sender on schedule, but on the client side (ie browser) the SSE events are not received until the connection is closed. It's like they're being buffered either in the mpsc channel or the ReceiverStream, but I can't figure out which, or how to flush either one.

I'm accessing via localhost so it's not a CDN issue, athough I don't know if there's some caching problem with my headers (I couldn't figure out the canonical way to disable caching, I thought there'd be some middleware helper functions, but I couldn't find any).

axum version

0.7.4

[jplatte]

Are you maybe applying a compression middleware? ISTR some people had issues with compression buffering SSE events. I also rememer some fixes landing in tower-http for that, but IIRC they're content-type based and maybe SSE doesn't always use a specific content type? Haven't used it myself.

[ericaltendorf]

Thanks! I don't think so. My stack gets layered thusly:

    let session_store = MemoryStore::default();
    let session_layer = SessionManagerLayer::new(session_store)
        .with_path("/".to_string())
        .with_same_site(tower_sessions::cookie::SameSite::Strict)
        .with_secure(false)
        .with_expiry(Expiry::OnInactivity(Duration::days(1)))
        ;

    let backend = auth::Backend::new(app_state.user_store.clone());
    let auth_layer = AuthManagerLayerBuilder::new(backend, session_layer).build();

    let app = router::mk_router()
        .layer(auth_layer)
        .with_state(app_state)
        .layer(axum::middleware::map_response(main_response_mapper))
        .layer(make_cors_layer())
        ;

FWIW, I tried switching over to sending the updates via websockets and that's working now. I'd seen a few things that suggested that since SSE is fully in HTTP, it's more subject to being mucked with by various middleware layers, browser caching, proxies, etc.

I didn't actually have any strong reason to prefer WS or SSE, so at this point I'm fine to just use what's working and move on. But I'll leave this post here in case it's useful to anyone else...