使用Golang实现Webhook URL的完整指南

以下是使用Golang实现Webhook URL接收日志回调的完整示例：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"
)

// 定义Webhook请求的数据结构
type LogEntry struct {
    Level     string    `json:"level"`
    Message   string    `json:"message"`
    Timestamp time.Time `json:"timestamp"`
    Service   string    `json:"service"`
    Metadata  any       `json:"metadata,omitempty"`
}

// Webhook处理器
func webhookHandler(w http.ResponseWriter, r *http.Request) {
    // 只接受POST请求
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    // 验证Content-Type
    contentType := r.Header.Get("Content-Type")
    if contentType != "application/json" {
        http.Error(w, "Content-Type must be application/json", http.StatusBadRequest)
        return
    }

    // 解析请求体
    var logEntry LogEntry
    decoder := json.NewDecoder(r.Body)
    decoder.DisallowUnknownFields()
    
    if err := decoder.Decode(&logEntry); err != nil {
        http.Error(w, fmt.Sprintf("Invalid JSON payload: %v", err), http.StatusBadRequest)
        return
    }

    // 验证必要字段
    if logEntry.Level == "" || logEntry.Message == "" {
        http.Error(w, "Missing required fields: level and message", http.StatusBadRequest)
        return
    }

    // 处理日志数据
    processLogEntry(logEntry)

    // 返回成功响应
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    response := map[string]string{
        "status":  "success",
        "message": "Log received and processed",
    }
    json.NewEncoder(w).Encode(response)
}

// 处理日志条目的业务逻辑
func processLogEntry(entry LogEntry) {
    // 这里可以添加日志处理逻辑，如：
    // 1. 存储到数据库
    // 2. 发送到消息队列
    // 3. 触发告警
    // 4. 实时分析
    
    fmt.Printf("[%s] %s: %s - %s\n", 
        entry.Timestamp.Format(time.RFC3339),
        entry.Service,
        entry.Level,
        entry.Message)
    
    // 示例：根据日志级别进行不同处理
    switch entry.Level {
    case "ERROR", "FATAL":
        // 发送告警通知
        sendAlert(entry)
    case "WARN":
        // 记录到特定文件
        logToFile(entry)
    }
}

// 辅助函数示例
func sendAlert(entry LogEntry) {
    // 实现告警逻辑
    log.Printf("ALERT: %s - %s\n", entry.Service, entry.Message)
}

func logToFile(entry LogEntry) {
    // 实现文件日志记录
    log.Printf("WARNING: %s - %s\n", entry.Service, entry.Message)
}

// 健康检查端点
func healthCheck(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "status": "healthy",
        "time":   time.Now().UTC().Format(time.RFC3339),
    })
}

// 中间件：记录请求信息
func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("Received %s request to %s from %s", 
            r.Method, r.URL.Path, r.RemoteAddr)
        
        next.ServeHTTP(w, r)
        
        log.Printf("Completed %s in %v", r.URL.Path, time.Since(start))
    }
}

func main() {
    // 设置路由
    http.HandleFunc("/webhook/logs", loggingMiddleware(webhookHandler))
    http.HandleFunc("/health", healthCheck)

    // 服务器配置
    server := &http.Server{
        Addr:         ":8080",
        Handler:      nil,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  30 * time.Second,
    }

    log.Println("Webhook server starting on :8080")
    log.Println("Endpoints:")
    log.Println("  POST   /webhook/logs")
    log.Println("  GET    /health")
    
    if err := server.ListenAndServe(); err != nil {
        log.Fatal("Server failed to start:", err)
    }
}

测试Webhook的示例客户端代码：

// 测试客户端
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

func sendTestLog() error {
    logEntry := map[string]any{
        "level":     "ERROR",
        "message":   "Database connection failed",
        "timestamp": time.Now().UTC(),
        "service":   "user-service",
        "metadata": map[string]string{
            "database": "users_db",
            "host":     "db.example.com:5432",
        },
    }

    jsonData, err := json.Marshal(logEntry)
    if err != nil {
        return err
    }

    resp, err := http.Post(
        "http://localhost:8080/webhook/logs",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    fmt.Printf("Response Status: %d\n", resp.StatusCode)
    return nil
}

func main() {
    if err := sendTestLog(); err != nil {
        fmt.Println("Error:", err)
    }
}

部署配置示例（Dockerfile）：

FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN go build -o webhook-server .

FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/webhook-server .
EXPOSE 8080
CMD ["./webhook-server"]

这个实现包含以下关键特性：

1. 完整的HTTP服务器：支持POST请求处理JSON格式的日志数据
2. 数据验证：检查请求方法、Content-Type和必需字段
3. 中间件支持：请求日志记录
4. 健康检查端点：用于监控服务状态
5. 错误处理：适当的HTTP状态码和错误消息
6. 并发安全：标准库的http.Server是并发安全的
7. 可扩展结构：便于添加认证、限流等功能

要添加身份验证，可以在中间件中实现：

func authMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "Bearer your-secret-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    }
}

然后更新路由：

http.HandleFunc("/webhook/logs", authMiddleware(loggingMiddleware(webhookHandler)))