Go Integration

// errorlogger/errorlogger.go
package errorlogger

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "runtime/debug"
)

type ErrorPayload struct {
    Message    string `json:"message"`
    StackTrace string `json:"stackTrace"`
}

var (
    apiKey      = os.Getenv("ERROR_LOG_API_KEY")
    securityKey = os.Getenv("ERROR_LOG_SECURITY_KEY")
    webhookURL  = fmt.Sprintf("https://your-domain.com/api/ingest/%s", apiKey)
)

func LogError(err error) {
    if err == nil {
        return
    }

    payload := ErrorPayload{
        Message:    err.Error(),
        StackTrace: string(debug.Stack()),
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", webhookURL, bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-Security-Key", securityKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        // Silently fail
        return
    }
    defer resp.Body.Close()
}

package main

import (
    "log"
    "net/http"
    "your-project/errorlogger"
)

func errorMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                errorlogger.LogError(fmt.Errorf("%v", err))
                http.Error(w, "Internal Server Error", 500)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", homeHandler)
    
    // Wrap with error middleware
    handler := errorMiddleware(mux)
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", handler))
}

package main

import (
    "github.com/gin-gonic/gin"
    "your-project/errorlogger"
)

func ErrorHandler() gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                errorlogger.LogError(fmt.Errorf("%v", err))
                c.JSON(500, gin.H{"error": "Internal server error"})
            }
        }()
        c.Next()
    }
}

func main() {
    r := gin.Default()
    
    // Add error handler middleware
    r.Use(ErrorHandler())
    
    r.GET("/users/:id", func(c *gin.Context) {
        // Your handler code
    })
    
    r.Run(":8080")
}

package main

import (
    "database/sql"
    "your-project/errorlogger"
)

func GetUser(id string) (*User, error) {
    user := &User{}
    err := db.QueryRow("SELECT * FROM users WHERE id = ?", id).Scan(user)
    
    if err != nil {
        // Log error to ErrorLogDashboard
        errorlogger.LogError(err)
        return nil, err
    }
    
    return user, nil
}