spdf/elektron
Archived
1
0
Fork 0
Code Issues 4 Pull requests 1 Projects Releases Packages Wiki Activity

Added functions to logging library

Browse source 
Added Logf() and WithFields() functions.
Logf() for logging formatted messages.
WithFields() for handling optional log fields.
This commit is contained in:
balandi1 2019-12-04 13:16:48 -05:00
parent b9592ed31c
commit bedfa52d7a
18 changed files with 319 additions and 260 deletions
Download patch file Download diff file Expand all files Collapse all files

38
elektronLogging/clsfnTaskDistOverheadLogger.go
View file

@ -12,29 +12,53 @@ type ClsfnTaskDistrOverheadLogger struct {
LoggerImpl
}
func NewClsfnTaskDistrOverheadLogger(logType int, prefix string) *ClsfnTaskDistrOverheadLogger {
func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string) *ClsfnTaskDistrOverheadLogger {
cLog := &ClsfnTaskDistrOverheadLogger{}
cLog.Type = logType
cLog.CreateLogFile(prefix)
cLog.next = nil
cLog.baseLogData = b
return cLog
}
func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) {
func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) {
if config.TaskDistrConfig.Enabled {
if cLog.Type == logType {
logger.SetLevel(level)
if cLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(logData).Println(message)
logger.WithFields(cLog.data).Log(level, message)
}
logger.SetOutput(cLog.LogFile)
logger.WithFields(logData).Println(message)
logger.WithFields(cLog.data).Log(level, message)
}
if cLog.next != nil {
cLog.next.Log(logType, level, logData, message)
cLog.next.Log(logType, level, message)
} else {
// Clearing the fields.
cLog.resetFields()
}
}
}
func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if config.TaskDistrConfig.Enabled {
if cLog.Type == logType {
if cLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
}
logger.SetOutput(cLog.LogFile)
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
}
if cLog.next != nil {
cLog.next.Logf(logType, level, msgFmtString, args...)
} else {
// Clearing the fields.
cLog.resetFields()
}
}
}

36
elektronLogging/consoleLogger.go
View file

@ -12,26 +12,48 @@ type ConsoleLogger struct {
LoggerImpl
}
func NewConsoleLogger(logType int, prefix string) *ConsoleLogger {
func NewConsoleLogger(b *baseLogData, logType int, prefix string) *ConsoleLogger {
cLog := &ConsoleLogger{}
cLog.Type = logType
cLog.CreateLogFile(prefix)
cLog.next = nil
cLog.baseLogData = b
return cLog
}
func (cLog ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) {
func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) {
if config.ConsoleConfig.Enabled {
if logType <= cLog.Type {
logger.SetLevel(level)
logger.SetOutput(os.Stdout)
logger.WithFields(logData).Println(message)
logger.WithFields(cLog.data).Log(level, message)
logger.SetOutput(cLog.LogFile)
logger.WithFields(logData).Println(message)
logger.WithFields(cLog.data).Log(level, message)
}
if cLog.next != nil {
cLog.next.Log(logType, level, logData, message)
cLog.next.Log(logType, level, message)
} else {
// Clearing the fields.
cLog.resetFields()
}
}
}
func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if config.ConsoleConfig.Enabled {
if logType <= cLog.Type {
logger.SetOutput(os.Stdout)
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
logger.SetOutput(cLog.LogFile)
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
}
if cLog.next != nil {
cLog.next.Logf(logType, level, msgFmtString, args...)
} else {
// Clearing the fields.
cLog.resetFields()
}
}
}

19
elektronLogging/logger.go
View file

@ -12,7 +12,7 @@ import (
var config LoggerConfig
var logger *log.Logger
var formatter ElektronFormatter
var ElektronLogger *ConsoleLogger
var ElektronLogger *LoggerImpl
var logDir logDirectory
func BuildLogger(prefix string, logConfigFilename string) {
@ -35,18 +35,21 @@ func BuildLogger(prefix string, logConfigFilename string) {
}
// Create a chain of loggers.
cLog := NewConsoleLogger(CONSOLE, prefix)
pLog := NewPCPLogger(PCP, prefix)
schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix)
spsLog := NewSchedPolicySwitchLogger(SPS, prefix)
schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix)
tskDistLog := NewClsfnTaskDistrOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix)
b := &baseLogData{data: log.Fields{}}
head := &LoggerImpl{baseLogData: b}
cLog := NewConsoleLogger(b, CONSOLE, prefix)
pLog := NewPCPLogger(b, PCP, prefix)
schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix)
spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix)
schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix)
tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDIST_OVERHEAD, prefix)
head.SetNext(cLog)
cLog.SetNext(pLog)
pLog.SetNext(schedTraceLog)
schedTraceLog.SetNext(spsLog)
spsLog.SetNext(schedWindowLog)
schedWindowLog.SetNext(tskDistLog)
ElektronLogger = cLog
ElektronLogger = head
}

32
elektronLogging/loggerChain.go
View file

@ -7,22 +7,48 @@ import (
type Logger interface {
SetNext(logType Logger)
Log(logType int, level log.Level, logData log.Fields, message string)
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
Type int
AllowOnConsole bool
LogFile *os.File
next Logger
}
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 Logger) {
l.next = logType
}
func (l *LoggerImpl) Log(logType int, level log.Level, logData log.Fields, message string) {
func (l LoggerImpl) Log(logType int, level log.Level, message string) {
if l.next != nil {
l.next.Log(logType, level, logData, message)
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{}
}

38
elektronLogging/pcpLogger.go
View file

@ -12,29 +12,53 @@ type PCPLogger struct {
LoggerImpl
}
func NewPCPLogger(logType int, prefix string) *PCPLogger {
func NewPCPLogger(b *baseLogData, logType int, prefix string) *PCPLogger {
pLog := &PCPLogger{}
pLog.Type = logType
pLog.CreateLogFile(prefix)
pLog.next = nil
pLog.baseLogData = b
return pLog
}
func (pLog PCPLogger) Log(logType int, level log.Level, logData log.Fields, message string) {
func (pLog PCPLogger) Log(logType int, level log.Level, message string) {
if config.PCPConfig.Enabled {
if pLog.Type == logType {
logger.SetLevel(level)
if pLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(logData).Println(message)
logger.WithFields(pLog.data).Log(level, message)
}
logger.SetOutput(pLog.LogFile)
logger.WithFields(logData).Println(message)
logger.WithFields(pLog.data).Log(level, message)
}
if pLog.next != nil {
pLog.next.Log(logType, level, logData, message)
pLog.next.Log(logType, level, message)
} else {
// Clearing the fields.
pLog.resetFields()
}
}
}
func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if config.PCPConfig.Enabled {
if pLog.Type == logType {
if pLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
}
logger.SetOutput(pLog.LogFile)
logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
}
if pLog.next != nil {
pLog.next.Logf(logType, level, msgFmtString, args...)
} else {
// Clearing the fields.
pLog.resetFields()
}
}
}

38
elektronLogging/schedPolicySwitchLogger.go
View file

@ -12,29 +12,53 @@ type SchedPolicySwitchLogger struct {
LoggerImpl
}
func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLogger {
func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string) *SchedPolicySwitchLogger {
sLog := &SchedPolicySwitchLogger{}
sLog.Type = logType
sLog.CreateLogFile(prefix)
sLog.next = nil
sLog.baseLogData = b
return sLog
}
func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) {
func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) {
if config.SPSConfig.Enabled {
if sLog.Type == logType {
logger.SetLevel(level)
if sLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(logData).Println(message)
logger.WithFields(sLog.data).Log(level, message)
}
logger.SetOutput(sLog.LogFile)
logger.WithFields(logData).Println(message)
logger.WithFields(sLog.data).Log(level, message)
}
if sLog.next != nil {
sLog.next.Log(logType, level, logData, message)
sLog.next.Log(logType, level, message)
} else {
// Clearing the fields.
sLog.resetFields()
}
}
}
func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if config.SPSConfig.Enabled {
if sLog.Type == logType {
if sLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
logger.SetOutput(sLog.LogFile)
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
if sLog.next != nil {
sLog.next.Logf(logType, level, msgFmtString, args...)
} else {
// Clearing the fields.
sLog.resetFields()
}
}
}

38
elektronLogging/schedTraceLogger.go
View file

@ -12,29 +12,53 @@ type SchedTraceLogger struct {
LoggerImpl
}
func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger {
func NewSchedTraceLogger(b *baseLogData, logType int, prefix string) *SchedTraceLogger {
sLog := &SchedTraceLogger{}
sLog.Type = logType
sLog.CreateLogFile(prefix)
sLog.next = nil
sLog.baseLogData = b
return sLog
}
func (sLog SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) {
func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) {
if config.SchedTraceConfig.Enabled {
if sLog.Type == logType {
logger.SetLevel(level)
if sLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(logData).Println(message)
logger.WithFields(sLog.data).Log(level, message)
}
logger.SetOutput(sLog.LogFile)
logger.WithFields(logData).Println(message)
logger.WithFields(sLog.data).Log(level, message)
}
if sLog.next != nil {
sLog.next.Log(logType, level, logData, message)
sLog.next.Log(logType, level, message)
} else {
// Clearing the fields.
sLog.resetFields()
}
}
}
func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if config.SchedTraceConfig.Enabled {
if sLog.Type == logType {
if sLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
logger.SetOutput(sLog.LogFile)
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
if sLog.next != nil {
sLog.next.Logf(logType, level, msgFmtString, args...)
} else {
// Clearing the fields.
sLog.resetFields()
}
}
}

38
elektronLogging/schedWindowLogger.go
View file

@ -12,29 +12,53 @@ type SchedWindowLogger struct {
LoggerImpl
}
func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger {
func NewSchedWindowLogger(b *baseLogData, logType int, prefix string) *SchedWindowLogger {
sLog := &SchedWindowLogger{}
sLog.Type = logType
sLog.CreateLogFile(prefix)
sLog.next = nil
sLog.baseLogData = b
return sLog
}
func (sLog SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) {
func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) {
if config.SchedWindowConfig.Enabled {
if sLog.Type == logType {
logger.SetLevel(level)
if sLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(logData).Println(message)
logger.WithFields(sLog.data).Log(level, message)
}
logger.SetOutput(sLog.LogFile)
logger.WithFields(logData).Println(message)
logger.WithFields(sLog.data).Log(level, message)
}
if sLog.next != nil {
sLog.next.Log(logType, level, logData, message)
sLog.next.Log(logType, level, message)
} else {
// Clearing the fields.
sLog.resetFields()
}
}
}
func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
if config.SchedWindowConfig.Enabled {
if sLog.Type == logType {
if sLog.AllowOnConsole {
logger.SetOutput(os.Stdout)
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
logger.SetOutput(sLog.LogFile)
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
}
if sLog.next != nil {
sLog.next.Logf(logType, level, msgFmtString, args...)
} else {
// Clearing the fields.
sLog.resetFields()
}
}
}