Initial elektromLogging library

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

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

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

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

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()

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
+}*/

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

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

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

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

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

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
+)
+