Add option for custom panic handler

Author: hampusohlsson

errors/panic_handler.go

@@ -0,0 +1,18 @@
+package errors
+
+import (
+	"context"
+)
+
+// PanicHandler is the interface used to create custom panic errors that occur during query execution
+type PanicHandler interface {
+	MakePanicError(ctx context.Context, value interface{}) *QueryError
+}
+
+// DefaultPanicHandler is the default PanicHandler
+type DefaultPanicHandler struct{}
+
+// MakePanicError creates a new QueryError from a panic that occurred during execution
+func (h *DefaultPanicHandler) MakePanicError(ctx context.Context, value interface{}) *QueryError {
+	return Errorf("graphql: panic occurred: %v", value)
+}

graphql.go

@@ -30,6 +30,7 @@ func ParseSchema(schemaString string, resolver interface{}, opts ...SchemaOpt) (
 		maxParallelism: 10,
 		tracer:         trace.OpenTracingTracer{},
 		logger:         &log.DefaultLogger{},
+		panicHandler:   &errors.DefaultPanicHandler{},
 	}
 	for _, opt := range opts {
 		opt(s)
@@ -78,6 +79,7 @@ type Schema struct {
 	tracer                   trace.Tracer
 	validationTracer         trace.ValidationTracerContext
 	logger                   log.Logger
+	panicHandler             errors.PanicHandler
 	useStringDescriptions    bool
 	disableIntrospection     bool
 	subscribeResolverTimeout time.Duration
@@ -143,6 +145,14 @@ func Logger(logger log.Logger) SchemaOpt {
 	}
 }
 
+// PanicHandler is used to customize the panic errors during query execution.
+// It defaults to errors.DefaultPanicHandler.
+func PanicHandler(panicHandler errors.PanicHandler) SchemaOpt {
+	return func(s *Schema) {
+		s.panicHandler = panicHandler
+	}
+}
+
 // DisableIntrospection disables introspection queries.
 func DisableIntrospection() SchemaOpt {
 	return func(s *Schema) {
@@ -244,9 +254,10 @@ func (s *Schema) exec(ctx context.Context, queryString string, operationName str
 			Schema:               s.schema,
 			DisableIntrospection: s.disableIntrospection,
 		},
-		Limiter: make(chan struct{}, s.maxParallelism),
-		Tracer:  s.tracer,
-		Logger:  s.logger,
+		Limiter:      make(chan struct{}, s.maxParallelism),
+		Tracer:       s.tracer,
+		Logger:       s.logger,
+		PanicHandler: s.panicHandler,
 	}
 	varTypes := make(map[string]*introspection.Type)
 	for _, v := range op.Vars {

internal/exec/exec.go

@@ -23,24 +23,21 @@ type Request struct {
 	Limiter                  chan struct{}
 	Tracer                   trace.Tracer
 	Logger                   log.Logger
+	PanicHandler             errors.PanicHandler
 	SubscribeResolverTimeout time.Duration
 }
 
 func (r *Request) handlePanic(ctx context.Context) {
 	if value := recover(); value != nil {
 		r.Logger.LogPanic(ctx, value)
-		r.AddError(makePanicError(value))
+		r.AddError(r.PanicHandler.MakePanicError(ctx, value))
 	}
 }
 
 type extensionser interface {
 	Extensions() map[string]interface{}
 }
 
-func makePanicError(value interface{}) *errors.QueryError {
-	return errors.Errorf("panic occurred: %v", value)
-}
-
 func (r *Request) Execute(ctx context.Context, s *resolvable.Schema, op *types.OperationDefinition) ([]byte, []*errors.QueryError) {
 	var out bytes.Buffer
 	func() {
@@ -188,7 +185,7 @@ func execFieldSelection(ctx context.Context, r *Request, s *resolvable.Schema, f
 		defer func() {
 			if panicValue := recover(); panicValue != nil {
 				r.Logger.LogPanic(ctx, panicValue)
-				err = makePanicError(panicValue)
+				err = r.PanicHandler.MakePanicError(ctx, panicValue)
 				err.Path = path.toSlice()
 			}
 		}()