improve error handling and logging for webhook events

- Replace generic error messages with structured error types in parser
- Add proper error classification for unsupported events and validation errors
- Reduce log noise by changing info logs to debug for routine events
- Skip error logging for expected unsupported event types in webhook handler

Author: CarlJi

internal/agent/agent.go

@@ -116,12 +116,11 @@ func (a *EnhancedAgent) ProcessGitHubWebhookEvent(ctx context.Context, eventType
 	xl := xlog.NewWith(ctx)
 
 	startTime := time.Now()
-	xl.Infof("Processing GitHub webhook event: %s, delivery_id: %s", eventType, deliveryID)
+	xl.Debugf("Processing GitHub webhook event: %s, delivery_id: %s", eventType, deliveryID)
 
 	// 1. 解析GitHub事件为类型安全的上下文
 	githubCtx, err := a.eventParser.ParseWebhookEvent(ctx, eventType, deliveryID, payload)
 	if err != nil {
-		xl.Warnf("Failed to parse GitHub webhook event: %v", err)
 		return fmt.Errorf("failed to parse webhook event: %w", err)
 	}
 

internal/events/errors.go

@@ -0,0 +1,75 @@
+package events
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Predefined error types for event operations
+var (
+	// Event parsing errors
+	ErrUnsupportedEventType = errors.New("unsupported event type")
+	ErrEventNotFound        = errors.New("event not found")
+	ErrInvalidEventFormat   = errors.New("invalid event format")
+	ErrEventParsingFailed   = errors.New("event parsing failed")
+
+	// Event validation errors
+	ErrMissingRepository  = errors.New("missing repository in event")
+	ErrMissingSender      = errors.New("missing sender in event")
+	ErrMissingIssue       = errors.New("missing issue in event")
+	ErrMissingComment     = errors.New("missing comment in event")
+	ErrMissingPullRequest = errors.New("missing pull request in event")
+	ErrMissingReview      = errors.New("missing review in event")
+)
+
+// EventError represents an event-related error with context
+type EventError struct {
+	Op        string // Operation that failed
+	EventType string // Event type (if applicable)
+	Err       error  // Underlying error
+	Context   string // Additional context
+}
+
+func (e *EventError) Error() string {
+	if e.EventType != "" && e.Context != "" {
+		return fmt.Sprintf("event %s failed for type %s: %v (context: %s)", e.Op, e.EventType, e.Err, e.Context)
+	}
+	if e.EventType != "" {
+		return fmt.Sprintf("event %s failed for type %s: %v", e.Op, e.EventType, e.Err)
+	}
+	if e.Context != "" {
+		return fmt.Sprintf("event %s failed: %v (context: %s)", e.Op, e.Err, e.Context)
+	}
+	return fmt.Sprintf("event %s failed: %v", e.Op, e.Err)
+}
+
+func (e *EventError) Unwrap() error {
+	return e.Err
+}
+
+// NewEventError creates a new EventError
+func NewEventError(op, eventType string, err error, context string) *EventError {
+	return &EventError{
+		Op:        op,
+		EventType: eventType,
+		Err:       err,
+		Context:   context,
+	}
+}
+
+// Helper functions for creating specific errors
+
+// UnsupportedEventTypeError creates an unsupported event type error
+func UnsupportedEventTypeError(eventType string) error {
+	return NewEventError("parse", eventType, ErrUnsupportedEventType, "")
+}
+
+// ParsingError creates a parsing-related error
+func ParsingError(eventType string, err error) error {
+	return NewEventError("parse", eventType, fmt.Errorf("parsing: %w", err), "")
+}
+
+// ValidationError creates a validation-related error
+func ValidationError(eventType string, err error, context string) error {
+	return NewEventError("validate", eventType, fmt.Errorf("validation: %w", err), context)
+}

internal/events/parser.go

@@ -35,7 +35,7 @@ func (p *EventParser) ParseEvent(ctx context.Context, eventType string, rawEvent
 			return p.ParseIssueCommentEvent(ctx, event)
 		}
 	}
-	return nil, fmt.Errorf("unsupported event type or format: %s", eventType)
+	return nil, UnsupportedEventTypeError(eventType)
 }
 
 // ParseIssueCommentEvent 解析Issue评论事件（从原始GitHub事件）
@@ -71,7 +71,7 @@ func (p *EventParser) ParseWebhookEvent(
 ) (models.GitHubContext, error) {
 	// 验证事件类型
 	if !models.IsValidEventType(eventType) {
-		return nil, fmt.Errorf("unsupported event type: %s", eventType)
+		return nil, UnsupportedEventTypeError(eventType)
 	}
 
 	// 根据事件类型解析
@@ -89,7 +89,7 @@ func (p *EventParser) ParseWebhookEvent(
 	case models.EventPush:
 		return p.parsePushEvent(ctx, payload, deliveryID)
 	default:
-		return nil, fmt.Errorf("event type %s not implemented yet", eventType)
+		return nil, UnsupportedEventTypeError(eventType)
 	}
 }
 
@@ -101,21 +101,21 @@ func (p *EventParser) parseIssueCommentEvent(
 ) (*models.IssueCommentContext, error) {
 	var event github.IssueCommentEvent
 	if err := json.Unmarshal(payload, &event); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal issue comment event: %w", err)
+		return nil, ParsingError("issue_comment", err)
 	}
 
 	// 检查必需字段
 	if event.Repo == nil {
-		return nil, fmt.Errorf("missing repository in issue comment event")
+		return nil, ValidationError("issue_comment", ErrMissingRepository, "")
 	}
 	if event.Sender == nil {
-		return nil, fmt.Errorf("missing sender in issue comment event")
+		return nil, ValidationError("issue_comment", ErrMissingSender, "")
 	}
 	if event.Issue == nil {
-		return nil, fmt.Errorf("missing issue in issue comment event")
+		return nil, ValidationError("issue_comment", ErrMissingIssue, "")
 	}
 	if event.Comment == nil {
-		return nil, fmt.Errorf("missing comment in issue comment event")
+		return nil, ValidationError("issue_comment", ErrMissingComment, "")
 	}
 
 	// 判断是否是PR评论

internal/webhook/handler.go

@@ -2,11 +2,13 @@ package webhook
 
 import (
 	"context"
+	"errors"
 	"io"
 	"net/http"
 
 	"github.com/qiniu/codeagent/internal/agent"
 	"github.com/qiniu/codeagent/internal/config"
+	"github.com/qiniu/codeagent/internal/events"
 	"github.com/qiniu/codeagent/pkg/signature"
 
 	"github.com/qiniu/x/reqid"
@@ -82,7 +84,11 @@ func (h *Handler) HandleWebhook(w http.ResponseWriter, r *http.Request) {
 	go func(eventType string, payload []byte, deliveryID string, traceCtx context.Context) {
 		traceLog := xlog.NewWith(traceCtx)
 		if err := h.enhancedAgent.ProcessGitHubWebhookEvent(traceCtx, eventType, deliveryID, payload); err != nil {
-			traceLog.Warnf("enhanced agent event processing error: %v", err)
+			if errors.Is(err, events.ErrUnsupportedEventType) {
+				traceLog.Debugf("enhanced agent unsupported event type: %v", err)
+			} else {
+				traceLog.Warnf("enhanced agent event processing error: %v", err)
+			}
 		} else {
 			traceLog.Infof("enhanced agent event processing completed successfully")
 		}