111

Author: lvan100

log_refresh.go

@@ -96,24 +96,25 @@ func RefreshConfig(s *barky.Storage) error {
 	initAppenderRefs := func(v reflect.Value, cAppenders map[string]Appender) (*LoggerBase, error) {
 		var (
 			base *LoggerBase
-			refs []*AppenderRef
+			ref  *AppenderRefs
 		)
 		switch config := v.Interface().(type) {
 		case *SyncLogger:
 			base = &config.LoggerBase
-			refs = config.AppenderRefs.AppenderRefs
+			ref = &config.AppenderRefs
 		case *AsyncLogger:
 			base = &config.LoggerBase
-			refs = config.AppenderRefs.AppenderRefs
+			ref = &config.AppenderRefs
 		default: // for linter
 		}
-		for _, r := range refs {
+		for _, r := range ref.AppenderRefs {
 			appender, ok := cAppenders[r.Ref]
 			if !ok {
 				return nil, util.FormatError(nil, "appender %s not found", r.Ref)
 			}
 			r.Appender = appender
 		}
+		ref.sortByLevel()
 		return base, nil
 	}
 

plugin_logger.go

@@ -25,13 +25,14 @@ import (
 
 func init() {
 	RegisterConverter[BufferFullPolicy](ParseBufferFullPolicy)
-}
 
-func init() {
-	RegisterPlugin[FileLogger]("File", PluginTypeLogger)
+	RegisterPlugin[AppenderRef]("AppenderRef", PluginTypeAppenderRef)
 	RegisterPlugin[SyncLogger]("Logger", PluginTypeLogger)
 	RegisterPlugin[AsyncLogger]("AsyncLogger", PluginTypeLogger)
-	RegisterPlugin[AppenderRef]("AppenderRef", PluginTypeAppenderRef)
+	RegisterPlugin[DiscardLogger]("Discard", PluginTypeLogger)
+	RegisterPlugin[ConsoleLogger]("Console", PluginTypeLogger)
+	RegisterPlugin[FileLogger]("File", PluginTypeLogger)
+	RegisterPlugin[RollingFileLogger]("RollingFile", PluginTypeLogger)
 }
 
 // Logger is the interface implemented by all loggers.
@@ -166,10 +167,8 @@ type SyncLogger struct {
 	AppenderRefs
 }
 
-func (c *SyncLogger) Start() error {
-	c.AppenderRefs.sortByLevel()
-	return nil
-}
+func (c *SyncLogger) Start() error { return nil }
+func (c *SyncLogger) Stop()        {}
 
 // Append sends the event directly to appenders (blocking).
 func (c *SyncLogger) Append(e *Event) {
@@ -189,8 +188,6 @@ func (c *SyncLogger) Write(b []byte) {
 	c.writeToAppenders(MaxLevel, b)
 }
 
-func (c *SyncLogger) Stop() {}
-
 // BufferFullPolicy specifies what to do when an async buffer is full.
 type BufferFullPolicy int
 
@@ -245,8 +242,6 @@ func (c *AsyncLogger) Start() error {
 	c.wait = make(chan struct{})
 	c.stop = &Event{}
 
-	c.AppenderRefs.sortByLevel()
-
 	// Worker goroutine to process buffered items
 	go func() {
 		for v := range c.buf {
@@ -342,16 +337,13 @@ func (c *AsyncLogger) Stop() {
 	close(c.buf)
 }
 
-// ----------------------------------------------------------------------------
-// rolling file logger
-// ----------------------------------------------------------------------------
-
 // 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.
 type RollingFileLogger struct {
 	LoggerBase
-	logger Logger
+	logger    Logger
+	appenders []*AppenderRef
 
 	// File output configuration
 	FileDir  string `PluginAttribute:"fileDir,default=./logs"`
@@ -450,8 +442,13 @@ func initRollingFileLogger(
 	default: // for linter
 	}
 
-	// Start the underlying logger (and all appenders)
-	return f.logger.Start()
+	f.appenders = appenders
+	for _, a := range f.appenders {
+		if err := a.Start(); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func (f *RollingFileLogger) Append(e *Event) {
@@ -463,5 +460,7 @@ func (f *RollingFileLogger) Write(b []byte) {
 }
 
 func (f *RollingFileLogger) Stop() {
-
+	for _, a := range f.appenders {
+		a.Stop()
+	}
 }