def/taskUtils.go

@@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 {
 	} else if task.Watts != 0.0 {
 		return []float64{task.Watts}
 	} else {
-		elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload")
+		elekLog.Log(elekLogTypes.CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload")
 		return []float64{0.0} // Won't reach here.
 	}
 }
@@ -107,7 +107,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64
 			} else {
 				// skip this value
 				// there is an error in the task config.
-				elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, err.Error())
+				elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, err.Error())
 			}
 		} else {
 			// There is only one observation for the task.

logging/clsfnTaskDistrOverheadLogger.go

@@ -9,25 +9,43 @@ import (
 )
 
 type ClsfnTaskDistrOverheadLogger struct {
-	loggerImpl
+	baseElektronLogger
 }
 
-func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string,
+func NewClsfnTaskDistrOverheadLogger(
-	logger *log.Logger, logDir *logDirectory) *ClsfnTaskDistrOverheadLogger {
+	config *LoggerConfig,
-	cLog := &ClsfnTaskDistrOverheadLogger{}
+	b *baseLogData,
-	cLog.logType = logType
+	logType int,
-	cLog.logDir = logDir
+	prefix string,
-	cLog.next = nil
+	logger *log.Logger,
-	cLog.baseLogData = b
+	logDir *logDirectory) *ClsfnTaskDistrOverheadLogger {
-	cLog.logger = logger
+
+	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.isEnabled() {
-			if cLog.allowOnConsole {
+			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.isEnabled() {
-			if cLog.allowOnConsole {
+			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 {
+	if cLog.isEnabled() {
-		filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "")
+		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
 			}
 		}
 	}

logging/consoleLogger.go

@@ -9,23 +9,46 @@ import (
 )
 
 type ConsoleLogger struct {
-	loggerImpl
+	baseElektronLogger
+	MinLogLevel string
 }
 
-func NewConsoleLogger(b *baseLogData, logType int, prefix string,
+func NewConsoleLogger(
-	logger *log.Logger, logDir *logDirectory) *ConsoleLogger {
+	config *LoggerConfig,
-	cLog := &ConsoleLogger{}
+	b *baseLogData,
-	cLog.logType = logType
+	logType int,
-	cLog.logDir = logDir
+	prefix string,
-	cLog.next = nil
+	logger *log.Logger,
-	cLog.baseLogData = b
+	logDir *logDirectory) *ConsoleLogger {
-	cLog.logger = logger
+
+	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 {
+	if cLog.isEnabled() {
-		filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "")
+		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
 			}
 		}
 	}

logging/logger.go

@@ -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.
+type baseLogData struct {
-	config.GetConfig(logConfigFilename)
+	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}
+	head := &baseElektronLogger{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)
+	// Read configuration from yaml.
-	cLog.setNext(pLog)
+	if config, err := GetConfig(logConfigFilename); err != nil {
-	pLog.setNext(schedTraceLog)
+		return errors.Wrap(err, "Failed to build logger")
-	schedTraceLog.setNext(spsLog)
+	} else {
-	spsLog.setNext(schedWindowLog)
+		cLog := NewConsoleLogger(config, b, CONSOLE, prefix, logger, logDir)
-	schedWindowLog.setNext(tskDistLog)
+		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)
 }

logging/loggerChain.go

@@ -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{}
-}

logging/loggerConfig.go

@@ -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
 }

logging/pcpLogger.go

@@ -9,25 +9,44 @@ import (
 )
 
 type PCPLogger struct {
-	loggerImpl
+	baseElektronLogger
 }
 
-func NewPCPLogger(b *baseLogData, logType int, prefix string,
+func NewPCPLogger(
-	logger *log.Logger, logDir *logDirectory) *PCPLogger {
+	config *LoggerConfig,
-	pLog := &PCPLogger{}
+	b *baseLogData,
-	pLog.logType = logType
+	logType int,
-	pLog.logDir = logDir
+	prefix string,
-	pLog.next = nil
+	logger *log.Logger,
-	pLog.baseLogData = b
+	logDir *logDirectory) *PCPLogger {
-	pLog.logger = logger
+
+	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.isEnabled() {
-			if pLog.allowOnConsole {
+			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.isEnabled() {
-			if pLog.allowOnConsole {
+			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 {
+	if pLog.isEnabled() {
-		filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "")
+		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
 			}
 		}
 	}

logging/schedPolicySwitchLogger.go

@@ -9,25 +9,44 @@ import (
 )
 
 type SchedPolicySwitchLogger struct {
-	loggerImpl
+	baseElektronLogger
 }
 
-func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string,
+func NewSchedPolicySwitchLogger(
-	logger *log.Logger, logDir *logDirectory) *SchedPolicySwitchLogger {
+	config *LoggerConfig,
-	sLog := &SchedPolicySwitchLogger{}
+	b *baseLogData,
-	sLog.logType = logType
+	logType int,
-	sLog.logDir = logDir
+	prefix string,
-	sLog.next = nil
+	logger *log.Logger,
-	sLog.baseLogData = b
+	logDir *logDirectory) *SchedPolicySwitchLogger {
-	sLog.logger = logger
+
+	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.isEnabled() {
-			if sLog.allowOnConsole {
+			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.isEnabled() {
-			if sLog.allowOnConsole {
+			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 {
+	if sLog.isEnabled() {
-		filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "")
+		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
 			}
 		}
 	}

logging/schedTraceLogger.go

@@ -9,25 +9,44 @@ import (
 )
 
 type SchedTraceLogger struct {
-	loggerImpl
+	baseElektronLogger
 }
 
-func NewSchedTraceLogger(b *baseLogData, logType int, prefix string,
+func NewSchedTraceLogger(
-	logger *log.Logger, logDir *logDirectory) *SchedTraceLogger {
+	config *LoggerConfig,
-	sLog := &SchedTraceLogger{}
+	b *baseLogData,
-	sLog.logType = logType
+	logType int,
-	sLog.logDir = logDir
+	prefix string,
-	sLog.next = nil
+	logger *log.Logger,
-	sLog.baseLogData = b
+	logDir *logDirectory) *SchedTraceLogger {
-	sLog.logger = logger
+
+	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.isEnabled() {
-			if sLog.allowOnConsole {
+			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.isEnabled() {
-			if sLog.allowOnConsole {
+			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 {
+	if sLog.isEnabled() {
-		filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "")
+		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
 			}
 		}
 	}

logging/schedWindowLogger.go

@@ -9,25 +9,44 @@ import (
 )
 
 type SchedWindowLogger struct {
-	loggerImpl
+	baseElektronLogger
 }
 
-func NewSchedWindowLogger(b *baseLogData, logType int, prefix string,
+func NewSchedWindowLogger(
-	logger *log.Logger, logDir *logDirectory) *SchedWindowLogger {
+	config *LoggerConfig,
-	sLog := &SchedWindowLogger{}
+	b *baseLogData,
-	sLog.logType = logType
+	logType int,
-	sLog.logDir = logDir
+	prefix string,
-	sLog.next = nil
+	logger *log.Logger,
-	sLog.baseLogData = b
+	logDir *logDirectory) *SchedWindowLogger {
-	sLog.logger = logger
+
+	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.isEnabled() {
-			if sLog.allowOnConsole {
+			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.isEnabled() {
-			if sLog.allowOnConsole {
+			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 {
+	if sLog.isEnabled() {
-		filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "")
+		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
 			}
 		}
 	}

logging/types/types.go

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

pcp/pcp.go

@@ -47,7 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) {
 		scanner.Scan()
 
 		// Write to logfile
-		elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text())
+		elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text())
 
 		// Throw away first set of results
 		scanner.Scan()
@@ -58,14 +58,14 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) {
 			text := scanner.Text()
 
 			if *logging {
-				elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text)
+				elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text)
 			}
 
 			seconds++
 		}
 	}(logging)
 
-	elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started")
+	elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started")
 
 	if err := cmd.Start(); err != nil {
 		log.Fatal(err)
@@ -75,7 +75,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) {
 
 	select {
 	case <-quit:
-		elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds")
+		elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds")
 		time.Sleep(5 * time.Second)
 
 		// http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly

powerCap/extrema.go

@@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 
 	if hiThreshold < loThreshold {
-		elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!")
+		elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!")
 	}
 
 	pipe, err := cmd.StdoutPipe()
@@ -59,7 +59,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 		scanner.Scan()
 
 		// Write to logfile
-		elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text())
+		elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text())
 
 		headers := strings.Split(scanner.Text(), ",")
 
@@ -95,12 +95,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 
 			if *logging {
 
-				elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...")
+				elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...")
 
 				text := scanner.Text()
 				split := strings.Split(text, ",")
 
-				elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text)
+				elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text)
 
 				totalPower := 0.0
 				for _, powerIndex := range powerIndexes {
@@ -111,7 +111,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 					powerHistories[host].Value = power
 					powerHistories[host] = powerHistories[host].Next()
 
-					elekLog.ElektronLogger.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]),
+					elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]),
 						"Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 
 					totalPower += power
@@ -123,11 +123,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 
 				clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist)
 
-				elekLog.ElektronLogger.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()),
+				elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()),
 					"Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 
 				if clusterMean > hiThreshold {
-					elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE,
+					elekLog.Log(elekLogTypes.CONSOLE,
 						log.InfoLevel, "Need to cap a node")
 					// Create statics for all victims and choose one to cap
 					victims := make([]pcp.Victim, 0, 8)
@@ -149,10 +149,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 						if !cappedHosts[victim.Host] {
 							cappedHosts[victim.Host] = true
 							orderCapped = append(orderCapped, victim.Host)
-							elekLog.ElektronLogger.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host),
+							elekLog.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host),
 								"Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 							if err := rapl.Cap(victim.Host, "rapl", 50); err != nil {
-								elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE,
+								elekLog.Log(elekLogTypes.CONSOLE,
 									log.ErrorLevel,
 									"Error capping host")
 							}
@@ -168,9 +168,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 						cappedHosts[host] = false
 						// User RAPL package to send uncap.
 						log.Printf("Uncapping host %s", host)
-						elekLog.ElektronLogger.WithFields(log.Fields{"Uncapped host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
+						elekLog.WithFields(log.Fields{"Uncapped host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 						if err := rapl.Cap(host, "rapl", 100); err != nil {
-							elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host")
+							elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host")
 						}
 					}
 				}
@@ -180,7 +180,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 		}
 	}(logging, hiThreshold, loThreshold)
 
-	elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started")
+	elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started")
 
 	if err := cmd.Start(); err != nil {
 		log.Fatal(err)
@@ -190,7 +190,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh
 
 	select {
 	case <-quit:
-		elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds")
+		elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds")
 		time.Sleep(5 * time.Second)
 
 		// http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly

powerCap/progressiveExtrema.go

@@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 
 	if hiThreshold < loThreshold {
-		elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!")
+		elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!")
 	}
 
 	pipe, err := cmd.StdoutPipe()
@@ -72,7 +72,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 		scanner.Scan()
 
 		// Write to logfile
-		elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text())
+		elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text())
 
 		headers := strings.Split(scanner.Text(), ",")
 
@@ -111,11 +111,11 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 
 		for scanner.Scan() {
 			if *logging {
-				elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...")
+				elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...")
 				split := strings.Split(scanner.Text(), ",")
 
 				text := scanner.Text()
-				elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text)
+				elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text)
 
 				totalPower := 0.0
 				for _, powerIndex := range powerIndexes {
@@ -126,7 +126,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 					powerHistories[host].Value = power
 					powerHistories[host] = powerHistories[host].Next()
 
-					elekLog.ElektronLogger.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]),
+					elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]),
 						"Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 					totalPower += power
 				}
