From 1fd6c7e4f4950fc556accb27c5b23233bc04a924 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 13 Nov 2019 11:19:04 -0500 Subject: [PATCH] Initial elektromLogging library --- elektronLogging/ElektronFormatter.go | 53 +++++++++++++++ .../clsfnTaskDistOverheadLogger.go | 53 +++++++++++++++ elektronLogging/consoleLogger.go | 48 +++++++++++++ elektronLogging/createLogDir.go | 38 +++++++++++ elektronLogging/logger.go | 48 +++++++++++++ elektronLogging/loggerChain.go | 37 ++++++++++ elektronLogging/loggerConfig.go | 68 +++++++++++++++++++ elektronLogging/pcpLogger.go | 52 ++++++++++++++ elektronLogging/schedPolicySwitchLogger.go | 53 +++++++++++++++ elektronLogging/schedTraceLogger.go | 53 +++++++++++++++ elektronLogging/schedWindowLogger.go | 51 ++++++++++++++ elektronLogging/types/types.go | 17 +++++ 12 files changed, 571 insertions(+) create mode 100644 elektronLogging/ElektronFormatter.go create mode 100644 elektronLogging/clsfnTaskDistOverheadLogger.go create mode 100644 elektronLogging/consoleLogger.go create mode 100644 elektronLogging/createLogDir.go create mode 100644 elektronLogging/logger.go create mode 100644 elektronLogging/loggerChain.go create mode 100644 elektronLogging/loggerConfig.go create mode 100644 elektronLogging/pcpLogger.go create mode 100644 elektronLogging/schedPolicySwitchLogger.go create mode 100644 elektronLogging/schedTraceLogger.go create mode 100644 elektronLogging/schedWindowLogger.go create mode 100644 elektronLogging/types/types.go diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go new file mode 100644 index 0000000..a929e56 --- /dev/null +++ b/elektronLogging/ElektronFormatter.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + "bytes" + "fmt" + "strings" + "github.com/fatih/color" + log "github.com/sirupsen/logrus" +) + +type ElektronFormatter struct { + TimestampFormat string +} + +func (f ElektronFormatter) getColor(entry *log.Entry) *color.Color { + switch entry.Level { + case log.InfoLevel: + return color.New(color.FgGreen, color.Bold) + case log.WarnLevel: + return color.New(color.FgYellow, color.Bold) + case log.ErrorLevel: + return color.New(color.FgRed, color.Bold) + case log.FatalLevel: + return color.New(color.FgRed, color.Bold) + default: + return color.New(color.FgWhite, color.Bold) + } +} +func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { + var b *bytes.Buffer + + if entry.Buffer != nil { + b = entry.Buffer + } else { + b = &bytes.Buffer{} + } + + levelColor := f.getColor(entry) + level := levelColor.Sprintf("[%s]:",strings.ToUpper(entry.Level.String())) + message := fmt.Sprintf("%s %s %s ",level,entry.Time.Format(f.TimestampFormat), entry.Message) + + var formattedFields []string + for key, value := range entry.Data { + formattedFields = append(formattedFields, + strings.Join([]string{key, fmt.Sprintf("%s", value)}, "=")) + } + + + b.WriteString(message) + b.WriteString(strings.Join(formattedFields, ", ")) + b.WriteByte('\n') + return b.Bytes(), nil +} diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go new file mode 100644 index 0000000..76191e7 --- /dev/null +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + //"fmt" + "os" + logrus "github.com/sirupsen/logrus" + data "gitlab.com/spdf/elektron/elektronLogging/data" +) + +type ClsfnTaskDistOverheadLogger struct { + LoggerImpl +} + +func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOverheadLogger { + cLog := new(ClsfnTaskDistOverheadLogger) + cLog.Type = logType + cLog.SetLogFile(prefix) + return cLog +} + +func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level logrus.Level, logData data.LogData,message string) { + if cLog.Type == logType { + + logFields := cloneFields(logData) + + log.SetLevel(level) + + if cLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logFields).Println(message) + } + + log.SetOutput(cLog.LogFileName) + log.WithFields(logFields).Println(message) + } + if cLog.next != nil { + cLog.next.Log(logType, level, logData, message) + } +} + +func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { + + tskDistLogPrefix := prefix + config.TaskDistConfig.FilenameExtension + if logDir != "" { + tskDistLogPrefix = logDir + "/" + tskDistLogPrefix + } + if logFile, err := os.Create(tskDistLogPrefix); err != nil { + logrus.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFileName = logFile + cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole + } +} diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go new file mode 100644 index 0000000..b053e42 --- /dev/null +++ b/elektronLogging/consoleLogger.go @@ -0,0 +1,48 @@ +package elektronLogging + +import ( + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type ConsoleLogger struct { + LoggerImpl +} + +func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { + cLog := new(ConsoleLogger) + cLog.Type = logType + cLog.SetLogFile(prefix) + return cLog +} +func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if logType <= cLog.Type { + + //logFields := cloneFields(logData) + log.SetLevel(level) + + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + + log.SetOutput(cLog.LogFileName) + log.WithFields(logData).Println(message) + } + if cLog.next != nil { + cLog.next.Log(logType, level, logData, message) + } +} + +func (cLog *ConsoleLogger) SetLogFile(prefix string) { + + consoleLogPrefix := prefix + config.ConsoleConfig.FilenameExtension + if logDir != "" { + consoleLogPrefix = logDir + "/" + consoleLogPrefix + } + if logFile, err := os.Create(consoleLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFileName = logFile + cLog.AllowOnConsole = true + } +} diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go new file mode 100644 index 0000000..b365396 --- /dev/null +++ b/elektronLogging/createLogDir.go @@ -0,0 +1,38 @@ +package elektronLogging + +import ( + "os" + "strconv" + "time" + logrus "github.com/sirupsen/logrus" +) + +var logDir string + +func GetLogDir(startTime time.Time, prefix string) { + if logDir == "" { + logDir = createLogDir(prefix, startTime) + } +} + +func createLogDir(prefix string, startTime time.Time) string { + // Creating directory to store all logs for this run + logDirName := "./" + prefix + strconv.Itoa(startTime.Year()) + logDirName += "-" + logDirName += startTime.Month().String() + logDirName += "-" + logDirName += strconv.Itoa(startTime.Day()) + logDirName += "_" + logDirName += strconv.Itoa(startTime.Hour()) + logDirName += "-" + logDirName += strconv.Itoa(startTime.Minute()) + logDirName += "-" + logDirName += strconv.Itoa(startTime.Second()) + if _, err := os.Stat(logDirName); os.IsNotExist(err) { + os.Mkdir(logDirName, 0755) + } else { + logrus.Println("Unable to create log directory: ", err) + logDirName = "" + } + return logDirName +} diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go new file mode 100644 index 0000000..6eef62e --- /dev/null +++ b/elektronLogging/logger.go @@ -0,0 +1,48 @@ +package elektronLogging + +import ( + "time" + "fmt" + "strconv" + . "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" +) + +var config LoggerConfig +var logger *log.Logger +var formatter ElektronFormatter +//var logDir string + +func BuildLogger() *LoggerImpl { + + config.GetConfig() + startTime := time.Now() + formatter.TimestampFormat = "2006-01-02 15:04:05" + GetLogDir(startTime, "_") + + prefix := fmt.Sprintf("_%s%s%s%s%s",startTime.Month().String(),strconv.Itoa(startTime.Day()), + strconv.Itoa(startTime.Hour()),strconv.Itoa(startTime.Minute()),strconv.Itoa(startTime.Second())) + + logger = log.New() + logger.SetFormatter(&formatter) + + head := new(LoggerImpl) + cLog := NewConsoleLogger(CONSOLE,prefix) + pLog := NewPcpLogger(PCP,prefix) + schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) + spsLog := NewSchedPolicySwitchLogger(SPS, prefix) + schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) + tskDistLog := NewClsfnTaskDistOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix) + + head.SetNext(cLog) + cLog.SetNext(pLog) + pLog.SetNext(schedTraceLog) + schedTraceLog.SetNext(spsLog) + + spsLog.SetNext(schedWindowLog) + schedWindowLog.SetNext(tskDistLog) + + return head +} + +var ElektronLog = BuildLogger() diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go new file mode 100644 index 0000000..baac3d5 --- /dev/null +++ b/elektronLogging/loggerChain.go @@ -0,0 +1,37 @@ +package elektronLogging + +import ( + "os" + //data "github.com/spdfg/elektron/elektronLogging/data" + log "github.com/sirupsen/logrus" +) + +type Logger interface { + SetNext(logType Logger) + Log(logType int, level log.Level, logData log.Fields, message string) + SetLogFile(prefix string) +} +type LoggerImpl struct { + Type int + AllowOnConsole bool + LogFileName *os.File + next Logger +} + +func (l *LoggerImpl) SetNext(logType Logger) { + l.next = logType +} + +func (l *LoggerImpl) Log(logType int, level log.Level, logData log.Fields, message string) { + if l.next != nil { + l.next.Log(logType, level, logData, message) + } +} + +/*func cloneFields(logData data.LogData) log.Fields { + var newMap = make(log.Fields) + for k,v := range logData { + newMap[k] = v + } + return newMap +}*/ diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go new file mode 100644 index 0000000..8d67a9f --- /dev/null +++ b/elektronLogging/loggerConfig.go @@ -0,0 +1,68 @@ +package elektronLogging +import ( + "gopkg.in/yaml.v2" + "io/ioutil" + log "github.com/sirupsen/logrus" + elekEnv "gitlab.com/spdf/elektron/environment" +) + +type LoggerConfig struct { + + SchedTraceConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"schedTrace"` + + PCPConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"pcp"` + + ConsoleConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + MinLogLevel string `yaml:"minLogLevel"` + } `yaml:"console"` + + SPSConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"sps"` + + TaskDistConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"clsfnTaskDistOverhead"` + + SchedWindowConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"schedWindow"` + + Format[] string `yaml:"format"` +} + +func (c *LoggerConfig) GetConfig() *LoggerConfig { + + yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) + if err != nil { + log.Printf("yamlFile.Get err #%v ", err) + } + err = yaml.Unmarshal(yamlFile, c) + if err != nil { + log.Fatalf("Unmarshal: %v", err) + } + + return c +} diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go new file mode 100644 index 0000000..1e0dad3 --- /dev/null +++ b/elektronLogging/pcpLogger.go @@ -0,0 +1,52 @@ +package elektronLogging + +import ( + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type PcpLogger struct { + LoggerImpl +} + +func NewPcpLogger(logType int, prefix string) *PcpLogger { + pLog := new(PcpLogger) + pLog.Type = logType + pLog.SetLogFile(prefix) + return pLog +} + +func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if pLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + + if pLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(pLog.LogFileName) + log.WithFields(logData).Println(message) + } + if pLog.next != nil { + pLog.next.Log(logType, level, logData, message) + } +} + +func (plog *PcpLogger) SetLogFile(prefix string) { + + pcpLogPrefix := prefix + config.PCPConfig.FilenameExtension + if logDir != "" { + pcpLogPrefix = logDir + "/" + pcpLogPrefix + } + if logFile, err := os.Create(pcpLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + plog.LogFileName = logFile + plog.AllowOnConsole = config.PCPConfig.AllowOnConsole + } +} diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go new file mode 100644 index 0000000..3f4e8f7 --- /dev/null +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + //"fmt" + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type SchedPolicySwitchLogger struct { + LoggerImpl +} + +func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLogger { + sLog := new(SchedPolicySwitchLogger) + sLog.Type = logType + sLog.SetLogFile(prefix) + return sLog +} + +func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if sLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + + if sLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(sLog.LogFileName) + log.WithFields(logData).Println(message) + } + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } +} + +func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { + + spsLogPrefix := prefix + config.SPSConfig.FilenameExtension + if logDir != "" { + spsLogPrefix = logDir + "/" + spsLogPrefix + } + if logFile, err := os.Create(spsLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + } +} diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go new file mode 100644 index 0000000..e117057 --- /dev/null +++ b/elektronLogging/schedTraceLogger.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + //"fmt" + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type SchedTraceLogger struct { + LoggerImpl +} + +func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { + sLog := new(SchedTraceLogger) + sLog.Type = logType + sLog.SetLogFile(prefix) + return sLog +} + +func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if sLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + + if sLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(sLog.LogFileName) + log.WithFields(logData).Println(message) + } + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } +} + +func (sLog *SchedTraceLogger) SetLogFile(prefix string) { + + schedTraceLogPrefix := prefix + config.SchedTraceConfig.FilenameExtension + if logDir != "" { + schedTraceLogPrefix = logDir + "/" + schedTraceLogPrefix + } + if logFile, err := os.Create(schedTraceLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + } +} diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go new file mode 100644 index 0000000..e5175e3 --- /dev/null +++ b/elektronLogging/schedWindowLogger.go @@ -0,0 +1,51 @@ +package elektronLogging + +import ( + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type SchedWindowLogger struct { + LoggerImpl +} + +func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { + sLog := new(SchedWindowLogger) + sLog.Type = logType + sLog.SetLogFile(prefix) + return sLog +} + +func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if sLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + if sLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(sLog.LogFileName) + log.WithFields(logData).Println(message) + } + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } +} + +func (sLog *SchedWindowLogger) SetLogFile(prefix string) { + + schedWindowLogPrefix := prefix + config.SchedWindowConfig.FilenameExtension + if logDir != "" { + schedWindowLogPrefix = logDir + "/" + schedWindowLogPrefix + } + if logFile, err := os.Create(schedWindowLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + } +} diff --git a/elektronLogging/types/types.go b/elektronLogging/types/types.go new file mode 100644 index 0000000..3ff94e9 --- /dev/null +++ b/elektronLogging/types/types.go @@ -0,0 +1,17 @@ +package elektronLogging + +import "github.com/fatih/color" + +const ( + ERROR = iota + WARNING = iota + GENERAL = iota + SUCCESS = iota + CONSOLE = iota + PCP = iota + SCHED_TRACE = iota + SPS = iota + SCHED_WINDOW = iota + CLSFN_TASKDIST_OVERHEAD = iota +) +