log: added option to rotate logs based on number of hours with a maximum of 24

log/async_file_writer.go

@@ -10,32 +10,43 @@ import (
 	"time"
 )
 
-type HourTicker struct {
+type TimeTicker struct {
 	stop chan struct{}
 	C    <-chan time.Time
 }
 
-func NewHourTicker() *HourTicker {
-	ht := &HourTicker{
+// NewTimeTicker notifies on a daily basis if dailyRotate is true, otherwise on an hourly basis
+func NewTimeTicker(dailyRotate bool) *TimeTicker {
+	ch := make(chan time.Time)
+	ht := TimeTicker{
 		stop: make(chan struct{}),
+		C:    ch,
 	}
-	ht.C = ht.Ticker()
-	return ht
+
+	ht.startTicker(ch, dailyRotate)
+
+	return &ht
 }
 
-func (ht *HourTicker) Stop() {
+func (ht *TimeTicker) Stop() {
 	ht.stop <- struct{}{}
 }
 
-func (ht *HourTicker) Ticker() <-chan time.Time {
-	ch := make(chan time.Time)
+func (ht *TimeTicker) startTicker(ch chan time.Time, dailyRotate bool) {
 	go func() {
+		day := time.Now().Day()
 		hour := time.Now().Hour()
 		ticker := time.NewTicker(time.Second)
 		defer ticker.Stop()
 		for {
 			select {
 			case t := <-ticker.C:
+				if dailyRotate && t.Day() != day {
+					ch <- t
+					day = t.Day()
+					continue
+				}
+
 				if t.Hour() != hour {
 					ch <- t
 					hour = t.Hour()
@@ -45,7 +56,6 @@ func (ht *HourTicker) Ticker() <-chan time.Time {
 			}
 		}
 	}()
-	return ch
 }
 
 type AsyncFileWriter struct {
@@ -56,20 +66,20 @@ type AsyncFileWriter struct {
 	started    int32
 	buf        chan []byte
 	stop       chan struct{}
-	hourTicker *HourTicker
+	timeTicker *TimeTicker
 }
 
-func NewAsyncFileWriter(filePath string, bufSize int64) *AsyncFileWriter {
+func NewAsyncFileWriter(filePath string, maxBytesSize int64, dailyRotate bool) *AsyncFileWriter {
 	absFilePath, err := filepath.Abs(filePath)
 	if err != nil {
 		panic(fmt.Sprintf("get file path of logger error. filePath=%s, err=%s", filePath, err))
 	}
 
 	return &AsyncFileWriter{
 		filePath:   absFilePath,
-		buf:        make(chan []byte, bufSize),
+		buf:        make(chan []byte, maxBytesSize),
 		stop:       make(chan struct{}),
-		hourTicker: NewHourTicker(),
+		timeTicker: NewTimeTicker(dailyRotate),
 	}
 }
 
@@ -159,7 +169,7 @@ func (w *AsyncFileWriter) SyncWrite(msg []byte) {
 
 func (w *AsyncFileWriter) rotateFile() {
 	select {
-	case <-w.hourTicker.C:
+	case <-w.timeTicker.C:
 		if err := w.flushAndClose(); err != nil {
 			fmt.Fprintf(os.Stderr, "flush and close file error. err=%s", err)
 		}
@@ -174,7 +184,7 @@ func (w *AsyncFileWriter) Stop() {
 	w.stop <- struct{}{}
 	w.wg.Wait()
 
-	w.hourTicker.Stop()
+	w.timeTicker.Stop()
 }
 
 func (w *AsyncFileWriter) Write(msg []byte) (n int, err error) {

log/async_file_writer_test.go

@@ -1,24 +1,41 @@
 package log
 
 import (
-	"io/ioutil"
 	"os"
 	"strings"
 	"testing"
 )
 
-func TestWriter(t *testing.T) {
-	w := NewAsyncFileWriter("./hello.log", 100)
+func TestWriterHourly(t *testing.T) {
+	w := NewAsyncFileWriter("./hello.log", 100, false)
 	w.Start()
 	w.Write([]byte("hello\n"))
 	w.Write([]byte("world\n"))
 	w.Stop()
-	files, _ := ioutil.ReadDir("./")
+	files, _ := os.ReadDir("./")
 	for _, f := range files {
 		fn := f.Name()
 		if strings.HasPrefix(fn, "hello") {
 			t.Log(fn)
-			content, _ := ioutil.ReadFile(fn)
+			content, _ := os.ReadFile(fn)
+			t.Log(content)
+			os.Remove(fn)
+		}
+	}
+}
+
+func TestWriterDaily(t *testing.T) {
+	w := NewAsyncFileWriter("./hello.log", 100, true)
+	w.Start()
+	w.Write([]byte("hello\n"))
+	w.Write([]byte("world\n"))
+	w.Stop()
+	files, _ := os.ReadDir("./")
+	for _, f := range files {
+		fn := f.Name()
+		if strings.HasPrefix(fn, "hello") {
+			t.Log(fn)
+			content, _ := os.ReadFile(fn)
 			t.Log(content)
 			os.Remove(fn)
 		}

log/handler.go

@@ -74,14 +74,14 @@ func FileHandler(path string, fmtr Format) (Handler, error) {
 // RotatingFileHandler returns a handler which writes log records to file chunks
 // at the given path. When a file's size reaches the limit, the handler creates
 // a new file named after the timestamp of the first log record it will contain.
-func RotatingFileHandler(filePath string, limit uint, formatter Format) (Handler, error) {
+func RotatingFileHandler(filePath string, limit uint, formatter Format, dailyRotate bool) (Handler, error) {
 	if _, err := os.Stat(path.Dir(filePath)); os.IsNotExist(err) {
 		err := os.MkdirAll(path.Dir(filePath), 0755)
 		if err != nil {
 			return nil, fmt.Errorf("could not create directory %s, %v", path.Dir(filePath), err)
 		}
 	}
-	fileWriter := NewAsyncFileWriter(filePath, int64(limit))
+	fileWriter := NewAsyncFileWriter(filePath, int64(limit), dailyRotate)
 	fileWriter.Start()
 	return StreamHandler(fileWriter, formatter), nil
 }

log/logger.go

@@ -244,12 +244,8 @@ func (c Ctx) toArray() []interface{} {
 	return arr
 }
 
-func NewFileLvlHandler(logPath string, maxBytesSize uint, level string) Handler {
-	rfh, err := RotatingFileHandler(
-		logPath,
-		maxBytesSize,
-		LogfmtFormat(),
-	)
+func NewFileLvlHandler(logPath string, maxBytesSize uint, level string, dailyRotate bool) Handler {
+	rfh, err := RotatingFileHandler(logPath, maxBytesSize, LogfmtFormat(), dailyRotate)
 	if err != nil {
 		panic(err)
 	}

node/config.go

@@ -520,6 +520,7 @@ type LogConfig struct {
 	FilePath     *string `toml:",omitempty"`
 	MaxBytesSize *uint   `toml:",omitempty"`
 	Level        *string `toml:",omitempty"`
+	DailyRotate  bool    `toml:",omitempty"`
 
 	// TermTimeFormat is the time format used for console logging.
 	TermTimeFormat *string `toml:",omitempty"`

node/node.go

@@ -103,7 +103,8 @@ func New(conf *Config) (*Node, error) {
 			} else {
 				logFilePath = path.Join(*conf.LogConfig.FileRoot, *conf.LogConfig.FilePath)
 			}
-			log.Root().SetHandler(log.NewFileLvlHandler(logFilePath, *conf.LogConfig.MaxBytesSize, *conf.LogConfig.Level))
+
+			log.Root().SetHandler(log.NewFileLvlHandler(logFilePath, *conf.LogConfig.MaxBytesSize, *conf.LogConfig.Level, conf.LogConfig.DailyRotate))
 		}
 	}
 	if conf.Logger == nil {