@@ -137,15 +137,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 
 				clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist)
 
-				elekLog.ElektronLogger.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()),
+				elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()),
 					"Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 
 				if clusterMean >= hiThreshold {
-					elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node")
+					elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node")
 
-					elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
+					elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 
-					elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
+					elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 					// Create statics for all victims and choose one to cap
 					victims := make([]pcp.Victim, 0, 8)
 
@@ -173,10 +173,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 							// Need to cap this victim.
 							if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil {
 
-								elekLog.ElektronLogger.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
+								elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
 							} else {
 
-								elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0)
+								elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0)
 								// Keeping track of this victim and it's cap value
 								cappedVictims[victims[i].Host] = 50.0
 								newVictimFound = true
@@ -200,10 +200,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 								newCapValue := getNextCapValue(capValue, 2)
 								if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil {
 
-									elekLog.ElektronLogger.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
+									elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
 								} else {
 									// Successful cap
-									elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel,
+									elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel,
 										"Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)
 									// Checking whether this victim can be capped further
 									if newCapValue <= constants.LowerCapLimit {
@@ -227,15 +227,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 							}
 						}
 						if !canCapAlreadyCappedVictim {
-							elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No Victim left to cap")
+							elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No Victim left to cap")
 						}
 					}
 
 				} else if clusterMean < loThreshold {
 
-					elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node")
+					elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node")
-					elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
+					elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
-					elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
+					elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 					if len(orderCapped) > 0 {
 						// We pick the host that is capped the most to uncap.
 						orderCappedToSort := utilities.GetPairList(orderCappedVictims)
@@ -246,10 +246,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 						newUncapValue := orderCappedVictims[hostToUncap] * 2.0
 						if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil {
 
-							elekLog.ElektronLogger.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
+							elekLog.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
 						} else {
 							// Successful uncap
-							elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue)
+							elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue)
 							// Can we uncap this host further. If not, then we remove its entry from orderCapped
 							if newUncapValue >= 100.0 { // can compare using ==
 								// Deleting entry from orderCapped
@@ -270,7 +270,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 							}
 						}
 					} else {
-						elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No host staged for Uncapped")
+						elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No host staged for Uncapped")
 					}
 				}
 			}
