From 3d201bf4376154e8aa462b41438af9e76a937269 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 17:38:56 -0500 Subject: [PATCH 1/7] refactored elektronLogging to logging --- def/taskUtils.go | 4 ++-- {elektronLogging => logging}/ElektronFormatter.go | 2 +- {elektronLogging => logging}/clsfnTaskDistOverheadLogger.go | 2 +- {elektronLogging => logging}/consoleLogger.go | 2 +- {elektronLogging => logging}/createLogDir.go | 2 +- {elektronLogging => logging}/logger.go | 4 ++-- {elektronLogging => logging}/loggerChain.go | 2 +- {elektronLogging => logging}/loggerConfig.go | 2 +- {elektronLogging => logging}/pcpLogger.go | 2 +- {elektronLogging => logging}/schedPolicySwitchLogger.go | 2 +- {elektronLogging => logging}/schedTraceLogger.go | 2 +- {elektronLogging => logging}/schedWindowLogger.go | 2 +- {elektronLogging => logging}/types/types.go | 0 pcp/pcp.go | 4 ++-- powerCap/extrema.go | 4 ++-- powerCap/progressiveExtrema.go | 4 ++-- scheduler.go | 4 ++-- schedulers/base.go | 4 ++-- schedulers/helpers.go | 4 ++-- schedulers/schedPolicy.go | 4 ++-- utilities/offerUtils/offerUtils.go | 4 ++-- utilities/schedUtils/schedUtils.go | 4 ++-- 22 files changed, 32 insertions(+), 32 deletions(-) rename {elektronLogging => logging}/ElektronFormatter.go (96%) rename {elektronLogging => logging}/clsfnTaskDistOverheadLogger.go (98%) rename {elektronLogging => logging}/consoleLogger.go (98%) rename {elektronLogging => logging}/createLogDir.go (97%) rename {elektronLogging => logging}/logger.go (95%) rename {elektronLogging => logging}/loggerChain.go (98%) rename {elektronLogging => logging}/loggerConfig.go (98%) rename {elektronLogging => logging}/pcpLogger.go (98%) rename {elektronLogging => logging}/schedPolicySwitchLogger.go (98%) rename {elektronLogging => logging}/schedTraceLogger.go (98%) rename {elektronLogging => logging}/schedWindowLogger.go (98%) rename {elektronLogging => logging}/types/types.go (100%) diff --git a/def/taskUtils.go b/def/taskUtils.go index 0d203eb..1822779 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -26,8 +26,8 @@ import ( "github.com/mash/gokmeans" "github.com/montanaflynn/stats" log "github.com/sirupsen/logrus" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) // Information about a cluster of tasks. diff --git a/elektronLogging/ElektronFormatter.go b/logging/ElektronFormatter.go similarity index 96% rename from elektronLogging/ElektronFormatter.go rename to logging/ElektronFormatter.go index a0b1ff0..1ea7ea0 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/logging/ElektronFormatter.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "bytes" diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/logging/clsfnTaskDistOverheadLogger.go similarity index 98% rename from elektronLogging/clsfnTaskDistOverheadLogger.go rename to logging/clsfnTaskDistOverheadLogger.go index bd13429..b965609 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/logging/clsfnTaskDistOverheadLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/consoleLogger.go b/logging/consoleLogger.go similarity index 98% rename from elektronLogging/consoleLogger.go rename to logging/consoleLogger.go index 052fc30..d1a115d 100644 --- a/elektronLogging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "fmt" diff --git a/elektronLogging/createLogDir.go b/logging/createLogDir.go similarity index 97% rename from elektronLogging/createLogDir.go rename to logging/createLogDir.go index b5666d9..e6730f4 100644 --- a/elektronLogging/createLogDir.go +++ b/logging/createLogDir.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/logger.go b/logging/logger.go similarity index 95% rename from elektronLogging/logger.go rename to logging/logger.go index 90c2b87..b271c44 100644 --- a/elektronLogging/logger.go +++ b/logging/logger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" @@ -6,7 +6,7 @@ import ( "time" log "github.com/sirupsen/logrus" - . "github.com/spdfg/elektron/elektronLogging/types" + . "github.com/spdfg/elektron/logging/types" ) var config LoggerConfig diff --git a/elektronLogging/loggerChain.go b/logging/loggerChain.go similarity index 98% rename from elektronLogging/loggerChain.go rename to logging/loggerChain.go index a771257..ff9792e 100644 --- a/elektronLogging/loggerChain.go +++ b/logging/loggerChain.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( log "github.com/sirupsen/logrus" diff --git a/elektronLogging/loggerConfig.go b/logging/loggerConfig.go similarity index 98% rename from elektronLogging/loggerConfig.go rename to logging/loggerConfig.go index 06ac247..a0ae5de 100644 --- a/elektronLogging/loggerConfig.go +++ b/logging/loggerConfig.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( log "github.com/sirupsen/logrus" diff --git a/elektronLogging/pcpLogger.go b/logging/pcpLogger.go similarity index 98% rename from elektronLogging/pcpLogger.go rename to logging/pcpLogger.go index 7dc8fd1..d9a91f8 100644 --- a/elektronLogging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go similarity index 98% rename from elektronLogging/schedPolicySwitchLogger.go rename to logging/schedPolicySwitchLogger.go index c3d555b..437c300 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/schedTraceLogger.go b/logging/schedTraceLogger.go similarity index 98% rename from elektronLogging/schedTraceLogger.go rename to logging/schedTraceLogger.go index 9174e80..ccbad63 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/schedWindowLogger.go b/logging/schedWindowLogger.go similarity index 98% rename from elektronLogging/schedWindowLogger.go rename to logging/schedWindowLogger.go index 75c6a50..b303b28 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/types/types.go b/logging/types/types.go similarity index 100% rename from elektronLogging/types/types.go rename to logging/types/types.go diff --git a/pcp/pcp.go b/pcp/pcp.go index 90d0b52..5f5affd 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -25,8 +25,8 @@ import ( "time" log "github.com/sirupsen/logrus" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { diff --git a/powerCap/extrema.go b/powerCap/extrema.go index dbd38aa..e2d2bec 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -30,8 +30,8 @@ import ( "time" log "github.com/sirupsen/logrus" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" ) diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index f75f849..2ab9147 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -32,8 +32,8 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" "github.com/spdfg/elektron/utilities" diff --git a/scheduler.go b/scheduler.go index ec2df7b..d376f38 100644 --- a/scheduler.go +++ b/scheduler.go @@ -31,8 +31,8 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" diff --git a/schedulers/base.go b/schedulers/base.go index 25f06a9..55657c3 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -30,8 +30,8 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" ) diff --git a/schedulers/helpers.go b/schedulers/helpers.go index a9004e0..fcc3f05 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -27,8 +27,8 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" ) diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index dfd44ec..cc6ae14 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -26,8 +26,8 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) type SchedPolicyContext interface { diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 4c1a475..0f9338e 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -24,8 +24,8 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) func OfferAgg(offer *mesos.Offer) (float64, float64, float64) { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index 5e4fc69..c28c201 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -21,8 +21,8 @@ package schedUtils import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" ) From 5a6d1bed4ace22a72504b30e00c998279fcea59a Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 17:40:00 -0500 Subject: [PATCH 2/7] refactored Dist to Distr in clsfnTaskDistOverheadLogger.go --- ...nTaskDistOverheadLogger.go => clsfnTaskDistrOverheadLogger.go} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename logging/{clsfnTaskDistOverheadLogger.go => clsfnTaskDistrOverheadLogger.go} (100%) diff --git a/logging/clsfnTaskDistOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go similarity index 100% rename from logging/clsfnTaskDistOverheadLogger.go rename to logging/clsfnTaskDistrOverheadLogger.go From 6fb0e4a3fe63e76982817bbdb2dcb8b5b80af7b1 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 21:32:37 -0500 Subject: [PATCH 3/7] move cfg to loggers + refactor + log fn wrappers 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. --- def/taskUtils.go | 4 +- logging/clsfnTaskDistrOverheadLogger.go | 51 ++++++---- logging/consoleLogger.go | 50 +++++++--- logging/logger.go | 124 ++++++++++++++++++++---- logging/loggerChain.go | 56 ----------- logging/loggerConfig.go | 9 +- logging/pcpLogger.go | 50 +++++++--- logging/schedPolicySwitchLogger.go | 50 +++++++--- logging/schedTraceLogger.go | 50 +++++++--- logging/schedWindowLogger.go | 50 +++++++--- logging/types/types.go | 2 +- pcp/pcp.go | 8 +- powerCap/extrema.go | 26 ++--- powerCap/progressiveExtrema.go | 44 ++++----- scheduler.go | 11 ++- schedulers/base.go | 49 +++++----- schedulers/helpers.go | 4 +- schedulers/schedPolicy.go | 2 +- utilities/offerUtils/offerUtils.go | 4 +- utilities/schedUtils/schedUtils.go | 2 +- 20 files changed, 396 insertions(+), 250 deletions(-) delete mode 100644 logging/loggerChain.go diff --git a/def/taskUtils.go b/def/taskUtils.go index 1822779..7de0a34 100644 --- a/def/taskUtils.go +++ b/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. diff --git a/logging/clsfnTaskDistrOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go index b965609..2d2777b 100644 --- a/logging/clsfnTaskDistrOverheadLogger.go +++ b/logging/clsfnTaskDistrOverheadLogger.go @@ -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 } } } diff --git a/logging/consoleLogger.go b/logging/consoleLogger.go index d1a115d..ab449b9 100644 --- a/logging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -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 } } } diff --git a/logging/logger.go b/logging/logger.go index b271c44..413fffb 100644 --- a/logging/logger.go +++ b/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. - 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) } diff --git a/logging/loggerChain.go b/logging/loggerChain.go deleted file mode 100644 index ff9792e..0000000 --- a/logging/loggerChain.go +++ /dev/null @@ -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{} -} diff --git a/logging/loggerConfig.go b/logging/loggerConfig.go index a0ae5de..cbf3cbc 100644 --- a/logging/loggerConfig.go +++ b/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 } diff --git a/logging/pcpLogger.go b/logging/pcpLogger.go index d9a91f8..52c1fbe 100644 --- a/logging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -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 } } } diff --git a/logging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go index 437c300..98a5094 100644 --- a/logging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -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 } } } diff --git a/logging/schedTraceLogger.go b/logging/schedTraceLogger.go index ccbad63..292dff8 100644 --- a/logging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -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 } } } diff --git a/logging/schedWindowLogger.go b/logging/schedWindowLogger.go index b303b28..9627e5e 100644 --- a/logging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -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 } } } diff --git a/logging/types/types.go b/logging/types/types.go index 903fe34..44b8484 100644 --- a/logging/types/types.go +++ b/logging/types/types.go @@ -1,4 +1,4 @@ -package elektronLogging +package types const ( CONSOLE = iota diff --git a/pcp/pcp.go b/pcp/pcp.go index 5f5affd..b2e886f 100644 --- a/pcp/pcp.go +++ b/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 diff --git a/powerCap/extrema.go b/powerCap/extrema.go index e2d2bec..6abb65f 100644 --- a/powerCap/extrema.go +++ b/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 diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 2ab9147..efa2023 100644 --- a/powerCap/progressiveExtrema.go +++ b/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.ElektronLogger.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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node") + elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).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 diff --git a/scheduler.go b/scheduler.go index d376f38..92b2e87 100644 --- a/scheduler.go +++ b/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...") } diff --git a/schedulers/base.go b/schedulers/base.go index 55657c3..cfb350b 100644 --- a/schedulers/base.go +++ b/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), - "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, - log.InfoLevel, "TASK STARTING... ") + elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), + "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, 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("", 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, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index fcc3f05..803fc58 100644 --- a/schedulers/helpers.go +++ b/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. diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index cc6ae14..3dc7bd9 100644 --- a/schedulers/schedPolicy.go +++ b/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. diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 0f9338e..5a3fb35 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/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 { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index c28c201..bde4dcc 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/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) { From 3b70a13cc8b7275cdfae1d3f05382c412f7448f3 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 21:43:16 -0500 Subject: [PATCH 4/7] refactored logging/types imports to dot imports --- def/taskUtils.go | 6 ++-- pcp/pcp.go | 10 +++---- powerCap/extrema.go | 28 ++++++++--------- powerCap/progressiveExtrema.go | 46 ++++++++++++++-------------- scheduler.go | 6 ++-- schedulers/base.go | 48 +++++++++++++++--------------- schedulers/helpers.go | 6 ++-- schedulers/schedPolicy.go | 4 +-- utilities/offerUtils/offerUtils.go | 6 ++-- utilities/schedUtils/schedUtils.go | 4 +-- 10 files changed, 82 insertions(+), 82 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index 7de0a34..d9904d4 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -27,7 +27,7 @@ import ( "github.com/montanaflynn/stats" log "github.com/sirupsen/logrus" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) // Information about a cluster of tasks. @@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elekLog.Log(elekLogTypes.CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") + elekLog.Log(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.Log(elekLogTypes.CONSOLE, log.ErrorLevel, err.Error()) + elekLog.Log(CONSOLE, log.ErrorLevel, err.Error()) } } else { // There is only one observation for the task. diff --git a/pcp/pcp.go b/pcp/pcp.go index b2e886f..25e6664 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -26,7 +26,7 @@ import ( log "github.com/sirupsen/logrus" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { @@ -47,7 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { scanner.Scan() // Write to logfile - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(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.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(PCP, log.InfoLevel, text) } seconds++ } }(logging) - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(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 diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 6abb65f..066d409 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -31,7 +31,7 @@ import ( log "github.com/sirupsen/logrus" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" ) @@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") + elekLog.Log(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.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") + elekLog.Log(CONSOLE, log.InfoLevel, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -112,7 +112,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host] = powerHistories[host].Next() elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") totalPower += power } @@ -124,10 +124,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") if clusterMean > hiThreshold { - elekLog.Log(elekLogTypes.CONSOLE, + elekLog.Log(CONSOLE, log.InfoLevel, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -150,9 +150,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[victim.Host] = true orderCapped = append(orderCapped, 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, "") + "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(CONSOLE, log.InfoLevel, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elekLog.Log(elekLogTypes.CONSOLE, + elekLog.Log(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.WithFields(log.Fields{"Uncapped host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Uncapped host": host}).Log(CONSOLE, log.InfoLevel, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host") + elekLog.Log(CONSOLE, log.ErrorLevel, "Error capping host") } } } @@ -180,7 +180,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(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 diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index efa2023..2de1bf7 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -33,7 +33,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" "github.com/spdfg/elektron/utilities" @@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") + elekLog.Log(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.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") + elekLog.Log(CONSOLE, log.InfoLevel, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -127,7 +127,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host] = powerHistories[host].Next() elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") totalPower += power } clusterPower := totalPower * pcp.RAPLUnits @@ -138,14 +138,14 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") if clusterMean >= hiThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node") + elekLog.Log(CONSOLE, log.InfoLevel, "Need to cap a node") - elekLog.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(CONSOLE, log.InfoLevel, "") - elekLog.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(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.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(CONSOLE, log.ErrorLevel, "") } else { - elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) + elekLog.Logf(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.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(CONSOLE, log.ErrorLevel, "") } else { // Successful cap - elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.Logf(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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No Victim left to cap") + elekLog.Log(CONSOLE, log.InfoLevel, "No Victim left to cap") } } } else if clusterMean < loThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node") - elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") - elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.Log(CONSOLE, log.InfoLevel, "Need to uncap a node") + elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(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.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(CONSOLE, log.ErrorLevel, "") } else { // Successful uncap - elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) + elekLog.Logf(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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No host staged for Uncapped") + elekLog.Log(CONSOLE, log.InfoLevel, "No host staged for Uncapped") } } } @@ -279,7 +279,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(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.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(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 diff --git a/scheduler.go b/scheduler.go index 92b2e87..3b7261f 100644 --- a/scheduler.go +++ b/scheduler.go @@ -32,7 +32,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" @@ -285,8 +285,8 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(CONSOLE, log.ErrorLevel, "Framework stopped ") } - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Exiting...") + elekLog.Log(CONSOLE, log.InfoLevel, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index cfb350b..f25a256 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -31,7 +31,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" ) @@ -250,29 +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.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(CONSOLE, log.InfoLevel, "TASKS STARTING...") } else { elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), - "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASK STARTING... ") + "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.InfoLevel, "TASK STARTING... ") } } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - elekLog.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(CONSOLE, log.InfoLevel, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - elekLog.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(CONSOLE, log.InfoLevel, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - elekLog.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(CONSOLE, log.WarnLevel, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - elekLog.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(CONSOLE, log.InfoLevel, "") } @@ -283,67 +283,67 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.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(CONSOLE, log.InfoLevel, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elekLog.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(SCHED_TRACE, log.InfoLevel, "") } func (s *BaseScheduler) LogTerminateScheduler() { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Done scheduling all tasks!") + elekLog.Log(CONSOLE, log.InfoLevel, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.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(CONSOLE, log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(CONSOLE, log.ErrorLevel, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(CONSOLE, log.ErrorLevel, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - elekLog.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(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(CONSOLE, log.InfoLevel, message) } func (s *BaseScheduler) LogMesosError(err string) { - elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(CONSOLE, log.ErrorLevel, "") } func (s *BaseScheduler) LogElectronError(err error) { - elekLog.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(CONSOLE, log.ErrorLevel, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - elekLog.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(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(CONSOLE, log.InfoLevel, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - elekLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master") + elekLog.Log(CONSOLE, log.WarnLevel, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -355,12 +355,12 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.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(CONSOLE, level, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Name": name}).Log(SPS, log.InfoLevel, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -369,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.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(SCHED_WINDOW, log.InfoLevel, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.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(CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 803fc58..802c7a7 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -28,7 +28,7 @@ import ( "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" ) @@ -36,10 +36,10 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for _, task := range tasks { - elekLog.WithFields(log.Fields{"Task": task}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Task": task}).Log(CONSOLE, log.InfoLevel, "") } - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "---------------------") + elekLog.Log(CONSOLE, log.InfoLevel, "---------------------") } // Get the powerClass of the given hostname. diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index 3dc7bd9..dddcb72 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -27,7 +27,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) type SchedPolicyContext interface { @@ -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.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(CONSOLE, log.InfoLevel, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 5a3fb35..69abec7 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -25,7 +25,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) func OfferAgg(offer *mesos.Offer) (float64, float64, float64) { @@ -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.WithFields(log.Fields{"Adding host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "New host detected") + elekLog.WithFields(log.Fields{"Adding host": host}).Log(CONSOLE, log.InfoLevel, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(CONSOLE, log.InfoLevel, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index bde4dcc..534651d 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -22,7 +22,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" ) @@ -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.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.Logf(CONSOLE, log.InfoLevel, "Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name) if canSchedule(task) { From 12f827c0feed7106b22e2f5474e73b1d8e2da9a0 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 22:33:28 -0500 Subject: [PATCH 5/7] Used WithField() and Logf() where required. Used elektronLogger#WithField(...) for single key-value pair. Used elektronLogger#Logf(...) where formatted string is required. --- powerCap/extrema.go | 26 +++++------ powerCap/progressiveExtrema.go | 30 +++++++------ scheduler.go | 6 ++- schedulers/base.go | 72 +++++++++++++++++------------- schedulers/helpers.go | 2 +- schedulers/schedPolicy.go | 19 ++++---- utilities/offerUtils/offerUtils.go | 8 ++-- 7 files changed, 91 insertions(+), 72 deletions(-) diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 066d409..34121d4 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -111,8 +111,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Host": indexToHost[powerIndex], + "Power": fmt.Sprintf("%f", power*pcp.RAPLUnits), + }).Log(CONSOLE, log.InfoLevel, "") totalPower += power } @@ -123,12 +125,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Total power": fmt.Sprintf("%f %d Sec", clusterPower, clusterPowerHist.Len()), + "Avg": fmt.Sprintf("%f", clusterMean), + }).Log(CONSOLE, log.InfoLevel, "") if clusterMean > hiThreshold { - elekLog.Log(CONSOLE, - log.InfoLevel, "Need to cap a node") + elekLog.Log(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,12 +152,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elekLog.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), - "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithField("Avg. Wattage", + fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)).Logf(CONSOLE, log.InfoLevel, "Capping Victim %s", victim.Host) if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elekLog.Log(CONSOLE, - log.ErrorLevel, - "Error capping host") + elekLog.Log(CONSOLE, log.ErrorLevel, "Error capping host") } break // Only cap one machine at at time. } @@ -167,8 +168,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh orderCapped = orderCapped[:len(orderCapped)-1] cappedHosts[host] = false // User RAPL package to send uncap. - log.Printf("Uncapping host %s", host) - elekLog.WithFields(log.Fields{"Uncapped host": host}).Log(CONSOLE, log.InfoLevel, "") + elekLog.Logf(CONSOLE, log.InfoLevel, "Uncapping host %s", host) if err := rapl.Cap(host, "rapl", 100); err != nil { elekLog.Log(CONSOLE, log.ErrorLevel, "Error capping host") } diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 2de1bf7..6102c39 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -126,8 +126,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Host": indexToHost[powerIndex], + "Power": fmt.Sprintf("%f", power*pcp.RAPLUnits), + }).Log(CONSOLE, log.InfoLevel, "") totalPower += power } clusterPower := totalPower * pcp.RAPLUnits @@ -137,15 +139,16 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Total power": fmt.Sprintf("%f %d Sec", clusterPower, clusterPowerHist.Len()), + "Avg": fmt.Sprintf("%f", clusterMean), + }).Log(CONSOLE, log.InfoLevel, "") if clusterMean >= hiThreshold { elekLog.Log(CONSOLE, log.InfoLevel, "Need to cap a node") + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of capped victims %v", cappedVictims) + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of victims to uncap %v", orderCappedVictims) - elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(CONSOLE, log.InfoLevel, "") - - elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(CONSOLE, log.InfoLevel, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -173,7 +176,7 @@ 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.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "Error capping host %s", victims[i].Host) } else { elekLog.Logf(CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) @@ -200,11 +203,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "Error capping host %s", alreadyCappedHosts[i]) } else { // Successful cap - elekLog.Logf(CONSOLE, log.InfoLevel, - "Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) + elekLog.Logf(CONSOLE, log.InfoLevel, "Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { // Deleting victim from cappedVictims. @@ -234,8 +236,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } else if clusterMean < loThreshold { elekLog.Log(CONSOLE, log.InfoLevel, "Need to uncap a node") - elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(CONSOLE, log.InfoLevel, "") - elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of capped victims - %v", cappedVictims) + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of victims to uncap - %v", orderCappedVictims) if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -246,7 +248,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elekLog.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "Error uncapping host %s", hostToUncap) } else { // Successful uncap elekLog.Logf(CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) diff --git a/scheduler.go b/scheduler.go index 3b7261f..89f77e3 100644 --- a/scheduler.go +++ b/scheduler.go @@ -285,8 +285,10 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(CONSOLE, - log.ErrorLevel, "Framework stopped ") + elekLog.WithFields(log.Fields{ + "status": status.String(), + "error": err.Error(), + }).Log(CONSOLE, log.ErrorLevel, "Framework stopped ") } elekLog.Log(CONSOLE, log.InfoLevel, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index f25a256..eadf1f3 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -250,30 +250,34 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { if ts == nil { - elekLog.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.InfoLevel, "TASKS STARTING...") + elekLog.WithField("host", offer.GetHostname()).Log(CONSOLE, log.InfoLevel, "TASKS STARTING...") } else { - elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), - "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.InfoLevel, "TASK STARTING... ") + elekLog.WithFields(log.Fields{ + "task": ts.Name, + "Instance": fmt.Sprintf("%d", *ts.Instances), + "host": offer.GetHostname(), + }).Log(CONSOLE, log.InfoLevel, "TASK STARTING... ") } } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - elekLog.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(CONSOLE, log.InfoLevel, "Watts considered for ") + elekLog.WithFields(log.Fields{ + "task": ts.Name, + "host": host, + "Watts": fmt.Sprintf("%f", wattsToConsider), + }).Log(CONSOLE, log.InfoLevel, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - elekLog.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(CONSOLE, - log.InfoLevel, "") + elekLog.WithField("numOffers", fmt.Sprintf("%d", len(offers))).Log(CONSOLE, log.InfoLevel, "Resource offers received") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - elekLog.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, - log.WarnLevel, "No tasks left to schedule ") + elekLog.Logf(CONSOLE, log.WarnLevel, "DECLINING OFFER for host %s. No tasks left to schedule", offer.GetHostname()) } func (s *BaseScheduler) LogNumberOfRunningTasks() { - elekLog.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(CONSOLE, - log.InfoLevel, "") + elekLog.Logf(CONSOLE, log.InfoLevel, "Number of tasks still running %d", s.tasksRunning) } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { @@ -283,12 +287,11 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(CONSOLE, - log.InfoLevel, "") + elekLog.WithField("Tasks", buffer.String()).Log(CONSOLE, log.InfoLevel, "Colocated with") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elekLog.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(SCHED_TRACE, log.InfoLevel, "") + elekLog.WithField(offer.GetHostname(), taskToSchedule.GetTaskId().GetValue()).Log(SCHED_TRACE, log.InfoLevel, "") } func (s *BaseScheduler) LogTerminateScheduler() { @@ -299,47 +302,48 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(CONSOLE, + elekLog.WithField("Offer Resources", buffer.String()).Log(CONSOLE, log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(CONSOLE, - log.ErrorLevel, "OFFER RESCINDED") + elekLog.WithField("OfferID", *offerID.Value).Log(CONSOLE, log.ErrorLevel, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(CONSOLE, - log.ErrorLevel, "SLAVE LOST") + elekLog.WithField("SlaveID", *slaveID.Value).Log(CONSOLE, log.ErrorLevel, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - elekLog.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") + elekLog.WithFields(log.Fields{ + "ExecutorID": executorID, + "SlaveID": slaveID, + }).Log(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(CONSOLE, - log.InfoLevel, message) + elekLog.Logf(CONSOLE, log.InfoLevel, "Received Framework message from executor %v", executorID) } func (s *BaseScheduler) LogMesosError(err string) { - elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(CONSOLE, - log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "MESOS CONSOLE %v", err) } func (s *BaseScheduler) LogElectronError(err error) { - elekLog.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "ELEKTRON CONSOLE %v", err) } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - elekLog.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") + elekLog.WithFields(log.Fields{ + "frameworkID": frameworkID, + "master": fmt.Sprintf("%v", masterInfo), + }).Log(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(CONSOLE, - log.InfoLevel, "Framework re-registered") + elekLog.WithField("master", fmt.Sprintf("%v", masterInfo)).Log(CONSOLE, log.InfoLevel, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { @@ -355,12 +359,15 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(CONSOLE, level, "Task Status received") + elekLog.WithFields(log.Fields{ + "task": *status.TaskId.Value, + "state": NameFor(status.State), + }).Log(CONSOLE, level, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.WithFields(log.Fields{"Name": name}).Log(SPS, log.InfoLevel, "") + elekLog.WithField("Name", name).Log(SPS, log.InfoLevel, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -369,10 +376,13 @@ 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.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(SCHED_WINDOW, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Window size": fmt.Sprintf("%d", s.schedWindowSize), + "Name": name, + }).Log(SCHED_WINDOW, log.InfoLevel, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") + elekLog.WithField("Overhead in microseconds", fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)).Log(CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 802c7a7..f335f38 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -36,7 +36,7 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for _, task := range tasks { - elekLog.WithFields(log.Fields{"Task": task}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithField("Task", fmt.Sprintf("%v", task)).Log(CONSOLE, log.InfoLevel, "") } elekLog.Log(CONSOLE, log.InfoLevel, "---------------------") diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index dddcb72..40f949c 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -90,8 +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.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(CONSOLE, - log.InfoLevel, "Switching... ") + elekLog.WithField("Task Distribution", fmt.Sprintf("%f", taskDist)).Log(CONSOLE, log.InfoLevel, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. @@ -219,9 +218,11 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { switchToPolicyName = switchBasedOn[baseSchedRef.schedPolSwitchCriteria](baseSchedRef) } else { // We continue working with the currently deployed scheduling policy. - log.Println("Continuing with the current scheduling policy...") - log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, - baseSchedRef.schedWindowSize) + elekLog.Log(CONSOLE, log.InfoLevel, "Continuing with the current scheduling policy...") + elekLog.WithFields(log.Fields{ + "TasksScheduled": fmt.Sprintf("%d", bsps.numTasksScheduled), + "SchedWindowSize": fmt.Sprintf("%d", baseSchedRef.schedWindowSize), + }).Log(CONSOLE, log.InfoLevel, "") return } } @@ -233,9 +234,11 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { bsps.numTasksScheduled = 0 } else { // We continue working with the currently deployed scheduling policy. - log.Println("Continuing with the current scheduling policy...") - log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, - baseSchedRef.schedWindowSize) + elekLog.Log(CONSOLE, log.InfoLevel, "Continuing with the current scheduling policy...") + elekLog.WithFields(log.Fields{ + "TasksScheduled": fmt.Sprintf("%d", bsps.numTasksScheduled), + "SchedWindowSize": fmt.Sprintf("%d", baseSchedRef.schedWindowSize), + }).Log(CONSOLE, log.InfoLevel, "") return } } diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 69abec7..15919c3 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -90,13 +90,15 @@ 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.WithFields(log.Fields{"Adding host": host}).Log(CONSOLE, log.InfoLevel, "New host detected") + elekLog.WithField("host", host).Log(CONSOLE, log.InfoLevel, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(CONSOLE, - log.InfoLevel, "Registering the power class...") + elekLog.WithFields(log.Fields{ + "host": host, + "PowerClass": class, + }).Log(CONSOLE, log.InfoLevel, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) From f084eddd68fd824fb0b0114b99890cb913164687 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 22:49:19 -0500 Subject: [PATCH 6/7] passing strings instead of pointers as values. --- schedulers/base.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/schedulers/base.go b/schedulers/base.go index eadf1f3..699ad90 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -316,8 +316,8 @@ func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { elekLog.WithFields(log.Fields{ - "ExecutorID": executorID, - "SlaveID": slaveID, + "ExecutorID": *executorID.Value, + "SlaveID": *slaveID.Value, }).Log(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } @@ -337,7 +337,7 @@ func (s *BaseScheduler) LogElectronError(err error) { func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { elekLog.WithFields(log.Fields{ - "frameworkID": frameworkID, + "frameworkID": *frameworkID.Value, "master": fmt.Sprintf("%v", masterInfo), }).Log(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } From 5a53998942714c1606c7714621d4017c269826ce Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 23:02:08 -0500 Subject: [PATCH 7/7] fixed visibility of structs. --- logging/clsfnTaskDistrOverheadLogger.go | 16 ++++++++-------- logging/consoleLogger.go | 16 ++++++++-------- ...ElektronFormatter.go => elektronFormatter.go} | 4 ++-- logging/logger.go | 16 ++++++++-------- logging/loggerConfig.go | 6 +++--- logging/pcpLogger.go | 16 ++++++++-------- logging/schedPolicySwitchLogger.go | 16 ++++++++-------- logging/schedTraceLogger.go | 16 ++++++++-------- logging/schedWindowLogger.go | 16 ++++++++-------- 9 files changed, 61 insertions(+), 61 deletions(-) rename logging/{ElektronFormatter.go => elektronFormatter.go} (87%) diff --git a/logging/clsfnTaskDistrOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go index 2d2777b..69e2ab0 100644 --- a/logging/clsfnTaskDistrOverheadLogger.go +++ b/logging/clsfnTaskDistrOverheadLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type ClsfnTaskDistrOverheadLogger struct { +type clsfnTaskDistrOverheadLogger struct { baseElektronLogger } -func NewClsfnTaskDistrOverheadLogger( - config *LoggerConfig, +func newClsfnTaskDistrOverheadLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *ClsfnTaskDistrOverheadLogger { + logDir *logDirectory) *clsfnTaskDistrOverheadLogger { - cLog := &ClsfnTaskDistrOverheadLogger{ + cLog := &clsfnTaskDistrOverheadLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -42,7 +42,7 @@ func NewClsfnTaskDistrOverheadLogger( cLog.createLogFile(prefix) return cLog } -func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { +func (cLog clsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { if cLog.logType == logType { if cLog.isEnabled() { if cLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa } } -func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (cLog clsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if cLog.logType == logType { if cLog.isEnabled() { if cLog.config.AllowOnConsole { @@ -83,7 +83,7 @@ func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF } } -func (cLog *ClsfnTaskDistrOverheadLogger) createLogFile(prefix string) { +func (cLog *clsfnTaskDistrOverheadLogger) createLogFile(prefix string) { if cLog.isEnabled() { filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") diff --git a/logging/consoleLogger.go b/logging/consoleLogger.go index ab449b9..2bc7666 100644 --- a/logging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -8,20 +8,20 @@ import ( "strings" ) -type ConsoleLogger struct { +type consoleLogger struct { baseElektronLogger MinLogLevel string } -func NewConsoleLogger( - config *LoggerConfig, +func newConsoleLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *ConsoleLogger { + logDir *logDirectory) *consoleLogger { - cLog := &ConsoleLogger{ + cLog := &consoleLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -46,7 +46,7 @@ func NewConsoleLogger( return cLog } -func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { +func (cLog consoleLogger) Log(logType int, level log.Level, message string) { if logType <= cLog.logType { if cLog.isEnabled() { cLog.logger.SetOutput(os.Stdout) @@ -65,7 +65,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{}) { +func (cLog consoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if logType <= cLog.logType { if cLog.isEnabled() { cLog.logger.SetOutput(os.Stdout) @@ -83,7 +83,7 @@ func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string } } -func (cLog *ConsoleLogger) createLogFile(prefix string) { +func (cLog *consoleLogger) createLogFile(prefix string) { // Create log file for the type if it is enabled. if cLog.isEnabled() { filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") diff --git a/logging/ElektronFormatter.go b/logging/elektronFormatter.go similarity index 87% rename from logging/ElektronFormatter.go rename to logging/elektronFormatter.go index 1ea7ea0..8116110 100644 --- a/logging/ElektronFormatter.go +++ b/logging/elektronFormatter.go @@ -8,11 +8,11 @@ import ( log "github.com/sirupsen/logrus" ) -type ElektronFormatter struct { +type elektronFormatter struct { TimestampFormat string } -func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { +func (f elektronFormatter) Format(entry *log.Entry) ([]byte, error) { var b *bytes.Buffer if entry.Buffer != nil { diff --git a/logging/logger.go b/logging/logger.go index 413fffb..b8c65d1 100644 --- a/logging/logger.go +++ b/logging/logger.go @@ -10,8 +10,8 @@ import ( . "github.com/spdfg/elektron/logging/types" ) -// var config LoggerConfig -var formatter ElektronFormatter +// var config loggerConfig +var formatter elektronFormatter var elektronLoggerInstance elektronLogger type elektronLogger interface { @@ -103,12 +103,12 @@ func BuildLogger(prefix string, logConfigFilename string) error { 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) + 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) head.setNext(cLog) cLog.setNext(pLog) diff --git a/logging/loggerConfig.go b/logging/loggerConfig.go index cbf3cbc..49297cc 100644 --- a/logging/loggerConfig.go +++ b/logging/loggerConfig.go @@ -7,7 +7,7 @@ import ( "io/ioutil" ) -type LoggerConfig struct { +type loggerConfig struct { SchedTraceConfig struct { Enabled bool `yaml:"enabled"` FilenameExtension string `yaml:"filenameExtension"` @@ -48,14 +48,14 @@ type LoggerConfig struct { Format []string `yaml:"format"` } -func GetConfig(logConfigFilename string) (*LoggerConfig, error) { +func GetConfig(logConfigFilename string) (*loggerConfig, error) { yamlFile, err := ioutil.ReadFile(logConfigFilename) if err != nil { return nil, errors.Wrap(err, "failed to read log config file") } - c := &LoggerConfig{} + c := &loggerConfig{} err = yaml.Unmarshal(yamlFile, c) if err != nil { log.Fatalf("Error in unmarshalling yaml: %v", err) diff --git a/logging/pcpLogger.go b/logging/pcpLogger.go index 52c1fbe..7767f4d 100644 --- a/logging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type PCPLogger struct { +type pcpLogger struct { baseElektronLogger } -func NewPCPLogger( - config *LoggerConfig, +func newPCPLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *PCPLogger { + logDir *logDirectory) *pcpLogger { - pLog := &PCPLogger{ + pLog := &pcpLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewPCPLogger( return pLog } -func (pLog PCPLogger) Log(logType int, level log.Level, message string) { +func (pLog pcpLogger) Log(logType int, level log.Level, message string) { if pLog.logType == logType { if pLog.isEnabled() { if pLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (pLog PCPLogger) Log(logType int, level log.Level, message string) { } } -func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (pLog pcpLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if pLog.logType == logType { if pLog.isEnabled() { if pLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, ar } } -func (pLog *PCPLogger) createLogFile(prefix string) { +func (pLog *pcpLogger) createLogFile(prefix string) { if pLog.isEnabled() { filename := strings.Join([]string{prefix, pLog.config.FilenameExtension}, "") dirName := pLog.logDir.getDirName() diff --git a/logging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go index 98a5094..a112db3 100644 --- a/logging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type SchedPolicySwitchLogger struct { +type schedPolicySwitchLogger struct { baseElektronLogger } -func NewSchedPolicySwitchLogger( - config *LoggerConfig, +func newSchedPolicySwitchLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *SchedPolicySwitchLogger { + logDir *logDirectory) *schedPolicySwitchLogger { - sLog := &SchedPolicySwitchLogger{ + sLog := &schedPolicySwitchLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewSchedPolicySwitchLogger( return sLog } -func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) { +func (sLog schedPolicySwitchLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message st } } -func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (sLog schedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr } } -func (sLog *SchedPolicySwitchLogger) createLogFile(prefix string) { +func (sLog *schedPolicySwitchLogger) createLogFile(prefix string) { if sLog.isEnabled() { filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() diff --git a/logging/schedTraceLogger.go b/logging/schedTraceLogger.go index 292dff8..ac08f27 100644 --- a/logging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type SchedTraceLogger struct { +type schedTraceLogger struct { baseElektronLogger } -func NewSchedTraceLogger( - config *LoggerConfig, +func newSchedTraceLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *SchedTraceLogger { + logDir *logDirectory) *schedTraceLogger { - sLog := &SchedTraceLogger{ + sLog := &schedTraceLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewSchedTraceLogger( return sLog } -func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { +func (sLog schedTraceLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { } } -func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (sLog schedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString str } } -func (sLog *SchedTraceLogger) createLogFile(prefix string) { +func (sLog *schedTraceLogger) createLogFile(prefix string) { if sLog.isEnabled() { filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() diff --git a/logging/schedWindowLogger.go b/logging/schedWindowLogger.go index 9627e5e..5a1ce1a 100644 --- a/logging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type SchedWindowLogger struct { +type schedWindowLogger struct { baseElektronLogger } -func NewSchedWindowLogger( - config *LoggerConfig, +func newSchedWindowLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *SchedWindowLogger { + logDir *logDirectory) *schedWindowLogger { - sLog := &SchedWindowLogger{ + sLog := &schedWindowLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewSchedWindowLogger( return sLog } -func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) { +func (sLog schedWindowLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -64,7 +64,7 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) } } -func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (sLog schedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString st } } -func (sLog *SchedWindowLogger) createLogFile(prefix string) { +func (sLog *schedWindowLogger) createLogFile(prefix string) { if sLog.isEnabled() { filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName()