I’ve an application which should use log in state of debug, i.e. all the logs that I want to provide is like log.debug
I’ve read about it and find the following
My question is how should I “tell” to the program that now run at debug mode an then all the logs will be printed since this I believe should come from outside …
example will be very helpful since I'm new to golfing.
Ok, a really simple example of the approach I suggested in the comment:
package main
import (
"os"
"github.com/sirupsen/logrus"
)
func init() {
lvl, ok := os.LookupEnv("LOG_LEVEL")
// LOG_LEVEL not set, let's default to debug
if !ok {
lvl = "debug"
}
// parse string, this is built-in feature of logrus
ll, err := logrus.ParseLevel(lvl)
if err != nil {
ll = logrus.DebugLevel
}
// set global log level
logrus.SetLevel(ll)
}
func main() {
logrus.Debug("Will only be visible if the loglevel permits it")
}
The original comment:
Check codebases that are out there. In go, the common way to do that is to load configuration via environment variables (eg LOG_LEVEL, and use os.Getenv or a config package to load the value). That's why logrus for example allows you to set log levels via ints or strings.
Please, please: before you ask a question, read the basic info about the packages you use. Even the github repo for logrus' main README contains an example setting the log level to a specific level:
if !ok and if ok , why ?5 for debug levelinit function ?info), you'll always see debug log output. Check the implementation of the ParseLevel function to see what string values you can assign to LOG_LEVEL. Having this in the main.init func is acceptable, but in most cases you'll want to configure some other things, and you'll end up setting up the logger in the main func somewhere. It all depends. In this small example, this is a valid use-case of the init func thoughgo run is not something that is recommended, especially not when you're running something that requires bootstrapping (which your example of go run -set loglevel=debug implies). I'd recommend you use go build and execute the binary, and have a look at fsnotify to use file-based config that can be reloaded at runtimeIf the only thing you need is check level before printing you can create you own thin wrapper for standard logger.
This will help to better understand how they work. Feel free to ask any questions.
package main
import (
"log"
)
type MyLog struct {
PrintDebug bool
}
func (m *MyLog) Debug(args ...interface{}) {
if m.PrintDebug {
m.Print(args...)
}
}
func (m *MyLog) Print(args ...interface{}) {
log.Print(args...)
}
func main() {
ml := MyLog{}
ml.Debug("PrintDebig = false, so no oitput")
ml.Print("this will be printed anyway")
ml.PrintDebug = true
ml.Debug("Hello, playground")
}
atomic package). You're not really implementing different levels. OP mentions logrus, which does have differen log levels. Why wouldn't you simply use that instead? Lastly: the question was mainly focused on how you switch to a different log level: hard-coding a boolean reassignment wouldn't be the way to go I don't think
Debug, Warn and Critical implemented. Usually you do not switch DebugLevels on fly, so bool var is really written only once. Original Logger is thread safe. Logrus is nice, but it has some drawbacks - for example bad handling of line numbers, what standard logger can do well. Solution
LOG_LEVEL, and useos.Getenvor a config package to load the value). That's whylogrusfor example allows you to set log levels via ints or strings.