[Feature]: Add panicHandlerBuilder

[PeterlitsZo]

Description of new feature

• And WithPanicHandlerBuilder option.
• If the task is paniced, and we submit more infomation, we can build the panicHandler by those (panicHandlerBuilder and the more infomation), and then handle the panic.

Scenarios for new feature

In my opinion, panicHandlerBuilder will be much helpful. Here is my view:

• When the function we called in the gorotine sadly paniced, we should recover it to make sure it will not hang the server. ants already did it well.
• When we try to recover it, leave a log sounds fine. This is also what ants already did, ant it even give us the panicHandler flag to leave better logs (or something else).
• It will be better if the log can have the trace. Trace can give us more infomation that how the HTTP request come in, etc. But we cannot do it by ants: we cannot give the infomation about trace to the panicHandler (can we?).

So, I think if we can have panicHandlerBuilder.

Breaking changes or not?

Yes

Code snippets (optional)

panicHandlerBuilder := (moreInfomation any) func(any) {
    mi := moreInfomation.(*MoreInfomation)
    logger := mi.Logger
    ctx := mi.ctx

    return func(e any) {
        logger.Error(ctx, map[string]any{ "err", e })
    }
}

pool, _ := ants.NewPool(poolSize, ants.WithPanicHandlerBuilder(panicHandlerBuilder))

pool.SubmitWithMoreInfomation(task, &MoreInfomation{
    ctx: ctx,
    logger: logger,
})

(Are Go generics useful? But I notice that the go version of the project is not >= 1.18)

Alternatives for new feature

pool.Submit(function() {
    defer function() {
        if err := recover(); err != nil {
            handlePanic(ctx, logger, err)
        }
    }

    task()
})

I do not think it looks pretty - If we have panicHandler, why not have panicHandlerBuilder?

Additional context (optional)

I think I am able to send a PR (maybe...).

[PeterlitsZo]

hello?

[panjf2000]

I appreciate your work here, but your feature request seems like a lot of code changes, and I don't see why a good deal of code changes are required to be added to ants when a simple wrapper outside ants will also work, something like:

type PoolWrapper struct {
    pool *ants.Pool
}

func (p *PoolWrapper) Submit(task func(), info *MoreInfomation) error {
    p.pool.Submit(func() {
        defer func() {
            if err := recover(); err != nil {
                handlePanic(info.ctx, info.logger, err)
            }
        }()

        task() 
    })
}

func handlePanic(ctx context.Context, logger Logger, err any) {
    logger.Error(ctx, map[string]any{"err", err})
}

[PeterlitsZo]

Yes, you are right. Thanks for your great work.