fix: refine SSE stream lifecycle handling

Author: ReneWerner87

docs/middleware/sse.md

@@ -99,7 +99,7 @@ app.Get("/events", sse.New(sse.Config{
 | OnClose           | `func(fiber.Ctx, error)`     | Called when the stream ends, with `nil` when the handler returned successfully and no stream write failed. | `nil` |
 | Retry             | `time.Duration`              | Initial EventSource reconnect delay.           | `0`                 |
 | HeartbeatInterval | `time.Duration`              | Interval for SSE comment heartbeats.           | `15 * time.Second`  |
-| DisableHeartbeat  | `bool`                       | Disable automatic heartbeat comments.          | `false`             |
+| DisableHeartbeat  | `bool`                       | Disable automatic heartbeat comments. When disabled, disconnected clients may not be detected until the next write. | `false` |
 
 ## Default Config
 
@@ -128,4 +128,6 @@ func (s *Stream) LastEventID() string
 
 Every write is flushed. A failed flush closes `Done`, stores the error returned by `Err`, and lets the handler stop without relying on `fasthttp.RequestCtx.Done`, which is not a per-client disconnect signal. After a normal handler return, `Done` is closed and `Context()` is canceled while `Err()` remains `nil`; writes after that return `sse: stream closed`.
 
+Automatic heartbeat comments keep idle streams active and make silent client disconnects observable through the next flush error. If heartbeats are disabled, a handler waiting on an external source might not notice a disconnected client until it writes again. Stopping a stream waits for an in-flight heartbeat write to finish, so a very slow client can delay shutdown until the underlying write unblocks.
+
 `Config.Retry` sends the initial reconnect delay when the stream opens. `Event.Retry` changes the reconnect delay for a specific event, following the SSE wire format.

middleware/sse/sse.go

@@ -37,11 +37,11 @@ func New(config ...Config) fiber.Handler {
 		c.Set(fiber.HeaderConnection, "keep-alive")
 		c.Set("X-Accel-Buffering", "no")
 
-		c.Abandon()
-
 		streamContext := c.Context()
 		lastEventID := c.Get(fiber.HeaderLastEventID)
 
+		c.Abandon()
+
 		return c.SendStreamWriter(func(w *bufio.Writer) {
 			stream := newStream(streamContext, w, lastEventID, c.App().Config().JSONEncoder)
 			var streamErr error
@@ -54,6 +54,11 @@ func New(config ...Config) fiber.Handler {
 					cfg.OnClose(c, finalErr)
 				}
 			}()
+			defer func() {
+				if recovered := recover(); recovered != nil {
+					streamErr = fmt.Errorf("sse: handler panic: %v", recovered)
+				}
+			}()
 			defer stream.closeStream()
 
 			if cfg.Retry > 0 {

middleware/sse/sse_test.go

@@ -500,6 +500,34 @@ func Test_SSE_HandlerErrorCallsOnClose(t *testing.T) {
 	}
 }
 
+func Test_SSE_HandlerPanicCallsOnClose(t *testing.T) {
+	t.Parallel()
+
+	closed := make(chan error, 1)
+
+	app := fiber.New()
+	app.Get("/events", New(Config{
+		DisableHeartbeat: true,
+		Handler: func(fiber.Ctx, *Stream) error {
+			panic("boom")
+		},
+		OnClose: func(_ fiber.Ctx, err error) {
+			closed <- err
+		},
+	}))
+
+	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/events", http.NoBody))
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+
+	select {
+	case err := <-closed:
+		require.EqualError(t, err, "sse: handler panic: boom")
+	case <-time.After(time.Second):
+		t.Fatal("OnClose was not called")
+	}
+}
+
 func Test_SSE_NewPanicsWithoutHandler(t *testing.T) {
 	t.Parallel()