Skip to content

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

Enhance LLM_DEBUG with took and first token time, short embedding to 3 float (#19816)

Wang Qi8363fc709db6
diff --git a/internal/entity/models/base_model.go b/internal/entity/models/base_model.go
index eb6dd71524..1768a5ab02 100644
--- a/internal/entity/models/base_model.go
+++ b/internal/entity/models/base_model.go
@@ -35,7 +35,8 @@ import (
)
const (
- redactedLogValue = "[REDACTED]"
+ redactedLogValue = "[REDACTED]"
+ maxLoggedVectorFloats = 3
)
type BaseModel struct {
@@ -494,11 +495,12 @@ func newProviderLoggingTransport(base http.RoundTripper) http.RoundTripper {
if !common.IsLLMDebugEnabled() {
return base
}
- return &providerLoggingTransport{base: base}
+ return &providerLoggingTransport{base: base, now: time.Now}
}
type providerLoggingTransport struct {
base http.RoundTripper
+ now func() time.Time
}
func (t *providerLoggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
@@ -509,20 +511,23 @@ func (t *providerLoggingTransport) RoundTrip(req *http.Request) (*http.Response,
providerURL := redactProviderURL(req.URL)
logPayload := redactProviderBody(payload)
+ startedAt := t.now()
resp, err := t.base.RoundTrip(req)
if err != nil {
- logProviderCall(providerURL, logPayload, 0, "", err)
+ logProviderCall(providerURL, logPayload, 0, "", t.now().Sub(startedAt), 0, err)
return nil, err
}
if resp.Body == nil {
- logProviderCall(providerURL, logPayload, resp.StatusCode, "", nil)
+ logProviderCall(providerURL, logPayload, resp.StatusCode, "", t.now().Sub(startedAt), 0, nil)
return resp, nil
}
resp.Body = &providerResponseBody{
ReadCloser: resp.Body,
- log: func(body []byte) {
- logProviderCall(providerURL, logPayload, resp.StatusCode, redactProviderBody(body), nil)
+ startedAt: startedAt,
+ now: t.now,
+ log: func(body []byte, took, firstToken time.Duration) {
+ logProviderCall(providerURL, logPayload, resp.StatusCode, redactProviderBody(body), took, firstToken, nil)
},
}
return resp, nil
@@ -532,31 +537,38 @@ func (t *providerLoggingTransport) RoundTrip(req *http.Request) (*http.Response,
// streaming delivery instead of eagerly reading the entire provider response.
type providerResponseBody struct {
io.ReadCloser
- body bytes.Buffer
- once sync.Once
- log func([]byte)
+ body bytes.Buffer
+ startedAt time.Time
+ now func() time.Time
+ firstToken time.Duration
+ firstOnce sync.Once
+ logOnce sync.Once
+ log func([]byte, time.Duration, time.Duration)
}
func (b *providerResponseBody) Read(p []byte) (int, error) {
n, err := b.ReadCloser.Read(p)
if n > 0 {
+ b.firstOnce.Do(func() {
+ b.firstToken = b.now().Sub(b.startedAt)
+ })
_, _ = b.body.Write(p[:n])
}
if err == io.EOF {
- b.logOnce()
+ b.writeLogOnce()
}
return n, err
}
func (b *providerResponseBody) Close() error {
err := b.ReadCloser.Close()
- b.logOnce()
+ b.writeLogOnce()
return err
}
-func (b *providerResponseBody) logOnce() {
- b.once.Do(func() {
- b.log(b.body.Bytes())
+func (b *providerResponseBody) writeLogOnce() {
+ b.logOnce.Do(func() {
+ b.log(b.body.Bytes(), b.now().Sub(b.startedAt), b.firstToken)
})
}
@@ -638,6 +650,10 @@ func redactProviderValue(value any) {
value[key] = redactedLogValue
continue
}
+ if isVectorLogKey(key) {
+ child = truncateLoggedVectors(child)
+ value[key] = child
+ }
redactProviderValue(child)
}
case []any:
@@ -647,6 +663,47 @@ func redactProviderValue(value any) {
}
}
+func isVectorLogKey(key string) bool {
+ switch strings.ToLower(key) {
+ case "embedding", "embeddings", "vector", "vectors":
+ return true
+ default:
+ return false
+ }
+}
+
+func truncateLoggedVectors(value any) any {
+ switch value := value.(type) {
+ case []any:
+ if isNumericVector(value) {
+ if len(value) > maxLoggedVectorFloats {
+ return value[:maxLoggedVectorFloats]
+ }
+ return value
+ }
+ for i, child := range value {
+ value[i] = truncateLoggedVectors(child)
+ }
+ case map[string]any:
+ for key, child := range value {
+ value[key] = truncateLoggedVectors(child)
+ }
+ }
+ return value
+}
+
+func isNumericVector(value []any) bool {
+ if len(value) == 0 {
+ return false
+ }
+ for _, item := range value {
+ if _, ok := item.(float64); !ok {
+ return false
+ }
+ }
+ return true
+}
+
func isSensitiveLogKey(key string) bool {
normalized := strings.NewReplacer("-", "", "_", "", ".", "").Replace(strings.ToLower(key))
switch normalized {
@@ -657,9 +714,9 @@ func isSensitiveLogKey(key string) bool {
}
}
-func logProviderCall(providerURL, payload string, statusCode int, responseBody string, err error) {
+func logProviderCall(providerURL, payload string, statusCode int, responseBody string, took, firstToken time.Duration, err error) {
request := fmt.Sprintf("url=%s payload=%s", providerURL, payload)
- response := fmt.Sprintf("response_code=%d response_body=%s", statusCode, responseBody)
+ response := fmt.Sprintf("response_code=%d took=%s first-token=%s response_body=%s", statusCode, took, firstToken, responseBody)
if err != nil {
response += " error=" + err.Error()
}
diff --git a/internal/entity/models/common_test.go b/internal/entity/models/common_test.go
index 5dedb238d7..db8608a087 100644
--- a/internal/entity/models/common_test.go
+++ b/internal/entity/models/common_test.go
@@ -60,7 +60,7 @@ func TestDriverHTTPClientLogsProviderRequestAndResponseWhenEnabled(t *testing.T)
if !strings.Contains(message, `payload={"api_key":"[REDACTED]","query":"hello"}`) {
t.Errorf("provider log payload is not raw redacted JSON: %q", message)
}
- if !strings.Contains(message, `response_code=200 response_body={"access_token":"[REDACTED]","answer":"ok"}`) {
+ if !strings.Contains(message, `response_code=200 took=`) || !strings.Contains(message, ` first-token=`) || !strings.Contains(message, ` response_body={"access_token":"[REDACTED]","answer":"ok"}`) {
t.Errorf("provider log response is not raw redacted JSON: %q", message)
}
if strings.Contains(message, "request-secret") || strings.Contains(message, "payload-secret") || strings.Contains(message, "response-secret") {
@@ -68,6 +68,67 @@ func TestDriverHTTPClientLogsProviderRequestAndResponseWhenEnabled(t *testing.T)
}
}
+func TestProviderLoggingRecordsTimingsAndTruncatesVectors(t *testing.T) {
+ core, logs := observer.New(zapcore.InfoLevel)
+ previousLogger := common.Logger
+ common.Logger = zap.New(core)
+ t.Cleanup(func() {
+ common.Logger = previousLogger
+ })
+
+ startedAt := time.Unix(100, 0)
+ times := []time.Time{
+ startedAt,
+ startedAt.Add(time.Second),
+ startedAt.Add(3 * time.Second),
+ }
+ timeIndex := 0
+ transport := &providerLoggingTransport{
+ base: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+ return &http.Response{
+ StatusCode: http.StatusOK,
+ Header: make(http.Header),
+ Body: io.NopCloser(strings.NewReader(`{"data":[{"embedding":[0.1,0.2,0.3,0.4,0.5]}],"vectors":[[1,2,3,4],[5,6]]}`)),
+ Request: req,
+ }, nil
+ }),
+ now: func() time.Time {
+ current := times[timeIndex]
+ timeIndex++
+ return current
+ },
+ }
+ req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "https://provider.example/v1/embeddings", nil)
+ if err != nil {
+ t.Fatalf("NewRequestWithContext() error = %v", err)
+ }
+ resp, err := transport.RoundTrip(req)
+ if err != nil {
+ t.Fatalf("RoundTrip() error = %v", err)
+ }
+ if _, err = io.ReadAll(resp.Body); err != nil {
+ t.Fatalf("ReadAll() error = %v", err)
+ }
+ if err = resp.Body.Close(); err != nil {
+ t.Fatalf("Close() error = %v", err)
+ }
+
+ entries := logs.All()
+ if len(entries) != 1 {
+ t.Fatalf("provider log count = %d, want 1", len(entries))
+ }
+ message := entries[0].Message
+ if !strings.Contains(message, "took=3s first-token=1s") {
+ t.Errorf("provider log timings = %q, want took=3s first-token=1s", message)
+ }
+ if !strings.Contains(message, `response_body={"data":[{"embedding":[0.1,0.2,0.3]}],"vectors":[[1,2,3],[5,6]]}`) {
+ t.Errorf("provider log did not truncate vectors: %q", message)
+ }
+ if strings.Contains(message, "0.4") || strings.Contains(message, "0.5") || strings.Contains(message, "[1,2,3,4]") {
+ t.Errorf("provider log contains vector values after the first three: %q", message)
+ }
+}
+
func TestProviderLoggingDisabledAvoidsPayloadWork(t *testing.T) {
t.Setenv(common.EnvLLMDebug, "")
core, logs := observer.New(zapcore.InfoLevel)