Skip to content

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

refactor(common): revert OSS ingest-log collection from #21711 (keep instrumentation only) (#21893)

xugangqiangdd3c77c582bc
diff --git a/internal/common/audit_test.go b/internal/common/audit_test.go
new file mode 100644
index 0000000000..914deda097
--- /dev/null
+++ b/internal/common/audit_test.go
@@ -0,0 +1,35 @@
+//go:build !ee
+
+package common_test
+
+import (
+ "testing"
+
+ "ragflow/internal/common"
+)
+
+// TestSyncAuditNoPanic verifies the OSS no-op audit flush is callable and
+// returns without panicking. The function must remain defined in the OSS stub
+// so the server entrypoint (cmd/ragflow_server.go) compiles and runs.
+func TestSyncAuditNoPanic(t *testing.T) {
+ defer func() {
+ if r := recover(); r != nil {
+ t.Fatalf("SyncAudit panicked: %v", r)
+ }
+ }()
+ common.SyncAudit()
+}
+
+// TestSyncAuditMultipleCalls guards against a regression where the no-op flush
+// cannot be invoked repeatedly (e.g. an accidental removal that leaves a dangling
+// deferred call in the server startup path).
+func TestSyncAuditMultipleCalls(t *testing.T) {
+ defer func() {
+ if r := recover(); r != nil {
+ t.Fatalf("SyncAudit panicked on repeated call: %v", r)
+ }
+ }()
+ common.SyncAudit()
+ common.SyncAudit()
+ common.SyncAudit()
+}
diff --git a/internal/common/ingest_log_path_test.go b/internal/common/ingest_log_path_test.go
deleted file mode 100644
index d7ba0eed5c..0000000000
--- a/internal/common/ingest_log_path_test.go
+++ /dev/null
@@ -1,68 +0,0 @@
-//go:build !ee
-
-package common
-
-import (
- "os"
- "path/filepath"
- "testing"
- "time"
-)
-
-// TestInitIngestLogPathTreatedAsFile is the regression test for P1b: the configured
-// ingestor.log.path is a FILE name (per conf/service_conf.yaml comment), so InitIngestLog
-// must write to that exact file and must NOT treat it as a directory.
-func TestInitIngestLogPathTreatedAsFile(t *testing.T) {
- t.Cleanup(resetIngestLog)
-
- dir := t.TempDir()
- filePath := filepath.Join(dir, "ingest_log.log")
-
- if err := InitIngestLog("file", FileOutput{Path: filePath}, "api_server_9381"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
-
- LogIngestEvent(IngestionLog{EventTime: time.Now().UTC(), TaskID: "t1", EventType: "created", Status: "CREATED"})
- SyncIngestLog()
-
- fi, err := os.Stat(filePath)
- if err != nil {
- t.Fatalf("expected log file at %s: %v", filePath, err)
- }
- if fi.IsDir() {
- t.Fatalf("%s was created as a DIRECTORY; path must be treated as a file", filePath)
- }
-
- if stray, err := os.Stat(filepath.Join(dir, "ingest_log.log")); err == nil && stray.IsDir() {
- t.Fatalf("stray directory %s/ created; path was misinterpreted as a directory", dir)
- }
-}
-
-// TestInitIngestLogEmptyPathNoFile asserts the documented default: an empty path emits to
-// stdout only and opens no rotated file. This guards the off-by-default contract.
-func TestInitIngestLogEmptyPathNoFile(t *testing.T) {
- t.Cleanup(resetIngestLog)
-
- dir := t.TempDir()
- if err := InitIngestLog("file", FileOutput{}, "api_server_9381"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
- LogIngestEvent(IngestionLog{EventTime: time.Now().UTC(), TaskID: "t1"})
- SyncIngestLog()
-
- entries, _ := os.ReadDir(dir)
- for _, e := range entries {
- if nameContains(e.Name(), "ingest") {
- t.Fatalf("empty path opened a file under %s: %s", dir, e.Name())
- }
- }
-}
-
-func nameContains(s, sub string) bool {
- for i := 0; i+len(sub) <= len(s); i++ {
- if s[i:i+len(sub)] == sub {
- return true
- }
- }
- return false
-}
diff --git a/internal/common/ingest_log_test.go b/internal/common/ingest_log_test.go
deleted file mode 100644
index 9abaedcce0..0000000000
--- a/internal/common/ingest_log_test.go
+++ /dev/null
@@ -1,186 +0,0 @@
-//go:build !ee
-
-package common
-
-import (
- "bytes"
- "encoding/json"
- "os"
- "path/filepath"
- "reflect"
- "strings"
- "testing"
- "time"
-
- "go.uber.org/zap"
-)
-
-func resetIngestLog() {
- ingestLogger.Store(zap.NewNop())
-}
-
-// TestIngestLogUnifiedStruct asserts the single unified type: renamed fields
-// (DocID not DocumentID, EventType not TaskType) and the absence of the
-// un-serializable Error error interface. Structural guard for 方案B unification.
-func TestIngestLogUnifiedStruct(t *testing.T) {
- typ := reflect.TypeOf(IngestionLog{})
- for _, f := range []string{"DocID", "EventType", "ErrorInfo", "Code"} {
- if _, ok := typ.FieldByName(f); !ok {
- t.Errorf("IngestionLog missing expected unified field %q", f)
- }
- }
- for _, bad := range []string{"DocumentID", "TaskType", "Error"} {
- if _, ok := typ.FieldByName(bad); ok {
- t.Errorf("IngestionLog must not keep legacy field %q after unification", bad)
- }
- }
-}
-
-// TestIngestLogEmitsUnifiedJSON happy path: flat JSON line with error_info (string) and code.
-func TestIngestLogEmitsUnifiedJSON(t *testing.T) {
- defer resetIngestLog()
- dir := t.TempDir()
- if err := InitIngestLog("json", FileOutput{Path: dir, Filename: "ingest.log"}, "svc"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
- LogIngestEvent(IngestionLog{
- EventTime: time.Now().UTC(),
- TenantID: "t1",
- DatasetID: "kb1",
- DocID: "d1",
- UserID: "u1",
- TaskID: "task1",
- EventType: "completed",
- Status: "COMPLETED",
- ErrorInfo: "boom",
- Filename: "report.pdf",
- FileType: "pdf",
- FileSize: 12345,
- ParserID: "pdf",
- Code: 7,
- })
- SyncIngestLog()
- raw, err := os.ReadFile(filepath.Join(dir, "ingest.log"))
- if err != nil {
- t.Fatalf("read sink: %v", err)
- }
- var m map[string]any
- if err := json.Unmarshal(raw, &m); err != nil {
- t.Fatalf("emitted line not JSON: %v (raw=%q)", err, raw)
- }
- if m["error_info"] != "boom" {
- t.Errorf("error_info = %v, want boom (string, not error interface)", m["error_info"])
- }
- if c, ok := m["code"].(float64); !ok || c != 7 {
- t.Errorf("code = %v (%T), want 7", m["code"], m["code"])
- }
- if _, ok := m["error"]; ok {
- t.Errorf("legacy error key must not be present; only error_info is allowed")
- }
-}
-
-// TestIngestLogCodeRoundTrips adversarial: Code is a first-class struct field,
-// not hard-coded 0 via a secondary mapping layer.
-func TestIngestLogCodeRoundTrips(t *testing.T) {
- defer resetIngestLog()
- dir := t.TempDir()
- if err := InitIngestLog("json", FileOutput{Path: dir, Filename: "ingest.log"}, "svc"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
- LogIngestEvent(IngestionLog{TaskID: "task1", EventType: "failed", Status: "FAILED", Code: 7})
- SyncIngestLog()
- raw, _ := os.ReadFile(filepath.Join(dir, "ingest.log"))
- var m map[string]any
- if err := json.Unmarshal(raw, &m); err != nil {
- t.Fatalf("emitted line not JSON: %v (raw=%q)", err, raw)
- }
- if c, ok := m["code"].(float64); !ok || c != 7 {
- t.Errorf("code = %v (%T), want 7 (first-class struct field, not hard-coded 0)", m["code"], m["code"])
- }
-}
-
-// TestIngestLogOmitsZeroTimes adversarial: zero-value times must not leak.
-func TestIngestLogOmitsZeroTimes(t *testing.T) {
- defer resetIngestLog()
- dir := t.TempDir()
- if err := InitIngestLog("json", FileOutput{Path: dir, Filename: "ingest.log"}, "svc"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
- LogIngestEvent(IngestionLog{EventTime: time.Now().UTC(), TaskID: "t1", EventType: "created", Status: "CREATED"})
- SyncIngestLog()
- raw, _ := os.ReadFile(filepath.Join(dir, "ingest.log"))
- if strings.Contains(string(raw), "0001-01-01") {
- t.Errorf("emitted zero-time sentinel 0001-01-01: %s", raw)
- }
- var m map[string]any
- json.Unmarshal(raw, &m)
- for _, k := range []string{"begin_time", "end_time", "upload_time", "enqueue_time"} {
- if _, ok := m[k]; ok {
- t.Errorf("zero-time field %q must be omitted, got %v", k, m[k])
- }
- }
- if _, ok := m["event_time"]; !ok {
- t.Errorf("event_time must always be present")
- }
-}
-
-// TestIngestLogOmitsEmptyErrorInfo adversarial: empty ErrorInfo omitted.
-func TestIngestLogOmitsEmptyErrorInfo(t *testing.T) {
- defer resetIngestLog()
- dir := t.TempDir()
- if err := InitIngestLog("json", FileOutput{Path: dir, Filename: "ingest.log"}, "svc"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
- LogIngestEvent(IngestionLog{TaskID: "t1", EventType: "created", Status: "CREATED"})
- SyncIngestLog()
- raw, _ := os.ReadFile(filepath.Join(dir, "ingest.log"))
- var m map[string]any
- json.Unmarshal(raw, &m)
- if _, ok := m["error_info"]; ok {
- t.Errorf("empty error_info must be omitted, got %v", m["error_info"])
- }
-}
-
-// TestIngestLogOmitsEmptyUserName corner.
-func TestIngestLogOmitsEmptyUserName(t *testing.T) {
- defer resetIngestLog()
- dir := t.TempDir()
- if err := InitIngestLog("json", FileOutput{Path: dir, Filename: "ingest.log"}, "svc"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
- LogIngestEvent(IngestionLog{TaskID: "task1", EventType: "created", Status: "CREATED"})
- SyncIngestLog()
- raw, _ := os.ReadFile(filepath.Join(dir, "ingest.log"))
- if strings.Contains(string(raw), "user_name") {
- t.Fatalf("emitted line contains user_name when UserName is empty: %s", raw)
- }
-}
-
-// TestIngestLogOneFlatLine adversarial: each event is exactly one JSON line.
-func TestIngestLogOneFlatLine(t *testing.T) {
- defer resetIngestLog()
- dir := t.TempDir()
- if err := InitIngestLog("json", FileOutput{Path: dir, Filename: "ingest.log"}, "svc"); err != nil {
- t.Fatalf("InitIngestLog: %v", err)
- }
- LogIngestEvent(IngestionLog{TaskID: "task1", EventType: "completed", Status: "COMPLETED", ErrorInfo: "boom"})
- SyncIngestLog()
- raw, _ := os.ReadFile(filepath.Join(dir, "ingest.log"))
- if len(bytes.TrimSpace(raw)) == 0 {
- t.Fatal("LogIngest wrote no output")
- }
- lines := 0
- for _, l := range bytes.Split(raw, []byte("\n")) {
- if len(bytes.TrimSpace(l)) == 0 {
- continue
- }
- lines++
- var m map[string]any
- if err := json.Unmarshal(l, &m); err != nil {
- t.Fatalf("non-JSON line: %v (raw=%q)", err, l)
- }
- }
- if lines != 1 {
- t.Fatalf("expected 1 line, got %d (raw=%q)", lines, raw)
- }
-}
diff --git a/internal/common/stub.go b/internal/common/stub.go
index f39de5b591..686b52421f 100644
--- a/internal/common/stub.go
+++ b/internal/common/stub.go
@@ -12,22 +12,15 @@
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
-//
//go:build !ee
package common
import (
- "fmt"
- "os"
- "path/filepath"
- "sync/atomic"
"time"
"go.uber.org/zap"
- "go.uber.org/zap/zapcore"
- "gopkg.in/natefinch/lumberjack.v2"
)
var (
@@ -61,182 +54,53 @@ type OperationLog struct {
func Audit(operationLog *OperationLog, fields ...zap.Field) {
}
+// SyncAudit is the OSS no-op flush for the audit logger. The real sink lives in
+// the EE build; the OSS binary keeps only the instrumentation seam so the
+// server entrypoint's deferred flush (cmd/ragflow_server.go) compiles and runs.
func SyncAudit() {
}
-// ingestLogger receives the serialized ingest events. It defaults to a no-op so a
-// binary that never calls InitIngestLog emits nothing and never panics.
-var ingestLogger atomic.Pointer[zap.Logger]
-
-func init() {
- ingestLogger.Store(zap.NewNop())
-}
-
-// InitIngestLog configures the sink for ingestion lifecycle events. It mirrors
-// InitLogger: output always goes to stdout, and an optional rotated file is added
-// when both Path and Filename are set.
+// InitIngestLog is the OSS no-op hook for ingestion lifecycle event sinks. The OSS
+// build does not collect these events; the real sink lives in the EE build via the
+// LogIngest seam. The signature is retained so the IngestionEventEmitter /
+// SetEventEmitter wiring in the ingestion service keeps compiling.
func InitIngestLog(logType string, file FileOutput, serviceName string) error {
- encoderConfig := zapcore.EncoderConfig{
- TimeKey: "timestamp",
- LevelKey: "level",
- NameKey: "service",
- CallerKey: "caller",
- FunctionKey: "",
- MessageKey: "msg",
- StacktraceKey: "stacktrace",
- LineEnding: zapcore.DefaultLineEnding,
- EncodeLevel: zapcore.LowercaseLevelEncoder,
- EncodeTime: zapcore.TimeEncoderOfLayout("2006-01-02 15:04:05.000-07:00"),
- EncodeDuration: zapcore.SecondsDurationEncoder,
- EncodeCaller: zapcore.ShortCallerEncoder,
- EncodeName: zapcore.FullNameEncoder,
- }
- maxSize := file.MaxSize
- if maxSize <= 0 {
- maxSize = DefaultLogMaxSizeMB
- }
- maxBackups := file.MaxBackups
- if maxBackups <= 0 {
- maxBackups = DefaultLogMaxBackups
- }
- maxAge := file.MaxAge
- if maxAge <= 0 {
- maxAge = DefaultLogMaxAgeDays
- }
- compress := DefaultLogCompress
- if file.Compress != nil {
- compress = *file.Compress
- }
- stdoutSyncer := zapcore.AddSync(os.Stdout)
- syncers := []zapcore.WriteSyncer{stdoutSyncer}
- // File output is opt-in via a non-empty Path. Path is treated as the log FILE
- // (matching conf/service_conf.yaml's "path is the file" wording): a stray
- // directory named after the file is never created. Only when Path is itself an
- // existing directory do we synthesize a per-service file name inside it.
- if file.Path != "" {
- filename := file.Path
- if fi, statErr := os.Stat(file.Path); statErr == nil && fi.IsDir() {
- name := file.Filename
- if name == "" {
- name = fmt.Sprintf("%s_ingest.log", serviceName)
- }
- filename = filepath.Join(file.Path, name)
- }
- ljLogger := &lumberjack.Logger{
- Filename: filename,
- MaxSize: maxSize,
- MaxBackups: maxBackups,
- MaxAge: maxAge,
- Compress: compress,
- LocalTime: true,
- }
- syncers = append(syncers, zapcore.AddSync(ljLogger))
- }
- core := zapcore.NewCore(zapcore.NewJSONEncoder(encoderConfig), zapcore.NewMultiWriteSyncer(syncers...), zapcore.InfoLevel)
- oldLogger := ingestLogger.Swap(zap.New(core))
- if oldLogger != nil {
- _ = oldLogger.Sync()
- }
return nil
}
type IngestionLog struct {
- EventTime time.Time `json:"event_time"`
- TenantID string `json:"tenant_id"`
- DatasetID string `json:"dataset_id"`
- DocID string `json:"doc_id"`
- UserID string `json:"user_id"`
- UserName string `json:"user_name,omitempty"`
- Worker string `json:"worker"`
- TaskID string `json:"task_id"`
- EventType string `json:"event_type"` // created|scheduled|running|completed|failed|stopped
- Status string `json:"status"`
- // ErrorInfo is the terminal reason as a plain string (not an error
- // interface) so the event serializes cleanly and portably to external
- // dashboards / ClickHouse.
- ErrorInfo string `json:"error_info,omitempty"`
- Filename string `json:"filename"`
- FileType string `json:"file_type"`
- FileSize int64 `json:"file_size"`
- ParserID string `json:"parser_id"`
- UploadTime time.Time `json:"upload_time"`
- EnqueueTime time.Time `json:"enqueue_time"`
- BeginTime time.Time `json:"begin_time"`
- EndTime time.Time `json:"end_time"`
- DurationMS int64 `json:"duration_ms"`
- WaitDurationS float64 `json:"wait_duration_s"`
- ParseDurationS float64 `json:"parse_duration_s"`
- Progress float64 `json:"progress"`
- RunCount int `json:"run_count"`
- // Code is a machine-readable category for grouping in dashboards. It
- // defaults to 0 when the caller does not set it.
- Code int `json:"code"`
- Operation map[string]any `json:"operation,omitempty"`
+ EventTime time.Time `json:"event_time"`
+ TenantID string `json:"tenant_id"`
+ DatasetID string `json:"dataset_id"`
+ DocID string `json:"doc_id"`
+ UserID string `json:"user_id"`
+ UserName string `json:"user_name,omitempty"`
+ Worker string `json:"worker"`
+ TaskID string `json:"task_id"`
+ EventType string `json:"event_type"`
+ Status string `json:"status"`
+ ErrorInfo string `json:"error_info,omitempty"`
+ Filename string `json:"filename"`
+ FileType string `json:"file_type"`
+ FileSize int64 `json:"file_size"`
+ ParserID string `json:"parser_id"`
+ UploadTime time.Time `json:"upload_time"`
+ EnqueueTime time.Time `json:"enqueue_time"`
+ BeginTime time.Time `json:"begin_time"`
+ EndTime time.Time `json:"end_time"`
+ DurationMS int64 `json:"duration_ms"`
+ WaitDurationS float64 `json:"wait_duration_s"`
+ ParseDurationS float64 `json:"parse_duration_s"`
+ Progress float64 `json:"progress"`
+ RunCount int `json:"run_count"`
+ Code int `json:"code"`
+ Operation map[string]any `json:"operation,omitempty"`
}
-// SyncIngestLog flushes any buffered ingest output. Call it before process exit
-// so no events are lost.
func SyncIngestLog() {
- _ = ingestLogger.Load().Sync()
-}
-
-// LogIngestEvent transmits one structured ingestion lifecycle event as a single,
-// flat JSON line. In the OSS build it writes to the local zap sink and also
-// forwards to the shared LogIngest seam (a no-op in OSS, the real sink in EE).
-func LogIngestEvent(log IngestionLog) {
- ingestLogger.Load().With(log.zapFields()...).Info("ingest_log")
- LogIngest(&log)
-}
-
-// zapFields renders the event as flat zap fields (top-level keys, UTC times) so
-// the emitted JSON line is directly consumable by ClickHouse / Grafana.
-func (l IngestionLog) zapFields() []zap.Field {
- fields := []zap.Field{
- zap.Time("event_time", l.EventTime.UTC()),
- zap.String("tenant_id", l.TenantID),
- zap.String("dataset_id", l.DatasetID),
- zap.String("doc_id", l.DocID),
- zap.String("user_id", l.UserID),
- zap.String("worker", l.Worker),
- zap.String("task_id", l.TaskID),
- zap.String("event_type", l.EventType),
- zap.String("status", l.Status),
- zap.String("filename", l.Filename),
- zap.String("file_type", l.FileType),
- zap.Int64("file_size", l.FileSize),
- zap.String("parser_id", l.ParserID),
- skipZeroTime("upload_time", l.UploadTime),
- skipZeroTime("enqueue_time", l.EnqueueTime),
- skipZeroTime("begin_time", l.BeginTime),
- skipZeroTime("end_time", l.EndTime),
- zap.Int64("duration_ms", l.DurationMS),
- zap.Float64("wait_duration_s", l.WaitDurationS),
- zap.Float64("parse_duration_s", l.ParseDurationS),
- zap.Float64("progress", l.Progress),
- zap.Int("run_count", l.RunCount),
- zap.Int("code", l.Code),
- }
- if l.UserName != "" {
- fields = append(fields, zap.String("user_name", l.UserName))
- }
- if l.ErrorInfo != "" {
- fields = append(fields, zap.String("error_info", l.ErrorInfo))
- }
- if len(l.Operation) > 0 {
- fields = append(fields, zap.Any("operation", l.Operation))
- }
- return fields
-}
-// skipZeroTime omits a time field from the emitted JSON when it is the zero
-// value, keeping the line compact and ClickHouse-friendly.
-func skipZeroTime(key string, t time.Time) zap.Field {
- if t.IsZero() {
- return zap.Skip()
- }
- return zap.Time(key, t.UTC())
}
// LogIngest is the shared upstream seam. In the OSS build it is a no-op; the EE
-// build provides the real sink. Our OSS LogIngestEvent forwards to it.
+// build provides the real sink.
func LogIngest(log *IngestionLog, fields ...zap.Field) {}
diff --git a/internal/observability/ingestion_log.go b/internal/observability/ingestion_log.go
index 447bf9a56e..8d47120163 100644
--- a/internal/observability/ingestion_log.go
+++ b/internal/observability/ingestion_log.go
@@ -25,7 +25,7 @@ type CommonLogEmitter struct{}
// EmitIngestLog forwards the event to the common ingest-log sink.
func (e *CommonLogEmitter) EmitIngestLog(_ context.Context, log common.IngestionLog) {
- common.LogIngestEvent(log)
+ common.LogIngest(&log)
}
// ComputeDurations derives wait (begin-enqueue) and parse (end-begin) seconds.
diff --git a/internal/server/api/server.go b/internal/server/api/server.go
index cbdf2fedf9..c28e619eaa 100644
--- a/internal/server/api/server.go
+++ b/internal/server/api/server.go
@@ -461,7 +461,6 @@ func startServer(ctx context.Context, serverName string, arguments *bootstrap.Se
// Initialize the ingestion lifecycle event sink (best-effort; stdout is
// always on, ingestor.log.path adds an optional rotated file). Flush it on shutdown.
bootstrap.SetIngestLog(serverName)
- defer common.SyncIngestLog()
// Start server in a goroutine
go func() {
diff --git a/internal/server/bootstrap/runtime.go b/internal/server/bootstrap/runtime.go
index a522f87ff9..4ba13ebbad 100644
--- a/internal/server/bootstrap/runtime.go
+++ b/internal/server/bootstrap/runtime.go
@@ -69,8 +69,6 @@ func SetLogger(serverName string, arguments *ServerArgs) {
func SetIngestLog(serverName string) {
globalConfig := server.GetConfig()
ingestLogConfig := globalConfig.GetIngestLogConfig()
- // Flush any prior sink before swapping it out (e.g. on a reconfigure).
- common.SyncIngestLog()
if err := common.InitIngestLog(ingestLogConfig.Type, ingestLogConfig.GetFileOutput(), serverName); err != nil {
common.Error("Failed to initialize ingest log sink", err)
}
diff --git a/internal/server/config/stub.go b/internal/server/config/stub.go
index 44f621407e..09f76af653 100644
--- a/internal/server/config/stub.go
+++ b/internal/server/config/stub.go
@@ -107,57 +107,8 @@ func (c *AuditConfig) GetFileOutput() common.FileOutput {
return common.FileOutput{}
}
-// Default ingest-log rotation values mirror the documented IngestLogConfig
-// defaults. File output is opt-in: leave ingestor.log.path empty and events emit
-// to stdout only.
-const (
- defaultIngestLogMaxSizeMB = 1000
- defaultIngestLogMaxBackups = 20
- defaultIngestLogMaxAgeDays = 60
-)
-
-// ParseIngestLogConfig reads the ingestor.log.* keys from the sub-viper passed by
-// the ingestor config parser (already merged with the environment by
-// server.Init), so env overrides such as RAGFLOW_INGESTOR_LOG_PATH win over the
-// YAML file. A nil viper is a no-op so the struct keeps its zero (off) state.
-func (c *IngestLogConfig) ParseIngestLogConfig(v *viper.Viper) error {
- if v == nil {
- return nil
- }
- c.Type = "file"
- c.Format = "json"
- c.MaxSize = defaultIngestLogMaxSizeMB
- c.MaxBackups = defaultIngestLogMaxBackups
- c.MaxAge = defaultIngestLogMaxAgeDays
- if v.IsSet("type") {
- c.Type = v.GetString("type")
- }
- if v.IsSet("format") {
- c.Format = v.GetString("format")
- }
- if v.IsSet("path") {
- c.Path = v.GetString("path")
- }
- if v.IsSet("max_size") {
- c.MaxSize = v.GetInt("max_size")
- }
- if v.IsSet("max_backups") {
- c.MaxBackups = v.GetInt("max_backups")
- }
- if v.IsSet("max_age") {
- c.MaxAge = v.GetInt("max_age")
- }
- return nil
-}
+func (c *IngestLogConfig) ParseIngestLogConfig(v *viper.Viper) error { return nil }
-// GetFileOutput projects the ingest log config onto the common.FileOutput sink
-// descriptor. An empty Path means no file sink (stdout only), which keeps the
-// feature off by default.
func (c *IngestLogConfig) GetFileOutput() common.FileOutput {
- return common.FileOutput{
- Path: c.Path,
- MaxSize: c.MaxSize,
- MaxBackups: c.MaxBackups,
- MaxAge: c.MaxAge,
- }
+ return common.FileOutput{}
}