WIP : Elektron Logging library #16
|
|
@ -22,9 +22,8 @@ func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string)
|
||||||
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) {
|
func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) {
|
||||||
if config.TaskDistrConfig.Enabled {
|
if cLog.Type == logType {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
if cLog.Type == logType {
|
if config.TaskDistrConfig.Enabled {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
|
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
if cLog.AllowOnConsole {
|
if cLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(cLog.data).Log(level, message)
|
logger.WithFields(cLog.data).Log(level, message)
|
||||||
|
|
@ -33,19 +32,19 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
logger.SetOutput(cLog.LogFile)
|
logger.SetOutput(cLog.LogFile)
|
||||||
logger.WithFields(cLog.data).Log(level, message)
|
logger.WithFields(cLog.data).Log(level, message)
|
||||||
}
|
}
|
||||||
if cLog.next != nil {
|
}
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
cLog.next.Log(logType, level, message)
|
// Forwarding to next logger
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
} else {
|
if cLog.next != nil {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
// Clearing the fields.
|
cLog.next.Log(logType, level, message)
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
cLog.resetFields()
|
} else {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
}
|
// Clearing the fields.
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
|
cLog.resetFields()
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
||||||
if config.TaskDistrConfig.Enabled {
|
if cLog.Type == logType {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
if cLog.Type == logType {
|
if config.TaskDistrConfig.Enabled {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
|
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
if cLog.AllowOnConsole {
|
if cLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
||||||
|
|
@ -54,12 +53,12 @@ func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
logger.SetOutput(cLog.LogFile)
|
logger.SetOutput(cLog.LogFile)
|
||||||
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
||||||
}
|
}
|
||||||
if cLog.next != nil {
|
}
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
cLog.next.Logf(logType, level, msgFmtString, args...)
|
if cLog.next != nil {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
} else {
|
cLog.next.Logf(logType, level, msgFmtString, args...)
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
// Clearing the fields.
|
} else {
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
cLog.resetFields()
|
// Clearing the fields.
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
}
|
cLog.resetFields()
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
Use struct literals instead of new as it's more descriptive: Use struct literals instead of new as it's more descriptive:
`&ClsfnTaskDistOverheadLogger{}`
Where is log dir coming from? Shouldn't be a global Where is log dir coming from? Shouldn't be a global
Okay, will do the changes Okay, will do the changes
It is defined in It is defined in `createLogDir.go`. Since all these files belong to same package, I accessed it in this way.
I think it will be better if it is encapsulated. I think it will be better if it is encapsulated.
Something like
```go
type logDir struct {
name string
// other fields if necessary.
}
```
Maybe refactor to Maybe refactor to `ClsfnTaskDistrOverheadLogger` so that it is clear that we are intending "Distribution" and now "Distance"?
You should use filepath.Join(...) to keep it generic. You should use [filepath.Join(...)](https://golang.org/src/path/filepath/path.go?s=5893:5925#L199) to keep it generic.
You can possible rewrite this function to something like the one shown below. You can possible rewrite this function to something like the one shown below.
```go
func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) {
filename := prefix + config.TaskDistConfig.FilenameExtension
if logDir != "" {
if logFile, err := os.Create(filepath.Join(logDir, filename)); err != nil {
log.Fatal("Unable to create logFile: ", err)
} else {
cLog.LogFileName = logFile
cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole
}
}
}
```
Done Done
Done Done
Okay. Sure Okay. Sure
Done Done
looks good now thanks! looks good now thanks!
|
|||||||
|
|
@ -21,45 +21,44 @@ func NewConsoleLogger(b *baseLogData, logType int, prefix string) *ConsoleLogger
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
return cLog
|
return cLog
|
||||||
}
|
}
|
||||||
func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) {
|
func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) {
|
||||||
if config.ConsoleConfig.Enabled {
|
if logType <= cLog.Type {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
if logType <= cLog.Type {
|
if config.ConsoleConfig.Enabled {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
|
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(cLog.data).Log(level, message)
|
logger.WithFields(cLog.data).Log(level, message)
|
||||||
|
|
||||||
logger.SetOutput(cLog.LogFile)
|
logger.SetOutput(cLog.LogFile)
|
||||||
logger.WithFields(cLog.data).Log(level, message)
|
logger.WithFields(cLog.data).Log(level, message)
|
||||||
}
|
}
|
||||||
if cLog.next != nil {
|
}
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
cLog.next.Log(logType, level, message)
|
// Forwarding to next logger.
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
} else {
|
if cLog.next != nil {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
// Clearing the fields.
|
cLog.next.Log(logType, level, message)
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
cLog.resetFields()
|
} else {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
}
|
// Clearing the fields.
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
|
cLog.resetFields()
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
||||||
if config.ConsoleConfig.Enabled {
|
if logType <= cLog.Type {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
if logType <= cLog.Type {
|
if config.ConsoleConfig.Enabled {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
|
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
||||||
|
|
||||||
logger.SetOutput(cLog.LogFile)
|
logger.SetOutput(cLog.LogFile)
|
||||||
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(cLog.data).Logf(level, msgFmtString, args...)
|
||||||
}
|
}
|
||||||
if cLog.next != nil {
|
}
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
cLog.next.Logf(logType, level, msgFmtString, args...)
|
if cLog.next != nil {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
} else {
|
cLog.next.Logf(logType, level, msgFmtString, args...)
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
// Clearing the fields.
|
} else {
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
cLog.resetFields()
|
// Clearing the fields.
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
}
|
cLog.resetFields()
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cLog *ConsoleLogger) CreateLogFile(prefix string) {
|
func (cLog *ConsoleLogger) CreateLogFile(prefix string) {
|
||||||
|
// Create log file for the type if it is enabled.
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
if config.ConsoleConfig.Enabled {
|
if config.ConsoleConfig.Enabled {
|
||||||
filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "")
|
filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "")
|
||||||
dirName := logDir.getDirName()
|
dirName := logDir.getDirName()
|
||||||
|
|
|
||||||
|
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
I see why you are directly assigning I see why you are directly assigning `true`. However, to allow disabling console logs to stdout retrofit this to `cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole`.
Why the pointer receiver? Technically, this function should not lead to change of state. Why the pointer receiver? Technically, this function should not lead to change of state.
Sure Sure
Yeah, thats right. I will change it Yeah, thats right. I will change it
|
|||||||
|
|
@ -20,7 +20,8 @@ func (logD *logDirectory) getDirName() string {
|
||||||
|
Why not use Why not use `string.join([]string{...}, "")` ?
Yeah, thats right Yeah, thats right
Extend the comment to show how the format of the log directory name is going to look. Extend the comment to show how the format of the log directory name is going to look.
Keep the alias for logrus import consistent. So, refactor this to "log". Keep the alias for logrus import consistent. So, refactor this to "log".
Done Done
Done Done
Why not use Why not use `string.join([]string{...}, "")` ?
Yeah, thats right Yeah, thats right
Extend the comment to show how the format of the log directory name is going to look. Extend the comment to show how the format of the log directory name is going to look.
Keep the alias for logrus import consistent. So, refactor this to "log". Keep the alias for logrus import consistent. So, refactor this to "log".
Done Done
Done Done
|
|||||||
func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) {
|
func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) {
|
||||||
|
|
||||||
if logD.name == "" {
|
if logD.name == "" {
|
||||||
// Creating directory to store all logs for this run. Directory name format - 2019-November-21_14-33-0.
|
// Creating directory to store all logs for this run. Directory name format : _2019-November-21_14-33-0.
|
||||||
|
Why not use Why not use `string.join([]string{...}, "")` ?
Yeah, thats right Yeah, thats right
Extend the comment to show how the format of the log directory name is going to look. Extend the comment to show how the format of the log directory name is going to look.
Keep the alias for logrus import consistent. So, refactor this to "log". Keep the alias for logrus import consistent. So, refactor this to "log".
Done Done
Done Done
Why not use Why not use `string.join([]string{...}, "")` ?
Yeah, thats right Yeah, thats right
Extend the comment to show how the format of the log directory name is going to look. Extend the comment to show how the format of the log directory name is going to look.
Keep the alias for logrus import consistent. So, refactor this to "log". Keep the alias for logrus import consistent. So, refactor this to "log".
Done Done
Done Done
|
|||||||
|
prefix = prefix + "_"
|
||||||
|
Why not use Why not use `string.join([]string{...}, "")` ?
Yeah, thats right Yeah, thats right
Extend the comment to show how the format of the log directory name is going to look. Extend the comment to show how the format of the log directory name is going to look.
Keep the alias for logrus import consistent. So, refactor this to "log". Keep the alias for logrus import consistent. So, refactor this to "log".
Done Done
Done Done
|
|||||||
logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "")
|
logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "")
|
||||||
logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-")
|
logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-")
|
||||||
logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_")
|
logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_")
|
||||||
|
|
|
||||||
|
Why not use Why not use `string.join([]string{...}, "")` ?
Yeah, thats right Yeah, thats right
Extend the comment to show how the format of the log directory name is going to look. Extend the comment to show how the format of the log directory name is going to look.
Keep the alias for logrus import consistent. So, refactor this to "log". Keep the alias for logrus import consistent. So, refactor this to "log".
Done Done
Done Done
Why not use Why not use `string.join([]string{...}, "")` ?
Yeah, thats right Yeah, thats right
Extend the comment to show how the format of the log directory name is going to look. Extend the comment to show how the format of the log directory name is going to look.
Keep the alias for logrus import consistent. So, refactor this to "log". Keep the alias for logrus import consistent. So, refactor this to "log".
Done Done
Done Done
|
|||||||
|
|
@ -42,7 +42,7 @@ func BuildLogger(prefix string, logConfigFilename string) {
|
||||||
|
Logger and Log are synonyms and therefore should not be used interchangeably. Logger and Log are synonyms and therefore should not be used interchangeably.
Comments should start with capital letters and should end with a full stop. Comments should start with capital letters and should end with a full stop.
The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the `-logPrefix` flag.
What is the rationale behind having a dummy node as the head of the chain? What is the rationale behind having a dummy node as the head of the chain?
Done Done
Nothing specific. I had kept Nothing specific. I had kept `ElektronLog` as `LoggerImpl` type. But I have changed to `ConsoleLogger` rather. Works fine now
Done Done
Changed Changed `ElektronLog` to `ElektronLogger`
Logger and Log are synonyms and therefore should not be used interchangeably. Logger and Log are synonyms and therefore should not be used interchangeably.
Comments should start with capital letters and should end with a full stop. Comments should start with capital letters and should end with a full stop.
The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the `-logPrefix` flag.
What is the rationale behind having a dummy node as the head of the chain? What is the rationale behind having a dummy node as the head of the chain?
Done Done
Nothing specific. I had kept Nothing specific. I had kept `ElektronLog` as `LoggerImpl` type. But I have changed to `ConsoleLogger` rather. Works fine now
Done Done
Changed Changed `ElektronLog` to `ElektronLogger`
|
|||||||
schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix)
|
schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix)
|
||||||
spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix)
|
spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix)
|
||||||
schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix)
|
schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix)
|
||||||
tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDIST_OVERHEAD, prefix)
|
tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix)
|
||||||
|
Logger and Log are synonyms and therefore should not be used interchangeably. Logger and Log are synonyms and therefore should not be used interchangeably.
Comments should start with capital letters and should end with a full stop. Comments should start with capital letters and should end with a full stop.
The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the `-logPrefix` flag.
What is the rationale behind having a dummy node as the head of the chain? What is the rationale behind having a dummy node as the head of the chain?
Done Done
Nothing specific. I had kept Nothing specific. I had kept `ElektronLog` as `LoggerImpl` type. But I have changed to `ConsoleLogger` rather. Works fine now
Done Done
Changed Changed `ElektronLog` to `ElektronLogger`
Logger and Log are synonyms and therefore should not be used interchangeably. Logger and Log are synonyms and therefore should not be used interchangeably.
Comments should start with capital letters and should end with a full stop. Comments should start with capital letters and should end with a full stop.
The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the `-logPrefix` flag.
What is the rationale behind having a dummy node as the head of the chain? What is the rationale behind having a dummy node as the head of the chain?
Done Done
Nothing specific. I had kept Nothing specific. I had kept `ElektronLog` as `LoggerImpl` type. But I have changed to `ConsoleLogger` rather. Works fine now
Done Done
Changed Changed `ElektronLog` to `ElektronLogger`
|
|||||||
|
|
||||||
head.SetNext(cLog)
|
head.SetNext(cLog)
|
||||||
cLog.SetNext(pLog)
|
cLog.SetNext(pLog)
|
||||||
|
|
|
||||||
|
Logger and Log are synonyms and therefore should not be used interchangeably. Logger and Log are synonyms and therefore should not be used interchangeably.
Comments should start with capital letters and should end with a full stop. Comments should start with capital letters and should end with a full stop.
The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the `-logPrefix` flag.
What is the rationale behind having a dummy node as the head of the chain? What is the rationale behind having a dummy node as the head of the chain?
Done Done
Nothing specific. I had kept Nothing specific. I had kept `ElektronLog` as `LoggerImpl` type. But I have changed to `ConsoleLogger` rather. Works fine now
Done Done
Changed Changed `ElektronLog` to `ElektronLogger`
Logger and Log are synonyms and therefore should not be used interchangeably. Logger and Log are synonyms and therefore should not be used interchangeably.
Comments should start with capital letters and should end with a full stop. Comments should start with capital letters and should end with a full stop.
The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the The second argument to GetLogDir() is a prefix. How is "_" a prefix? This is probably why the log directory name is not ending up prefixed with the one specified with the `-logPrefix` flag.
What is the rationale behind having a dummy node as the head of the chain? What is the rationale behind having a dummy node as the head of the chain?
Done Done
Nothing specific. I had kept Nothing specific. I had kept `ElektronLog` as `LoggerImpl` type. But I have changed to `ConsoleLogger` rather. Works fine now
Done Done
Changed Changed `ElektronLog` to `ElektronLogger`
|
|||||||
|
|
@ -22,9 +22,8 @@ func NewPCPLogger(b *baseLogData, logType int, prefix string) *PCPLogger {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (pLog PCPLogger) Log(logType int, level log.Level, message string) {
|
func (pLog PCPLogger) Log(logType int, level log.Level, message string) {
|
||||||
if config.PCPConfig.Enabled {
|
if pLog.Type == logType {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
if pLog.Type == logType {
|
if config.PCPConfig.Enabled {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
|
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
if pLog.AllowOnConsole {
|
if pLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(pLog.data).Log(level, message)
|
logger.WithFields(pLog.data).Log(level, message)
|
||||||
|
|
@ -33,19 +32,18 @@ func (pLog PCPLogger) Log(logType int, level log.Level, message string) {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
logger.SetOutput(pLog.LogFile)
|
logger.SetOutput(pLog.LogFile)
|
||||||
logger.WithFields(pLog.data).Log(level, message)
|
logger.WithFields(pLog.data).Log(level, message)
|
||||||
}
|
}
|
||||||
if pLog.next != nil {
|
}
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
pLog.next.Log(logType, level, message)
|
if pLog.next != nil {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
} else {
|
pLog.next.Log(logType, level, message)
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
// Clearing the fields.
|
} else {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
pLog.resetFields()
|
// Clearing the fields.
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
}
|
pLog.resetFields()
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
||||||
if config.PCPConfig.Enabled {
|
if pLog.Type == logType {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
if pLog.Type == logType {
|
if config.PCPConfig.Enabled {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
|
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
if pLog.AllowOnConsole {
|
if pLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
|
||||||
|
|
@ -54,12 +52,13 @@ func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, ar
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
logger.SetOutput(pLog.LogFile)
|
logger.SetOutput(pLog.LogFile)
|
||||||
logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(pLog.data).Logf(level, msgFmtString, args...)
|
||||||
}
|
}
|
||||||
if pLog.next != nil {
|
}
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
pLog.next.Logf(logType, level, msgFmtString, args...)
|
// Forwarding to next logger
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
} else {
|
if pLog.next != nil {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
// Clearing the fields.
|
pLog.next.Logf(logType, level, msgFmtString, args...)
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
pLog.resetFields()
|
} else {
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
}
|
// Clearing the fields.
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
|
pLog.resetFields()
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
Refactor to Refactor to `PCPLogger`.
Why not just do this? Where Why not just do this?
```go
return &PCPLogger{
LoggerIml{
Type: logType
LogFile: CreateLogFile(prefix),
}
}
```
Where `func CreateLogFile(prefix string) string` replaces `func SetLogFile(prefix string)`.
Done Done
|
|||||||
|
|
@ -22,9 +22,8 @@ func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string) *Sch
|
||||||
}
|
}
|
||||||
|
|
||||||
func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) {
|
func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) {
|
||||||
if config.SPSConfig.Enabled {
|
if sLog.Type == logType {
|
||||||
if sLog.Type == logType {
|
if config.SPSConfig.Enabled {
|
||||||
|
|
||||||
if sLog.AllowOnConsole {
|
if sLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(sLog.data).Log(level, message)
|
logger.WithFields(sLog.data).Log(level, message)
|
||||||
|
|
@ -33,19 +32,18 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message st
|
||||||
logger.SetOutput(sLog.LogFile)
|
logger.SetOutput(sLog.LogFile)
|
||||||
logger.WithFields(sLog.data).Log(level, message)
|
logger.WithFields(sLog.data).Log(level, message)
|
||||||
}
|
}
|
||||||
if sLog.next != nil {
|
}
|
||||||
sLog.next.Log(logType, level, message)
|
if sLog.next != nil {
|
||||||
} else {
|
sLog.next.Log(logType, level, message)
|
||||||
// Clearing the fields.
|
} else {
|
||||||
sLog.resetFields()
|
// Clearing the fields.
|
||||||
}
|
sLog.resetFields()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
||||||
if config.SPSConfig.Enabled {
|
if sLog.Type == logType {
|
||||||
if sLog.Type == logType {
|
if config.SPSConfig.Enabled {
|
||||||
|
|
||||||
if sLog.AllowOnConsole {
|
if sLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
||||||
|
|
@ -54,12 +52,13 @@ func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr
|
||||||
logger.SetOutput(sLog.LogFile)
|
logger.SetOutput(sLog.LogFile)
|
||||||
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
||||||
}
|
}
|
||||||
if sLog.next != nil {
|
}
|
||||||
sLog.next.Logf(logType, level, msgFmtString, args...)
|
// Forwarding to next logger
|
||||||
} else {
|
if sLog.next != nil {
|
||||||
// Clearing the fields.
|
sLog.next.Logf(logType, level, msgFmtString, args...)
|
||||||
sLog.resetFields()
|
} else {
|
||||||
}
|
// Clearing the fields.
|
||||||
|
sLog.resetFields()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -22,9 +22,8 @@ func NewSchedTraceLogger(b *baseLogData, logType int, prefix string) *SchedTrace
|
||||||
}
|
}
|
||||||
|
|
||||||
func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) {
|
func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) {
|
||||||
if config.SchedTraceConfig.Enabled {
|
if sLog.Type == logType {
|
||||||
if sLog.Type == logType {
|
if config.SchedTraceConfig.Enabled {
|
||||||
|
|
||||||
if sLog.AllowOnConsole {
|
if sLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(sLog.data).Log(level, message)
|
logger.WithFields(sLog.data).Log(level, message)
|
||||||
|
|
@ -33,19 +32,18 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) {
|
||||||
logger.SetOutput(sLog.LogFile)
|
logger.SetOutput(sLog.LogFile)
|
||||||
logger.WithFields(sLog.data).Log(level, message)
|
logger.WithFields(sLog.data).Log(level, message)
|
||||||
}
|
}
|
||||||
if sLog.next != nil {
|
}
|
||||||
sLog.next.Log(logType, level, message)
|
if sLog.next != nil {
|
||||||
} else {
|
sLog.next.Log(logType, level, message)
|
||||||
// Clearing the fields.
|
} else {
|
||||||
sLog.resetFields()
|
// Clearing the fields.
|
||||||
}
|
sLog.resetFields()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
||||||
if config.SchedTraceConfig.Enabled {
|
if sLog.Type == logType {
|
||||||
if sLog.Type == logType {
|
if config.SchedTraceConfig.Enabled {
|
||||||
|
|
||||||
if sLog.AllowOnConsole {
|
if sLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
||||||
|
|
@ -54,12 +52,13 @@ func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString str
|
||||||
logger.SetOutput(sLog.LogFile)
|
logger.SetOutput(sLog.LogFile)
|
||||||
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
||||||
}
|
}
|
||||||
if sLog.next != nil {
|
}
|
||||||
sLog.next.Logf(logType, level, msgFmtString, args...)
|
// Forwarding to next logger
|
||||||
} else {
|
if sLog.next != nil {
|
||||||
// Clearing the fields.
|
sLog.next.Logf(logType, level, msgFmtString, args...)
|
||||||
sLog.resetFields()
|
} else {
|
||||||
}
|
// Clearing the fields.
|
||||||
|
sLog.resetFields()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -22,9 +22,8 @@ func NewSchedWindowLogger(b *baseLogData, logType int, prefix string) *SchedWind
|
||||||
}
|
}
|
||||||
|
|
||||||
func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) {
|
func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) {
|
||||||
if config.SchedWindowConfig.Enabled {
|
if sLog.Type == logType {
|
||||||
if sLog.Type == logType {
|
if config.SchedWindowConfig.Enabled {
|
||||||
|
|
||||||
if sLog.AllowOnConsole {
|
if sLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(sLog.data).Log(level, message)
|
logger.WithFields(sLog.data).Log(level, message)
|
||||||
|
|
@ -33,19 +32,19 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string)
|
||||||
logger.SetOutput(sLog.LogFile)
|
logger.SetOutput(sLog.LogFile)
|
||||||
logger.WithFields(sLog.data).Log(level, message)
|
logger.WithFields(sLog.data).Log(level, message)
|
||||||
}
|
}
|
||||||
if sLog.next != nil {
|
}
|
||||||
sLog.next.Log(logType, level, message)
|
// Forwarding to next logger
|
||||||
} else {
|
if sLog.next != nil {
|
||||||
// Clearing the fields.
|
sLog.next.Log(logType, level, message)
|
||||||
sLog.resetFields()
|
} else {
|
||||||
}
|
// Clearing the fields.
|
||||||
|
sLog.resetFields()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) {
|
||||||
if config.SchedWindowConfig.Enabled {
|
if sLog.Type == logType {
|
||||||
if sLog.Type == logType {
|
if config.SchedWindowConfig.Enabled {
|
||||||
|
|
||||||
if sLog.AllowOnConsole {
|
if sLog.AllowOnConsole {
|
||||||
logger.SetOutput(os.Stdout)
|
logger.SetOutput(os.Stdout)
|
||||||
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
||||||
|
|
@ -54,12 +53,12 @@ func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString st
|
||||||
logger.SetOutput(sLog.LogFile)
|
logger.SetOutput(sLog.LogFile)
|
||||||
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
logger.WithFields(sLog.data).Logf(level, msgFmtString, args...)
|
||||||
}
|
}
|
||||||
if sLog.next != nil {
|
}
|
||||||
sLog.next.Logf(logType, level, msgFmtString, args...)
|
if sLog.next != nil {
|
||||||
} else {
|
sLog.next.Logf(logType, level, msgFmtString, args...)
|
||||||
// Clearing the fields.
|
} else {
|
||||||
sLog.resetFields()
|
// Clearing the fields.
|
||||||
}
|
sLog.resetFields()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -6,5 +6,5 @@ const (
|
||||||
SCHED_TRACE
|
SCHED_TRACE
|
||||||
SPS
|
SPS
|
||||||
SCHED_WINDOW
|
SCHED_WINDOW
|
||||||
CLSFN_TASKDIST_OVERHEAD
|
CLSFN_TASKDISTR_OVERHEAD
|
||||||
)
|
)
|
||||||
|
|
|
||||||
|
|
@ -375,5 +375,5 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy
|
||||||
|
|
||||||
func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) {
|
func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) {
|
||||||
// Logging the overhead in microseconds.
|
// Logging the overhead in microseconds.
|
||||||
elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, log.InfoLevel, "")
|
elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "")
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Use struct literals instead of new as it's more descriptive:
&ClsfnTaskDistOverheadLogger{}Where is log dir coming from? Shouldn't be a global