spdf/elektron
Archived
1
0
Fork 0
Code Issues 4 Pull requests 1 Projects Releases Packages Wiki Activity

move cfg to loggers + refactor + log fn wrappers

Browse source 
1. Instead of maintaining a global config, each specialized logger
now stores its config.
2. Refactored logInterface to elektronLogger.
3. Refactored loggerImpl to baseElektronLogger to be consistent with
the rest of the code base.
4. Wrapped elektronLogger#Log(...) and elektronLogf(...) so that we
do not have to use the instance of elektronLogger everytime we want
to log. Instead, we just do logging.Log(...) or logging.Logf(...).
5. Wrapped elektronLogger#WithFields(...) and
elektronLogger#WithField(...).
6. Refactored codebase to adhere to the changes.
This commit is contained in:
Pradyumna Kaushik 2019-12-05 21:32:37 -05:00
parent 5a6d1bed4a
commit 6fb0e4a3fe
20 changed files with 396 additions and 250 deletions
Download patch file Download diff file Expand all files Collapse all files

51
logging/clsfnTaskDistrOverheadLogger.go
View file

@ -9,25 +9,43 @@ import (
)
type ClsfnTaskDistrOverheadLogger struct {
loggerImpl
baseElektronLogger
}
func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string,
logger *log.Logger, logDir *logDirectory) *ClsfnTaskDistrOverheadLogger {
cLog := &ClsfnTaskDistrOverheadLogger{}
cLog.logType = logType
cLog.logDir = logDir
cLog.next = nil
cLog.baseLogData = b
cLog.logger = logger
func NewClsfnTaskDistrOverheadLogger(
config *LoggerConfig,
b *baseLogData,
logType int,
prefix string,
logger *log.Logger,
logDir *logDirectory) *ClsfnTaskDistrOverheadLogger {
cLog := &ClsfnTaskDistrOverheadLogger{
baseElektronLogger: baseElektronLogger{
baseLogData: b,
config: struct {
Enabled bool
FilenameExtension string
AllowOnConsole bool
}{
Enabled: config.TaskDistrConfig.Enabled,
FilenameExtension: config.TaskDistrConfig.FilenameExtension,
AllowOnConsole: config.TaskDistrConfig.AllowOnConsole,
},
logType: logType,
next: nil,
logger: logger,
logDir: logDir,
},
}
cLog.createLogFile(prefix)
return cLog
}
func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) {
if cLog.logType == logType {
if config.TaskDistrConfig.Enabled {
if cLog.allowOnConsole {
if cLog.isEnabled() {
if cLog.config.AllowOnConsole {
cLog.logger.SetOutput(os.Stdout)
cLog.logger.WithFields(cLog.data).Log(level, message)
}
@ -47,8 +65,8 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa
func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if cLog.logType == logType {
if config.TaskDistrConfig.Enabled {
if cLog.allowOnConsole {
if cLog.isEnabled() {
if cLog.config.AllowOnConsole {
cLog.logger.SetOutput(os.Stdout)
cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
}
@ -67,15 +85,14 @@ func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF
func (cLog *ClsfnTaskDistrOverheadLogger) createLogFile(prefix string) {
if config.TaskDistrConfig.Enabled {
filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "")
if cLog.isEnabled() {
filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "")
dirName := cLog.logDir.getDirName()
if dirName != "" {
if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.logFile = logFile
cLog.allowOnConsole = config.TaskDistrConfig.AllowOnConsole
}
}
}

50
logging/consoleLogger.go
View file

@ -9,23 +9,46 @@ import (
)
type ConsoleLogger struct {
loggerImpl
baseElektronLogger
MinLogLevel string
}
func NewConsoleLogger(b *baseLogData, logType int, prefix string,
logger *log.Logger, logDir *logDirectory) *ConsoleLogger {
cLog := &ConsoleLogger{}
cLog.logType = logType
cLog.logDir = logDir
cLog.next = nil
cLog.baseLogData = b
cLog.logger = logger
func NewConsoleLogger(
config *LoggerConfig,
b *baseLogData,
logType int,
prefix string,
logger *log.Logger,
logDir *logDirectory) *ConsoleLogger {
cLog := &ConsoleLogger{
baseElektronLogger: baseElektronLogger{
baseLogData: b,
config: struct {
Enabled bool
FilenameExtension string
AllowOnConsole bool
}{
Enabled: config.ConsoleConfig.Enabled,
FilenameExtension: config.ConsoleConfig.FilenameExtension,
AllowOnConsole: config.ConsoleConfig.AllowOnConsole,
},
logType: logType,
next: nil,
logger: logger,
logDir: logDir,
},
MinLogLevel: config.ConsoleConfig.MinLogLevel,
}
cLog.createLogFile(prefix)
return cLog
}
func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) {
if logType <= cLog.logType {
if config.ConsoleConfig.Enabled {
if cLog.isEnabled() {
cLog.logger.SetOutput(os.Stdout)
cLog.logger.WithFields(cLog.data).Log(level, message)
@ -44,7 +67,7 @@ func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) {
func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if logType <= cLog.logType {
if config.ConsoleConfig.Enabled {
if cLog.isEnabled() {
cLog.logger.SetOutput(os.Stdout)
cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
@ -62,8 +85,8 @@ func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string
func (cLog *ConsoleLogger) createLogFile(prefix string) {
// Create log file for the type if it is enabled.
if config.ConsoleConfig.Enabled {
filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "")
if cLog.isEnabled() {
filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "")
dirName := cLog.logDir.getDirName()
fmt.Println(dirName)
if dirName != "" {
@ -71,7 +94,6 @@ func (cLog *ConsoleLogger) createLogFile(prefix string) {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.logFile = logFile
cLog.allowOnConsole = config.ConsoleConfig.AllowOnConsole
}
}
}

124
logging/logger.go
View file

@ -1,6 +1,7 @@
package logging
import (
"github.com/pkg/errors"
"os"
"strings"
"time"
@ -9,14 +10,75 @@ import (
. "github.com/spdfg/elektron/logging/types"
)
var config LoggerConfig
// var config LoggerConfig
var formatter ElektronFormatter
var ElektronLogger *loggerImpl
var elektronLoggerInstance elektronLogger
func BuildLogger(prefix string, logConfigFilename string) {
type elektronLogger interface {
setNext(next elektronLogger)
isEnabled() bool
Log(logType int, level log.Level, message string)
Logf(logType int, level log.Level, msgFmtString string, args ...interface{})
WithFields(logData log.Fields) elektronLogger
WithField(key string, value string) elektronLogger
}
// Read configuration from yaml.
config.GetConfig(logConfigFilename)
type baseLogData struct {
data log.Fields
}
type baseElektronLogger struct {
*baseLogData
config struct {
Enabled bool
FilenameExtension string
AllowOnConsole bool
}
logType int
logFile *os.File
next elektronLogger
logger *log.Logger
logDir *logDirectory
}
func (l baseElektronLogger) isEnabled() bool {
return l.config.Enabled
}
func (l *baseElektronLogger) WithFields(logData log.Fields) elektronLogger {
l.data = logData
return l
}
func (l *baseElektronLogger) WithField(key string, value string) elektronLogger {
l.data[key] = value
return l
}
func (l *baseElektronLogger) setNext(next elektronLogger) {
l.next = next
}
func (l baseElektronLogger) Log(logType int, level log.Level, message string) {
if l.next != nil {
l.next.Log(logType, level, message)
}
}
func (l baseElektronLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if l.next != nil {
l.next.Logf(logType, level, msgFmtString, args...)
}
}
func (l *baseElektronLogger) resetFields() {
l.data = nil
l.data = log.Fields{}
}
func BuildLogger(prefix string, logConfigFilename string) error {
// Create the log directory.
startTime := time.Now()
@ -35,20 +97,44 @@ func BuildLogger(prefix string, logConfigFilename string) {
// Create a chain of loggers.
b := &baseLogData{data: log.Fields{}}
head := &loggerImpl{baseLogData: b}
cLog := NewConsoleLogger(b, CONSOLE, prefix, logger, logDir)
pLog := NewPCPLogger(b, PCP, prefix, logger, logDir)
schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix, logger, logDir)
spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix, logger, logDir)
schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix, logger, logDir)
tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger, logDir)
head := &baseElektronLogger{baseLogData: b}
head.setNext(cLog)
cLog.setNext(pLog)
pLog.setNext(schedTraceLog)
schedTraceLog.setNext(spsLog)
spsLog.setNext(schedWindowLog)
schedWindowLog.setNext(tskDistLog)
// Read configuration from yaml.
if config, err := GetConfig(logConfigFilename); err != nil {
return errors.Wrap(err, "Failed to build logger")
} else {
cLog := NewConsoleLogger(config, b, CONSOLE, prefix, logger, logDir)
pLog := NewPCPLogger(config, b, PCP, prefix, logger, logDir)
schedTraceLog := NewSchedTraceLogger(config, b, SCHED_TRACE, prefix, logger, logDir)
spsLog := NewSchedPolicySwitchLogger(config, b, SPS, prefix, logger, logDir)
schedWindowLog := NewSchedWindowLogger(config, b, SCHED_WINDOW, prefix, logger, logDir)
tskDistLog := NewClsfnTaskDistrOverheadLogger(config, b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger, logDir)
ElektronLogger = head
head.setNext(cLog)
cLog.setNext(pLog)
pLog.setNext(schedTraceLog)
schedTraceLog.setNext(spsLog)
spsLog.setNext(schedWindowLog)
schedWindowLog.setNext(tskDistLog)
}
elektronLoggerInstance = head
return nil
}
func Log(logType int, level log.Level, message string) {
elektronLoggerInstance.Log(logType, level, message)
}
func Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
elektronLoggerInstance.Logf(logType, level, msgFmtString, args...)
}
func WithFields(logData log.Fields) elektronLogger {
return elektronLoggerInstance.WithFields(logData)
}
func WithField(key string, value string) elektronLogger {
return elektronLoggerInstance.WithField(key, value)
}

56
logging/loggerChain.go
View file

@ -1,56 +0,0 @@
package logging
import (
log "github.com/sirupsen/logrus"
"os"
)
type logInterface interface {
setNext(logType logInterface)
Log(logType int, level log.Level, message string)
Logf(logType int, level log.Level, msgFmtString string, args ...interface{})
createLogFile(prefix string)
}
type baseLogData struct {
data log.Fields
}
type loggerImpl struct {
*baseLogData
logType int
allowOnConsole bool
logFile *os.File
next logInterface
logger *log.Logger
logDir *logDirectory
}
func (l *loggerImpl) WithFields(logData log.Fields) *loggerImpl {
l.data = logData
return l
}
func (l *loggerImpl) WithField(key string, value string) *loggerImpl {
l.data[key] = value
return l
}
func (l *loggerImpl) setNext(logType logInterface) {
l.next = logType
}
func (l loggerImpl) Log(logType int, level log.Level, message string) {
if l.next != nil {
l.next.Log(logType, level, message)
}
}
func (l loggerImpl) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if l.next != nil {
l.next.Logf(logType, level, msgFmtString, args...)
}
}
func (l *loggerImpl) resetFields() {
l.data = nil
l.data = log.Fields{}
}

9
logging/loggerConfig.go
View file

@ -1,6 +1,7 @@
package logging
import (
"github.com/pkg/errors"
log "github.com/sirupsen/logrus"
"gopkg.in/yaml.v2"
"io/ioutil"
@ -47,16 +48,18 @@ type LoggerConfig struct {
Format []string `yaml:"format"`
}
func (c *LoggerConfig) GetConfig(logConfigFilename string) *LoggerConfig {
func GetConfig(logConfigFilename string) (*LoggerConfig, error) {
yamlFile, err := ioutil.ReadFile(logConfigFilename)
if err != nil {
log.Printf("Error in reading yaml file #%v ", err)
return nil, errors.Wrap(err, "failed to read log config file")
}
c := &LoggerConfig{}
err = yaml.Unmarshal(yamlFile, c)
if err != nil {
log.Fatalf("Error in unmarshalling yaml: %v", err)
}
return c
return c, nil
}

50
logging/pcpLogger.go
View file

@ -9,25 +9,44 @@ import (
)
type PCPLogger struct {
loggerImpl
baseElektronLogger
}
func NewPCPLogger(b *baseLogData, logType int, prefix string,
logger *log.Logger, logDir *logDirectory) *PCPLogger {
pLog := &PCPLogger{}
pLog.logType = logType
pLog.logDir = logDir
pLog.next = nil
pLog.baseLogData = b
pLog.logger = logger
func NewPCPLogger(
config *LoggerConfig,
b *baseLogData,
logType int,
prefix string,
logger *log.Logger,
logDir *logDirectory) *PCPLogger {
pLog := &PCPLogger{
baseElektronLogger: baseElektronLogger{
baseLogData: b,
config: struct {
Enabled bool
FilenameExtension string
AllowOnConsole bool
}{
Enabled: config.PCPConfig.Enabled,
FilenameExtension: config.PCPConfig.FilenameExtension,
AllowOnConsole: config.PCPConfig.AllowOnConsole,
},
logType: logType,
next: nil,
logger: logger,
logDir: logDir,
},
}
pLog.createLogFile(prefix)
return pLog
}
func (pLog PCPLogger) Log(logType int, level log.Level, message string) {
if pLog.logType == logType {
if config.PCPConfig.Enabled {
if pLog.allowOnConsole {
if pLog.isEnabled() {
if pLog.config.AllowOnConsole {
pLog.logger.SetOutput(os.Stdout)
pLog.logger.WithFields(pLog.data).Log(level, message)
}
@ -46,8 +65,8 @@ func (pLog PCPLogger) Log(logType int, level log.Level, message string) {
func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if pLog.logType == logType {
if config.PCPConfig.Enabled {
if pLog.allowOnConsole {
if pLog.isEnabled() {
if pLog.config.AllowOnConsole {
pLog.logger.SetOutput(os.Stdout)
pLog.logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
}
@ -66,15 +85,14 @@ func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, ar
}
func (pLog *PCPLogger) createLogFile(prefix string) {
if config.PCPConfig.Enabled {
filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "")
if pLog.isEnabled() {
filename := strings.Join([]string{prefix, pLog.config.FilenameExtension}, "")
dirName := pLog.logDir.getDirName()
if dirName != "" {
if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
pLog.logFile = logFile
pLog.allowOnConsole = config.PCPConfig.AllowOnConsole
}
}
}

50
logging/schedPolicySwitchLogger.go
View file

@ -9,25 +9,44 @@ import (
)
type SchedPolicySwitchLogger struct {
loggerImpl
baseElektronLogger
}
func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string,
logger *log.Logger, logDir *logDirectory) *SchedPolicySwitchLogger {
sLog := &SchedPolicySwitchLogger{}
sLog.logType = logType
sLog.logDir = logDir
sLog.next = nil
sLog.baseLogData = b
sLog.logger = logger
func NewSchedPolicySwitchLogger(
config *LoggerConfig,
b *baseLogData,
logType int,
prefix string,
logger *log.Logger,
logDir *logDirectory) *SchedPolicySwitchLogger {
sLog := &SchedPolicySwitchLogger{
baseElektronLogger: baseElektronLogger{
baseLogData: b,
config: struct {
Enabled bool
FilenameExtension string
AllowOnConsole bool
}{
Enabled: config.SPSConfig.Enabled,
FilenameExtension: config.SPSConfig.FilenameExtension,
AllowOnConsole: config.SPSConfig.AllowOnConsole,
},
logType: logType,
next: nil,
logger: logger,
logDir: logDir,
},
}
sLog.createLogFile(prefix)
return sLog
}
func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) {
if sLog.logType == logType {
if config.SPSConfig.Enabled {
if sLog.allowOnConsole {
if sLog.isEnabled() {
if sLog.config.AllowOnConsole {
sLog.logger.SetOutput(os.Stdout)
sLog.logger.WithFields(sLog.data).Log(level, message)
}
@ -46,8 +65,8 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message st
func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if sLog.logType == logType {
if config.SPSConfig.Enabled {
if sLog.allowOnConsole {
if sLog.isEnabled() {
if sLog.config.AllowOnConsole {
sLog.logger.SetOutput(os.Stdout)
sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
@ -66,15 +85,14 @@ func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr
}
func (sLog *SchedPolicySwitchLogger) createLogFile(prefix string) {
if config.SPSConfig.Enabled {
filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "")
if sLog.isEnabled() {
filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "")
dirName := sLog.logDir.getDirName()
if dirName != "" {
if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
sLog.logFile = logFile
sLog.allowOnConsole = config.SPSConfig.AllowOnConsole
}
}
}

50
logging/schedTraceLogger.go
View file

@ -9,25 +9,44 @@ import (
)
type SchedTraceLogger struct {
loggerImpl
baseElektronLogger
}
func NewSchedTraceLogger(b *baseLogData, logType int, prefix string,
logger *log.Logger, logDir *logDirectory) *SchedTraceLogger {
sLog := &SchedTraceLogger{}
sLog.logType = logType
sLog.logDir = logDir
sLog.next = nil
sLog.baseLogData = b
sLog.logger = logger
func NewSchedTraceLogger(
config *LoggerConfig,
b *baseLogData,
logType int,
prefix string,
logger *log.Logger,
logDir *logDirectory) *SchedTraceLogger {
sLog := &SchedTraceLogger{
baseElektronLogger: baseElektronLogger{
baseLogData: b,
config: struct {
Enabled bool
FilenameExtension string
AllowOnConsole bool
}{
Enabled: config.SchedTraceConfig.Enabled,
FilenameExtension: config.SchedTraceConfig.FilenameExtension,
AllowOnConsole: config.SchedTraceConfig.AllowOnConsole,
},
logType: logType,
next: nil,
logger: logger,
logDir: logDir,
},
}
sLog.createLogFile(prefix)
return sLog
}
func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) {
if sLog.logType == logType {
if config.SchedTraceConfig.Enabled {
if sLog.allowOnConsole {
if sLog.isEnabled() {
if sLog.config.AllowOnConsole {
sLog.logger.SetOutput(os.Stdout)
sLog.logger.WithFields(sLog.data).Log(level, message)
}
@ -46,8 +65,8 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) {
func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if sLog.logType == logType {
if config.SchedTraceConfig.Enabled {
if sLog.allowOnConsole {
if sLog.isEnabled() {
if sLog.config.AllowOnConsole {
sLog.logger.SetOutput(os.Stdout)
sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
@ -66,15 +85,14 @@ func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString str
}
func (sLog *SchedTraceLogger) createLogFile(prefix string) {
if config.SchedTraceConfig.Enabled {
filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "")
if sLog.isEnabled() {
filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "")
dirName := sLog.logDir.getDirName()
if dirName != "" {
if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
sLog.logFile = logFile
sLog.allowOnConsole = config.SchedTraceConfig.AllowOnConsole
}
}
}

50
logging/schedWindowLogger.go
View file

@ -9,25 +9,44 @@ import (
)
type SchedWindowLogger struct {
loggerImpl
baseElektronLogger
}
func NewSchedWindowLogger(b *baseLogData, logType int, prefix string,
logger *log.Logger, logDir *logDirectory) *SchedWindowLogger {
sLog := &SchedWindowLogger{}
sLog.logType = logType
sLog.logDir = logDir
sLog.next = nil
sLog.baseLogData = b
sLog.logger = logger
func NewSchedWindowLogger(
config *LoggerConfig,
b *baseLogData,
logType int,
prefix string,
logger *log.Logger,
logDir *logDirectory) *SchedWindowLogger {
sLog := &SchedWindowLogger{
baseElektronLogger: baseElektronLogger{
baseLogData: b,
config: struct {
Enabled bool
FilenameExtension string
AllowOnConsole bool
}{
Enabled: config.SchedWindowConfig.Enabled,
FilenameExtension: config.SchedWindowConfig.FilenameExtension,
AllowOnConsole: config.SchedWindowConfig.AllowOnConsole,
},
logType: logType,
next: nil,
logger: logger,
logDir: logDir,
},
}
sLog.createLogFile(prefix)
return sLog
}
func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) {
if sLog.logType == logType {
if config.SchedWindowConfig.Enabled {
if sLog.allowOnConsole {
if sLog.isEnabled() {
if sLog.config.AllowOnConsole {
sLog.logger.SetOutput(os.Stdout)
sLog.logger.WithFields(sLog.data).Log(level, message)
}
@ -47,8 +66,8 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string)
func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if sLog.logType == logType {
if config.SchedWindowConfig.Enabled {
if sLog.allowOnConsole {
if sLog.isEnabled() {
if sLog.config.AllowOnConsole {
sLog.logger.SetOutput(os.Stdout)
sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
@ -66,15 +85,14 @@ func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString st
}
func (sLog *SchedWindowLogger) createLogFile(prefix string) {
if config.SchedWindowConfig.Enabled {
filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "")
if sLog.isEnabled() {
filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "")
dirName := sLog.logDir.getDirName()
if dirName != "" {
if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
sLog.logFile = logFile
sLog.allowOnConsole = config.SchedWindowConfig.AllowOnConsole
}
}
}

2
logging/types/types.go
View file

@ -1,4 +1,4 @@
package elektronLogging
package types
const (
CONSOLE = iota