refactored elektronLogging to logging

logging/ElektronFormatter.go

@@ -0,0 +1,36 @@
+package logging
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type ElektronFormatter struct {
+	TimestampFormat string
+}
+
+func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) {
+	var b *bytes.Buffer
+
+	if entry.Buffer != nil {
+		b = entry.Buffer
+	} else {
+		b = &bytes.Buffer{}
+	}
+
+	level := fmt.Sprintf("[%s]:", strings.ToUpper(entry.Level.String()))
+	message := strings.Join([]string{level, entry.Time.Format(f.TimestampFormat), entry.Message, " "}, " ")
+
+	var formattedFields []string
+	for key, value := range entry.Data {
+		formattedFields = append(formattedFields, strings.Join([]string{key, value.(string)}, "="))
+	}
+
+	b.WriteString(message)
+	b.WriteString(strings.Join(formattedFields, ", "))
+	b.WriteByte('\n')
+	return b.Bytes(), nil
+}

logging/clsfnTaskDistOverheadLogger.go

@@ -0,0 +1,82 @@
+package logging
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type ClsfnTaskDistrOverheadLogger struct {
+	loggerImpl
+}
+
+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
+	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 {
+				cLog.logger.SetOutput(os.Stdout)
+				cLog.logger.WithFields(cLog.data).Log(level, message)
+			}
+
+			cLog.logger.SetOutput(cLog.logFile)
+			cLog.logger.WithFields(cLog.data).Log(level, message)
+		}
+	}
+	// Forwarding to next logger
+	if cLog.next != nil {
+		cLog.next.Log(logType, level, message)
+	} else {
+		// Clearing the fields.
+		cLog.resetFields()
+	}
+}
+
+func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
+	if cLog.logType == logType {
+		if config.TaskDistrConfig.Enabled {
+			if cLog.allowOnConsole {
+				cLog.logger.SetOutput(os.Stdout)
+				cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
+			}
+
+			cLog.logger.SetOutput(cLog.logFile)
+			cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
+		}
+	}
+	if cLog.next != nil {
+		cLog.next.Logf(logType, level, msgFmtString, args...)
+	} else {
+		// Clearing the fields.
+		cLog.resetFields()
+	}
+}
+
+func (cLog *ClsfnTaskDistrOverheadLogger) createLogFile(prefix string) {
+
+	if config.TaskDistrConfig.Enabled {
+		filename := strings.Join([]string{prefix, config.TaskDistrConfig.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
+			}
+		}
+	}
+}

logging/consoleLogger.go

@@ -0,0 +1,78 @@
+package logging
+
+import (
+	"fmt"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type ConsoleLogger struct {
+	loggerImpl
+}
+
+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
+	cLog.createLogFile(prefix)
+	return cLog
+}
+func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) {
+	if logType <= cLog.logType {
+		if config.ConsoleConfig.Enabled {
+			cLog.logger.SetOutput(os.Stdout)
+			cLog.logger.WithFields(cLog.data).Log(level, message)
+
+			cLog.logger.SetOutput(cLog.logFile)
+			cLog.logger.WithFields(cLog.data).Log(level, message)
+		}
+	}
+	// Forwarding to next logger.
+	if cLog.next != nil {
+		cLog.next.Log(logType, level, message)
+	} else {
+		// Clearing the fields.
+		cLog.resetFields()
+	}
+}
+
+func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
+	if logType <= cLog.logType {
+		if config.ConsoleConfig.Enabled {
+			cLog.logger.SetOutput(os.Stdout)
+			cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
+
+			cLog.logger.SetOutput(cLog.logFile)
+			cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
+		}
+	}
+	if cLog.next != nil {
+		cLog.next.Logf(logType, level, msgFmtString, args...)
+	} else {
+		// Clearing the fields.
+		cLog.resetFields()
+	}
+}
+
+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}, "")
+		dirName := cLog.logDir.getDirName()
+		fmt.Println(dirName)
+		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.ConsoleConfig.AllowOnConsole
+			}
+		}
+	}
+}

logging/createLogDir.go

@@ -0,0 +1,39 @@
+package logging
+
+import (
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type logDirectory struct {
+	name string
+}
+
+func (logD *logDirectory) getDirName() string {
+	return logD.name
+}
+
+func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) {
+
+	if logD.name == "" {
+		// Creating directory to store all logs for this run. Directory name format : _2019-November-21_14-33-0.
+		prefix = prefix + "_"
+		logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "")
+		logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-")
+		logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_")
+		logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())}, "-")
+
+		if _, err := os.Stat(logDirName); os.IsNotExist(err) {
+			os.Mkdir(logDirName, 0755)
+		} else {
+			log.Println("Unable to create log directory: ", err)
+			logDirName = ""
+		}
+
+		logD.name = logDirName
+	}
+}

logging/logger.go

