[DO NOT MERGE] Test PR for teamcity link

cmd/node/config/config.toml

@@ -783,7 +783,11 @@
         MaxOpenFiles = 10
 
 [Logs]
-    LogFileLifeSpanInSec = 86400
+    [Logs.LifeSpan]
+    #available options: second, epoch or megabyte
+    Type="epoch"
+    #recreate every: 86400 second, 1 epoch, 10 megabyte etc.
+    RecreateEvery = 1
 
 [TrieSync]
     NumConcurrentTrieSyncers  = 200

cmd/node/factory/interface.go

@@ -1,8 +1,6 @@
 package factory
 
 import (
-	"time"
-
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/data"
 	"github.com/ElrondNetwork/elrond-go-core/data/typeConverters"
@@ -40,7 +38,7 @@ type P2PAntifloodHandler interface {
 
 // FileLoggingHandler will handle log file rotation
 type FileLoggingHandler interface {
-	ChangeFileLifeSpan(newDuration time.Duration) error
+	ChangeFileLifeSpan(LogLifeSpanner) error
 	Close() error
 	IsInterfaceNil() bool
 }
@@ -60,3 +58,10 @@ type StatusHandlersUtils interface {
 type StatusHandlerUtilsFactory interface {
 	Create(marshalizer marshal.Marshalizer, converter typeConverters.Uint64ByteSliceConverter) (StatusHandlersUtils, error)
 }
+
+// LogLifeSpanner defines a notification channel for the file logging lifespan
+type LogLifeSpanner interface {
+	GetNotification() <-chan string
+	SetCurrentFile(string)
+	IsInterfaceNil() bool
+}

cmd/node/main.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"runtime"
-	"time"
 
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/core/check"
@@ -91,13 +90,6 @@ func startNodeRunner(c *cli.Context, log logger.Logger, version string) error {
 		return errCfg
 	}
 
-	if !check.IfNil(fileLogging) {
-		err := fileLogging.ChangeFileLifeSpan(time.Second * time.Duration(cfgs.GeneralConfig.Logs.LogFileLifeSpanInSec))
-		if err != nil {
-			return err
-		}
-	}
-
 	err := applyFlags(c, cfgs, flagsConfig, log)
 	if err != nil {
 		return err
@@ -110,6 +102,10 @@ func startNodeRunner(c *cli.Context, log logger.Logger, version string) error {
 		return errRunner
 	}
 
+	if !check.IfNil(fileLogging) {
+		nodeRunner.SetFileLoggingData(fileLogging)
+	}
+
 	err = nodeRunner.Start()
 	if err != nil {
 		log.Error(err.Error())

cmd/seednode/config/config.toml

@@ -8,4 +8,8 @@
    SizeCheckDelta = 10
 
 [Logs]
-   LogFileLifeSpanInSec = 86400
+    [Logs.LifeSpan]
+    #available options: second, epoch or megabyte
+    Type="epoch"
+    #recreate every: 86400 second, 1 epoch, 10 megabyte etc.
+    RecreateEvery = 1

cmd/seednode/main.go

@@ -15,6 +15,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go-core/marshal"
 	factoryMarshalizer "github.com/ElrondNetwork/elrond-go-core/marshal/factory"
 	logger "github.com/ElrondNetwork/elrond-go-logger"
+	"github.com/ElrondNetwork/elrond-go-logger/lifespan"
 	"github.com/ElrondNetwork/elrond-go/cmd/node/factory"
 	"github.com/ElrondNetwork/elrond-go/cmd/seednode/api"
 	"github.com/ElrondNetwork/elrond-go/common"
@@ -156,7 +157,18 @@ func startNode(ctx *cli.Context) error {
 			return fmt.Errorf("%w creating a log file", err)
 		}
 
-		err = fileLogging.ChangeFileLifeSpan(time.Second * time.Duration(generalConfig.Logs.LogFileLifeSpanInSec))
+		args := logger.LogLifeSpanFactoryArgs{
+			LifeSpanType:  "second",
+			RecreateEvery: generalConfig.Logs.LifeSpan.RecreateEvery,
+		}
+
+		lifeSpanFactory := lifespan.NewTypeLogLifeSpanFactory()
+		lls, errLifeSpan := lifeSpanFactory.CreateLogLifeSpanner(args)
+		if errLifeSpan != nil {
+			return errLifeSpan
+		}
+
+		err = fileLogging.ChangeFileLifeSpan(lls)
 		if err != nil {
 			return err
 		}

common/logging/fileLogging.go

@@ -10,66 +10,94 @@ import (
 	"time"
 
 	"github.com/ElrondNetwork/elrond-go-core/core"
+	"github.com/ElrondNetwork/elrond-go-core/core/check"
 	logger "github.com/ElrondNetwork/elrond-go-logger"
+	"github.com/ElrondNetwork/elrond-go-logger/lifespan"
 	"github.com/ElrondNetwork/elrond-go-logger/redirects"
+	"github.com/ElrondNetwork/elrond-go/cmd/node/factory"
 )
 
-const minFileLifeSpan = time.Second
 const defaultFileLifeSpan = time.Hour * 24
 
 var log = logger.GetOrCreate("common/logging")
 
 // fileLogging is able to rotate the log files
 type fileLogging struct {
-	chLifeSpanChanged chan time.Duration
-	mutFile           sync.Mutex
-	currentFile       *os.File
-	workingDir        string
-	defaultLogsPath   string
-	logFilePrefix     string
-	cancelFunc        func()
-	mutIsClosed       sync.Mutex
-	isClosed          bool
+	logLifeSpanner  lifeSpanWrapper
+	mutFile         sync.Mutex
+	currentFile     *os.File
+	workingDir      string
+	defaultLogsPath string
+	logFilePrefix   string
+	cancelFunc      func()
+	mutIsClosed     sync.Mutex
+	isClosed        bool
 }
 
 // NewFileLogging creates a file log watcher used to break the log file into multiple smaller files
 func NewFileLogging(workingDir string, defaultLogsPath string, logFilePrefix string) (*fileLogging, error) {
 	fl := &fileLogging{
-		workingDir:        workingDir,
-		defaultLogsPath:   defaultLogsPath,
-		logFilePrefix:     logFilePrefix,
-		chLifeSpanChanged: make(chan time.Duration),
-		isClosed:          false,
+		workingDir:      workingDir,
+		defaultLogsPath: defaultLogsPath,
+		logFilePrefix:   logFilePrefix,
+		isClosed:        false,
 	}
-	fl.recreateLogFile()
+	identifier := ""
+	fl.recreateLogFile(identifier)
 
 	//we need this function as to call file.Close() when the code panics and the defer func associated
 	//with the file pointer in the main func will never be reached
 	runtime.SetFinalizer(fl, func(fileLogHandler *fileLogging) {
 		_ = fileLogHandler.currentFile.Close()
 	})
 
+	lifeSpanFactory := lifespan.NewTypeLogLifeSpanFactory()
+
+	lifeSpanner, err := lifeSpanFactory.CreateLogLifeSpanner(logger.LogLifeSpanFactoryArgs{
+		LifeSpanType:  "second",
+		RecreateEvery: int(defaultFileLifeSpan.Seconds()),
+	})
+
+	if err != nil {
+		log.Debug("autoRecreateFile NewSecondsLifeSpanner failed", "err", err)
+	}
+
+	startRecreateFile(fl, lifeSpanner)
+
+	return fl, nil
+}
+
+func startRecreateFile(fl *fileLogging, lifeSpanner logger.LogLifeSpanner) {
+	if fl.cancelFunc != nil {
+		fl.cancelFunc()
+	}
+
+	fl.logLifeSpanner.SetLifeSpanner(lifeSpanner)
+
 	ctx, cancelFunc := context.WithCancel(context.Background())
 	go fl.autoRecreateFile(ctx)
 	fl.cancelFunc = cancelFunc
 
-	return fl, nil
+	fl.logLifeSpanner.SetCurrentFile(fl.currentFile.Name())
 }
 
-func (fl *fileLogging) createFile() (*os.File, error) {
+func (fl *fileLogging) createFile(identifier string) (*os.File, error) {
 	logDirectory := filepath.Join(fl.workingDir, fl.defaultLogsPath)
 
+	if len(identifier) > 0 {
+		identifier = fmt.Sprintf("-%s", identifier)
+	}
 	return core.CreateFile(
 		core.ArgCreateFileArgument{
-			Prefix:        fl.logFilePrefix,
+			Prefix:        fmt.Sprintf("%s%s", fl.logFilePrefix, identifier),
 			Directory:     logDirectory,
 			FileExtension: "log",
 		},
 	)
 }
 
-func (fl *fileLogging) recreateLogFile() {
-	newFile, err := fl.createFile()
+func (fl *fileLogging) recreateLogFile(identifier string) {
+	newFile, err := fl.createFile(identifier)
 	if err != nil {
 		log.Error("error creating new log file", "error", err)
 		return
@@ -102,34 +130,36 @@ func (fl *fileLogging) recreateLogFile() {
 }
 
 func (fl *fileLogging) autoRecreateFile(ctx context.Context) {
-	fileLifeSpan := defaultFileLifeSpan
+	lifeSpannerChannel := fl.logLifeSpanner.GetNotificationChannel()
 	for {
 		select {
 		case <-ctx.Done():
-			log.Debug("closing fileLogging.autoRecreateFile go routine")
+			log.Info("closing fileLogging.autoRecreateFile go routine")
 			return
-		case <-time.After(fileLifeSpan):
-			fl.recreateLogFile()
-		case fileLifeSpan = <-fl.chLifeSpanChanged:
-			log.Debug("changed log file span", "new value", fileLifeSpan)
+		case identifier := <-lifeSpannerChannel:
+			log.Debug("autoRecreateFile - recreate log from lifeSpanner", "identifier", identifier)
+			fl.recreateLogFile(identifier)
+
+			fl.logLifeSpanner.SetCurrentFile(fl.currentFile.Name())
 		}
 	}
 }
 
 // ChangeFileLifeSpan changes the log file span
-func (fl *fileLogging) ChangeFileLifeSpan(newDuration time.Duration) error {
-	if newDuration < minFileLifeSpan {
-		return fmt.Errorf("%w, provided %v", core.ErrInvalidLogFileMinLifeSpan, newDuration)
-	}
-
+func (fl *fileLogging) ChangeFileLifeSpan(lifeSpanner factory.LogLifeSpanner) error {
 	fl.mutIsClosed.Lock()
 	defer fl.mutIsClosed.Unlock()
 
 	if fl.isClosed {
 		return core.ErrFileLoggingProcessIsClosed
 	}
 
-	fl.chLifeSpanChanged <- newDuration
+	if check.IfNil(lifeSpanner) {
+		return fmt.Errorf("%w, error: nil lifespan", core.ErrInvalidLogFileMinLifeSpan)
+	}
+
+	startRecreateFile(fl, lifeSpanner)
+
 	return nil
 }
 

common/logging/fileLogging_test.go

@@ -10,6 +10,9 @@ import (
 
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/core/check"
+	logger "github.com/ElrondNetwork/elrond-go-logger"
+	"github.com/ElrondNetwork/elrond-go-logger/lifespan"
+	"github.com/ElrondNetwork/elrond-go/testscommon"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -40,7 +43,7 @@ func TestNewFileLogging_CloseShouldStopCreatingLogFiles(t *testing.T) {
 	}()
 
 	fl, _ := NewFileLogging(dir, logsDirectory, "elrond-go")
-	_ = fl.ChangeFileLifeSpan(time.Second)
+	_ = fl.ChangeFileLifeSpan(createSecondsLogLifeSpan(time.Second))
 	time.Sleep(time.Second*3 + time.Millisecond*200)
 
 	err := fl.Close()
@@ -83,7 +86,7 @@ func TestFileLogging_ChangeFileLifeSpanInvalidValueShouldErr(t *testing.T) {
 	}()
 
 	fl, _ := NewFileLogging(dir, logsDirectory, "elrond-go")
-	err := fl.ChangeFileLifeSpan(time.Millisecond)
+	err := fl.ChangeFileLifeSpan(createSecondsLogLifeSpan(time.Millisecond))
 
 	assert.True(t, errors.Is(err, core.ErrInvalidLogFileMinLifeSpan))
 }
@@ -98,11 +101,24 @@ func TestFileLogging_ChangeFileLifeSpanAfterCloseShouldErr(t *testing.T) {
 	}()
 
 	fl, _ := NewFileLogging(dir, logsDirectory, "elrond-go")
-	err := fl.ChangeFileLifeSpan(time.Second)
+	err := fl.ChangeFileLifeSpan(createSecondsLogLifeSpan(time.Second))
 	assert.Nil(t, err)
 
 	_ = fl.Close()
 
-	err = fl.ChangeFileLifeSpan(time.Second)
+	err = fl.ChangeFileLifeSpan(createSecondsLogLifeSpan(time.Second))
 	assert.True(t, errors.Is(err, core.ErrFileLoggingProcessIsClosed))
 }
+
+func createSecondsLogLifeSpan(duration time.Duration) logger.LogLifeSpanner {
+	args := logger.LogLifeSpanFactoryArgs{
+		EpochStartNotifierWithConfirm: &testscommon.EpochStartNotifierStub{},
+		LifeSpanType:                  "second",
+		RecreateEvery:                 int(duration.Seconds()),
+	}
+
+	factory := lifespan.NewTypeLogLifeSpanFactory()
+	lls, _ := factory.CreateLogLifeSpanner(args)
+
+	return lls
+}

common/logging/lifeSpanWrapper.go

@@ -0,0 +1,35 @@
+package logging
+
+import (
+	"sync"
+
+	"github.com/ElrondNetwork/elrond-go/cmd/node/factory"
+)
+
+type lifeSpanWrapper struct {
+	mutLogLifeSpanner sync.Mutex
+	lifeSpanner       factory.LogLifeSpanner
+}
+
+// SetLifeSpanner sets the current lifeSpanner
+func (llsw *lifeSpanWrapper) SetLifeSpanner(spanner factory.LogLifeSpanner) {
+	llsw.mutLogLifeSpanner.Lock()
+	log.Debug("lifeSpanWrapper - set life spanner", "spanner", spanner)
+	llsw.lifeSpanner = spanner
+	llsw.mutLogLifeSpanner.Unlock()
+}
+
+// SetCurrentFile sets the new logger file
+func (llsw *lifeSpanWrapper) SetCurrentFile(newFile string) {
+	llsw.mutLogLifeSpanner.Lock()
+	log.Debug("lifeSpanWrapper - set new file", "new file", newFile)
+	llsw.lifeSpanner.SetCurrentFile(newFile)
+	llsw.mutLogLifeSpanner.Unlock()
+}
+
+// GetNotificationChannel gets the notification channel for the log lifespan
+func (llsw *lifeSpanWrapper) GetNotificationChannel() <-chan string {
+	llsw.mutLogLifeSpanner.Lock()
+	defer llsw.mutLogLifeSpanner.Unlock()
+	return llsw.lifeSpanner.GetNotification()
+}

config/config.go

@@ -191,7 +191,13 @@ type Config struct {
 
 // LogsConfig will hold settings related to the logging sub-system
 type LogsConfig struct {
-	LogFileLifeSpanInSec int
+	LifeSpan LifeSpanConfig
+}
+
+// LifeSpanConfig will hold settings regarding the lifespan of the log
+type LifeSpanConfig struct {
+	Type          string
+	RecreateEvery int
 }
 
 // StoragePruningConfig will hold settings related to storage pruning