@@ -279,7 +279,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 
 	}(logging, hiThreshold, loThreshold)
 
-	elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started")
+	elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started")
 	if err := cmd.Start(); err != nil {
 		log.Fatal(err)
 	}
@@ -288,7 +288,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh
 
 	select {
 	case <-quit:
-		elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds")
+		elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds")
 		time.Sleep(5 * time.Second)
 
 		// http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly

scheduler.go

@@ -226,8 +226,11 @@ func main() {
 	if strings.Contains(*pcplogPrefix, "/") {
 		log.Fatal("log file prefix should not contain '/'.")
 	}
-	// Build Logger for elektron.
+
-	elekLog.BuildLogger(*pcplogPrefix, *logConfigFilename)
+	// Build Logger.
+	if err := elekLog.BuildLogger(*pcplogPrefix, *logConfigFilename); err != nil {
+		log.Fatal(err)
+	}
 
 	// Starting PCP logging.
 	if noPowercap {
@@ -282,8 +285,8 @@ func main() {
 
 	// Starting the scheduler driver.
 	if status, err := driver.Run(); err != nil {
-		elekLog.ElektronLogger.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(elekLogTypes.CONSOLE,
+		elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(elekLogTypes.CONSOLE,
 			log.ErrorLevel, "Framework stopped ")
 	}
-	elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Exiting...")
+	elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Exiting...")
 }

schedulers/base.go

@@ -250,30 +250,29 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos
 
 func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) {
 	if ts == nil {
-		elekLog.ElektronLogger.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASKS   STARTING...")
+		elekLog.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASKS   STARTING...")
 	} else {
-		elekLog.ElektronLogger.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name),
+		elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances),
-			"Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE,
+			"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASK STARTING... ")
-			log.InfoLevel, "TASK STARTING... ")
 	}
 }
 
 func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Watts considered for ")