@@ -0,0 +1,54 @@
+package logging
+
+import (
+	"os"
+	"strings"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+	. "github.com/spdfg/elektron/logging/types"
+)
+
+var config LoggerConfig
+var formatter ElektronFormatter
+var ElektronLogger *loggerImpl
+
+func BuildLogger(prefix string, logConfigFilename string) {
+
+	// Read configuration from yaml.
+	config.GetConfig(logConfigFilename)
+
+	// Create the log directory.
+	startTime := time.Now()
+	formatter.TimestampFormat = "2006-01-02 15:04:05"
+	formattedStartTime := startTime.Format("20060102150405")
+	logDir := &logDirectory{}
+	logDir.createLogDir(prefix, startTime)
+
+	// Instantiate the logrus instance.
+	prefix = strings.Join([]string{prefix, formattedStartTime}, "_")
+	logger := &log.Logger{
+		Out:       os.Stderr,
+		Level:     log.DebugLevel,
+		Formatter: &formatter,
+	}
+
+	// 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.setNext(cLog)
+	cLog.setNext(pLog)
+	pLog.setNext(schedTraceLog)
+	schedTraceLog.setNext(spsLog)
+	spsLog.setNext(schedWindowLog)
+	schedWindowLog.setNext(tskDistLog)
+
+	ElektronLogger = head
+}

logging/loggerChain.go

@@ -0,0 +1,56 @@
+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{}
+}

logging/loggerConfig.go

@@ -0,0 +1,62 @@
+package logging
+
+import (
+	log "github.com/sirupsen/logrus"
+	"gopkg.in/yaml.v2"
+	"io/ioutil"
+)
+
+type LoggerConfig struct {
+	SchedTraceConfig struct {
+		Enabled           bool   `yaml:"enabled"`
+		FilenameExtension string `yaml:"filenameExtension"`
+		AllowOnConsole    bool   `yaml:"allowOnConsole"`
+	} `yaml:"schedTrace"`
+
+	PCPConfig struct {
+		Enabled           bool   `yaml:"enabled"`
+		FilenameExtension string `yaml:"filenameExtension"`
+		AllowOnConsole    bool   `yaml:"allowOnConsole"`
+	} `yaml:"pcp"`
+
+	ConsoleConfig struct {
+		Enabled           bool   `yaml:"enabled"`
+		FilenameExtension string `yaml:"filenameExtension"`
+		MinLogLevel       string `yaml:"minLogLevel"`
+		AllowOnConsole    bool   `yaml:"allowOnConsole"`
+	} `yaml:"console"`
+
+	SPSConfig struct {
+		Enabled           bool   `yaml:"enabled"`
+		FilenameExtension string `yaml:"filenameExtension"`
+		AllowOnConsole    bool   `yaml:"allowOnConsole"`
+	} `yaml:"sps"`
+
+	TaskDistrConfig struct {
+		Enabled           bool   `yaml:"enabled"`
+		FilenameExtension string `yaml:"filenameExtension"`
+		AllowOnConsole    bool   `yaml:"allowOnConsole"`
+	} `yaml:"clsfnTaskDistrOverhead"`
+
+	SchedWindowConfig struct {
+		Enabled           bool   `yaml:"enabled"`
+		FilenameExtension string `yaml:"filenameExtension"`
+		AllowOnConsole    bool   `yaml:"allowOnConsole"`
+	} `yaml:"schedWindow"`
+
+	Format []string `yaml:"format"`
+}
+
+func (c *LoggerConfig) GetConfig(logConfigFilename string) *LoggerConfig {
+
+	yamlFile, err := ioutil.ReadFile(logConfigFilename)
+	if err != nil {
+		log.Printf("Error in reading yaml file   #%v ", err)
+	}
+	err = yaml.Unmarshal(yamlFile, c)
+	if err != nil {
+		log.Fatalf("Error in unmarshalling yaml: %v", err)
+	}
+
+	return c
+}

logging/pcpLogger.go

@@ -0,0 +1,81 @@
+package logging
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type PCPLogger struct {
+	loggerImpl
+}
+
+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
+	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 {
+				pLog.logger.SetOutput(os.Stdout)
+				pLog.logger.WithFields(pLog.data).Log(level, message)
+			}
+
+			pLog.logger.SetOutput(pLog.logFile)
+			pLog.logger.WithFields(pLog.data).Log(level, message)
+		}
+	}
+	if pLog.next != nil {
+		pLog.next.Log(logType, level, message)
+	} else {
+		// Clearing the fields.
+		pLog.resetFields()
+	}
+}
+
+func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
+	if pLog.logType == logType {
+		if config.PCPConfig.Enabled {
+			if pLog.allowOnConsole {
+				pLog.logger.SetOutput(os.Stdout)
+				pLog.logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
+			}
+
+			pLog.logger.SetOutput(pLog.logFile)
+			pLog.logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
+		}
+	}
+	// Forwarding to next logger
+	if pLog.next != nil {
+		pLog.next.Logf(logType, level, msgFmtString, args...)
+	} else {
+		// Clearing the fields.
+		pLog.resetFields()
+	}
+}
+
+func (pLog *PCPLogger) createLogFile(prefix string) {
+	if config.PCPConfig.Enabled {
+		filename := strings.Join([]string{prefix, config.PCPConfig.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
+			}
+		}
+	}
+}

