138 lines
2.7 KiB
Go
138 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"runtime/debug"
|
|
|
|
"github.com/getsentry/raven-go"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
type (
|
|
ErrorHandlerFunc func(recovery interface{}, c *gin.Context)
|
|
)
|
|
|
|
func ErrorHandler(handlers ...ErrorHandlerFunc) gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
defer func() {
|
|
rec := recover()
|
|
for _, handler := range handlers {
|
|
handler(rec, c)
|
|
}
|
|
|
|
if rec != nil || len(c.Errors) > 0 {
|
|
c.Abort()
|
|
}
|
|
}()
|
|
|
|
c.Next()
|
|
}
|
|
}
|
|
|
|
func ErrorResponseHandler() ErrorHandlerFunc {
|
|
return func(recovery interface{}, c *gin.Context) {
|
|
publicErrors := c.Errors.ByType(gin.ErrorTypePublic)
|
|
privateLen := len(c.Errors.ByType(gin.ErrorTypePrivate))
|
|
publicLen := len(publicErrors)
|
|
|
|
if privateLen == 0 && publicLen == 0 && recovery == nil {
|
|
return
|
|
}
|
|
|
|
messagesLen := publicLen
|
|
if privateLen > 0 || recovery != nil {
|
|
messagesLen++
|
|
}
|
|
|
|
messages := make([]string, messagesLen)
|
|
index := 0
|
|
for _, err := range publicErrors {
|
|
messages[index] = err.Error()
|
|
index++
|
|
}
|
|
|
|
if privateLen > 0 || recovery != nil {
|
|
messages[index] = getLocalizedMessage("error_save")
|
|
}
|
|
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": messages})
|
|
}
|
|
}
|
|
|
|
func ErrorCaptureHandler(client *raven.Client, errorsStacktrace bool) ErrorHandlerFunc {
|
|
return func(recovery interface{}, c *gin.Context) {
|
|
tags := map[string]string{
|
|
"endpoint": c.Request.RequestURI,
|
|
}
|
|
|
|
var (
|
|
ok bool
|
|
conn Connection
|
|
)
|
|
|
|
connection, ok := c.Get("connection")
|
|
if ok {
|
|
conn = connection.(Connection)
|
|
}
|
|
|
|
b, ok := c.Get("bot")
|
|
if ok {
|
|
tags["bot"] = b.(Bot).Token
|
|
conn = *getConnectionById(b.(Bot).ConnectionID)
|
|
}
|
|
|
|
if conn.APIURL != "" {
|
|
tags["crm"] = conn.APIURL
|
|
}
|
|
|
|
if conn.ClientID != "" {
|
|
tags["clientID"] = conn.ClientID
|
|
}
|
|
|
|
if recovery != nil {
|
|
stacktrace := raven.NewStacktrace(4, 3, nil)
|
|
recStr := fmt.Sprint(recovery)
|
|
err := errors.New(recStr)
|
|
go client.CaptureMessageAndWait(
|
|
recStr,
|
|
tags,
|
|
raven.NewException(err, stacktrace),
|
|
raven.NewHttp(c.Request),
|
|
)
|
|
}
|
|
|
|
for _, err := range c.Errors {
|
|
if errorsStacktrace {
|
|
stacktrace := NewRavenStackTrace(client, err.Err, 0)
|
|
go client.CaptureMessageAndWait(
|
|
err.Error(),
|
|
tags,
|
|
raven.NewException(err.Err, stacktrace),
|
|
raven.NewHttp(c.Request),
|
|
)
|
|
} else {
|
|
go client.CaptureErrorAndWait(err.Err, tags)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func PanicLogger() ErrorHandlerFunc {
|
|
return func(recovery interface{}, c *gin.Context) {
|
|
if recovery != nil {
|
|
logger.Error(c.Request.RequestURI, recovery)
|
|
debug.PrintStack()
|
|
}
|
|
}
|
|
}
|
|
|
|
func ErrorLogger() ErrorHandlerFunc {
|
|
return func(recovery interface{}, c *gin.Context) {
|
|
for _, err := range c.Errors {
|
|
logger.Error(c.Request.RequestURI, err.Err)
|
|
}
|
|
}
|
|
}
|