+	elekLog.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Watts considered for ")
 }
 
 func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(elekLogTypes.CONSOLE,
 		log.InfoLevel, "")
 }
 
 func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE,
 		log.WarnLevel, "No tasks left to schedule ")
 }
 
 func (s *BaseScheduler) LogNumberOfRunningTasks() {
-	elekLog.ElektronLogger.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(elekLogTypes.CONSOLE,
 		log.InfoLevel, "")
 }
 
@@ -284,67 +283,67 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) {
 		buffer.WriteString(fmt.Sprintln(taskName))
 	}
 	s.TasksRunningMutex.Unlock()
-	elekLog.ElektronLogger.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE,
 		log.InfoLevel, "")
 }
 
 func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) {
-	elekLog.ElektronLogger.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, "")
+	elekLog.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, "")
 }
 
 func (s *BaseScheduler) LogTerminateScheduler() {
-	elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Done scheduling all tasks!")
+	elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Done scheduling all tasks!")
 }
 
 func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer,
 	offerResources ...interface{}) {
 	buffer := bytes.Buffer{}
 	buffer.WriteString(fmt.Sprintf("<CPU: %f, RAM: %f, Watts: %f>", offerResources...))
-	elekLog.ElektronLogger.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE,
 		log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task")
 }
 
 func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE,
 		log.ErrorLevel, "OFFER RESCINDED")
 }
 
 func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE,
 		log.ErrorLevel, "SLAVE LOST")
 }
 
 func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST")