logging/schedPolicySwitchLogger.go

@@ -0,0 +1,81 @@
+package logging
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type SchedPolicySwitchLogger struct {
+	loggerImpl
+}
+
+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
+	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 {
+				sLog.logger.SetOutput(os.Stdout)
+				sLog.logger.WithFields(sLog.data).Log(level, message)
+			}
+
+			sLog.logger.SetOutput(sLog.logFile)
+			sLog.logger.WithFields(sLog.data).Log(level, message)
+		}
+	}
+	if sLog.next != nil {
+		sLog.next.Log(logType, level, message)
+	} else {
+		// Clearing the fields.
+		sLog.resetFields()
+	}
+}
+
+func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
+	if sLog.logType == logType {
+		if config.SPSConfig.Enabled {
+			if sLog.allowOnConsole {
+				sLog.logger.SetOutput(os.Stdout)
+				sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
+			}
+
+			sLog.logger.SetOutput(sLog.logFile)
+			sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
+		}
+	}
+	// Forwarding to next logger
+	if sLog.next != nil {
+		sLog.next.Logf(logType, level, msgFmtString, args...)
+	} else {
+		// Clearing the fields.
+		sLog.resetFields()
+	}
+}
+
+func (sLog *SchedPolicySwitchLogger) createLogFile(prefix string) {
+	if config.SPSConfig.Enabled {
+		filename := strings.Join([]string{prefix, config.SPSConfig.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
+			}
+		}
+	}
+}

logging/schedTraceLogger.go

@@ -0,0 +1,81 @@
+package logging
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type SchedTraceLogger struct {
+	loggerImpl
+}
+
+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
+	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 {
+				sLog.logger.SetOutput(os.Stdout)
+				sLog.logger.WithFields(sLog.data).Log(level, message)
+			}
+
+			sLog.logger.SetOutput(sLog.logFile)
+			sLog.logger.WithFields(sLog.data).Log(level, message)
+		}
+	}
+	if sLog.next != nil {
+		sLog.next.Log(logType, level, message)
+	} else {
+		// Clearing the fields.
+		sLog.resetFields()
+	}
+}
+
+func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
+	if sLog.logType == logType {
+		if config.SchedTraceConfig.Enabled {
+			if sLog.allowOnConsole {
+				sLog.logger.SetOutput(os.Stdout)
+				sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
+			}
+
+			sLog.logger.SetOutput(sLog.logFile)
+			sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
+		}
+	}
+	// Forwarding to next logger
+	if sLog.next != nil {
+		sLog.next.Logf(logType, level, msgFmtString, args...)
+	} else {
+		// Clearing the fields.
+		sLog.resetFields()
+	}
+}
+
+func (sLog *SchedTraceLogger) createLogFile(prefix string) {
+	if config.SchedTraceConfig.Enabled {
+		filename := strings.Join([]string{prefix, config.SchedTraceConfig.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
+			}
+		}
+	}
+}

logging/schedWindowLogger.go

@@ -0,0 +1,81 @@
+package logging
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type SchedWindowLogger struct {
+	loggerImpl
+}
+
+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
+	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 {
+				sLog.logger.SetOutput(os.Stdout)
+				sLog.logger.WithFields(sLog.data).Log(level, message)
+			}
+
+			sLog.logger.SetOutput(sLog.logFile)
+			sLog.logger.WithFields(sLog.data).Log(level, message)
+		}
+	}
+	// Forwarding to next logger
+	if sLog.next != nil {
+		sLog.next.Log(logType, level, message)
+	} else {
+		// Clearing the fields.
+		sLog.resetFields()
+	}
+}
+
+func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
+	if sLog.logType == logType {
+		if config.SchedWindowConfig.Enabled {
+			if sLog.allowOnConsole {
+				sLog.logger.SetOutput(os.Stdout)
+				sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
+			}
+
+			sLog.logger.SetOutput(sLog.logFile)
+			sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
+		}
+	}
+	if sLog.next != nil {
+		sLog.next.Logf(logType, level, msgFmtString, args...)
+	} else {
+		// Clearing the fields.
+		sLog.resetFields()
+	}
+}
+
+func (sLog *SchedWindowLogger) createLogFile(prefix string) {
+	if config.SchedWindowConfig.Enabled {
+		filename := strings.Join([]string{prefix, config.SchedWindowConfig.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
+			}
+		}
+	}
+}

logging/types/types.go

@@ -0,0 +1,10 @@
+package elektronLogging
+
+const (
+	CONSOLE = iota
+	PCP
+	SCHED_TRACE
+	SPS
+	SCHED_WINDOW
+	CLSFN_TASKDISTR_OVERHEAD
+)