How to implement level based logging in golang?

Is there any good wrapper available for level based logging in golang?
If not, how should I go about implementing one myself?

What I want is pretty simple. I want a few functions e.g.

log.Error()
log.Info()

etc that display their outputs to stdout as well as save these in a log file (based on the level given to the program as commandline argument).
How do I implement this wrapper?

Some more suggestions, now that the existing answers are quite old:

• https://github.com/op/go-logging - smaller than the other here
• https://github.com/sirupsen/logrus - used in many popular projects such as Docker
• https://github.com/inconshreveable/log15
• https://github.com/golang/glog - from Google, implementation of their C++ glog library in Go
• https://github.com/go-kit/kit/tree/master/log focused on "structured logging" which is better for tools to consume
• https://github.com/uber-go/zap - "blazing fast"
• https://github.com/rs/zerolog - zero-allocation JSON logger

• Uber-go/Zap: Fast, structured, leveled logging in Go
• Logrus: Structured, pluggable logging for Go. (JSON and text formatting)

Both libraries have level hooks also, which is a very interesting feature. Hooks can be registered for particular log levels. So for example any error(logged using log.Error()) occurs you can report to some monitoring tool etc.

https://github.com/hashicorp/logutils I found this to be very easy to use and you don't even need to change the method calls to log.Printf of the std library.

I think seelog fits your requirements, and it seems to be pretty popular as it pops up often in log discussions. I never used it seriously, so I can't comment beyond that.

Take a look at http://cgl.tideland.biz and there at the package "applog". It's working that way.

PS: The whole CGL is currently reworked and will soon be released with new features, but under a different name.

stdlog fits exactly your requirements:

log := stdlog.GetFromFlags()
log.Info("Connecting to the server...")
log.Errorf("Connection failed: %q", err)

I am working with rlog at the moment and like their approach. The code looks good, simplistic and sufficiently documented.

What convinced me:

• no external dependencies

• i can use rlog.Info() anywhere without passing around references

• good usage of environment variables

• arbitrary number of trace levels e.g. rlog.Trace(4, "foo")

I have added logging level support to the built-in Go log package. You can find my code here:

https://github.com/gologme/log

In addition to adding support for Info, Warn, and Debug, users can also define their own arbitrary logging levels. Logging levels are enabled and disabled individually. This means you can turn on Debug logs without also getting everything else.

You can use the module midlog to implements any other log library,
https://github.com/lingdor/midlog

One of the logging module that you can consider is klog . It support 'V' logging which gives the flexibility to log at certain level

klog is a fork of glog and overcomes following drawbacks

glog presents a lot "gotchas" and introduces challenges in containerized environments, all of which aren't well documented.
glog doesn't provide an easy way to test logs, which detracts from the stability of software using it
glog is C++ based and klog is a pure golang implementation

Sample Implementation

package main

import (
    "flag"

    "k8s.io/klog"
)

type myError struct {
    str string
}

func (e myError) Error() string {
    return e.str
}

func main() {
    klog.InitFlags(nil)
    flag.Set("v", "1")
    flag.Parse()

    klog.Info("hello", "val1", 1, "val2", map[string]int{"k": 1})
    klog.V(3).Info("nice to meet you")
    klog.Error(nil, "uh oh", "trouble", true, "reasons", []float64{0.1, 0.11, 3.14})
    klog.Error(myError{"an error occurred"}, "goodbye", "code", -1)
    klog.Flush()
}

In 2023 today, Go 1.21.0 finally comes with a standard level logger: log/slog package.

No external library is needed anymore for average users.

1. Basic Usage

package main

import "log/slog"

func main() {
	slog.Info("hello")
	slog.Warn("hello")
	slog.Error("hello")
}

2023/08/09 20:05:49 INFO hello
2023/08/09 20:05:49 WARN hello
2023/08/09 20:05:49 ERROR hello

(Debug log level is disabled by default. See "4. Create Your Own Logger" below to enable it.)

2. Add Context

It can optionally receive any number of key-value pairs:

package main

import "log/slog"

func main() {
	slog.Info("hello", "username", "Mike", "age", 18)
}

2023/08/09 20:07:51 INFO hello username=Mike age=18

3. Customize Format

log package can be used to customize the format of log/slog logger.

package main

import "log"
import "log/slog"

func main() {
	slog.Info("hello")
	log.SetFlags(log.Ldate | log.Lmicroseconds)
	slog.Info("hello")
}

2023/08/09 20:15:36 INFO hello
2023/08/09 20:15:36.601583 INFO hello

4. Create Your Own Logger

Basic usage is covered by the top-level functions (e.g. slog.Info()) but you can create your own logger for detailed customization.

A created logger can be set as the default logger via slog.SetDefault(). After that, the top-level functions (e.g. slog.Info()) use your logger.

Here's an example which enables Debug log level and customizes the output format:

package main

import (
	"log/slog"
	"os"
)

func main() {
    //text logger
	{
		handler := slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})
		slog.SetDefault(slog.New(handler))

		slog.Debug("hello", "username", "Mike", "age", 18)
	}

    //JSON logger
	{
		handler := slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})
		slog.SetDefault(slog.New(handler))

		slog.Debug("hello", "username", "Mike", "age", 18)
	}
}

time=2023-08-09T20:31:05.798+09:00 level=DEBUG msg=hello username=Mike age=18
{"time":"2023-08-09T20:31:05.798984192+09:00","level":"DEBUG","msg":"hello","username":"Mike","age":18}

Side Notes

At the time of writing this answer, enabling Debug log level while preserving the default output format seems impossible.

The default logger, whose format is different from slog.NewTexthandler() and slog.NewJSONHandler(), is created via a private method in log/slog/logger.go:

var defaultLogger atomic.Value

func init() {
	defaultLogger.Store(New(newDefaultHandler(loginternal.DefaultOutput)))
}