+	elekLog.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST")
 }
 
 func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID,
 	slaveID *mesos.SlaveID, message string) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE,
 		log.InfoLevel, message)
 }
 
 func (s *BaseScheduler) LogMesosError(err string) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE,
 		log.ErrorLevel, "")
 }
 
 func (s *BaseScheduler) LogElectronError(err error) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
+	elekLog.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
 }
 
 func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID,
 	masterInfo *mesos.MasterInfo) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!")
+	elekLog.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!")
 }
 
 func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) {
-	elekLog.ElektronLogger.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE,
 		log.InfoLevel, "Framework re-registered")
 }
 
 func (s *BaseScheduler) LogDisconnected() {
-	elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master")
+	elekLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master")
 }
 
 func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) {
@@ -356,12 +355,12 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) {
 	default:
 		level = log.InfoLevel
 	}
-	elekLog.ElektronLogger.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received")
+	elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received")
 }
 
 func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) {
 	logSPS := func() {
-		elekLog.ElektronLogger.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "")
+		elekLog.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "")
 	}
 	if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) {
 		logSPS()
@@ -370,10 +369,10 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy
 	}
 	// Logging the size of the scheduling window and the scheduling policy
 	// 	that is going to schedule the tasks in the scheduling window.
-	elekLog.ElektronLogger.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "")
+	elekLog.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "")
 }
 
 func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) {
 	// Logging the overhead in microseconds.
-	elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "")
+	elekLog.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "")
 }

schedulers/helpers.go

@@ -36,10 +36,10 @@ import (
 func coLocated(tasks map[string]bool, s BaseScheduler) {
 
 	for _, task := range tasks {
-		elekLog.ElektronLogger.WithFields(log.Fields{"Task": task}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
+		elekLog.WithFields(log.Fields{"Task": task}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "")
 	}
 
-	elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "---------------------")
+	elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "---------------------")
 }
 
 // Get the powerClass of the given hostname.

schedulers/schedPolicy.go

@@ -90,7 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string {
 	// Determine the distribution of tasks in the new scheduling window.
 	taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks)
 	baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime))
-	elekLog.ElektronLogger.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(elekLogTypes.CONSOLE,
+	elekLog.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(elekLogTypes.CONSOLE,
 		log.InfoLevel, "Switching... ")
 	if err != nil {
 		// All the tasks in the window were only classified into 1 cluster.

utilities/offerUtils/offerUtils.go

@@ -90,12 +90,12 @@ func UpdateEnvironment(offer *mesos.Offer) {
 	var host = offer.GetHostname()
 	// If this host is not present in the set of hosts.
 	if _, ok := constants.Hosts[host]; !ok {
-		elekLog.ElektronLogger.WithFields(log.Fields{"Adding host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "New host detected")
+		elekLog.WithFields(log.Fields{"Adding host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "New host detected")
 		// Add this host.
 		constants.Hosts[host] = struct{}{}
 		// Get the power class of this host.
 		class := PowerClass(offer)
-		elekLog.ElektronLogger.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(elekLogTypes.CONSOLE,
+		elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(elekLogTypes.CONSOLE,
 			log.InfoLevel, "Registering the power class...")
 		// If new power class, register the power class.
 		if _, ok := constants.PowerClasses[class]; !ok {

utilities/schedUtils/schedUtils.go

@@ -78,7 +78,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) {
 	for _, task := range taskQueue {
 		numberOfTasksTraversed++
 		for i := *task.Instances; i > 0; i-- {
-			elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel,
+			elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel,
 				"Checking if Instance #%d of Task[%s] can be scheduled "+
 					"during the next offer cycle...", i, task.Name)
 			if canSchedule(task) {