gofiber/fiber · error

client panic

Error message

client panic: %v

What it means

execFunc runs the HTTP exchange in a goroutine and recovers any panic, converting it into this error so a crash inside fasthttp (or a request hook) surfaces as a normal error instead of killing the process. The %v renders the recovered value, which may be a runtime.Error or any panic payload.

Solutions

1. Inspect the recovered payload in logs (enable debug logging) to find the panic origin.
2. Wrap any custom callbacks (Dial, body readers, hooks) so they cannot panic into fasthttp; recover at their boundary.
3. Ensure the Client and Request are used according to their lifetime contract (do not reuse a Request across goroutines, do not mutate RawRequest after sending).

Example fix

// before
c.SetDial(func(addr string) (net.Conn, error) { return myPool.Get(addr) })

// after
c.SetDial(func(addr string) (net.Conn, error) {
    defer func() { _ = recover() }() // keep panics out of fasthttp
    return myPool.Get(addr)
})

resp, err := c.Get(url)
if err != nil && strings.Contains(err.Error(), "client panic") {
    // a hook or fasthttp internals panicked; log payload, do not blindly retry
    log.Printf("recovered panic in request: %v", err)
}

When it happens

Trigger: A nil-pointer dereference or index-out-of-range inside fasthttp's Do/DoRedirects, a buggy request hook (e.g. a custom dialer or header callback) panicking, or a bodyStream whose Read panics. Also reachable if c.req.RawRequest is malformed in a way fasthttp does not guard.

Common situations: Custom DialFunc, ProxyDialer, or StreamingBody callback that panics; concurrent use of a non-thread-safe object shared across requests; a fasthttp version regression.

Related errors

• client cannot be nil
• failed to append certificate
• sse: handler panic
• add: invalid http method
• boundary generation

AI-assisted analysis of gofiber/fiber@a105acad6c (2026-08-11). Data as JSON: /api/errors/a6eae34fde4cf5ad. Report an issue: GitHub.

Appendix: source

Thrown at client/core.go:77

		defer releaseResponseChan(respChan)

		reqv := fasthttp.AcquireRequest()
		defer fasthttp.ReleaseRequest(reqv)

		respv := fasthttp.AcquireResponse()
		defer func() {
			if respv != nil {
				fasthttp.ReleaseResponse(respv)
			}
		}()

		var resp *Response
		defer func() {
			if r := recover(); r != nil {
				if resp != nil {
					ReleaseResponse(resp)
				}
				errChan <- fmt.Errorf("client panic: %v", r)
			}
		}()

		c.req.RawRequest.CopyTo(reqv)
		if bodyStream := c.req.RawRequest.BodyStream(); bodyStream != nil {
			reqv.SetBodyStream(bodyStream, c.req.RawRequest.Header.ContentLength())
		}

		var err error
		if cfg != nil {
			// Use an exponential backoff retry strategy.
			err = retry.NewExponentialBackoff(*cfg).Retry(func() error {
				if c.req.maxRedirects > 0 && (string(reqv.Header.Method()) == fiber.MethodGet || string(reqv.Header.Method()) == fiber.MethodHead || string(reqv.Header.Method()) == fiber.MethodQuery) {
					return c.client.DoRedirects(reqv, respv, c.req.maxRedirects)
				}
				return c.client.Do(reqv, respv)
			})
		} else {

View on GitHub (pinned to a105acad6c)