RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
fix(agent): persist webhook traces as JSON objects (#18883)
Guofang.Tangd45008090f00
diff --git a/internal/handler/agent_webhook.go b/internal/handler/agent_webhook.goindex 4b73cb3a3b..bc1028d501 100644--- a/internal/handler/agent_webhook.go+++ b/internal/handler/agent_webhook.go@@ -743,20 +743,27 @@ func mustJSON(v any) string {}// appendWebhookTrace appends a single RunEvent to the per-canvas trace-// key in Redis. Mirrors python's append_webhook_trace at-// agent_api.py:2073-2091.-//+// key in Redis.// The trace key is `webhook-trace-<agent_id>-logs` with a 600 s TTL.// Each event is recorded as {"ts": <float>, "event": <type>, ...}.-// Tests use miniredis to verify the key shape.func appendWebhookTrace(ctx context.Context, agentID string, startTs time.Time, ev canvas.RunEvent) {rdb := rediscli.Get()if rdb == nil {return}+ appendWebhookTraceWithWriter(ctx, rdb, agentID, startTs, ev)+}++type webhookTraceWriter interface {+ Get(context.Context, string) (string, error)+ SetObj(context.Context, string, any, time.Duration) bool+}+func appendWebhookTraceWithWriter(+ ctx context.Context, writer webhookTraceWriter, agentID string, startTs time.Time, ev canvas.RunEvent,+) {key := fmt.Sprintf("webhook-trace-%s-logs", agentID)- raw, _ := rdb.Get(ctx, key)+ raw, _ := writer.Get(ctx, key)obj := map[string]any{}if raw != "" {_ = json.Unmarshal([]byte(raw), &obj)@@ -792,10 +799,5 @@ func appendWebhookTrace(ctx context.Context, agentID string, startTs time.Time,}entry["events"] = append(events, eventRecord)- encoded, err := json.Marshal(obj)- if err != nil {- common.Warn("webhook trace marshal failed", zap.Error(err))- return- }- rdb.SetObj(ctx, key, string(encoded), 600*time.Second)+ writer.SetObj(ctx, key, obj, 600*time.Second)}diff --git a/internal/handler/agent_webhook_trace_test.go b/internal/handler/agent_webhook_trace_test.goindex d6acce0291..d2d019746d 100644--- a/internal/handler/agent_webhook_trace_test.go+++ b/internal/handler/agent_webhook_trace_test.go@@ -15,6 +15,7 @@package handlerimport (+ "context""encoding/json""errors""net/http/httptest"@@ -28,6 +29,7 @@ import ("github.com/gin-gonic/gin"goredis "github.com/redis/go-redis/v9"+ "ragflow/internal/agent/canvas""ragflow/internal/common""ragflow/internal/dao""ragflow/internal/entity"@@ -47,6 +49,26 @@ type webhookTraceResponse struct {Message string `json:"message"`}+type miniredisWebhookTraceWriter struct {+ client *goredis.Client+}++func (w miniredisWebhookTraceWriter) Get(ctx context.Context, key string) (string, error) {+ value, err := w.client.Get(ctx, key).Result()+ if errors.Is(err, goredis.Nil) {+ return "", nil+ }+ return value, err+}++func (w miniredisWebhookTraceWriter) SetObj(ctx context.Context, key string, value any, ttl time.Duration) bool {+ payload, err := json.Marshal(value)+ if err != nil {+ return false+ }+ return w.client.Set(ctx, key, payload, ttl).Err() == nil+}+// newWebhookTraceTestHandler wires ownership storage and miniredis for HTTP tests.func newWebhookTraceTestHandler(t *testing.T) (*AgentHandler, *goredis.Client) {t.Helper()@@ -115,6 +137,53 @@ func seedWebhookTrace(t *testing.T, rdb *goredis.Client, canvasID string, webhoo}}+func TestAppendWebhookTracePersistsReadableEvents(t *testing.T) {+ mr, err := miniredis.Run()+ if err != nil {+ t.Fatalf("miniredis.Run: %v", err)+ }+ t.Cleanup(mr.Close)+ rdb := goredis.NewClient(&goredis.Options{Addr: mr.Addr()})+ t.Cleanup(func() { _ = rdb.Close() })++ ctx := t.Context()+ writer := miniredisWebhookTraceWriter{client: rdb}+ start := time.Unix(1_700_000_000, 0)+ appendWebhookTraceWithWriter(ctx, writer, "c1", start, canvas.RunEvent{+ Type: "message",+ Data: `{"content":"hello"}`,+ SessionID: "task-1",+ })+ appendWebhookTraceWithWriter(ctx, writer, "c1", start, canvas.RunEvent{+ Type: "finished",+ Data: `{"success":true}`,+ })++ const key = "webhook-trace-c1-logs"+ raw, err := rdb.Get(ctx, key).Result()+ if err != nil {+ t.Fatalf("read persisted trace: %v", err)+ }+ sinceTS := float64(start.Unix() - 1)+ discovery, err := pollWebhookTrace(raw, sinceTS, "")+ if err != nil || discovery.WebhookID == nil {+ t.Fatalf("discover persisted trace: result=%+v err=%v", discovery, err)+ }+ poll, err := pollWebhookTrace(raw, sinceTS, *discovery.WebhookID)+ if err != nil {+ t.Fatalf("poll persisted trace: %v", err)+ }+ if len(poll.Events) != 2 || poll.Events[0]["event"] != "message" || poll.Events[1]["event"] != "finished" {+ t.Fatalf("persisted events = %+v, want message and finished", poll.Events)+ }+ if !poll.Finished {+ t.Fatal("persisted trace should be finished")+ }+ if ttl := mr.TTL(key); ttl != 600*time.Second {+ t.Fatalf("trace TTL = %s, want 10m0s", ttl)+ }+}+// TestGetAgentWebhookLogsPollsTraceIncrementally covers the complete UI poll flow.func TestGetAgentWebhookLogsPollsTraceIncrementally(t *testing.T) {h, rdb := newWebhookTraceTestHandler(t)