111

Author: lvan100

plugin_logger.go

@@ -42,8 +42,8 @@ type Logger interface {
 	GetLevel() LevelRange
 }
 
-// AppenderRef represents a reference to an appender by name.
-// The actual Appender is resolved and injected later during configuration.
+// AppenderRef represents a reference to an Appender by name.
+// The actual Appender is resolved and injected during configuration.
 type AppenderRef struct {
 	Appender
 	Ref   string     `PluginAttribute:"ref"`
@@ -64,10 +64,10 @@ func (c *AppenderRef) Write(b []byte) {
 
 // LoggerBase contains fields shared by all logger configurations.
 type LoggerBase struct {
-	Name   string     `PluginAttribute:"name"`          // Logger name
-	Tags   string     `PluginAttribute:"tags,default="` // Optional tags
-	Level  LevelRange `PluginAttribute:"level,default="`
-	Layout Layout     `PluginElement:"Layout?"`
+	Name   string     `PluginAttribute:"name"`           // Logger name
+	Tags   string     `PluginAttribute:"tags,default="`  // Optional tags
+	Level  LevelRange `PluginAttribute:"level,default="` // Logger level range
+	Layout Layout     `PluginElement:"Layout?"`          // Layout for formatting logs
 }
 
 // GetName returns the name of the logger.
@@ -94,48 +94,55 @@ var (
 	_ Logger = (*RollingFileLogger)(nil)
 )
 
+// DiscardLogger ignores all log events (no-op).
 type DiscardLogger struct {
 	LoggerBase
 	DiscardAppender
 }
 
+// ConsoleLogger writes log events to standard output.
 type ConsoleLogger struct {
 	LoggerBase
 	ConsoleAppender
 }
 
+// Append sends the event to the console if the level is enabled.
 func (c *ConsoleLogger) Append(e *Event) {
 	if c.Level.Enable(e.Level) {
 		c.ConsoleAppender.Append(e)
 	}
 }
 
+// FileLogger writes log events to a file.
 type FileLogger struct {
 	LoggerBase
 	FileAppender
 }
 
+// Append writes the event to the file if the level is enabled.
 func (c *FileLogger) Append(e *Event) {
 	if c.Level.Enable(e.Level) {
 		c.FileAppender.Append(e)
 	}
 }
 
-// AppenderRefs represents a group of appenders.
+// AppenderRefs represents a collection of AppenderRef objects.
 type AppenderRefs struct {
 	AppenderRefs []*AppenderRef `PluginElement:"AppenderRef"`
 }
 
-// sortByLevel sorts appender references by level.
+// sortByLevel sorts appender references by minimum level,
+// and adjusts MaxLevel for chained ranges.
 func (c *AppenderRefs) sortByLevel() {
 
-	// Sort appender references by level
+	// Sort appender references by MinLevel
 	sort.Slice(c.AppenderRefs, func(i, j int) bool {
 		iCode := c.AppenderRefs[i].Level.MinLevel.code
 		jCode := c.AppenderRefs[j].Level.MinLevel.code
 		return iCode < jCode
 	})
 
+	// Adjust MaxLevel to match the next appender's MinLevel if needed
 	for i := len(c.AppenderRefs) - 1; i >= 1; i-- {
 		if c.AppenderRefs[i-1].Level.MaxLevel == MaxLevel {
 			c.AppenderRefs[i-1].Level.MaxLevel = c.AppenderRefs[i].Level.MinLevel
@@ -232,7 +239,7 @@ func (c *AsyncLogger) GetDiscardCounter() int64 {
 	return atomic.LoadInt64(&c.discardCounter)
 }
 
-// Start initializes channels and launches the worker goroutine.
+// Start initializes the AsyncLogger and launches the worker goroutine.
 func (c *AsyncLogger) Start() error {
 	if c.BufferSize < 100 {
 		return util.FormatError(nil, "bufferSize is too small")
@@ -315,10 +322,8 @@ func (c *AsyncLogger) onBufferFull(v any) {
 			}
 		}
 	case BufferFullPolicyBlock:
-		// Block until space is available
-		c.buf <- v
+		c.buf <- v // Block until space is available
 	case BufferFullPolicyDiscard:
-		// Discard new item
 		atomic.AddInt64(&c.discardCounter, 1)
 		if e, ok := v.(*Event); ok {
 			PutEvent(e)
@@ -329,17 +334,13 @@ func (c *AsyncLogger) onBufferFull(v any) {
 }
 
 // Stop gracefully shuts down the async logger.
-// It signals the worker goroutine to exit and waits for it.
-// NOTE: Stop must be called only once, otherwise panic may occur.
 func (c *AsyncLogger) Stop() {
 	c.buf <- c.stop
 	<-c.wait
 	close(c.buf)
 }
 
-// RollingFileLogger is a logger implementation that writes log events to files.
-// It can work in either synchronous or asynchronous mode depending on AsyncWrite.
-// It also supports splitting warning/error logs into a separate file.
+// RollingFileLogger writes log events to files with optional rotation, separation, and async behavior.
 type RollingFileLogger struct {
 	LoggerBase
 	logger    Logger
@@ -352,21 +353,19 @@ type RollingFileLogger struct {
 	// If true, warning/error logs go to a separate .wf file.
 	Separate bool `PluginAttribute:"separate,default=false"`
 
-	// rotation and cleanup configuration
+	// Rotation and retention
 	Rotation TimeRotation `PluginAttribute:"rotation"`
 	MaxAge   int32        `PluginAttribute:"maxAge,default=168"`
 
-	// asynchronous logging configuration
+	// Async logging options
 	AsyncWrite       bool             `PluginAttribute:"async,default=false"`
 	BufferSize       int              `PluginAttribute:"bufferSize,default=10000"`
 	BufferFullPolicy BufferFullPolicy `PluginAttribute:"bufferFullPolicy,default=Discard"`
 }
 
-// Start initializes the FileLogger according to AsyncWrite flag
-// and then starts the underlying logger and its appenders.
+// Start initializes the RollingFileLogger, either synchronous or asynchronous.
 func (f *RollingFileLogger) Start() error {
 	if f.AsyncWrite {
-		// Async mode: use AsyncLogger and AsyncRotateFileWriter
 		return initRollingFileLogger(f, func(f *RollingFileLogger) Logger {
 			return &AsyncLogger{
 				LoggerBase:       f.LoggerBase,
@@ -375,7 +374,6 @@ func (f *RollingFileLogger) Start() error {
 			}
 		})
 	} else {
-		// Sync mode: use SyncLogger and SyncRotateFileWriter
 		return initRollingFileLogger(f, func(f *RollingFileLogger) Logger {
 			return &SyncLogger{
 				LoggerBase: f.LoggerBase,
@@ -384,9 +382,7 @@ func (f *RollingFileLogger) Start() error {
 	}
 }
 
-// initRollingFileLogger is a generic helper to configure both synchronous and asynchronous FileLogger.
-//   - fnAppender creates either SyncRotateFileWriter or AsyncRotateFileWriter.
-//   - fnLogger creates either SyncLogger or AsyncLogger.
+// initRollingFileLogger is a helper to configure appenders for RollingFileLogger.
 func initRollingFileLogger(
 	f *RollingFileLogger,
 	fnLogger func(f *RollingFileLogger) Logger,
@@ -451,14 +447,17 @@ func initRollingFileLogger(
 	return nil
 }
 
+// Append forwards the event to the underlying logger.
 func (f *RollingFileLogger) Append(e *Event) {
 	f.logger.Append(e)
 }
 
+// Write forwards raw bytes to the underlying logger.
 func (f *RollingFileLogger) Write(b []byte) {
 	f.logger.Write(b)
 }
 
+// Stop stops all appenders.
 func (f *RollingFileLogger) Stop() {
 	for _, a := range f.appenders {
 		a.Stop()