From 6fb0e4a3fe63e76982817bbdb2dcb8b5b80af7b1 Mon Sep 17 00:00:00 2001
From: Pradyumna Kaushik <pkaushi1@binghamton.edu>
Date: Thu, 5 Dec 2019 21:32:37 -0500
Subject: [PATCH] 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("<CPU: %f, RAM: %f, Watts: %f>", offerResources...))
- elekLog.ElektronLogger.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE,
+ elekLog.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE,
log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task")
}
func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) {
- elekLog.ElektronLogger.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE,
+ elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE,
log.ErrorLevel, "OFFER RESCINDED")
}
func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) {
- elekLog.ElektronLogger.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE,
+ elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE,
log.ErrorLevel, "SLAVE LOST")
}
func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) {
- elekLog.ElektronLogger.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST")
+ elekLog.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST")
}
func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID,
slaveID *mesos.SlaveID, message string) {
- elekLog.ElektronLogger.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE,
+ elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE,
log.InfoLevel, message)
}
func (s *BaseScheduler) LogMesosError(err string) {
- elekLog.ElektronLogger.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE,
+ elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE,
log.ErrorLevel, "")
}
func (s *BaseScheduler) LogElectronError(err error) {
- elekLog.ElektronLogger.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
+ elekLog.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "")
}
func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID,
masterInfo *mesos.MasterInfo) {
- elekLog.ElektronLogger.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!")
+ elekLog.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!")
}
func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) {
- elekLog.ElektronLogger.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE,
+ elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE,
log.InfoLevel, "Framework re-registered")
}
func (s *BaseScheduler) LogDisconnected() {
- elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master")
+ elekLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master")
}
func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) {
@@ -356,12 +355,12 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) {
default:
level = log.InfoLevel
}
- elekLog.ElektronLogger.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received")
+ elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received")
}
func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) {
logSPS := func() {
- elekLog.ElektronLogger.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "")
+ elekLog.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "")
}
if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) {
logSPS()
@@ -370,10 +369,10 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy
}
// Logging the size of the scheduling window and the scheduling policy
// that is going to schedule the tasks in the scheduling window.
- elekLog.ElektronLogger.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "")
+ elekLog.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "")
}
func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) {
// Logging the overhead in microseconds.
- elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "")
+ elekLog.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "")
}
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) {