Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(agent): persist webhook traces as JSON objects (#18883)

Guofang.Tangd45008090f00
diff --git a/internal/handler/agent_webhook.go b/internal/handler/agent_webhook.go
index 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.go
index d6acce0291..d2d019746d 100644
--- a/internal/handler/agent_webhook_trace_test.go
+++ b/internal/handler/agent_webhook_trace_test.go
@@ -15,6 +15,7 @@
package handler
import (
+ "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)