Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(db): stop logging bound parameters in GORM slow-query logs (#4561)

jack9224b1f40313
diff --git a/internal/container/container.go b/internal/container/container.go
index 29206d06e..81f775f38 100644
--- a/internal/container/container.go
+++ b/internal/container/container.go
@@ -1048,6 +1048,7 @@ func initDatabase(cfg *config.Config) (*gorm.DB, error) {
NowFunc: func() time.Time {
return time.Now().UTC()
},
+ Logger: newGormLogger(os.Stdout),
})
if err != nil {
return nil, err
diff --git a/internal/container/gorm_logger.go b/internal/container/gorm_logger.go
new file mode 100644
index 000000000..d973afa47
--- /dev/null
+++ b/internal/container/gorm_logger.go
@@ -0,0 +1,27 @@
+package container
+
+import (
+ "io"
+ stdlog "log"
+ "time"
+
+ gormlogger "gorm.io/gorm/logger"
+)
+
+// gormSlowSQLThreshold is GORM's default slow-query threshold. Statements
+// faster than this are not logged at Warn.
+const gormSlowSQLThreshold = 200 * time.Millisecond
+
+// newGormLogger is the application database logger. It matches GORM's
+// default slow-SQL threshold (200ms), Warn level, and record-not-found
+// handling. ParameterizedQueries is set so slow-query logs keep the SQL
+// text and timing but omit bound values such as chunk text and vectors.
+func newGormLogger(w io.Writer) gormlogger.Interface {
+ return gormlogger.New(stdlog.New(w, "\r\n", stdlog.LstdFlags), gormlogger.Config{
+ SlowThreshold: gormSlowSQLThreshold,
+ LogLevel: gormlogger.Warn,
+ IgnoreRecordNotFoundError: false,
+ Colorful: true,
+ ParameterizedQueries: true,
+ })
+}
diff --git a/internal/container/gorm_logger_test.go b/internal/container/gorm_logger_test.go
new file mode 100644
index 000000000..e628e9652
--- /dev/null
+++ b/internal/container/gorm_logger_test.go
@@ -0,0 +1,57 @@
+package container
+
+import (
+ "bytes"
+ "strings"
+ "testing"
+ "time"
+
+ "gorm.io/driver/sqlite"
+ "gorm.io/gorm"
+)
+
+// TestNewGormLoggerSlowSQLOmitsBoundParameters is the regression test for
+// issue #4543: a slow statement must still log SQL text and timing, but the
+// bound chunk text and embedding vector must not appear in the log line.
+//
+// The production break this catches is ParameterizedQueries left false (or the
+// logger omitted), which makes GORM inline every bound value before Trace.
+func TestNewGormLoggerSlowSQLOmitsBoundParameters(t *testing.T) {
+ var buf bytes.Buffer
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{
+ Logger: newGormLogger(&buf),
+ })
+ if err != nil {
+ t.Fatalf("gorm.Open: %v", err)
+ }
+ // GORM's default slow threshold is 200ms. Sleep inside the callback so the
+ // measured statement is slow without depending on the host database.
+ if err := db.Callback().Raw().Before("gorm:raw").Register("test:slow", func(*gorm.DB) {
+ time.Sleep(250 * time.Millisecond)
+ }); err != nil {
+ t.Fatalf("register slow callback: %v", err)
+ }
+
+ const chunk = "SECRET_CHUNK_TEXT_do_not_log_9f3a7c1e"
+ vector := "[" + strings.Repeat("0.123456789,", 32) + "0.5]"
+ if err := db.Exec("SELECT ?, ?", chunk, vector).Error; err != nil {
+ t.Fatalf("exec: %v", err)
+ }
+
+ logged := buf.String()
+ if strings.Contains(logged, chunk) {
+ t.Fatalf("slow SQL log included bound chunk text:\n%s", logged)
+ }
+ if strings.Contains(logged, "0.123456789") {
+ t.Fatalf("slow SQL log included embedding vector values:\n%s", logged)
+ }
+ if !strings.Contains(logged, "SLOW SQL") {
+ t.Fatalf("expected a slow SQL log entry, got %q", logged)
+ }
+ if !strings.Contains(logged, "SELECT") {
+ t.Fatalf("slow SQL log should still include the SQL text, got %q", logged)
+ }
+ if !strings.Contains(logged, "?") {
+ t.Fatalf("slow SQL log should keep placeholders, got %q", logged)
+ }
+}