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
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.goindex 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] = redactedLogValuecontinue}+ 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.goindex 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)