How Can I Gracefully Handle and Report Panics from Goroutines in Go?

Generic Panic Recovery in Go Programs

When concurrent routines in a Go program encounter critical errors that result in panics, it becomes crucial to gracefully handle and report these exceptions to an external reporting service like Sentry or Raygun. However, capturing panics from routines running in separate goroutines poses a challenge.

The Problem of Goroutine Panics

A goroutine cannot recover from a panic that occurs in another goroutine. This limitation poses a problem in capturing and reporting panics from concurrent routines.

Idiomatic Recovery Techniques

To recover from panics in concurrent routines, it's necessary to inject code into the goroutine's function that checks for recovered values. The standard way to achieve this is by using a deferred function that calls recover().

go func() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Caught:", r)
        }
    }()

    panic("catch me")
}()

This approach ensures that any panic within the goroutine will be caught by the deferred function and logged accordingly.

Wrapper Function for Simplified Recovery

To simplify the recovery process, you can create a wrapper function that encapsulates the recovery logic:

func wrap(f func()) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Caught:", r)
        }
    }()

    f()
}

Now, you can use the wrap() function to protect any goroutine function from panics:

go wrap(func() {
    panic("catch me")
})

Note: The wrap() function allows you to execute arbitrary functions without explicitly creating new goroutines, while still ensuring panic recovery.

The above is the detailed content of How Can I Gracefully Handle and Report Panics from Goroutines in Go?. For more information, please follow other related articles on the PHP Chinese website!