# Logdump

[![Godoc Reference][godoc-img]][godoc]
[![Build Status][ci-img]][ci]
[![Go Report Card][goreportcard-img]][goreportcard]

Package for writing logs to multiple files

## Usage
``` $ go get github.com/ewwwwwqm/logdump ```

## Example
``` main.go ```
```go
package main

import (
	"log"

	"github.com/ewwwwwqm/logdump"
)

func main() {
	// create message zones and assign files for output
	newLog := map[string]interface{}{
		"error": "error.log",
		"warning": "warning.log",
		"notice": "notice.log",
	}

	// init logger
	logdump.Init(newLog)

	// for ex. dump error
	logdump.Write("error", "something had an error")

	// default output
	log.Println("Standard output to os.Stderr")

	// few more errors
	logdump.Write("notice", "some notice")
	logdump.Write("error", "another error")
	logdump.Write("warning", "fancy warning")

	// wrong message zone, output to os.Stderr
	logdump.Write("wrong_zone", "fail")
}
```
Before running:

![Before run](https://lh3.googleusercontent.com/qu3mHs6Ug0fxwtFFDKb5BiJdsQRG1gpSyygB4mi4869ukJpdTtjoVaNzpwGzyBeSk1eZOpyvejSib56FayhNa1PP9FPIHvZ9jEED_bPO7rrLlcsNJBQzmuydzC2Kww5d-s1DlChnFOpiv3PV_bzYHYhVLODXJeq6IC8DfuzRQUq5jTBJIifzwdGXmaFtBW3islxQffHn4OJTbAqldgXXyPL4dX-5QO3GFagcjom-FN2Jm0c069H3ZhqvR6c_N1NbHuDsDR7pOggKq8R8cRbmdd5n4ZW2zrQbopzvH_H87pJdfVovAB8W1A9XxB6iebZk4PcRp1eHmFygImkVlCEd1xYWUfGFuBG_29YJ0VxVyh1e_uEtJ2uUnFh7lqerYHcSdyZVjaeTpZvLnkB4u-ppwmsU3KzyBKIU-x1_9nYQWjVkV5VUU8bFvFY2lFF4misTR7U-jaG6HKMVLhIaBVLY-RO7zQpOpDSesV3AFIo5sHhoiPNzMvwpEt1pOOjHRenwfkGQT0vvpIm7zrv00NJAGAXkmJviKC3qVK8n7xkO36-um4icFbvArQxIyQqtj_0OW8n7z2pb5eDKicR4qrNA066jHGoTcuaS7PSQZAK-37f2OyR32N-h1L3lLef_1WAepheI9A8G7eDQkvPN_reG3p_ylzscQz5jsXlmTHYJeg=w609-h84-no)

Run the app:

``` $ go run main.go ```

![After run](https://lh3.googleusercontent.com/ADOHxXnHMnZO1Dt5oqHhWBkuTq-5oM13mhQUcQtoMZ2LsPQqecsACPepOTbXZO9bemgJb0rHIKQAD7Sa45s6CXccUS7ugNbYehJZ69tXcj8y2PYBXLnT0SgzyXTmPVlY30r-BKuyBVFoMTsoZIE5Fx6w9LP2hDfd_Nb_vpPzy2sQRVSwxRXGilJKwSuc6M0b8YriUk4EB6e_d4FWGF6LTV9F6NeXg-WRKp5JS5XoHi5WAkW9ntlpKOd_EbMuNnw4IjJIbjI0d-geZEpXoT7RsKTRVjARUBuPR3K8LZ4MgPQMLM7e4MAC5-uH9JqB6Sp5Dbu9viEbrtlBG8HrhQmPlztJ7KBfBGxVmauzoRIqY4nOBffhXu7Wd89_jw5PsBtxr4tyf8w7bApdET2q98V2_UtDFz47L5mZ44OYPip6wEoSBEixSOhgajUdNY-Sz_HAWZDdszqyYA0R_H1SvGpMD-AVeTyTH849UAyl7yHJ4s2uON14VPztpJP-WvkRhpBnv5sDw-LM30uAOsuYfAEh8WLSoKxGdqxPlJsHnwDeRb_rvxAyKKp8PAz_bA0k8kywdIM8V6MgA8_5NIE5xCh-qfOgqAxBMog9qVSnSue5Tmd5bfgpmIQlQ5HuK9qUK2cjz6Utce_Eq70FdGprruyiT-n1ymg7fnPv1SJDHtYh6w=w609-h84-no)

Files were created.

#### Output
``` os.Stderr: ```
```
2017/01/13 17:45:48 Standard output to os.Stderr
2017/01/13 17:45:48 Type wrong_zone was not assigned for log output
```
``` error.log ```
```
2017/01/13 17:45:48 Start error logging
2017/01/13 17:45:48 something had an error
2017/01/13 17:45:48 another error
```
``` warning.log ```
```
2017/01/13 17:45:48 Start warning logging
2017/01/13 17:45:48 fancy warning
```
``` notice.log ```
```
2017/01/13 17:45:48 Start notice logging
2017/01/13 17:45:48 some notice
```

[godoc]: http://godoc.org/github.com/ewwwwwqm/logdump
[godoc-img]: https://godoc.org/github.com/ewwwwwqm/logdump?status.svg
[ci-img]: https://travis-ci.org/ewwwwwqm/logdump.svg?branch=master
[cov-img]: https://coveralls.io/repos/github/ewwwwwqm/logdumpbadge.svg?branch=master
[ci]: https://travis-ci.org/ewwwwwqm/logdump
[cov]: https://coveralls.io/github/ewwwwwqm/logdump?branch=master
[goreportcard-img]: https://goreportcard.com/badge/github.com/ewwwwwqm/logdump?branch=master
[goreportcard]: https://goreportcard.com/report/github.com/ewwwwwqm/logdump?branch=master


logdump

Simple rolling logger, implements io.WriteCloser.

# lumberjack  [![GoDoc](https://godoc.org/gopkg.in/natefinch/lumberjack.v2?status.png)](https://godoc.org/gopkg.in/natefinch/lumberjack.v2) [![Build Status](https://travis-ci.org/natefinch/lumberjack.svg?branch=v2.0)](https://travis-ci.org/natefinch/lumberjack) [![Build status](https://ci.appveyor.com/api/projects/status/00gchpxtg4gkrt5d)](https://ci.appveyor.com/project/natefinch/lumberjack) [![Coverage Status](https://coveralls.io/repos/natefinch/lumberjack/badge.svg?branch=v2.0)](https://coveralls.io/r/natefinch/lumberjack?branch=v2.0)

### Lumberjack is a Go package for writing logs to rolling files.

Package lumberjack provides a rolling logger.

Note that this is v2.0 of lumberjack, and should be imported using gopkg.in
thusly:

    import "gopkg.in/natefinch/lumberjack.v2"

The package name remains simply lumberjack, and the code resides at
https://github.com/natefinch/lumberjack under the v2.0 branch.

Lumberjack is intended to be one part of a logging infrastructure.
It is not an all-in-one solution, but instead is a pluggable
component at the bottom of the logging stack that simply controls the files
to which logs are written.

Lumberjack plays well with any logging package that can write to an
io.Writer, including the standard library's log package.

Lumberjack assumes that only one process is writing to the output files.
Using the same lumberjack configuration from multiple processes on the same
machine will result in improper behavior.


**Example**

To use lumberjack with the standard library's log package, just pass it into the SetOutput function when your application starts.

Code:

```go
log.SetOutput(&lumberjack.Logger{
    Filename:   "/var/log/myapp/foo.log",
    MaxSize:    500, // megabytes
    MaxBackups: 3,
    MaxAge:     28, //days
    Compress:   true, // disabled by default
})
```



## type Logger
``` go
type Logger struct {
    // Filename is the file to write logs to.  Backup log files will be retained
    // in the same directory.  It uses <processname>-lumberjack.log in
    // os.TempDir() if empty.
    Filename string `json:"filename" yaml:"filename"`

    // MaxSize is the maximum size in megabytes of the log file before it gets
    // rotated. It defaults to 100 megabytes.
    MaxSize int `json:"maxsize" yaml:"maxsize"`

    // MaxAge is the maximum number of days to retain old log files based on the
    // timestamp encoded in their filename.  Note that a day is defined as 24
    // hours and may not exactly correspond to calendar days due to daylight
    // savings, leap seconds, etc. The default is not to remove old log files
    // based on age.
    MaxAge int `json:"maxage" yaml:"maxage"`

    // MaxBackups is the maximum number of old log files to retain.  The default
    // is to retain all old log files (though MaxAge may still cause them to get
    // deleted.)
    MaxBackups int `json:"maxbackups" yaml:"maxbackups"`

    // LocalTime determines if the time used for formatting the timestamps in
    // backup files is the computer's local time.  The default is to use UTC
    // time.
    LocalTime bool `json:"localtime" yaml:"localtime"`

    // Compress determines if the rotated log files should be compressed
    // using gzip. The default is not to perform compression.
    Compress bool `json:"compress" yaml:"compress"`
    // contains filtered or unexported fields
}
```
Logger is an io.WriteCloser that writes to the specified filename.

Logger opens or creates the logfile on first Write.  If the file exists and
is less than MaxSize megabytes, lumberjack will open and append to that file.
If the file exists and its size is >= MaxSize megabytes, the file is renamed
by putting the current time in a timestamp in the name immediately before the
file's extension (or the end of the filename if there's no extension). A new
log file is then created using original filename.

Whenever a write would cause the current log file exceed MaxSize megabytes,
the current file is closed, renamed, and a new log file created with the
original name. Thus, the filename you give Logger is always the "current" log
file.

Backups use the log file name given to Logger, in the form `name-timestamp.ext`
where name is the filename without the extension, timestamp is the time at which
the log was rotated formatted with the time.Time format of
`2006-01-02T15-04-05.000` and the extension is the original extension.  For
example, if your Logger.Filename is `/var/log/foo/server.log`, a backup created
at 6:30pm on Nov 11 2016 would use the filename
`/var/log/foo/server-2016-11-04T18-30-00.000.log`

### Cleaning Up Old Log Files
Whenever a new logfile gets created, old log files may be deleted.  The most
recent files according to the encoded timestamp will be retained, up to a
number equal to MaxBackups (or all of them if MaxBackups is 0).  Any files
with an encoded timestamp older than MaxAge days are deleted, regardless of
MaxBackups.  Note that the time encoded in the timestamp is the rotation
time, which may differ from the last time that file was written to.

If MaxBackups and MaxAge are both 0, no old log files will be deleted.











### func (\*Logger) Close
``` go
func (l *Logger) Close() error
```
Close implements io.Closer, and closes the current logfile.



### func (\*Logger) Rotate
``` go
func (l *Logger) Rotate() error
```
Rotate causes Logger to close the existing log file and immediately create a
new one.  This is a helper function for applications that want to initiate
rotations outside of the normal rotation rules, such as in response to
SIGHUP.  After rotating, this initiates a cleanup of old log files according
to the normal rules.

**Example**

Example of how to rotate in response to SIGHUP.

Code:

```go
l := &lumberjack.Logger{}
log.SetOutput(l)
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGHUP)

go func() {
    for {
        <-c
        l.Rotate()
    }
}()
```

### func (\*Logger) Write
``` go
func (l *Logger) Write(p []byte) (n int, err error)
```
Write implements io.Writer.  If a write would cause the log file to be larger
than MaxSize, the file is closed, renamed to include a timestamp of the
current time, and a new log file is created using the original log file name.
If the length of the write is greater than MaxSize, an error is returned.









- - -
Generated by [godoc2md](http://godoc.org/github.com/davecheney/godoc2md)


lumberjack

A simple to use log system, minimalist but with features for debugging and differentiation of messages.

# structy/log

[![Build Status](https://travis-ci.org/structy/log.svg?branch=master)](https://travis-ci.org/structy/log)
A simple to use log system, minimalist but with features for debugging and differentiation of messages

## Example

[![Example](examples/example.png)](examples/example.go)

```go
package main

import (
    "fmt"
    "github.com/structy/log"
)

func main() {
    log.Debugln("Debug message")

    log.DebugMode = false
    log.Debugln("Debug message that will be hidden")

    log.Println("Info message")
    log.Warningln("Warning message")
    log.Errorln("Error message")
    log.Fatal("Fatal error message")
    fmt.Println("I will never be printed because of Fatal()")
}
```


structy/log

distilled levelled logging (think of it as stdlib + log levels).

[![Build Status](https://travis-ci.org/amoghe/distillog.svg)](https://travis-ci.org/amoghe/distillog)
[![Documentation](https://godoc.org/github.com/amoghe/distillog?status.svg)](http://godoc.org/github.com/amoghe/distillog)
[![Go Report Card](https://goreportcard.com/badge/github.com/amoghe/distillog)](https://goreportcard.com/report/github.com/amoghe/distillog)

# What is `distillog`?

`distillog` aims to offer a minimalistic logging interface that also supports
log levels. It takes the `stdlib` API and only slightly enhances it. Hence, you
could think of it as levelled logging, _distilled_.

# Yet _another_ logging library for go(lang)?

> Logging libraries are like opinions, everyone seems to have one -- Anon(?)

Most other logging libraries do either __too little__ ([stdlib][0])
or __too much__ ([glog][1]).

As with most other libraries, this one is opinionated. In terms of functionality
it exposes, it attempts to sit somewhere between the stdlib and the majority of
other logging libraries available (but leans mostly towards the spartan side
of stdlib).

## The stdlib does _too little_, you say?

Just a smidge.

Presenting varying levels of verbosity (or severity) are an important part of
what makes a program more usable or debuggable. For example, `debug` or `info`
level messages may be useful to the developers during the development cycle.
These messages may be dropped or suppressed in production since they are not
useful to everyone. Similarly `warning` messages may be emitted when a error has
been gracefully handled but the program would like to notify its human overlords
of some impending doom.

In most cases, some downstream entity "knows" how to filter the messages and
keep those that are relevant to the environment. As evidence of this, most
other languages have log libraries that support levels. Similarly some programs
offer varying verbosity levels (e.g. `-v`, `-vv` etc). The golang stdlib takes
a much more spartan approach (exposing only `Println` and friends) so using it
in programs to emit messages of varying interest/levels can get tedious (manual
prefixes, anyone?). This is where `distillog` steps in. It aims to slightly
improve on this minimalstic logging interface. __Slightly__.

## Other libraries do _too much_, you say?

Ever used `log.Panicf` or `log.Fatalf`? Exiting your program is *not* something
your log library should be doing! Similarly, other libraries offer options for
maintaining old log files and rotating them. Your logging library shouldn't need
to care about this. Whatever facility (other libraries call this a "backend")
messages are sent to should determine how old messages are handled. `distillog`
prefers that you use `lumberjack` (or an equivalent WriteCloser) depending on
where you choose to persist the messages.

> But log file rotation is absolutely necessary!

Agreed, and someone's gotta do it, but it need not be your logging library!

You can use `distillog` along with a [lumberjack][2] "backend". It provides an
`io.WriteCloser` which performs all the magic you need. Initialize a logger
using `distillog.NewStream`, pass it an instance of the `io.WriteCloser`
that lumberjack returns, _et voila_, you have a logger that does what you need.

## And how is `distillog` different?

`distillog` aims to offer a only slightly richer interface than the stdlib.

To this end, it restricts itself to:
- presenting a minimal interface so that you can emit levelled log messages
- providing logger implementations for logging to the most common backends
	- streams - e.g. stderr/stdout 
	- files - anything via `io.WriteCloser` (via `lumberjack`)
	- syslog
- avoid taking on any non-essential responsibilities (colors, _ahem_)
- expose a logger interface, instead of an implementation

## Expose an interface? Why?

By exposing an interface you can write programs that use levelled log messages,
but switch between logging to various facilities by simply instantiating the
appropriate logger as determined by the caller (Your program can offer a
command-line switch like so - `--log-to=[syslog,stderr,<file>]` and the simply
instantiate the appropriate logger).

# Usage/examples:

As seen in the [godoc](https://godoc.org/github.com/amoghe/distillog#Logger),
the interface is limited to:

```golang
type Logger interface {
	Debugf(format string, v ...interface{})
	Debugln(v ...interface{})

	Infof(format string, v ...interface{})
	Infoln(v ...interface{})

	Warningf(format string, v ...interface{})
	Warningln(v ...interface{})

	Errorf(format string, v ...interface{})
	Errorln(v ...interface{})

	Close() error
}
```

Log to stdout, or stderr using a logger instantiated like so:

```golang
outLogger := distillog.NewStdoutLogger("test")

errLogger := distillog.NewStderrLogger("test")

sysLogger := distillog.NewSyslogLogger("test")
```

Alternatively, you can use the package for your logging needs:

```golang
import log "github.com/amoghe/distillog"

// ... later ...

log.Infoln("Starting program")
log.Debugln("initializing the frobnicator")
log.Warningln("frobnicator failure detected, proceeding anyways...")
log.Infoln("Exiting")
```

If you have a file you wish to log to, you should open the file and instantiate
a logger using the file handle, like so:

```golang
if fileHandle, err := ioutil.Tempfile("/tmp", "distillog-test"); err == nil {
        fileLogger := distillog.NewStreamLogger("test", fileHandle)
}
```

If you need a logger that manages the rotation of its files, use `lumberjack`,
like so:

```golang
lumberjackHandle := &lumberjack.Logger{
        Filename:   "/var/log/myapp/foo.log",
        MaxSize:    500,                       // megabytes
        MaxBackups: 3,
        MaxAge:     28,                        // days
}

logger := distillog.NewStreamLogger("tag", lumberjackHandle)

// Alternatively, configure the pkg level logger to emit here

distillog.SetOutput(lumberjackHandle)
```

Once instantiated, you can log messages, like so:

```golang
var := "World!"
myLogger.Infof("Hello, %s", var)
myLogger.Warningln("Goodbye, cruel world!")

```

# Contributing

1. Create an issue, describe the bugfix/feature you wish to implement.
2. Fork the repository
3. Create your feature branch (`git checkout -b my-new-feature`)
4. Commit your changes (`git commit -am 'Add some feature'`)
5. Push to the branch (`git push origin my-new-feature`)
6. Create a new Pull Request

# License

See [LICENSE.txt](LICENSE.txt)

[0]: https://golang.org/pkg/log/
[1]: https://github.com/golang/glog
[2]: https://github.com/natefinch/lumberjack


distillog

glg is simple and fast leveled logging library for Go.

<div align="center">
<img src="./images/logo.png" width="50%">
</div>

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](https://opensource.org/licenses/MIT)
[![release](https://img.shields.io/github/release/kpango/glg.svg?style=flat-square)](https://github.com/kpango/glg/releases/latest)
[![CircleCI](https://circleci.com/gh/kpango/glg.svg)](https://circleci.com/gh/kpango/glg)
[![codecov](https://codecov.io/gh/kpango/glg/branch/main/graph/badge.svg?token=2CzooNJtUu&style=flat-square)](https://codecov.io/gh/kpango/glg)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/a6e544eee7bc49e08a000bb10ba3deed)](https://www.codacy.com/app/i.can.feel.gravity/glg?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=kpango/glg&amp;utm_campaign=Badge_Grade)
[![Go Report Card](https://goreportcard.com/badge/github.com/kpango/glg)](https://goreportcard.com/report/github.com/kpango/glg)
[![GolangCI](https://golangci.com/badges/github.com/kpango/glg.svg?style=flat-square)](https://golangci.com/r/github.com/kpango/glg)
[![Go Walker](http://gowalker.org/api/v1/badge)](https://gowalker.org/github.com/kpango/glg)
[![GoDoc](http://godoc.org/github.com/kpango/glg?status.svg)](http://godoc.org/github.com/kpango/glg)
[![DepShield Badge](https://depshield.sonatype.org/badges/kpango/glg/depshield.svg)](https://depshield.github.io)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fkpango%2Fglg.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fkpango%2Fglg?ref=badge_shield)


glg is simple golang logging library

## Requirement
Go 1.16

## Installation
```shell
go get github.com/kpango/glg
```

## Example
```go
package main

import (
	"net/http"
	"time"

	"github.com/kpango/glg"
)

// NetWorkLogger sample network logger
type NetWorkLogger struct{}

func (n NetWorkLogger) Write(b []byte) (int, error) {
	// http.Post("localhost:8080/log", "", bytes.NewReader(b))
	http.Get("http://127.0.0.1:8080/log")
	glg.Success("Requested")
	glg.Infof("RawString is %s", glg.RawString(b))
	return 1, nil
}

func main() {

	// var errWriter io.Writer
	// var customWriter io.Writer
	infolog := glg.FileWriter("/tmp/info.log", 0666)

	customTag := "FINE"
	customErrTag := "CRIT"

	errlog := glg.FileWriter("/tmp/error.log", 0666)
	defer infolog.Close()
	defer errlog.Close()

	glg.Get().
		SetMode(glg.BOTH). // default is STD
		// DisableColor().
		// SetMode(glg.NONE).
		// SetMode(glg.WRITER).
		// SetMode(glg.BOTH).
		// InitWriter().
		// AddWriter(customWriter).
		// SetWriter(customWriter).
		// AddLevelWriter(glg.LOG, customWriter).
		// AddLevelWriter(glg.INFO, customWriter).
		// AddLevelWriter(glg.WARN, customWriter).
		// AddLevelWriter(glg.ERR, customWriter).
		// SetLevelWriter(glg.LOG, customWriter).
		// SetLevelWriter(glg.INFO, customWriter).
		// SetLevelWriter(glg.WARN, customWriter).
		// SetLevelWriter(glg.ERR, customWriter).
		// EnableJSON().
		SetLineTraceMode(glg.TraceLineNone).
		AddLevelWriter(glg.INFO, infolog). // add info log file destination
		AddLevelWriter(glg.ERR, errlog).   // add error log file destination
		AddLevelWriter(glg.WARN, rotate)   // add error log file destination

	glg.Info("info")
	glg.Infof("%s : %s", "info", "formatted")
	glg.Log("log")
	glg.Logf("%s : %s", "info", "formatted")
	glg.Debug("debug")
	glg.Debugf("%s : %s", "info", "formatted")
	glg.Trace("Trace")
	glg.Tracef("%s : %s", "tracef", "formatted")
	glg.Warn("warn")
	glg.Warnf("%s : %s", "info", "formatted")
	glg.Error("error")
	glg.Errorf("%s : %s", "info", "formatted")
	glg.Success("ok")
	glg.Successf("%s : %s", "info", "formatted")
	glg.Fail("fail")
	glg.Failf("%s : %s", "info", "formatted")
	glg.Print("Print")
	glg.Println("Println")
	glg.Printf("%s : %s", "printf", "formatted")

	// set global log level to ERR level
	glg.Info("before setting level to ERR this message will show")
	glg.Get().SetLevel(glg.ERR)
	glg.Info("after setting level to ERR this message will not show")
	glg.Error("this log is ERR level this will show")
	glg.Get().SetLevel(glg.DEBG)
	glg.Info("log level is now DEBG, this INFO level log will show")

	glg.Get().
		AddStdLevel(customTag, glg.STD, false).                    // user custom log level
		AddErrLevel(customErrTag, glg.STD, true).                  // user custom error log level
		SetLevelColor(glg.TagStringToLevel(customTag), glg.Cyan).  // set color output to user custom level
		SetLevelColor(glg.TagStringToLevel(customErrTag), glg.Red) // set color output to user custom level
	glg.CustomLog(customTag, "custom logging")
	glg.CustomLog(customErrTag, "custom error logging")

	// glg.Info("kpango's glg supports disable timestamp for logging")
	glg.Get().DisableTimestamp()
	glg.Info("timestamp disabled")
	glg.Warn("timestamp disabled")
	glg.Log("timestamp disabled")
	glg.Get().EnableTimestamp()
	glg.Info("timestamp enabled")
	glg.Warn("timestamp enabled")
	glg.Log("timestamp enabled")

	glg.Info("kpango's glg support line trace logging")
	glg.Error("error log shows short line trace by default")
	glg.Info("error log shows none trace by default")
	glg.Get().SetLineTraceMode(glg.TraceLineShort)
	glg.Error("after configure TraceLineShort, error log shows short line trace")
	glg.Info("after configure TraceLineShort, info log shows short line trace")
	glg.Get().DisableTimestamp()
	glg.Error("after configure TraceLineShort and DisableTimestamp, error log shows short line trace without timestamp")
	glg.Info("after configure TraceLineShort and DisableTimestamp, info log shows short line trace without timestamp")
	glg.Get().EnableTimestamp()
	glg.Get().SetLineTraceMode(glg.TraceLineLong)
	glg.Error("after configure TraceLineLong, error log shows long line trace")
	glg.Info("after configure TraceLineLong, info log shows long line trace")
	glg.Get().DisableTimestamp()
	glg.Error("after configure TraceLineLong and DisableTimestamp, error log shows long line trace without timestamp")
	glg.Info("after configure TraceLineLong and DisableTimestamp, info log shows long line trace without timestamp")
	glg.Get().EnableTimestamp()
	glg.Get().SetLineTraceMode(glg.TraceLineNone)
	glg.Error("after configure TraceLineNone, error log without line trace")
	glg.Info("after configure TraceLineNone, info log without line trace")
	glg.Get().SetLevelLineTraceMode(glg.INFO, glg.TraceLineLong)
	glg.Info("after configure Level trace INFO=TraceLineLong, only info log shows long line trace")
	glg.Error("after configure Level trace INFO=TraceLineLong, error log without long line trace")
	glg.Get().SetLevelLineTraceMode(glg.ERR, glg.TraceLineShort)
	glg.Info("after configure Level trace ERR=TraceLineShort, info log still shows long line trace")
	glg.Error("after configure Level trace ERR=TraceLineShort, error log now shows short line trace")
	glg.Get().SetLineTraceMode(glg.TraceLineNone)

	glg.Info("kpango's glg support json logging")
	glg.Get().EnableJSON()
	err := glg.Warn("kpango's glg", "support", "json", "logging")
	if err != nil {
		glg.Get().DisableJSON()
		glg.Error(err)
		glg.Get().EnableJSON()
	}
	err = glg.Info("hello", struct {
		Name   string
		Age    int
		Gender string
	}{
		Name:   "kpango",
		Age:    28,
		Gender: "male",
	}, 2020)
	if err != nil {
		glg.Get().DisableJSON()
		glg.Error(err)
		glg.Get().EnableJSON()
	}	glg.CustomLog(customTag, "custom logging")

	glg.CustomLog(customErrTag, "custom error logging")

	glg.Get().AddLevelWriter(glg.DEBG, NetWorkLogger{}) // add info log file destination

	http.Handle("/glg", glg.HTTPLoggerFunc("glg sample", func(w http.ResponseWriter, r *http.Request) {
		glg.New().
		AddLevelWriter(glg.Info, NetWorkLogger{}).
		AddLevelWriter(glg.Info, w).
		Info("glg HTTP server logger sample")
	}))

	http.ListenAndServe("port", nil)

	// fatal logging
	glg.Fatalln("fatal")
}
```

<div align="center">
<img src="./images/sample.png" width="100%">
</div>

## Benchmarks

<div align="center">
<img src="./images/bench.png" width="100%">
</div>

## Contribution
1. Fork it ( https://github.com/kpango/glg/fork )
2. Create your feature branch (git checkout -b my-new-feature)
3. Commit your changes (git commit -am 'Add some feature')
4. Push to the branch (git push origin my-new-feature)
5. Create new Pull Request

## Author
[kpango](https://github.com/kpango)

## LICENSE
glg released under MIT license, refer [LICENSE](https://github.com/kpango/glg/blob/main/LICENSE) file.  
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fkpango%2Fglg.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fkpango%2Fglg?ref=badge_large)


PHP Monolog inspired logging facility with identical severity levels.

[![GoDoc](https://godoc.org/github.com/lajosbencz/glo?status.svg)](https://godoc.org/github.com/lajosbencz/glo)
[![Go Report Card](https://goreportcard.com/badge/github.com/lajosbencz/glo)](https://goreportcard.com/report/github.com/lajosbencz/glo)
[![codecov](https://codecov.io/gh/lajosbencz/glo/branch/master/graph/badge.svg)](https://codecov.io/gh/lajosbencz/glo)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/696a39293abd4f42b3f749c8b022a039)](https://app.codacy.com/app/lajosbencz/glo)
[![Build Status](https://travis-ci.com/lajosbencz/glo.svg?branch=master)](https://travis-ci.com/lajosbencz/glo.svg?branch=master)

# GLO

## Logging library for Golang

Inspired by Monolog for PHP, severity levels are identical

### Install

```bash
go get github.com/lajosbencz/glo
```

### Severity levels

```bash
Debug     = 100
Info      = 200
Notice    = 250
Warning   = 300
Error     = 400
Critical  = 500
Alert     = 550
Emergency = 600
```

### Simple example

```go
package main

import "github.com/lajosbencz/glo"

func main() {
	// Info - Warning will go to os.Stdout
	// Error - Emergency will go to os.Stderr
	log := glo.NewStdFacility()

	// goes to os.Stdout
	log.Debug("Detailed debug line: %#v", map[string]string{"x": "foo", "y": "bar"})

	// goes to os.Stderr
	log.Error("Oooof!")
}
```

Output:

```bash
2019-01-22T15:16:08+01:00 [DEBUG] Detailed debug line [map[x:foo y:bar]]
2019-01-22T15:16:08+01:00 [ERROR] Oooof! []
```

### Customized example

```go
package main

import (
	"bytes"
	"fmt"
	"os"
	"strings"

	"github.com/lajosbencz/glo"
)

func main() {
	log := glo.NewFacility()

	// write everything to a buffer
	bfr := bytes.NewBufferString("")
	handlerBfr := glo.NewHandler(bfr)
	log.PushHandler(handlerBfr)

	// write only errors and above using a short format
	handlerStd := glo.NewHandler(os.Stdout)
	formatter := glo.NewFormatter("{L}: {M}")
	filter := glo.NewFilterLevel(glo.Error)
	handlerStd.SetFormatter(formatter)
	handlerStd.PushFilter(filter)
	log.PushHandler(handlerStd)

	fmt.Println("Log output:")
	fmt.Println(strings.Repeat("=", 70))
	log.Info("Only written to the buffer")
	log.Alert("Written to both buffer and stdout")

	fmt.Println("")
	fmt.Println("Buffer contents:")
	fmt.Println(strings.Repeat("=", 70))
	fmt.Println(bfr.String())
}
```

Output:

```bash
Log output:
======================================================================
ALERT: Written to both buffer and stdout []

Buffer contents:
======================================================================
2019-01-22T15:14:16+01:00 [INFO] Only written to the buffer []
2019-01-22T15:14:16+01:00 [ALERT] Written to both buffer and stdout []
```

### Custom filter

```go
package main

import (
	"os"
	"regexp"

	"github.com/lajosbencz/glo"
)

func main() {
	handler := glo.NewHandler(os.Stdout)
	filterEmptyLines := &filterRgx{regexp.MustCompile(`^.+$`)}
	handler.PushFilter(filterEmptyLines)

	log := glo.NewFacility()
	log.PushHandler(handler)

	log.Debug("", "format is empty, should be ignored")
	log.Debug("only this should appear at the output")
}

type filterRgx struct {
	rgx *regexp.Regexp
}

func (f *filterRgx) Check(level glo.Level, line string, params ...interface{}) bool {
	return f.rgx.MatchString(line)
}
```

Output:

```bash
2019-01-22T15:30:23+01:00 [DEBUG] only this should appear at the output
```


# glog

[![PkgGoDev](https://pkg.go.dev/badge/github.com/golang/glog)](https://pkg.go.dev/github.com/golang/glog)

Leveled execution logs for Go.

This is an efficient pure Go implementation of leveled logs in the
manner of the open source C++ package [_glog_](https://github.com/google/glog).

By binding methods to booleans it is possible to use the log package without paying the expense of evaluating the arguments to the log. Through the `-vmodule` flag, the package also provides fine-grained
control over logging at the file level.

The comment from `glog.go` introduces the ideas:

Package _glog_ implements logging analogous to the Google-internal C++ INFO/ERROR/V setup.  It provides the functions Info, Warning, Error, Fatal, plus formatting variants such as Infof. It also provides V-style loggingcontrolled by the `-v` and `-vmodule=file=2` flags.
	
Basic examples:

```go
glog.Info("Prepare to repel boarders")
	
glog.Fatalf("Initialization failed: %s", err)
```
	
See the documentation for the V function for an explanation of these examples:

```go
if glog.V(2) {
	glog.Info("Starting transaction...")
}
glog.V(2).Infoln("Processed", nItems, "elements")
```

The repository contains an open source version of the log package used inside Google. The master copy of the source lives inside Google, not here. The code in this repo is for export only and is not itself under development. Feature requests will be ignored.

Send bug reports to golang-nuts@googlegroups.com.


glog

Simple writer that rotate log files automatically based on current date and time, like cronolog.

# cronowriter

[![GoDoc Reference](https://godoc.org/github.com/utahta/go-cronowriter?status.svg)](http://godoc.org/github.com/utahta/go-cronowriter)
[![CircleCI](https://circleci.com/gh/utahta/go-cronowriter.svg?style=svg)](https://circleci.com/gh/utahta/go-cronowriter)
[![codecov](https://codecov.io/gh/utahta/go-cronowriter/branch/master/graph/badge.svg)](https://codecov.io/gh/utahta/go-cronowriter)
[![Go Report Card](https://goreportcard.com/badge/github.com/utahta/go-cronowriter)](https://goreportcard.com/report/github.com/utahta/go-cronowriter)
[![GitHub release](https://img.shields.io/github/release/utahta/go-cronowriter.svg)](https://github.com/utahta/go-cronowriter/releases)

This is a simple file writer that it writes message to the specified format path.

The file path is constructed based on current date and time, like cronolog.

This project follows the [Semantic Versioning](https://semver.org/).

## Installation

```
$ go get -u github.com/utahta/go-cronowriter
```

## Documentation

API documentation can be found [here](http://godoc.org/github.com/utahta/go-cronowriter).

The format specifications can be found [here](https://github.com/lestrrat-go/strftime#supported-conversion-specifications).

## Examples

```go
import "github.com/utahta/go-cronowriter"
```

```go
w := cronowriter.MustNew("/path/to/example.log.%Y%m%d")
w.Write([]byte("test"))

// output file
// /path/to/example.log.20170204
```

You can specify the directory as below
```go
w := cronowriter.MustNew("/path/to/%Y/%m/%d/example.log")
w.Write([]byte("test"))

// output file
// /path/to/2017/02/04/example.log
```

with Location
```go
w := cronowriter.MustNew("/path/to/example.log.%Z", writer.WithLocation(time.UTC))
w.Write([]byte("test"))

// output file
// /path/to/example.log.UTC
```

with Symlink
```go
w := cronowriter.MustNew("/path/to/example.log.%Y%m%d", writer.WithSymlink("/path/to/example.log"))
w.Write([]byte("test"))

// output file
// /path/to/example.log.20170204
// /path/to/example.log -> /path/to/example.log.20170204
```

with Mutex
```go
w := cronowriter.MustNew("/path/to/example.log.%Y%m%d", writer.WithMutex())
```

no use Mutex
```go
w := cronowriter.MustNew("/path/to/example.log.%Y%m%d", writer.WithNopMutex())
```

with Debug (stdout and stderr)
```go
w := cronowriter.MustNew("/path/to/example.log.%Y%m%d", writer.WithDebug())
w.Write([]byte("test"))

// output file, stdout and stderr
// /path/to/example.log.20170204
```

with Init
```go
w := cronowriter.MustNew("/path/to/example.log.%Y%m%d", writer.WithInit())

// open the file when New() method is called
// /path/to/example.log.20170204
```

## Example using with zap

### [uber-go/zap](https://github.com/uber-go/zap)

```go
package main

import (
	"github.com/utahta/go-cronowriter"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

func main() {
	w1 := cronowriter.MustNew("/tmp/example.log.%Y%m%d")
	w2 := cronowriter.MustNew("/tmp/internal_error.log.%Y%m%d")
	l := zap.New(
		zapcore.NewCore(
			zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
			zapcore.AddSync(w1),
			zapcore.InfoLevel,
		),
		zap.ErrorOutput(zapcore.AddSync(w2)),
	)
	l.Info("test")
}

// output
// /tmp/example.log.20170204
// {"level":"info","ts":1486198722.1201255,"msg":"test"}
```

## Contributing

1. Fork it ( https://github.com/utahta/go-cronowriter/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request



go-cronowriter

A logging library with stack traces, object dumping and optional timestamps.

## go-log

[![Build Status](https://img.shields.io/github/workflow/status/pieterclaerhout/go-log/Go)](https://github.com/pieterclaerhout/go-log/actions?query=workflow%3AGo)
[![Go Report Card](https://goreportcard.com/badge/github.com/pieterclaerhout/go-log)](https://goreportcard.com/report/github.com/pieterclaerhout/go-log)
[![Documentation](https://godoc.org/github.com/pieterclaerhout/go-log?status.svg)](http://godoc.org/github.com/pieterclaerhout/go-log)
[![license](https://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://github.com/pieterclaerhout/go-log/raw/master/LICENSE)
[![GitHub version](https://badge.fury.io/gh/pieterclaerhout%2Fgo-log.svg)](https://badge.fury.io/gh/pieterclaerhout%2Fgo-log)
[![GitHub issues](https://img.shields.io/github/issues/pieterclaerhout/go-log.svg)](https://github.com/pieterclaerhout/go-log/issues)

This is a [Golang](https://golang.org) library with logging related functions which I use in my different projects.

## Usage

```go
package main

import (
    "github.com/pieterclaerhout/go-log"
)

func main() {

    log.DebugMode = true
    log.PrintTimestamp = true
    log.PrintColors = true
    log.TimeFormat = "2006-01-02 15:04:05.000"

    myVar := map[string]string{"hello": "world"}

    log.Debug("arg1", "arg2")
    log.Debugf("arg1 %d", 1)
    log.DebugDump(myVar, "prefix")
    log.DebugSeparator("title")

    log.Info("arg1", "arg2")
    log.Infof("arg1 %d", 1)
    log.InfoDump(myVar, "prefix")
    log.InfoSeparator("title")

    log.Warn("arg1", "arg2")
    log.Warnf("arg1 %d", 1)
    log.WarnDump(myVar, "prefix")
    log.WarnSeparator("title")

    log.Error("arg1", "arg2")
    log.Errorf("arg1 %d", 1)
    log.ErrorDump(myVar, "prefix")
    log.ErrorSeparator("title")

    log.Fatal("arg1", "arg2")
    log.Fatalf("arg1 %d", 1)

    err1 := funcWithError()
    log.StackTrace(err1)

    err2 := funcWithError()
    log.CheckError(err2)

}
```

## Environment variables

The defaults are taken from the environment variables:

* `DEBUG`: `log.DebugMode`
* `PRINT_TIMESTAMP`: `log.PrintTimestamp`

go-log

Simple and configurable Logging in Go, with level, formatters and writers.

go-log
================

[![GoDoc](https://godoc.org/github.com/subchen/go-log?status.svg)](https://godoc.org/github.com/subchen/go-log)
[![Build Status](https://travis-ci.org/subchen/go-log.svg?branch=master)](https://travis-ci.org/subchen/go-log)
[![Coverage Status](https://coveralls.io/repos/github/subchen/go-log/badge.svg?branch=master)](https://coveralls.io/github/subchen/go-log?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/subchen/go-log)](https://goreportcard.com/report/github.com/subchen/go-log)
[![License](http://img.shields.io/badge/License-Apache_2-red.svg?style=flat)](http://www.apache.org/licenses/LICENSE-2.0)

Logging package similar to log4j for the Golang.

- Support dynamic log level
- Support customized formatter
  - TextFormatter
  - JSONFormatter
- Support multiple rolling file writers
  - FixedSizeFileWriter
  - DailyFileWriter
  - AlwaysNewFileWriter

Installation
---------------

```bash
$ go get github.com/subchen/go-log
```

Usage
---------------

```go
package main

import (
	"os"
	"errors"
	"github.com/subchen/go-log"
)

func main() {
	log.Debugf("app = %s", os.Args[0])
	log.Errorf("error = %v", errors.New("some error"))

	// dynamic set level
	log.Default.Level = log.WARN

	log.Debug("cannot output debug message")
	log.Errorln("can output error message", errors.New("some error"))
}
```

### Output

Default log to console, you can set `Logger.Out` to set a file writer into log.

```go
import (
	"github.com/subchen/go-log"
	"github.com/subchen/go-log/writers"
)

log.Default.Out = &writers.FixedSizeFileWriter{
	Name:	 "/tmp/test.log",
	MaxSize:  10 * 1024 * 1024, // 10m
	MaxCount: 10,
})
```

Three builtin writers for use

```go
// Create log file if file size large than fixed size (10m)
// files: /tmp/test.log.0 .. test.log.10
&writers.FixedSizeFileWriter{
	Name:	 "/tmp/test.log",
	MaxSize:  10 * 1024 * 1024, // 10m
	MaxCount: 10,
}

// Create log file every day.
// files: /tmp/test.log.20160102
&writers.DailyFileWriter{
	Name: "/tmp/test.log",
	MaxCount: 10,
}

// Create log file every process.
// files: /tmp/test.log.20160102_150405
&writers.AlwaysNewFileWriter{
	Name: "/tmp/test.log",
	MaxCount: 10,
}

// Output to multiple writes
io.MultiWriter(
	os.Stdout,
	&writers.DailyFileWriter{
		Name: "/tmp/test.log",
		MaxCount: 10,
	}
	//...
)
```

### Formatter

```go
import (
	"github.com/subchen/go-log"
	"github.com/subchen/go-log/formatters"
)

log.Default.Formatter = new(formatters.TextFormatter)
```


### New Logger instance

```go
import (
	"github.com/subchen/go-log"
)

func main() {
	logger := &log.Logger{
		Level:     log.INFO,
		Formatter: new(formatters.JSONFormatter),
		Out:       os.Stdout,
	}

	logger.Infof("i = %d", 99)
}
```

## LICENSE

Apache 2.0


Log lib supports level and multi handlers.

## go-log

a golang log lib supports level and multi handlers

## Use

    import "github.com/siddontang/go-log/log"

    //log with different level
    log.Info("hello world")
    log.Error("hello world")

    //create a logger with specified handler
    h := NewStreamHandler(os.Stdout)
    l := log.NewDefault(h)
    l.Info("hello world")

## go-doc

[![GoDoc](https://godoc.org/github.com/siddontang/go-log?status.png)](https://godoc.org/github.com/siddontang/go-log)


Go-Log
======

[![Build Status](https://travis-ci.org/ian-kent/go-log.svg?branch=master)](https://travis-ci.org/ian-kent/go-log)

A logger, for Go!

It's sort of ```log``` and ```code.google.com/p/log4go``` compatible, so in most cases
can be used without any code changes.

#### Breaking change

go-log was inconsistent with the default Go 'log' package, and log.Fatal calls didn't trigger an os.Exit(1).

This has been fixed in the current release of go-log, which might break backwards compatibility.

You can disable the fix by setting ExitOnFatal to false, e.g.

    log.Logger().ExitOnFatal = false

### Getting started

Install go-log:

```
go get github.com/ian-kent/go-log/log
```

Use the logger in your application:

```
import(
  "github.com/ian-kent/go-log/log"
)

// Pass a log message and arguments directly
log.Debug("Example log message: %s", "example arg")

// Pass a function which returns a log message and arguments
log.Debug(func(){[]interface{}{"Example log message: %s", "example arg"}})
log.Debug(func(i ...interface{}){[]interface{}{"Example log message: %s", "example arg"}})
```

You can also get the logger instance:
```
logger := log.Logger()
logger.Debug("Yey!")
```

Or get a named logger instance:

```
logger := log.Logger("foo.bar")
```

### Log levels

The default log level is DEBUG.

To get the current log level:

```
level := logger.Level()
```

Or to set the log level:

```
// From a LogLevel
logger.SetLevel(levels.TRACE)

// From a string
logger.SetLevel(log.Stol("TRACE"))
```

### Log appenders

The default log appender is ```appenders.Console()```, which logs
the raw message to STDOUT.

To get the current log appender:

```
appender := logger.Appender()
```

If the appender is ```nil```, the parent loggers appender will be used
instead.

If the appender eventually resolves to ```nil```, log data will be
silently dropped.

You can set the log appender:

```
logger.SetAppender(appenders.Console())
```

#### Rolling file appender

Similar to log4j's rolling file appender, you can use

```
// Append to (or create) file
logger.SetAppender(appenders.RollingFile("filename.log", true))

// Truncate (or create) file
logger.SetAppender(appenders.RollingFile("filename.log", false))
```

You can also control the number of log files which are kept:
```
r := appenders.RollingFile("filename.log", true)
r.MaxBackupIndex = 2 // filename.log, filename.log.1, filename.log.2
```

And the maximum log file size (in bytes):
```
r := appenders.RollingFile("filename.log", true)
r.MaxFileSize = 1024 // 1KB, defaults to 100MB
```

#### Fluentd appender

The fluentd appender lets you write log data directly to fluentd:

```
logger.SetAppender(appenders.Fluentd(fluent.Config{}))
```

It uses ```github.com/t-k/fluent-logger-golang```.

The tag is currently fixed to 'go-log', and the data structure sent
to fluentd is simple:

```
{
  message: "<output from layout>"
}

```

### Layouts

Each appender has its own layout. This allows the log data to be transformed
as it is written to the appender.

The default layout is ```layout.Basic()```, which passes the log message
and its arguments through ```fmt.Sprintf```.

To get the current log appender layout:
```
appender := logger.Appender()
layout := appender.Layout()
```

To set the log appender layout:
```
appender.SetLayout(layout.Basic())
```

You can also use ```layout.Pattern(pattern string)```, which accepts a
pattern format similar to log4j:

| Code | Description
| ---- | -----------
| %c   | The package the log statement is in
| %C   | Currently also the package the log statement is in
| %d   | The current date/time, using ```time.Now().String()```
| %F   | The filename the log statement is in
| %l   | The location of the log statement, e.g. ```package/somefile.go:12```
| %L   | The line number the log statement is on
| %m   | The log message and its arguments formatted with ```fmt.Sprintf```
| %n   | A new-line character
| %p   | Priority - the log level
| %r   | ms since logger was created

### Logger inheritance

Loggers are namespaced with a ```.```, following similar rules to Log4j.

If you create a logger named ```foo```, it will automatically inherit the
log settings (levels and appender) of the root logger.

If you then create a logger named ```foo.bar```, it will inherit the log
settings of ```foo```, which in turn inherits the log settings from the
root logger.

You can break this by setting the log level or setting an appender on
a child logger, e.g.:

```
logger := log.Logger("foo.bar")
logger.SetLevel(levels.TRACE)
logger.SetAppender(appenders.Console())
```

If you then created a logger named ```foo.bar.qux```, it would inherit
the trace level and console appender of the ```foo.bar``` logger.

### Roadmap

* log4j configuration support
  * .properties
  * .xml
  * .json
* layouts
  * fixmes/todos in pattern layout
* appenders
  * add socket appender
  * fixmes/todos and tests for fluentd appender
* optimise logger creation
  * collapse loggers when parent namespace is unused
  * reorganise loggers when new child tree is created
* add godoc documentation

### Contributing

Before submitting a pull request:

  * Format your code: ```go fmt ./...```
  * Make sure tests pass: ```go test ./...```

### Licence

Copyright ©‎ 2014, Ian Kent (http://www.iankent.eu).

Released under MIT license, see [LICENSE](LICENSE.md) for details.


Simple logger of Go Programs, with level handlers.


# go-logger

[![Build Status](https://travis-ci.org/apsdehal/go-logger.svg?branch=master)](https://travis-ci.org/apsdehal/go-logger)
[![GoDoc](https://godoc.org/github.com/apsdehal/go-logger?status.svg)](http://godoc.org/github.com/apsdehal/go-logger)

A simple go logger for easy logging in your programs. Allows setting custom format for messages.

# Preview

[![Example Output](examples/example.png)](examples/example.go)


# Install

`go get github.com/apsdehal/go-logger`

Use `go get -u` to update the package.

# Example

Example [program](examples/example.go) demonstrates how to use the logger. See below for __formatting__ instructions.


```go
package main

import (
	"github.com/apsdehal/go-logger"
	"os"
)

func main () {
	// Get the instance for logger class, "test" is the module name, 1 is used to
	// state if we want coloring
	// Third option is optional and is instance of type io.Writer, defaults to os.Stderr
	log, err := logger.New("test", 1, os.Stdout)
	if err != nil {
		panic(err) // Check for error
	}

	// Critically log critical
	log.Critical("This is Critical!")
	log.CriticalF("%+v", err)
	// You can also use fmt compliant naming scheme such as log.Criticalf, log.Panicf etc
	// with small 'f'
	
	// Debug
	// Since default logging level is Info this won't print anything
	log.Debug("This is Debug!")
	log.DebugF("Here are some numbers: %d %d %f", 10, -3, 3.14)
	// Give the Warning
	log.Warning("This is Warning!")
	log.WarningF("This is Warning!")
	// Show the error
	log.Error("This is Error!")
	log.ErrorF("This is Error!")
	// Notice
	log.Notice("This is Notice!")
	log.NoticeF("%s %s", "This", "is Notice!")
	// Show the info
	log.Info("This is Info!")
	log.InfoF("This is %s!", "Info")

	log.StackAsError("Message before printing stack");

	// Show warning with format
	log.SetFormat("[%{module}] [%{level}] %{message}")
	log.Warning("This is Warning!") // output: "[test] [WARNING] This is Warning!"
	// Also you can set your format as default format for all new loggers
	logger.SetDefaultFormat("%{message}")
	log2, _ := logger.New("pkg", 1, os.Stdout)
	log2.Error("This is Error!") // output: "This is Error!"

	// Use log levels to set your log priority
	log2.SetLogLevel(DebugLevel)
	// This will be printed
	log2.Debug("This is debug!")
	log2.SetLogLevel(WarningLevel)
	// This won't be printed
	log2.Info("This is an error!")
}
```


# Formatting

By default all log messages have format that you can see above (on pic).
But you can override the default format and set format that you want.

You can do it for Logger instance (after creating logger) ...
```go
log, _ := logger.New("pkgname", 1)
log.SetFormat(format)
```
... or for package
```go
logger.SetDefaultFormat(format)
```
If you do it for package, all existing loggers will print log messages with format that these used already.
But all newest loggers (which will be created after changing format for package) will use your specified format.

But anyway after this, you can still set format of message for specific Logger instance.

Format of log message must contains verbs that represent some info about current log entry.
Ofc, format can contain not only verbs but also something else (for example text, digits, symbols, etc)

### Format verbs:
You can use the following verbs:
```
%{id}           - means number of current log message
%{module}       - means module name (that you passed to func New())
%{time}			- means current time in format "2006-01-02 15:04:05"
%{time:format}	- means current time in format that you want
					(supports all formats supported by go package "time")
%{level}		- means level name (upper case) of log message ("ERROR", "DEBUG", etc)
%{lvl}			- means first 3 letters of level name (upper case) of log message ("ERR", "DEB", etc)
%{file} 		- means name of file in what you wanna write log
%{filename}		- means the same as %{file}
%{line}			- means line number of file in what you wanna write log
%{message}		- means your log message
```
Non-existent verbs (like ```%{nonex-verb}``` or ```%{}```) will be replaced by an empty string.
Invalid verbs (like ```%{inv-verb```) will be treated as plain text.

# Tests

Run:
- `go test logger` to run test on logger.
- `go test -bench=.` for benchmarks.

## Thanks

Thanks goes to all go-loggers out there which I used as reference.

## Contributors

Following contributors have made major contributions to go-logger:

- [@qioalice](https://github.com/qioalice)
- [@gjvnq](https://github.com/gjvnq)
- [@maezen](https://github.com/maezen)

## License

The [BSD 3-Clause license](http://opensource.org/licenses/BSD-3-Clause), the same as the [Go language](http://golang.org/LICENSE).


go-logger

Multiple-output, structured logging for Go with extensible logging outputs.

gomol
=====

[![GoDoc](https://godoc.org/github.com/aphistic/gomol?status.svg)](https://godoc.org/github.com/aphistic/gomol)
[![Build Status](https://travis-ci.org/aphistic/gomol.svg?branch=master)](https://travis-ci.org/aphistic/gomol)
[![Code Coverage](https://img.shields.io/codecov/c/github/aphistic/gomol.svg)](http://codecov.io/github/aphistic/gomol?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/aphistic/gomol)](https://goreportcard.com/report/github.com/aphistic/gomol)

Gomol (Go Multi-Output Logger) is an MIT-licensed structured logging library for Go.  Gomol grew
from a desire to have a structured logging library that could write to any number of outputs
while also keeping a small in-band footprint.

Features
========

* Attach meta-data to each log message with attributes
* Multiple outputs at the same time
* Pluggable Logger interface
* Asynchronous logging so slow loggers won't slow down your application

Installation
============

Gomol can also be installed the standard way for Go:

    go get github.com/aphistic/gomol
    ...
    import "github.com/aphistic/gomol"

Vendoring is recommended!

Loggers
=======

Gomol has a growing list of supported logging formats.  The known loggers are listed
below.  If you have a logger you've written to support gomol and you'd like to add it
to this list please either submit a pull request with the updated document or let me
know and I can add it!

* **Console** - https://github.com/aphistic/gomol-console
* **Graylog Extended Log Format (GELF)** - https://github.com/aphistic/gomol-gelf
* **io.Writer** - https://github.com/aphistic/gomol-writer
* **JSON** - https://github.com/aphistic/gomol-json
* **Loggly** - https://github.com/aphistic/gomol-loggly

Other Usages
============

In addition to the loggers listed above, gomol can be used with other projects as well.

* **negroni-gomol** (https://github.com/aphistic/negroni-gomol) - Negroni logging middleware
	using gomol.

Examples
========

For brevity a lot of error checking has been omitted, be sure you do your checks!

This is a super basic example of adding a number of loggers and then logging a few messages:

```go
package main

import (
	"github.com/aphistic/gomol"
	gc "github.com/aphistic/gomol-console"
	gg "github.com/aphistic/gomol-gelf"
)

func main() {
	// Add a console logger
	consoleCfg := gc.NewConsoleLoggerConfig()
	consoleLogger, _ := gc.NewConsoleLogger(consoleCfg)
	// Set the template to display the full message, including
	// attributes.
	consoleLogger.SetTemplate(gc.NewTemplateFull())
	gomol.AddLogger(consoleLogger)

	// Add a GELF logger
	gelfCfg := gg.NewGelfLoggerConfig()
	gelfCfg.Hostname = "localhost"
	gelfCfg.Port = 12201
	gelfLogger, _ := gg.NewGelfLogger(gelfCfg)
	gomol.AddLogger(gelfLogger)

	// Set some global attrs that will be added to all
	// messages automatically
	gomol.SetAttr("facility", "gomol.example")
	gomol.SetAttr("another_attr", 1234)

	// Configure gomol to add the filename and line number that the
	// log was generated from, the internal sequence number to help
	// with ordering events if your log system doesn't support a
	// small enough sub-second resolution, and set the size of the
	// internal queue (default is 10k messages).
	cfg := gomol.NewConfig()
	cfg.FilenameAttr = "filename"
	cfg.LineNumberAttr = "line"
	cfg.SequenceAttr = "sequence"
	cfg.MaxQueueSize = 50000
	gomol.SetConfig(cfg)

	// Initialize the loggers
	gomol.InitLoggers()
	defer gomol.ShutdownLoggers()

	// Create a channel on which to receive internal (asynchronous)
	// logger errors. This is optional, but recommended in order to
	// determine when logging may be dropping messages.
	ch := make(chan error)

	go func() {
		// This consumer is expected to be efficient as writes to 
		// the channel are blocking. If this handler is slow, the
		// user should add a buffer to the channel, or manually
		// queue and batch errors for processing.

		for err := range ch {
			fmt.Printf("[Internal Error] %s\n", err.Error())
		}
	}()

	gomol.SetErrorChan(ch)

	// Log some debug messages with message-level attrs
	// that will be sent only with that message
	for idx := 1; idx <= 10; idx++ {
		gomol.Dbgm(gomol.NewAttrsFromMap(map[string]interface{}{
			"msg_attr1": 4321,
		}), "Test message %v", idx)
	}
}
```

Fallback Logger
===============

One feature gomol supports is the concept of a fallback logger.  In some cases a logger
may go unhealthy (a logger to a remote server, for example) and you want to log to a
different logger to ensure log messages are not lost.  The SetFallbackLogger method is
available for these such instances.

A fallback logger will be triggered if any of the primary loggers goes unhealthy even if
all others are fine. It's recommended the fallback logger not be added to the primary
loggers or you may see duplicate messages.  This does mean if multiple loggers are added
as primary loggers and just one is unhealthy the fallback logger logger will be triggered.

To add a fallback logger there are two options.  One is to use the default gomol instance
(`gomol.SetFallbackLogger()`) and the other is to use the method on a Base instance:

```go
import (
	"github.com/aphistic/gomol"
	"github.com/aphistic/gomol-console"
	"github.com/aphistic/gomol-json"
)

func main() {
	// Create a logger that logs over TCP using JSON
	jsonCfg := gomoljson.NewJSONLoggerConfig("tcp://192.0.2.125:4321")
	// Continue startup even if we can't connect initially
	jsonCfg.AllowDisconnectedInit = true
	jsonLogger, _ := gomoljson.NewJSONLogger(jsonCfg)
	gomol.AddLogger(jsonLogger)

	// Create a logger that logs to the console
	consoleCfg := gomolconsole.NewConsoleLoggerConfig()
	consoleLogger, _ := gomolconsole.NewConsoleLogger(consoleCfg)

	// Set the fallback logger to the console so if the
	// TCP JSON logger is unhealthy we still get logs
	// to stdout.
	_ = gomol.SetFallbackLogger(consoleLogger)

	gomol.InitLoggers()
	defer gomol.ShutdownLoggers()

	gomol.Debug("This is my message!")
}
```


gomol

A tiny debug logging tool inspired by [debug](https://github.com/visionmedia/debug), great for CLI tools and applications.

# kemba
[![License: MIT](https://img.shields.io/badge/License-MIT-brightgreen.svg)](https://github.com/clok/kemba/blob/master/LICENSE)
[![Go Report Card](https://goreportcard.com/badge/clok/kemba)](https://goreportcard.com/report/clok/kemba)
[![Coverage Status](https://coveralls.io/repos/github/clok/kemba/badge.svg)](https://coveralls.io/github/clok/kemba)
[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white)](https://pkg.go.dev/github.com/clok/kemba?tab=overview)
[![Mentioned in Awesome
Go](https://awesome.re/mentioned-badge-flat.svg)](https://github.com/avelino/awesome-go)

`debug` logging tool inspired by https://github.com/visionmedia/debug

#### Why is it named `kemba`?

`debug` is more generally considered to be [`runtime/debug`](https://golang.org/pkg/runtime/debug/) within Go. Since this takes heavy inspiration from my experiences using the `npm` module [`debug`](https://github.com/visionmedia/debug) I wanted to find a word that was somewhat connected to the inspiration. According to [Google translate](https://www.google.com/search?q=debug+in+icelandic) "debug" in English translated to Icelandic results in "kemba".

## Usage

The `kemba` logger reads the `DEBUG` and `KEMBA` environment variables to determine if a log line should be output. The logger outputs to `STDERR`.

When it is not set, the logger will immediately return, taking no action.

When the value is set (ex. `DEBUG=example:*,tool:details` and/or `KEMBA=plugin:fxn:start`), the logger will determine if it should be `enabled` when instantiated.

The value of these flags can be a simple regex alternative where a wildcard (`*`) are replaced with `.*` and all terms are prepended with `^` and appended with `$`. If a term does not include a wildcard, then an exact match it required.

Example of a wildcard in the middle of a tag string: `DEBUG=example:*:fxn` will match tags like `[example:tag1:fxn, example:tag2:fxn, example:anything:fxn, ...]`

To disabled colors, set the `NOCOLOR` environment variable to any value.

![image](https://user-images.githubusercontent.com/1429775/88557149-7973ff80-cfef-11ea-8ec2-ff332fd1b25f.png)

```go
package main

import (
    "time"

	"github.com/clok/kemba"
)

type myType struct {
	a, b int
}

// When the DEBUG or KEMBA environment variable is set to DEBUG=example:* the kemba logger will output to STDERR
func main () {
    k := kemba.New("example:tag")
	
    var x = []myType{
    	{1, 2},
    	{3, 4},
    }
    k.Printf("%#v", x)
    // Output to os.Stderr
    // example:tag []main.myType{main.myType{a:1, b:2}, main.myType{a:3, b:4}} +0s

    // Artificial delay to demonstrate the time tagging
    time.Sleep(250 * time.Millisecond)
    k.Printf("%# v", x)
    k.Println(x)

    // Artificial delay to demonstrate the time tagging
    time.Sleep(100 * time.Millisecond)
    k.Log(x)
    // All result in the same output to os.Stderr
    // example:tag []main.myType{ +XXms
    // example:tag     {a:1, b:2},
    // example:tag     {a:3, b:4},
    // example:tag }

    // Create a new logger with an extended tag
    k1 := k.Extend("1")
    k1.Println("a string", 12, true)
    // Output to os.Stderr
    // example:tag:1 a string +0s
    // example:tag:1 int(12)
    // example:tag:1 bool(true)
}
```

## Development

1. Fork the [clok/kemba](https://github.com/clok/kemba) repo
1. Use `go >= 1.16`
1. Branch & Code
1. Run linters :broom: `golangci-lint run`
    - The project uses [golangci-lint](https://golangci-lint.run/usage/install/#local-installation)
1. Commit with a Conventional Commit
1. Open a PR

kemba

An O(1) logging system that allows you to connect one log to multiple writers (e.g. stdout, a file and a TCP connection).

# log

[![Godoc][godoc-image]][godoc-url]
[![Report][report-image]][report-url]
[![Tests][tests-image]][tests-url]
[![Coverage][coverage-image]][coverage-url]
[![Sponsor][sponsor-image]][sponsor-url]

An O(1) constant time logging system that allows you to connect one log to multiple writers (e.g. stdout, a file and a TCP connection).

## Installation

```shell
go get -u github.com/aerogo/log/...
```

## Example

```go
hello := log.New()                          // Create a new log
hello.AddWriter(log.File("hello.log"))      // Add a writer

hello.Info("Hello World %d %d %d", 1, 2, 3) // Write non-critical data (buffered)
hello.Error("Something went wrong")         // Force an immediate I/O flush for error messages
```

## Under the hood

All `Write` calls are queued into a channel that is read in a separate goroutine. Once the channel receives new data it writes the data to all registered outputs.

## Style

Please take a look at the [style guidelines](https://github.com/akyoto/quality/blob/master/STYLE.md) if you'd like to make a pull request.

## Sponsors

| [![Cedric Fung](https://avatars3.githubusercontent.com/u/2269238?s=70&v=4)](https://github.com/cedricfung) | [![Scott Rayapoullé](https://avatars3.githubusercontent.com/u/11772084?s=70&v=4)](https://github.com/soulcramer) | [![Eduard Urbach](https://avatars3.githubusercontent.com/u/438936?s=70&v=4)](https://twitter.com/eduardurbach) |
| --- | --- | --- |
| [Cedric Fung](https://github.com/cedricfung) | [Scott Rayapoullé](https://github.com/soulcramer) | [Eduard Urbach](https://eduardurbach.com) |

Want to see [your own name here?](https://github.com/users/akyoto/sponsorship)

[godoc-image]: https://godoc.org/github.com/aerogo/log?status.svg
[godoc-url]: https://godoc.org/github.com/aerogo/log
[report-image]: https://goreportcard.com/badge/github.com/aerogo/log
[report-url]: https://goreportcard.com/report/github.com/aerogo/log
[tests-image]: https://cloud.drone.io/api/badges/aerogo/log/status.svg
[tests-url]: https://cloud.drone.io/aerogo/log
[coverage-image]: https://codecov.io/gh/aerogo/log/graph/badge.svg
[coverage-url]: https://codecov.io/gh/aerogo/log
[sponsor-image]: https://img.shields.io/badge/github-donate-green.svg
[sponsor-url]: https://github.com/users/akyoto/sponsorship


Simple leveled logging wrapper around standard log package.

# `log` - Simple leveled logging based on standard log package

<p align="center">
  <img src="https://imagedelivery.net/r-FGMwXlTVvJHWFyznDr1Q/b6462eaf-74a1-4225-8548-45c4c8ea0100/public" width="800" title="hover text" alt="logo">
</p>

## Documentation
[![](https://goreportcard.com/badge/github.com/heartwilltell/log)](https://goreportcard.com/report/github.com/heartwilltell/log)
[![](https://pkg.go.dev/badge/github.com/heartwilltell/log?utm_source=godoc)](https://pkg.go.dev/github.com/heartwilltell/log)
[![Build](https://github.com/heartwilltell/log/actions/workflows/pr.yml/badge.svg?branch=master&event=push)](https://github.com/heartwilltell/log/actions/workflows/pr.yml)
[![codecov](https://codecov.io/gh/heartwilltell/log/branch/master/graph/badge.svg?token=JFY9EQ4F2A)](https://codecov.io/gh/heartwilltell/log)

## Benefits

- 😻 Leveled logging
- 😚 Simple API
- 🤝 `fmt` friendly
- 👌 Zero dependencies
- 😮‍💨 No global logger
- 👏 No structured logging bullshit


## Installation
```bash
go get github.com/heartwilltell/log
```

## Leveled logging

The `StdLog` implements a simple interface:
```go
// Logger formats the message according to standard format specifiers from the fmt package
// and writes the message to writer specified by the concrete interface implementation.
type Logger interface {
	// Error formats and writes the error level message.
	Error(format string, v ...any)
	// Warning formats and writes the warning level message.
	Warning(format string, v ...any)
	// Info formats and writes the information level message.
	Info(format string, v ...any)
	// Debug formats and writes the debug level message.
	Debug(format string, v ...any)
}
```

## Usage

👇 The usage is pretty simple. Just create a logger instance and call any of leveled methods.
```go
logger := log.New()
logger.Info("Listen on port: %d", 8080)
```
###

👇 Sets the logging level to `debug` level.
```go
logger := log.New(log.WithLevel(log.DBG))
```
###

👇 Parses string to level and creates logger with `warning` level.
```go
level, levelErr := log.ParseLevel("warning")
if levelErr != nil {
	// handle error here
}

logger := log.New(log.WithLevel(level))
```
###

👇 Creates logger with different `io.Writer`.
```go
var w bytes.Buffer 

logger := log.New(log.WithWriter(w))
```
###

👇 Disables the colorful output.
```go
logger := log.New(log.WithNoColor())
```
###

👇 Sets the UTC time format.
```go
logger := log.New(log.WithUTC())
```
###

👇 Enables printing the code line number.
```go
// Short format:
// INF: 2022/07/08 11:22:30 server.go:111: message
logger := log.New(log.WithLineNum(log.ShortFmt))
```
OR
```go
// Long format:
// INF: 2022/07/08 11:22:30 /Users/heartwilltell/Go/app/server.go:111: message
logger := log.New(log.WithLineNum(log.LongFmt))
```
###

👇 Sets the level mark at the end of log prefix.
```go
logger := log.New(log.WithLevelAtPrefixEnd())
```
Will produce this 👇
```
// 2022/07/08 11:22:30 INF: message
```
Instead of this 👇
```
// INF: 2022/07/08 11:22:30: message
```

###

👇 Creates nop logger which implements `log.Logger` interface.
```go
logger := log.NewNopLog()
```
💡 _Useful for tests or places where logger should be disabled by default_

## License
[MIT License](LICENSE).

Simple logging module for go, with 5 levels, an optional rotating logfile feature and stdout/stderr output.

A simple logging module for go, with a rotating file feature and console logging.

## Installation
go get github.com/jbrodriguez/mlog

## Usage
Sample usage

Write to stdout/stderr and create a rotating logfile
```go
package main

import "github.com/jbrodriguez/mlog"

func main() {
	mlog.Start(mlog.LevelInfo, "app.log")

	mlog.Info("Hello World !")

	ipsum := "ipsum"
	mlog.Warning("Lorem %s", ipsum)
}
```

Write to stdout/stderr only
```go
package main

import "github.com/jbrodriguez/mlog"

func main() {
	mlog.Start(mlog.LevelInfo, "")

	mlog.Info("Hello World !")

	ipsum := "ipsum"
	mlog.Warning("Lorem %s", ipsum)
}
```

By default, the log will be rolled over to a backup file when its size reaches 10Mb and 10 such files will be created (and eventually reused).

Alternatively, you can specify the max size of the log file before it gets rotated, and the number of backup files you want to create, with the StartEx function.

```go
package main

import "github.com/jbrodriguez/mlog"

func main() {
    mlog.StartEx(mlog.LevelInfo, "app.log", 5*1024*1024, 5)

    mlog.Info("Hello World !")

    ipsum := "ipsum"
    mlog.Warning("Lorem %s", ipsum)
}
```
This will rotate the file when it reaches 5Mb and 5 backup files will eventually be created.

Setting logger flags:
```go
mlog.DefaultFlags = log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile
```

## Output

```
I: 2015/05/15 07:09:45 main.go:10: Hello World !
W: 2015/05/15 07:09:45 main.go:13: Lorem ipsum
```


mlog

phuslu/log

# pp [![Go](https://github.com/k0kubun/pp/workflows/Go/badge.svg)](https://github.com/k0kubun/pp/actions) [![Go Reference](https://pkg.go.dev/badge/github.com/k0kubun/pp/v3.svg)](https://pkg.go.dev/github.com/k0kubun/pp/v3)

Colored pretty printer for Go language

![](http://i.gyazo.com/d3253ae839913b7239a7229caa4af551.png)

## Usage

Just call `pp.Print()`.

```go
import "github.com/k0kubun/pp/v3"

m := map[string]string{"foo": "bar", "hello": "world"}
pp.Print(m)
```

![](http://i.gyazo.com/0d08376ed2656257627f79626d5e0cde.png)

### API

fmt package-like functions are provided.

```go
pp.Print()
pp.Println()
pp.Sprint()
pp.Fprintf()
```

See [the documentation](https://pkg.go.dev/github.com/k0kubun/pp/v3#section-documentation) for API details.

### Configuration

They can be customized globally with `pp.Default`.

```go
pp.Default.SetColoringEnabled(false)
pp.Println() // no color
```

You can also create individual instances that do not interfere with the default printer:

```go
mypp := pp.New()
mypp.SetColoringEnabled(false)
mypp.SetExportedOnly(true)
mypp.Println()
```

See [PrettyPrinter documentation](https://pkg.go.dev/github.com/k0kubun/pp/v3#PrettyPrinter) for all available configurations.

### Custom colors

If you require, you may change the colors (all or some) for syntax highlighting:

```go
// Create a struct describing your scheme
scheme := pp.ColorScheme{
	Integer:       pp.Green | pp.Bold,
	Float:         pp.Black | pp.BackgroundWhite | pp.Bold,
	String:        pp.Yellow,
}

// Register it for usage
pp.Default.SetColorScheme(scheme)
```

Look into ColorScheme struct for the field names.

If you would like to revert to the default highlighting, you may do so by calling `pp.ResetColorScheme()`.

Out of the following color flags, you may combine any color with a background color and optionally with the bold parameter. Please note that bold will likely not work on the windows platform.

```go
// Colors
Black
Red
Green
Yellow
Blue
Magenta
Cyan
White

// Background colors
BackgroundBlack
BackgroundRed
BackgroundGreen
BackgroundYellow
BackgroundBlue
BackgroundMagenta
BackgroundCyan
BackgroundWhite

// Other
Bold

// Special
NoColor
```

## Demo

### Timeline

![](http://i.gyazo.com/a8adaeec965db943486e35083cf707f2.png)

### UserStream event

![](http://i.gyazo.com/1e88915b3a6a9129f69fb5d961c4f079.png)

### Works on windows

![](http://i.gyazo.com/ab791997a980f1ab3ee2a01586efdce6.png)

## License

MIT License


RollingWriter is an auto-rotate `io.Writer` implementation with multi policies to provide log file rotation.

# RollingWriter [![Build Status](https://travis-ci.org/arthurkiller/rollingWriter.svg?branch=master)](https://travis-ci.org/arthurkiller/rollingWriter) [![Go Report Card](https://goreportcard.com/badge/github.com/arthurkiller/rollingwriter)](https://goreportcard.com/report/github.com/arthurkiller/rollingwriter) [![GoDoc](https://godoc.org/github.com/arthurkiller/rollingWriter?status.svg)](https://godoc.org/github.com/arthurkiller/rollingWriter) [![codecov](https://codecov.io/gh/arthurkiller/rollingwriter/branch/master/graph/badge.svg)](https://codecov.io/gh/arthurkiller/rollingwriter) [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/avelino/awesome-go#logging)
RollingWriter is an auto rotate `io.Writer` implementation. It can works well with logger.

__Awesome Go popular log helper__

__New Version v2.0 is comming out! Much more Powerfull and Efficient. Try it by follow the demo__

RollingWriter contains 2 separate patrs:
* Manager: decide when to rotate the file with policy. RlingPolicy give out the rolling policy
    * WithoutRolling: no rolling will happen
    * TimeRolling: rolling by time
    * VolumeRolling: rolling by file size

* IOWriter: impement the io.Writer and do the io write
    * Writer: not parallel safe writer
    * LockedWriter: parallel safe garented by lock
    * AsyncWtiter: parallel safe async writer
    * BufferWriter: merge serval write into one `file.Write()`

## Features
* Auto rotate with multi rotate policies
* Implement go io.Writer, provide parallel safe writer
* Max remain rolling files with auto cleanup
* Easy for user to implement your manager

## Benchmark
```bash
goos: darwin
goarch: amd64
pkg: github.com/arthurkiller/rollingWriter
BenchmarkWrite-4                          300000              5952 ns/op               0 B/op          0 allocs/op
BenchmarkParallelWrite-4                  200000              7846 ns/op               0 B/op          0 allocs/op
BenchmarkAsynWrite-4                      200000              7917 ns/op           16324 B/op          1 allocs/op
BenchmarkParallelAsynWrite-4              200000              8632 ns/op           12513 B/op          1 allocs/op
BenchmarkLockedWrite-4                    200000              5829 ns/op               0 B/op          0 allocs/op
BenchmarkParallelLockedWrite-4            200000              7796 ns/op               0 B/op          0 allocs/op
BenchmarkBufferWrite-4                    200000              6943 ns/op            1984 B/op          4 allocs/op
BenchmarkParallelBufferWrite-4           1000000              1026 ns/op            7129 B/op          1 allocs/op
PASS
ok      github.com/arthurkiller/rollingWriter   14.867s
```

## Quick Start
```golang
	writer, err := rollingwriter.NewWriterFromConfig(&config)
	if err != nil {
		panic(err)
	}

	writer.Write([]byte("hello, world"))
```
Want more? View `demo` for more details.

Any suggestion or new feature inneed, please [put up an issue](https://github.com/arthurkiller/rollingWriter/issues/new)


rollingwriter

Logging functionality with flexible dispatching, filtering, and formatting.

Seelog
=======

Seelog is a powerful and easy-to-learn logging framework that provides functionality for flexible dispatching, filtering, and formatting log messages.
It is natively written in the [Go](http://golang.org/) programming language. 

[![Build Status](https://drone.io/github.com/cihub/seelog/status.png)](https://drone.io/github.com/cihub/seelog/latest)

Features
------------------

* Xml configuring to be able to change logger parameters without recompilation
* Changing configurations on the fly without app restart
* Possibility to set different log configurations for different project files and functions
* Adjustable message formatting
* Simultaneous log output to multiple streams
* Choosing logger priority strategy to minimize performance hit
* Different output writers
  * Console writer
  * File writer 
  * Buffered writer (Chunk writer)
  * Rolling log writer (Logging with rotation)
  * SMTP writer
  * Others... (See [Wiki](https://github.com/cihub/seelog/wiki))
* Log message wrappers (JSON, XML, etc.)
* Global variables and functions for easy usage in standalone apps
* Functions for flexible usage in libraries

Quick-start
-----------

```go
package main

import log "github.com/cihub/seelog"

func main() {
    defer log.Flush()
    log.Info("Hello from Seelog!")
}
```

Installation
------------

If you don't have the Go development environment installed, visit the 
[Getting Started](http://golang.org/doc/install.html) document and follow the instructions. Once you're ready, execute the following command:

```
go get -u github.com/cihub/seelog
```

*IMPORTANT*: If you are not using the latest release version of Go, check out this [wiki page](https://github.com/cihub/seelog/wiki/Notes-on-'go-get')

Documentation
---------------

Seelog has github wiki pages, which contain detailed how-tos references: https://github.com/cihub/seelog/wiki

Examples
---------------

Seelog examples can be found here: [seelog-examples](https://github.com/cihub/seelog-examples)

Issues
---------------

Feel free to push issues that could make Seelog better: https://github.com/cihub/seelog/issues

Changelog
---------------
* **v2.6** : Config using code and custom formatters
    * Configuration using code in addition to xml (All internal receiver/dispatcher/logger types are now exported).
    * Custom formatters. Check [wiki](https://github.com/cihub/seelog/wiki/Custom-formatters)
    * Bugfixes and internal improvements.
* **v2.5** : Interaction with other systems. Part 2: custom receivers
    * Finished custom receivers feature. Check [wiki](https://github.com/cihub/seelog/wiki/custom-receivers)
    * Added 'LoggerFromCustomReceiver'
    * Added 'LoggerFromWriterWithMinLevelAndFormat'
    * Added 'LoggerFromCustomReceiver'
    * Added 'LoggerFromParamConfigAs...' 
* **v2.4** : Interaction with other systems. Part 1: wrapping seelog
    * Added configurable caller stack skip logic
    * Added 'SetAdditionalStackDepth' to 'LoggerInterface'
* **v2.3** : Rethinking 'rolling' receiver
    * Reimplemented 'rolling' receiver
    * Added 'Max rolls' feature for 'rolling' receiver with type='date'
    * Fixed 'rolling' receiver issue: renaming on Windows
* **v2.2** : go1.0 compatibility point [go1.0 tag]
    * Fixed internal bugs
    * Added 'ANSI n [;k]' format identifier:  %EscN
    * Made current release go1 compatible 
* **v2.1** : Some new features
    * Rolling receiver archiving option.
    * Added format identifier: %Line
    * Smtp: added paths to PEM files directories
    * Added format identifier: %FuncShort
    * Warn, Error and Critical methods now return an error
* **v2.0** : Second major release. BREAKING CHANGES.
    * Support of binaries with stripped symbols
    * Added log strategy: adaptive
    * Critical message now forces Flush()
    * Added predefined formats: xml-debug, xml-debug-short, xml, xml-short, json-debug, json-debug-short, json, json-short, debug, debug-short, fast
    * Added receiver: conn (network connection writer)
    * BREAKING CHANGE: added Tracef, Debugf, Infof, etc. to satisfy the print/printf principle
    * Bug fixes
* **v1.0** : Initial release. Features:
    * Xml config
    * Changing configurations on the fly without app restart
    * Contraints and exceptions
    * Formatting
    * Log strategies: sync, async loop, async timer
    * Receivers: buffered, console, file, rolling, smtp





seelog

Simple Logging Facade for Golang: Simple structured logging; but powerful, extendable and customizable, with huge amount of learnings from decades of past logging frameworks.

[![PkgGoDev](https://pkg.go.dev/badge/github.com/echocat/slf4g)](https://pkg.go.dev/github.com/echocat/slf4g)
[![Continuous Integration](https://github.com/echocat/slf4g/workflows/Continuous%20Integration/badge.svg)](https://github.com/echocat/slf4g/actions?query=workflow%3A%22Continuous+Integration%22)
[![Coverage Status](https://coveralls.io/repos/github/echocat/slf4g/badge.svg?branch=main)](https://coveralls.io/github/echocat/slf4g?branch=main)
[![Go Report Card](https://goreportcard.com/badge/github.com/echocat/slf4g)](https://goreportcard.com/report/github.com/echocat/slf4g)

# Simple Log Framework for Golang (slf4g)

## TOC

* [Principles](#principles)
* [Motivation](#motivation)
* [Getting started](#getting-started)
* [Implementations](#implementations)
* [Contributing](#contributing)
* [License](#license)

## Principles

### KISS for users

If you want to log something it should be easy, intuitive and straight forward. This should work either for very small applications (just one file) or big applications, too.

You should not care about the implementation, you want just to use it.

### KISS for implementators

If you want to implement a new logger you should not be required to educate your users how to use it.

You just want to write a logger for a user-case. Someone else should take care of the public API.

### Separation

A logging framework should not be both, by design: API and implementation.

You want to have one API and the possibility to use whatever implementation you want.

### Interoperable

Regardless how used or implemented you want that just everything sticks together, and you're not ending up over and over again in writing new wrappers or in worst-case see different styled log messages in the console.

Every library should just work transparently with one logger.

## Motivation

I've tried out many logging frameworks for Golang. They're coming with different promises, like:

1. There are ones which tries to be "blazing fast"; focussing on be fast and non-blocking to be able to log as much log events as possible.

2. Other ones are trying to be as minimalistic as possible. Just using a very few amount of code to work.

3. ...

...but overall they're just violating the [Principles listed above](#principles) and we're ending up in just mess.

Slf4g is born out of feeling this pain every day again and be simply annoyed. It is inspired by [Simple Logging Facade for Java (SLF4J)](http://www.slf4j.org/), which was born out of the same pains; but obviously in Java before. Since [SLF4J](http://www.slf4j.org/) exists, and it is now broadly used in Java, nobody does experience this issues any longer.

## Getting started

It is very easy to use slf4g (as the naming is promising ☺️):

1. Import the API to your current project (in best with a [Go Modules project](https://blog.golang.org/using-go-modules))
    ```bash
    $ go get -u github.com/echocat/slf4g
    ```

2. Select one of the implementation of [slf4g](https://github.com/echocat/slf4g) and import it too (see [Implementations](#implementations)). Example:

    ```bash
    $ go get -u github.com/echocat/slf4g/native
    ```

   > ℹ️ If you do not pick one implementation the fallback logger is used. It works, too, but is obviously less powerful and is not customizable. It is comparable with the [SDK based logger](https://pkg.go.dev/log).

3. Configure your application to use the selected logger implementation:

   This should be only done in `main/main.go`:

    ```go
    package main
   
    import (
    	_ "github.com/echocat/slf4g/native"
    )
   
    func main() {
    	// do your stuff...
    }
    ```

4. In each package create a logger variable, in best case you create a file named `common.go` or `package.go` which will contain it:

    ```go
    package foo
   
    import (
    	"github.com/echocat/slf4g"
    )
   
    var logger = log.GetLoggerForCurrentPackage()
    ```

5. Now you're ready to go. In every file of this package you can do stuff, like:

    ```go
    package foo
   
    func MyFunction() {
    	logger.Info("Hello, world!")

    	if !loaded {
    		logger.With("field", 123).
    		       Warn("That's not great.")
    	}

    	if err := doSomething(); err != nil {
    		logger.WithError(err).
    		       Error("Doh!")
    	}
    }
    ```

   For sure, you're able to simply do stuff like that (although to ensure interoperability this is not recommended):

    ```go
    package foo
    
    import (
    	"github.com/echocat/slf4g"
    )
    
    func MyFunction() {
    	log.Info("Hello, world!")
    
    	if !loaded {
    		log.With("field", 123).
    		    Warn("That's not great.")
    	}

    	if err := doSomething(); err != nil {
    		log.WithError(err).
    		    Error("Doh!")
    	}
    }
    ```

Done. Enjoy!

## Implementations

1. [native](native): Reference implementation of [slf4g](https://github.com/echocat/slf4g).

2. [testlog](sdk/testlog): Ensure that everything which is logged within test by [slf4g](https://github.com/echocat/slf4g) appears correctly within tests.

2. [recording](testing/recording): Will record everything which is logged by [slf4g](https://github.com/echocat/slf4g) and can then be asserted inside test cases.

## Contributing

**slf4g** is an open source project by [echocat](https://echocat.org). So if you want to make this project even better, you can contribute to this project on [Github](https://github.com/echocat/slf4g) by [fork us](https://github.com/echocat/slf4g/fork).

If you commit code to this project, you have to accept that this code will be released under the [license](#license) of this project.

## License

See the [LICENSE](LICENSE) file.


slf4g

Lightweight, configurable, extensible logger for Go.

slog

Common formatters for slog and helpers to build your own.


# slog: Attribute formatting

[![tag](https://img.shields.io/github/tag/samber/slog-formatter.svg)](https://github.com/samber/slog-formatter/releases)
![Go Version](https://img.shields.io/badge/Go-%3E%3D%201.21-%23007d9c)
[![GoDoc](https://godoc.org/github.com/samber/slog-formatter?status.svg)](https://pkg.go.dev/github.com/samber/slog-formatter)
![Build Status](https://github.com/samber/slog-formatter/actions/workflows/test.yml/badge.svg)
[![Go report](https://goreportcard.com/badge/github.com/samber/slog-formatter)](https://goreportcard.com/report/github.com/samber/slog-formatter)
[![Coverage](https://img.shields.io/codecov/c/github/samber/slog-formatter)](https://codecov.io/gh/samber/slog-formatter)
[![Contributors](https://img.shields.io/github/contributors/samber/slog-formatter)](https://github.com/samber/slog-formatter/graphs/contributors)
[![License](https://img.shields.io/github/license/samber/slog-formatter)](./LICENSE)

Common formatters for [slog](https://pkg.go.dev/log/slog) library + helpers for building your own.

<div align="center">
  <hr>
  <sup><b>Sponsored by:</b></sup>
  <br>
  <a href="https://quickwit.io?utm_campaign=github_sponsorship&utm_medium=referral&utm_content=samber-slog-formatter&utm_source=github">
    <div>
      <img src="https://github.com/samber/oops/assets/2951285/49aaaa2b-b8c6-4f21-909f-c12577bb6a2e" width="240" alt="Quickwit">
    </div>
    <div>
      Cloud-native search engine for observability - An OSS alternative to Splunk, Elasticsearch, Loki, and Tempo.
    </div>
  </a>
  <hr>
</div>

**Handlers:**
- [NewFormatterHandler](#NewFormatterHandler): main handler
- [NewFormatterMiddleware](#NewFormatterMiddleware): compatible with `slog-multi` middlewares

**Common formatters:**
- [TimeFormatter](#TimeFormatter): transforms a `time.Time` into a readable string
- [UnixTimestampFormatter](#UnixTimestampFormatter): transforms a `time.Time` into a unix timestamp.
- [TimezoneConverter](#TimezoneConverter): set a `time.Time` to a different timezone
- [ErrorFormatter](#ErrorFormatter): transforms a go error into a readable error
- [HTTPRequestFormatter](#HTTPRequestFormatter-and-HTTPResponseFormatter): transforms a *http.Request into a readable object
- [HTTPResponseFormatter](#HTTPRequestFormatter-and-HTTPResponseFormatter): transforms a *http.Response into a readable object
- [PIIFormatter](#PIIFormatter): hide private Personal Identifiable Information (PII)
- [IPAddressFormatter](#IPAddressFormatter): hide ip address from logs
- [FlattenFormatterMiddleware](#FlattenFormatterMiddleware): returns a formatter middleware that flatten attributes recursively

**Custom formatter:**
- [Format](#Format): pass any attribute into a formatter
- [FormatByKind](#FormatByKind): pass attributes matching `slog.Kind` into a formatter
- [FormatByType](#FormatByType): pass attributes matching generic type into a formatter
- [FormatByKey](#FormatByKey): pass attributes matching key into a formatter
- [FormatByFieldType](#FormatByFieldType): pass attributes matching both key and generic type into a formatter
- [FormatByGroup](#FormatByGroup): pass attributes under a group into a formatter
- [FormatByGroupKey](#FormatByGroupKey): pass attributes under a group and matching key, into a formatter
- [FormatByGroupKeyType](#FormatByGroupKeyType): pass attributes under a group, matching key and matching a generic type, into a formatter

**See also:**

- [slog-multi](https://github.com/samber/slog-multi): `slog.Handler` chaining, fanout, routing, failover, load balancing...
- [slog-formatter](https://github.com/samber/slog-formatter): `slog` attribute formatting
- [slog-sampling](https://github.com/samber/slog-sampling): `slog` sampling policy
- [slog-mock](https://github.com/samber/slog-mock): `slog.Handler` for test purposes

**HTTP middlewares:**

- [slog-gin](https://github.com/samber/slog-gin): Gin middleware for `slog` logger
- [slog-echo](https://github.com/samber/slog-echo): Echo middleware for `slog` logger
- [slog-fiber](https://github.com/samber/slog-fiber): Fiber middleware for `slog` logger
- [slog-chi](https://github.com/samber/slog-chi): Chi middleware for `slog` logger
- [slog-http](https://github.com/samber/slog-http): `net/http` middleware for `slog` logger

**Loggers:**

- [slog-zap](https://github.com/samber/slog-zap): A `slog` handler for `Zap`
- [slog-zerolog](https://github.com/samber/slog-zerolog): A `slog` handler for `Zerolog`
- [slog-logrus](https://github.com/samber/slog-logrus): A `slog` handler for `Logrus`

**Log sinks:**

- [slog-datadog](https://github.com/samber/slog-datadog): A `slog` handler for `Datadog`
- [slog-betterstack](https://github.com/samber/slog-betterstack): A `slog` handler for `Betterstack`
- [slog-rollbar](https://github.com/samber/slog-rollbar): A `slog` handler for `Rollbar`
- [slog-loki](https://github.com/samber/slog-loki): A `slog` handler for `Loki`
- [slog-sentry](https://github.com/samber/slog-sentry): A `slog` handler for `Sentry`
- [slog-syslog](https://github.com/samber/slog-syslog): A `slog` handler for `Syslog`
- [slog-logstash](https://github.com/samber/slog-logstash): A `slog` handler for `Logstash`
- [slog-fluentd](https://github.com/samber/slog-fluentd): A `slog` handler for `Fluentd`
- [slog-graylog](https://github.com/samber/slog-graylog): A `slog` handler for `Graylog`
- [slog-quickwit](https://github.com/samber/slog-quickwit): A `slog` handler for `Quickwit`
- [slog-slack](https://github.com/samber/slog-slack): A `slog` handler for `Slack`
- [slog-telegram](https://github.com/samber/slog-telegram): A `slog` handler for `Telegram`
- [slog-mattermost](https://github.com/samber/slog-mattermost): A `slog` handler for `Mattermost`
- [slog-microsoft-teams](https://github.com/samber/slog-microsoft-teams): A `slog` handler for `Microsoft Teams`
- [slog-webhook](https://github.com/samber/slog-webhook): A `slog` handler for `Webhook`
- [slog-kafka](https://github.com/samber/slog-kafka): A `slog` handler for `Kafka`
- [slog-nats](https://github.com/samber/slog-nats): A `slog` handler for `NATS`
- [slog-parquet](https://github.com/samber/slog-parquet): A `slog` handler for `Parquet` + `Object Storage`
- [slog-channel](https://github.com/samber/slog-channel): A `slog` handler for Go channels

## 🚀 Install

```sh
go get github.com/samber/slog-formatter
```

**Compatibility**: go >= 1.21

No breaking changes will be made to exported APIs before v2.0.0.

⚠️ Warnings:
- in some case, you should consider implementing `slog.LogValuer` instead of using this library.
- use this library carefully, log processing can be very costly (!)

## 🚀 Getting started

The following example has 3 formatters that anonymize data, format errors and format user. 👇

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	"log/slog"
)

formatter1 := slogformatter.FormatByKey("very_private_data", func(v slog.Value) slog.Value {
    return slog.StringValue("***********")
})
formatter2 := slogformatter.ErrorFormatter("error")
formatter3 := slogformatter.FormatByType(func(u User) slog.Value {
	return slog.StringValue(fmt.Sprintf("%s %s", u.firstname, u.lastname))
})

logger := slog.New(
    slogformatter.NewFormatterHandler(formatter1, formatter2, formatter3)(
        slog.NewTextHandler(os.Stdout, nil),
    ),
)

err := fmt.Errorf("an error")
logger.Error("a message",
    slog.Any("very_private_data", "abcd"),
    slog.Any("user", user),
    slog.Any("err", err))

// outputs:
// time=2023-04-10T14:00:0.000000+00:00 level=ERROR msg="a message" error.message="an error" error.type="*errors.errorString" user="John doe" very_private_data="********"
```

## 💡 Spec

GoDoc: [https://pkg.go.dev/github.com/samber/slog-formatter](https://pkg.go.dev/github.com/samber/slog-formatter)

### NewFormatterHandler

Returns a slog.Handler that applies formatters to.

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	"log/slog"
)

type User struct {
	email     string
	firstname string
	lastname  string
}

formatter1 := slogformatter.FormatByKey("very_private_data", func(v slog.Value) slog.Value {
    return slog.StringValue("***********")
})
formatter2 := slogformatter.ErrorFormatter("error")
formatter3 := slogformatter.FormatByType(func(u User) slog.Value {
	return slog.StringValue(fmt.Sprintf("%s %s", u.firstname, u.lastname))
})

logger := slog.New(
    slogformatter.NewFormatterHandler(formatter1, formatter2, formatter3)(
        slog.NewTextHandler(os.StdErr, nil),
    ),
)

err := fmt.Errorf("an error")
logger.Error("a message",
    slog.Any("very_private_data", "abcd"),
    slog.Any("user", user),
    slog.Any("err", err))

// outputs:
// time=2023-04-10T14:00:0.000000+00:00 level=ERROR msg="a message" error.message="an error" error.type="*errors.errorString" user="John doe" very_private_data="********"
```

### NewFormatterMiddleware

Returns a `slog-multi` middleware that applies formatters to.

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	slogmulti "github.com/samber/slog-multi"
	"log/slog"
)

formatter1 := slogformatter.FormatByKey("very_private_data", func(v slog.Value) slog.Value {
    return slog.StringValue("***********")
})
formatter2 := slogformatter.ErrorFormatter("error")
formatter3 := slogformatter.FormatByType(func(u User) slog.Value {
	return slog.StringValue(fmt.Sprintf("%s %s", u.firstname, u.lastname))
})

formattingMiddleware := slogformatter.NewFormatterHandler(formatter1, formatter2, formatter3)
sink := slog.NewJSONHandler(os.Stderr, slog.HandlerOptions{})

logger := slog.New(
    slogmulti.
        Pipe(formattingMiddleware).
        Handler(sink),
)

err := fmt.Errorf("an error")
logger.Error("a message",
    slog.Any("very_private_data", "abcd"),
    slog.Any("user", user),
    slog.Any("err", err))

// outputs:
// time=2023-04-10T14:00:0.000000+00:00 level=ERROR msg="a message" error.message="an error" error.type="*errors.errorString" user="John doe" very_private_data="********"
```

### TimeFormatter

Transforms a `time.Time` into a readable string.

```go
slogformatter.NewFormatterHandler(
    slogformatter.TimeFormatter(time.DateTime, time.UTC),
)
```

### UnixTimestampFormatter

Transforms a `time.Time` into a unix timestamp.

```go
slogformatter.NewFormatterHandler(
    slogformatter.UnixTimestampFormatter(time.Millisecond),
)
```

### TimezoneConverter

Set a `time.Time` to a different timezone.

```go
slogformatter.NewFormatterHandler(
    slogformatter.TimezoneConverter(time.UTC),
)
```

### ErrorFormatter

Transforms a Go error into a readable error.

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	"log/slog"
)

logger := slog.New(
    slogformatter.NewFormatterHandler(
        slogformatter.ErrorFormatter("error"),
    )(
        slog.NewTextHandler(os.Stdout, nil),
    ),
)

err := fmt.Errorf("an error")
logger.Error("a message", slog.Any("error", err))

// outputs:
// {
//   "time":"2023-04-10T14:00:0.000000+00:00",
//   "level": "ERROR",
//   "msg": "a message",
//   "error": {
//     "message": "an error",
//     "type": "*errors.errorString"
//     "stacktrace": "main.main()\n\t/Users/samber/src/github.com/samber/slog-formatter/example/example.go:108 +0x1c\n"
//   }
// }
```

### HTTPRequestFormatter and HTTPResponseFormatter

Transforms *http.Request and *http.Response into readable objects.

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	"log/slog"
)

logger := slog.New(
    slogformatter.NewFormatterHandler(
        slogformatter.HTTPRequestFormatter(false),
        slogformatter.HTTPResponseFormatter(false),
    )(
        slog.NewJSONHandler(os.Stdout, nil),
    ),
)

req, _ := http.NewRequest(http.MethodGet, "https://api.screeb.app", nil)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-TOKEN", "1234567890")

res, _ := http.DefaultClient.Do(req)

logger.Error("a message",
    slog.Any("request", req),
    slog.Any("response", res))
```

### PIIFormatter

Hides private Personal Identifiable Information (PII).

IDs are kept as is. Values longer than 5 characters have a plain text prefix.

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	"log/slog"
)

logger := slog.New(
    slogformatter.NewFormatterHandler(
        slogformatter.PIIFormatter("user"),
    )(
        slog.NewTextHandler(os.Stdout, nil),
    ),
)

logger.
    With(
        slog.Group(
            "user",
            slog.String("id", "bd57ffbd-8858-4cc4-a93b-426cef16de61"),
            slog.String("email", "foobar@example.com"),
            slog.Group(
                "address",
                slog.String("street", "1st street"),
                slog.String("city", "New York"),
                slog.String("country", "USA"),
                slog.Int("zip", 12345),
            ),
        ),
    ).
    Error("an error")

// outputs:
// {
//   "time":"2023-04-10T14:00:0.000000+00:00",
//   "level": "ERROR",
//   "msg": "an error",
//   "user": {
//     "id": "bd57ffbd-8858-4cc4-a93b-426cef16de61",
//     "email": "foob*******",
//     "address": {
//       "street": "1st *******",
//       "city": "New *******",
//       "country": "*******",
//       "zip": "*******"
//     }
//   }
// }
```

### IPAddressFormatter

Transforms an IP address into "********".

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	"log/slog"
)

logger := slog.New(
    slogformatter.NewFormatterHandler(
        slogformatter.IPAddressFormatter("ip_address"),
    )(
        slog.NewTextHandler(os.Stdout, nil),
    ),
)

logger.
    With("ip_address", "1.2.3.4").
    Error("an error")

// outputs:
// {
//   "time":"2023-04-10T14:00:0.000000+00:00",
//   "level": "ERROR",
//   "msg": "an error",
//   "ip_address": "*******",
// }
```

### FlattenFormatterMiddleware

A formatter middleware that flatten attributes recursively.

```go
import (
	slogformatter "github.com/samber/slog-formatter"
	slogmulti "github.com/samber/slog-multi"
	"log/slog"
)

logger := slog.New(
    slogmulti.
        Pipe(slogformatter.FlattenFormatterMiddlewareOptions{Separator: ".", Prefix: "attrs", IgnorePath: false}.NewFlattenFormatterMiddlewareOptions()).
        Handler(slog.NewJSONHandler(os.Stdout, nil)),
)

logger.
    With("email", "samuel@acme.org").
    With("environment", "dev").
    WithGroup("group1").
    With("hello", "world").
    WithGroup("group2").
    With("hello", "world").
    Error("A message", "foo", "bar")

// outputs:
// {
//   "time": "2023-05-20T22:14:55.857065+02:00",
//   "level": "ERROR",
//   "msg": "A message",
//   "attrs.email": "samuel@acme.org",
//   "attrs.environment": "dev",
//   "attrs.group1.hello": "world",
//   "attrs.group1.group2.hello": "world",
//   "foo": "bar"
// }
```

### Format

Pass every attributes into a formatter.

```go
slogformatter.NewFormatterHandler(
    slogformatter.Format(func(groups []string, key string, value slog.Value) slog.Value {
        // hide everything under "user" group
        if lo.Contains(groups, "user") {
            return slog.StringValue("****")
        }

        return value
    }),
)
```

### FormatByKind

Pass attributes matching `slog.Kind` into a formatter.

```go
slogformatter.NewFormatterHandler(
    slogformatter.FormatByKind(slog.KindDuration, func(value slog.Value) slog.Value {
        return ...
    }),
)
```

### FormatByType

Pass attributes matching generic type into a formatter.

```go
slogformatter.NewFormatterHandler(
    // format a custom error type
    slogformatter.FormatByType[*customError](func(err *customError) slog.Value {
        return slog.GroupValue(
            slog.Int("code", err.code),
            slog.String("message", err.msg),
        )
    }),
    // format other errors
    slogformatter.FormatByType[error](func(err error) slog.Value {
        return slog.GroupValue(
            slog.Int("code", err.Error()),
            slog.String("type", reflect.TypeOf(err).String()),
        )
    }),
)
```

⚠️ Consider implementing `slog.LogValuer` when possible:

```go
type customError struct {
    ...
}

func (customError) Error() string {
    ...
}

// implements slog.LogValuer
func (customError) LogValue() slog.Value {
	return slog.StringValue(...)
}
```

### FormatByKey

Pass attributes matching key into a formatter.

```go
slogformatter.NewFormatterHandler(
    slogformatter.FormatByKey("abcd", func(value slog.Value) slog.Value {
        return ...
    }),
)
```

### FormatByFieldType

Pass attributes matching both key and generic type into a formatter.

```go
slogformatter.NewFormatterHandler(
    slogformatter.FormatByFieldType[User]("user", func(u User) slog.Value {
        return ...
    }),
)
```

### FormatByGroup

Pass attributes under a group into a formatter.

```go
slogformatter.NewFormatterHandler(
    slogformatter.FormatByGroup([]{"user", "address"}, func(attr []slog.Attr) slog.Value {
        return ...
    }),
)
```

### FormatByGroupKey

Pass attributes under a group and matching key, into a formatter.

```go
slogformatter.NewFormatterHandler(
    slogformatter.FormatByGroupKey([]{"user", "address"}, "country", func(value slog.Value) slog.Value {
        return ...
    }),
)
```

### FormatByGroupKeyType

Pass attributes under a group, matching key and matching a generic type, into a formatter.

```go
slogformatter.NewFormatterHandler(
    slogformatter.FormatByGroupKeyType[string]([]{"user", "address"}, "country", func(value string) slog.Value {
        return ...
    }),
)
```

## 🤝 Contributing

- Ping me on twitter [@samuelberthe](https://twitter.com/samuelberthe) (DMs, mentions, whatever :))
- Fork the [project](https://github.com/samber/slog-formatter)
- Fix [open issues](https://github.com/samber/slog-formatter/issues) or request new features

Don't hesitate ;)

```bash
# Install some dev dependencies
make tools

# Run tests
make test
# or
make watch-test
```

## 👤 Contributors

![Contributors](https://contrib.rocks/image?repo=samber/slog-formatter)

## 💫 Show your support

Give a ⭐️ if this project helped you!

[![GitHub Sponsors](https://img.shields.io/github/sponsors/samber?style=for-the-badge)](https://github.com/sponsors/samber)

## 📝 License

Copyright © 2023 [Samuel Berthe](https://github.com/samber).

This project is [MIT](./LICENSE) licensed.


slog-formatter

Chain of slog.Handler (pipeline, fanout...).


# slog: Handler chaining, fanout, routing, failover, load balancing...

[![tag](https://img.shields.io/github/tag/samber/slog-multi.svg)](https://github.com/samber/slog-multi/releases)
![Go Version](https://img.shields.io/badge/Go-%3E%3D%201.21-%23007d9c)
[![GoDoc](https://godoc.org/github.com/samber/slog-multi?status.svg)](https://pkg.go.dev/github.com/samber/slog-multi)
![Build Status](https://github.com/samber/slog-multi/actions/workflows/test.yml/badge.svg)
[![Go report](https://goreportcard.com/badge/github.com/samber/slog-multi)](https://goreportcard.com/report/github.com/samber/slog-multi)
[![Coverage](https://img.shields.io/codecov/c/github/samber/slog-multi)](https://codecov.io/gh/samber/slog-multi)
[![Contributors](https://img.shields.io/github/contributors/samber/slog-multi)](https://github.com/samber/slog-multi/graphs/contributors)
[![License](https://img.shields.io/github/license/samber/slog-multi)](./LICENSE)

Design workflows of [slog](https://pkg.go.dev/log/slog) handlers:
- **fanout**: distribute `log.Record` to multiple `slog.Handler` in parallel
- **pipeline**: rewrite `log.Record` on the fly (eg: for privacy reason)
- **routing**: forward `log.Record` to all matching `slog.Handler`
- **failover**: forward `log.Record` to the first available `slog.Handler`
- **load balancing**: increase log bandwidth by sending `log.Record` to a pool of `slog.Handler`

Here a simple workflow with both pipeline and fanout:

![workflow example with pipeline and fanout](./images/workflow.png)

<div align="center">
  <hr>
  <sup><b>Sponsored by:</b></sup>
  <br>
  <a href="https://quickwit.io?utm_campaign=github_sponsorship&utm_medium=referral&utm_content=samber-slog-multi&utm_source=github">
    <div>
      <img src="https://github.com/samber/oops/assets/2951285/49aaaa2b-b8c6-4f21-909f-c12577bb6a2e" width="240" alt="Quickwit">
    </div>
    <div>
      Cloud-native search engine for observability - An OSS alternative to Splunk, Elasticsearch, Loki, and Tempo.
    </div>
  </a>
  <hr>
</div>

**See also:**

- [slog-multi](https://github.com/samber/slog-multi): `slog.Handler` chaining, fanout, routing, failover, load balancing...
- [slog-formatter](https://github.com/samber/slog-formatter): `slog` attribute formatting
- [slog-sampling](https://github.com/samber/slog-sampling): `slog` sampling policy
- [slog-mock](https://github.com/samber/slog-mock): `slog.Handler` for test purposes

**HTTP middlewares:**

- [slog-gin](https://github.com/samber/slog-gin): Gin middleware for `slog` logger
- [slog-echo](https://github.com/samber/slog-echo): Echo middleware for `slog` logger
- [slog-fiber](https://github.com/samber/slog-fiber): Fiber middleware for `slog` logger
- [slog-chi](https://github.com/samber/slog-chi): Chi middleware for `slog` logger
- [slog-http](https://github.com/samber/slog-http): `net/http` middleware for `slog` logger

**Loggers:**

- [slog-zap](https://github.com/samber/slog-zap): A `slog` handler for `Zap`
- [slog-zerolog](https://github.com/samber/slog-zerolog): A `slog` handler for `Zerolog`
- [slog-logrus](https://github.com/samber/slog-logrus): A `slog` handler for `Logrus`

**Log sinks:**

- [slog-datadog](https://github.com/samber/slog-datadog): A `slog` handler for `Datadog`
- [slog-betterstack](https://github.com/samber/slog-betterstack): A `slog` handler for `Betterstack`
- [slog-rollbar](https://github.com/samber/slog-rollbar): A `slog` handler for `Rollbar`
- [slog-loki](https://github.com/samber/slog-loki): A `slog` handler for `Loki`
- [slog-sentry](https://github.com/samber/slog-sentry): A `slog` handler for `Sentry`
- [slog-syslog](https://github.com/samber/slog-syslog): A `slog` handler for `Syslog`
- [slog-logstash](https://github.com/samber/slog-logstash): A `slog` handler for `Logstash`
- [slog-fluentd](https://github.com/samber/slog-fluentd): A `slog` handler for `Fluentd`
- [slog-graylog](https://github.com/samber/slog-graylog): A `slog` handler for `Graylog`
- [slog-quickwit](https://github.com/samber/slog-quickwit): A `slog` handler for `Quickwit`
- [slog-slack](https://github.com/samber/slog-slack): A `slog` handler for `Slack`
- [slog-telegram](https://github.com/samber/slog-telegram): A `slog` handler for `Telegram`
- [slog-mattermost](https://github.com/samber/slog-mattermost): A `slog` handler for `Mattermost`
- [slog-microsoft-teams](https://github.com/samber/slog-microsoft-teams): A `slog` handler for `Microsoft Teams`
- [slog-webhook](https://github.com/samber/slog-webhook): A `slog` handler for `Webhook`
- [slog-kafka](https://github.com/samber/slog-kafka): A `slog` handler for `Kafka`
- [slog-nats](https://github.com/samber/slog-nats): A `slog` handler for `NATS`
- [slog-parquet](https://github.com/samber/slog-parquet): A `slog` handler for `Parquet` + `Object Storage`
- [slog-channel](https://github.com/samber/slog-channel): A `slog` handler for Go channels

## 🚀 Install

```sh
go get github.com/samber/slog-multi
```

**Compatibility**: go >= 1.21

No breaking changes will be made to exported APIs before v2.0.0.

⚠️ Use this library carefully, log processing can be very costly (!)

## 💡 Usage

GoDoc: [https://pkg.go.dev/github.com/samber/slog-multi](https://pkg.go.dev/github.com/samber/slog-multi)

### Broadcast: `slogmulti.Fanout()`

Distribute logs to multiple `slog.Handler` in parallel.

```go
import (
    slogmulti "github.com/samber/slog-multi"
    "log/slog"
)

func main() {
    logstash, _ := net.Dial("tcp", "logstash.acme:4242")    // use github.com/netbrain/goautosocket for auto-reconnect
    stderr := os.Stderr

    logger := slog.New(
        slogmulti.Fanout(
            slog.NewJSONHandler(logstash, &slog.HandlerOptions{}),  // pass to first handler: logstash over tcp
            slog.NewTextHandler(stderr, &slog.HandlerOptions{}),    // then to second handler: stderr
            // ...
        ),
    )

    logger.
        With(
            slog.Group("user",
                slog.String("id", "user-123"),
                slog.Time("created_at", time.Now()),
            ),
        ).
        With("environment", "dev").
        With("error", fmt.Errorf("an error")).
        Error("A message")
}
```

Stderr output:

```
time=2023-04-10T14:00:0.000000+00:00 level=ERROR msg="A message" user.id=user-123 user.created_at=2023-04-10T14:00:0.000000+00:00 environment=dev error="an error"
```

Netcat output:

```json
{
	"time":"2023-04-10T14:00:0.000000+00:00",
	"level":"ERROR",
	"msg":"A message",
	"user":{
		"id":"user-123",
		"created_at":"2023-04-10T14:00:0.000000+00:00"
	},
	"environment":"dev",
	"error":"an error"
}
```

### Routing: `slogmulti.Router()`

Distribute logs to all matching `slog.Handler` in parallel.

```go
import (
    slogmulti "github.com/samber/slog-multi"
	slogslack "github.com/samber/slog-slack"
    "log/slog"
)

func main() {
    slackChannelUS := slogslack.Option{Level: slog.LevelError, WebhookURL: "xxx", Channel: "supervision-us"}.NewSlackHandler()
	slackChannelEU := slogslack.Option{Level: slog.LevelError, WebhookURL: "xxx", Channel: "supervision-eu"}.NewSlackHandler()
	slackChannelAPAC := slogslack.Option{Level: slog.LevelError, WebhookURL: "xxx", Channel: "supervision-apac"}.NewSlackHandler()

	logger := slog.New(
		slogmulti.Router().
			Add(slackChannelUS, recordMatchRegion("us")).
			Add(slackChannelEU, recordMatchRegion("eu")).
			Add(slackChannelAPAC, recordMatchRegion("apac")).
			Handler(),
	)

	logger.
		With("region", "us").
		With("pool", "us-east-1").
		Error("Server desynchronized")
}

func recordMatchRegion(region string) func(ctx context.Context, r slog.Record) bool {
	return func(ctx context.Context, r slog.Record) bool {
		ok := false

		r.Attrs(func(attr slog.Attr) bool {
			if attr.Key == "region" && attr.Value.Kind() == slog.KindString && attr.Value.String() == region {
				ok = true
				return false
			}

			return true
		})

		return ok
	}
}
```

### Failover: `slogmulti.Failover()`

List multiple targets for a `slog.Record` instead of retrying on the same unavailable log management system.

```go
import (
	"net"
    slogmulti "github.com/samber/slog-multi"
    "log/slog"
)


func main() {
	// ncat -l 1000 -k
	// ncat -l 1001 -k
	// ncat -l 1002 -k

    // list AZs
    // use github.com/netbrain/goautosocket for auto-reconnect
	logstash1, _ := net.Dial("tcp", "logstash.eu-west-3a.internal:1000")
	logstash2, _ := net.Dial("tcp", "logstash.eu-west-3b.internal:1000")
	logstash3, _ := net.Dial("tcp", "logstash.eu-west-3c.internal:1000")

	logger := slog.New(
		slogmulti.Failover()(
			slog.HandlerOptions{}.NewJSONHandler(logstash1, nil),    // send to this instance first
			slog.HandlerOptions{}.NewJSONHandler(logstash2, nil),    // then this instance in case of failure
			slog.HandlerOptions{}.NewJSONHandler(logstash3, nil),    // and finally this instance in case of double failure
		),
	)

	logger.
		With(
			slog.Group("user",
				slog.String("id", "user-123"),
				slog.Time("created_at", time.Now()),
			),
		).
		With("environment", "dev").
		With("error", fmt.Errorf("an error")).
		Error("A message")
}
```

### Load balancing: `slogmulti.Pool()`

Increase log bandwidth by sending `log.Record` to a pool of `slog.Handler`.

```go
import (
	"net"
    slogmulti "github.com/samber/slog-multi"
    "log/slog"
)

func main() {
	// ncat -l 1000 -k
	// ncat -l 1001 -k
	// ncat -l 1002 -k

    // list AZs
    // use github.com/netbrain/goautosocket for auto-reconnect
	logstash1, _ := net.Dial("tcp", "logstash.eu-west-3a.internal:1000")
	logstash2, _ := net.Dial("tcp", "logstash.eu-west-3b.internal:1000")
	logstash3, _ := net.Dial("tcp", "logstash.eu-west-3c.internal:1000")

	logger := slog.New(
		slogmulti.Pool()(
            // a random handler will be picked
			slog.HandlerOptions{}.NewJSONHandler(logstash1, nil),
			slog.HandlerOptions{}.NewJSONHandler(logstash2, nil),
			slog.HandlerOptions{}.NewJSONHandler(logstash3, nil),
		),
	)

	logger.
		With(
			slog.Group("user",
				slog.String("id", "user-123"),
				slog.Time("created_at", time.Now()),
			),
		).
		With("environment", "dev").
		With("error", fmt.Errorf("an error")).
		Error("A message")
}
```

### Chaining: `slogmulti.Pipe()`

Rewrite `log.Record` on the fly (eg: for privacy reason).

```go
func main() {
    // first middleware: format go `error` type into an object {error: "*myCustomErrorType", message: "could not reach https://a.b/c"}
    errorFormattingMiddleware := slogmulti.NewHandleInlineMiddleware(errorFormattingMiddleware)

    // second middleware: remove PII
    gdprMiddleware := NewGDPRMiddleware()

    // final handler
    sink := slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{})

    logger := slog.New(
        slogmulti.
            Pipe(errorFormattingMiddleware).
            Pipe(gdprMiddleware).
            // ...
            Handler(sink),
    )

    logger.
        With(
            slog.Group("user",
                slog.String("id", "user-123"),
                slog.String("email", "user-123"),
                slog.Time("created_at", time.Now()),
            ),
        ).
        With("environment", "dev").
        Error("A message",
            slog.String("foo", "bar"),
            slog.Any("error", fmt.Errorf("an error")),
        )
}
```

Stderr output:

```json
{
    "time":"2023-04-10T14:00:0.000000+00:00",
    "level":"ERROR",
    "msg":"A message",
    "user":{
        "id":"*******",
        "email":"*******",
        "created_at":"*******"
    },
    "environment":"dev",
    "foo":"bar",
    "error":{
        "type":"*myCustomErrorType",
        "message":"an error"
    }
}
```

#### Custom middleware

Middleware must match the following prototype:

```go
type Middleware func(slog.Handler) slog.Handler
```

The example above uses:
- a custom middleware, [see here](./examples/pipe/gdpr.go)
- an inline middleware, [see here](./examples/pipe/errors.go)

Note: `WithAttrs` and `WithGroup` methods of custom middleware must return a new instance, instead of `this`.

#### Inline middleware

An "inline middleware" (aka. lambda), is a shortcut to middleware implementation, that hooks a single method and proxies others.

```go
// hook `logger.Enabled` method
mdw := slogmulti.NewEnabledInlineMiddleware(func(ctx context.Context, level slog.Level, next func(context.Context, slog.Level) bool) bool{
    // [...]
    return next(ctx, level)
})
```

```go
// hook `logger.Handle` method
mdw := slogmulti.NewHandleInlineMiddleware(func(ctx context.Context, record slog.Record, next func(context.Context, slog.Record) error) error {
    // [...]
    return next(ctx, record)
})
```

```go
// hook `logger.WithAttrs` method
mdw := slogmulti.NewWithAttrsInlineMiddleware(func(attrs []slog.Attr, next func([]slog.Attr) slog.Handler) slog.Handler{
    // [...]
    return next(attrs)
})
```

```go
// hook `logger.WithGroup` method
mdw := slogmulti.NewWithGroupInlineMiddleware(func(name string, next func(string) slog.Handler) slog.Handler{
    // [...]
    return next(name)
})
```

A super inline middleware that hooks all methods.

> Warning: you would rather implement your own middleware.

```go
mdw := slogmulti.NewInlineMiddleware(
    func(ctx context.Context, level slog.Level, next func(context.Context, slog.Level) bool) bool{
        // [...]
        return next(ctx, level)
    },
    func(ctx context.Context, record slog.Record, next func(context.Context, slog.Record) error) error{
        // [...]
        return next(ctx, record)
    },
    func(attrs []slog.Attr, next func([]slog.Attr) slog.Handler) slog.Handler{
        // [...]
        return next(attrs)
    },
    func(name string, next func(string) slog.Handler) slog.Handler{
        // [...]
        return next(name)
    },
)
```

## 🤝 Contributing

- Ping me on twitter [@samuelberthe](https://twitter.com/samuelberthe) (DMs, mentions, whatever :))
- Fork the [project](https://github.com/samber/slog-multi)
- Fix [open issues](https://github.com/samber/slog-multi/issues) or request new features

Don't hesitate ;)

```bash
# Install some dev dependencies
make tools

# Run tests
make test
# or
make watch-test
```

## 👤 Contributors

![Contributors](https://contrib.rocks/image?repo=samber/slog-multi)

## 💫 Show your support

Give a ⭐️ if this project helped you!

[![GitHub Sponsors](https://img.shields.io/github/sponsors/samber?style=for-the-badge)](https://github.com/sponsors/samber)

## 📝 License

Copyright © 2023 [Samuel Berthe](https://github.com/samber).

This project is [MIT](./LICENSE) licensed.


slog-multi

Implements a deep pretty printer for Go data structures to aid in debugging.

go-spew
=======

[![Build Status](https://img.shields.io/travis/davecgh/go-spew.svg)](https://travis-ci.org/davecgh/go-spew)
[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
[![Coverage Status](https://img.shields.io/coveralls/davecgh/go-spew.svg)](https://coveralls.io/r/davecgh/go-spew?branch=master)

Go-spew implements a deep pretty printer for Go data structures to aid in
debugging.  A comprehensive suite of tests with 100% test coverage is provided
to ensure proper functionality.  See `test_coverage.txt` for the gocov coverage
report.  Go-spew is licensed under the liberal ISC license, so it may be used in
open source or commercial projects.

If you're interested in reading about how this package came to life and some
of the challenges involved in providing a deep pretty printer, there is a blog
post about it
[here](https://web.archive.org/web/20160304013555/https://blog.cyphertite.com/go-spew-a-journey-into-dumping-go-data-structures/).

## Documentation

[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/davecgh/go-spew/spew)

Full `go doc` style documentation for the project can be viewed online without
installing this package by using the excellent GoDoc site here:
http://godoc.org/github.com/davecgh/go-spew/spew

You can also view the documentation locally once the package is installed with
the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to
http://localhost:6060/pkg/github.com/davecgh/go-spew/spew

## Installation

```bash
$ go get -u github.com/davecgh/go-spew/spew
```

## Quick Start

Add this import line to the file you're working in:

```Go
import "github.com/davecgh/go-spew/spew"
```

To dump a variable with full newlines, indentation, type, and pointer
information use Dump, Fdump, or Sdump:

```Go
spew.Dump(myVar1, myVar2, ...)
spew.Fdump(someWriter, myVar1, myVar2, ...)
str := spew.Sdump(myVar1, myVar2, ...)
```

Alternatively, if you would prefer to use format strings with a compacted inline
printing style, use the convenience wrappers Printf, Fprintf, etc with %v (most
compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types
and pointer addresses): 

```Go
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
```

## Debugging a Web Application Example

Here is an example of how you can use `spew.Sdump()` to help debug a web application. Please be sure to wrap your output using the `html.EscapeString()` function for safety reasons. You should also only use this debugging technique in a development environment, never in production.

```Go
package main

import (
    "fmt"
    "html"
    "net/http"

    "github.com/davecgh/go-spew/spew"
)

func handler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    fmt.Fprintf(w, "Hi there, %s!", r.URL.Path[1:])
    fmt.Fprintf(w, "")
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}
```

## Sample Dump Output

```
(main.Foo) {
 unexportedField: (*main.Bar)(0xf84002e210)({
  flag: (main.Flag) flagTwo,
  data: (uintptr) <nil>
 }),
 ExportedField: (map[interface {}]interface {}) {
  (string) "one": (bool) true
 }
}
([]uint8) {
 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
 00000020  31 32                                             |12|
}
```

## Sample Formatter Output

Double pointer to a uint8:
```
	  %v: <**>5
	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
	 %#v: (**uint8)5
	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
```

Pointer to circular struct with a uint8 field and a pointer to itself:
```
	  %v: <*>{1 <*><shown>}
	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
```

## Configuration Options

Configuration of spew is handled by fields in the ConfigState type. For
convenience, all of the top-level functions use a global state available via the
spew.Config global.

It is also possible to create a ConfigState instance that provides methods
equivalent to the top-level functions. This allows concurrent configuration
options. See the ConfigState documentation for more details.

```
* Indent
	String to use for each indentation level for Dump functions.
	It is a single space by default.  A popular alternative is "\t".

* MaxDepth
	Maximum number of levels to descend into nested data structures.
	There is no limit by default.

* DisableMethods
	Disables invocation of error and Stringer interface methods.
	Method invocation is enabled by default.

* DisablePointerMethods
	Disables invocation of error and Stringer interface methods on types
	which only accept pointer receivers from non-pointer variables.  This option
	relies on access to the unsafe package, so it will not have any effect when
	running in environments without access to the unsafe package such as Google
	App Engine or with the "safe" build tag specified.
	Pointer method invocation is enabled by default.

* DisablePointerAddresses
	DisablePointerAddresses specifies whether to disable the printing of
	pointer addresses. This is useful when diffing data structures in tests.

* DisableCapacities
	DisableCapacities specifies whether to disable the printing of capacities
	for arrays, slices, maps and channels. This is useful when diffing data
	structures in tests.

* ContinueOnMethod
	Enables recursion into types after invoking error and Stringer interface
	methods. Recursion after method invocation is disabled by default.

* SortKeys
	Specifies map keys should be sorted before being printed. Use
	this to have a more deterministic, diffable output.  Note that
	only native types (bool, int, uint, floats, uintptr and string)
	and types which implement error or Stringer interfaces are supported,
	with other types sorted according to the reflect.Value.String() output
	which guarantees display stability.  Natural map order is used by
	default.

* SpewKeys
	SpewKeys specifies that, as a last resort attempt, map keys should be
	spewed to strings and sorted by those strings.  This is only considered
	if SortKeys is true.

```

## Unsafe Package Dependency

This package relies on the unsafe package to perform some of the more advanced
features, however it also supports a "limited" mode which allows it to work in
environments where the unsafe package is not available.  By default, it will
operate in this mode on Google App Engine and when compiled with GopherJS.  The
"safe" build tag may also be specified to force the package to build without
using the unsafe package.

## License

Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.

spew

A logger for Go SQL database driver without modify existing \*sql.DB stdlib usage.

# SQLDB-Logger

[![Coverage Status](https://coveralls.io/repos/github/simukti/sqldb-logger/badge.svg)](https://coveralls.io/github/simukti/sqldb-logger) [![Go Report Card](https://goreportcard.com/badge/github.com/simukti/sqldb-logger)](https://goreportcard.com/report/github.com/simukti/sqldb-logger) [![Sonar Violations (long format)](https://img.shields.io/sonar/violations/simukti_sqldb-logger?server=https%3A%2F%2Fsonarcloud.io)](https://sonarcloud.io/dashboard?id=simukti_sqldb-logger) [![Sonar Tech Debt](https://img.shields.io/sonar/tech_debt/simukti_sqldb-logger?server=https%3A%2F%2Fsonarcloud.io)](https://sonarcloud.io/dashboard?id=simukti_sqldb-logger) [![Sonar Quality Gate](https://img.shields.io/sonar/quality_gate/simukti_sqldb-logger?server=https%3A%2F%2Fsonarcloud.io)](https://sonarcloud.io/dashboard?id=simukti_sqldb-logger) [![Documentation](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/simukti/sqldb-logger) [![License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://raw.githubusercontent.com/simukti/sqldb-logger/master/LICENSE.txt)

A logger for Go SQL database driver without modify existing `*sql.DB` stdlib usage.

![shameless console output sample](./logadapter/zerologadapter/console.jpg?raw=true "go sql database logger output") 
_Colored console writer output above only for sample/development_

## FEATURES

- Leveled, detailed and [configurable](./options.go) logging.
- Keep using (or re-use existing) `*sql.DB` as is.
- Bring your own logger backend via simple log interface.
- Trackable log output:
    - Every call has its own unique ID.
    - Prepared statement and execution will have same ID.
    - On execution/result error, it will include the query, arguments, params, and related IDs. 

## INSTALL

```bash
go get -u -v github.com/simukti/sqldb-logger
```

_Version pinning using dependency manager such as [Mod](https://github.com/golang/go/wiki/Modules) or [Dep](https://github.com/golang/dep) is highly recommended._

## USAGE

As a start, `Logger` is just a simple interface:

```go
type Logger interface {
	Log(ctx context.Context, level Level, msg string, data map[string]interface{})
}
``` 

There are 4 included basic implementation that uses well-known JSON structured logger for quickstart:

- [Zerolog adapter](logadapter/zerologadapter): Using [rs/zerolog](https://github.com/rs/zerolog) as its logger.
- [Onelog adapter](logadapter/onelogadapter): Using [francoispqt/onelog](https://github.com/francoispqt/onelog) as its logger.
- [Zap adapter](logadapter/zapadapter): Using [uber-go/zap](https://github.com/uber-go/zap) as its logger.
- [Logrus adapter](logadapter/logrusadapter): Using [sirupsen/logrus](https://github.com/sirupsen/logrus) as its logger.

_Note: [those adapters](./logadapter) does not use given `context`, you need to modify it and adjust with your needs._ 
_(example: add http request id/whatever value from context to query log when you call `QueryerContext` and`ExecerContext` methods)_

Then for that logger to works, you need to integrate with a compatible driver which will be used by `*sql.DB`.

### INTEGRATE WITH EXISTING SQL DB DRIVER
 
Re-use from existing `*sql.DB` driver, this is the simplest way:

For example, from:

```go
dsn := "username:passwd@tcp(mysqlserver:3306)/dbname?parseTime=true"
db, err := sql.Open("mysql", dsn) // db is *sql.DB
db.Ping() // to check connectivity and DSN correctness
```

To:

```go
// import sqldblogger "github.com/simukti/sqldb-logger"
// import "github.com/simukti/sqldb-logger/logadapter/zerologadapter"
dsn := "username:passwd@tcp(mysqlserver:3306)/dbname?parseTime=true"
db, err := sql.Open("mysql", dsn) // db is *sql.DB
// handle err
loggerAdapter := zerologadapter.New(zerolog.New(os.Stdout))
db = sqldblogger.OpenDriver(dsn, db.Driver(), loggerAdapter/*, using_default_options*/) // db is STILL *sql.DB
db.Ping() // to check connectivity and DSN correctness
```

That's it, all `*sql.DB` interaction now logged.

### INTEGRATE WITH SQL DRIVER STRUCT

It is also possible to integrate with following public empty struct driver directly: 

#### MySQL ([go-sql-driver/mysql](https://github.com/go-sql-driver/mysql))

```go
db := sqldblogger.OpenDriver(dsn, &mysql.MySQLDriver{}, loggerAdapter /*, ...options */)
```

#### PostgreSQL ([lib/pq](https://github.com/lib/pq))

```go
db := sqldblogger.OpenDriver(dsn, &pq.Driver{}, loggerAdapter /*, ...options */) 
```

#### SQLite3 ([mattn/go-sqlite3](https://github.com/mattn/go-sqlite3))

```go
db := sqldblogger.OpenDriver(dsn, &sqlite3.SQLiteDriver{}, loggerAdapter /*, ...options */)
```

_Following struct drivers **maybe** compatible:_ 

#### SQL Server ([denisenkom/go-mssqldb](https://github.com/denisenkom/go-mssqldb))

```go
db := sqldblogger.OpenDriver(dsn, &mssql.Driver{}, loggerAdapter /*, ...options */)
```

#### Oracle ([mattn/go-oci8](https://github.com/mattn/go-oci8))

```go
db := sqldblogger.OpenDriver(dsn, oci8.OCI8Driver, loggerAdapter /*, ...options */)
```

## LOGGER OPTIONS

When using `sqldblogger.OpenDriver(dsn, driver, logger, opt...)` without 4th variadic argument, it will use [default options](./options.go#L37-L59).

Here is sample of `OpenDriver()` using all available options and use non-default value:

```go
db = sqldblogger.OpenDriver(
    dsn, 
    db.Driver(), 
    loggerAdapter,
    // AVAILABLE OPTIONS
    sqldblogger.WithErrorFieldname("sql_error"),                    // default: error
    sqldblogger.WithDurationFieldname("query_duration"),            // default: duration
    sqldblogger.WithTimeFieldname("log_time"),                      // default: time
    sqldblogger.WithSQLQueryFieldname("sql_query"),                 // default: query
    sqldblogger.WithSQLArgsFieldname("sql_args"),                   // default: args
    sqldblogger.WithMinimumLevel(sqldblogger.LevelTrace),           // default: LevelDebug
    sqldblogger.WithLogArguments(false),                            // default: true
    sqldblogger.WithDurationUnit(sqldblogger.DurationNanosecond),   // default: DurationMillisecond
    sqldblogger.WithTimeFormat(sqldblogger.TimeFormatRFC3339),      // default: TimeFormatUnix
    sqldblogger.WithLogDriverErrorSkip(true),                       // default: false
    sqldblogger.WithSQLQueryAsMessage(true),                        // default: false
    sqldblogger.WithUIDGenerator(sqldblogger.UIDGenerator),         // default: *defaultUID
    sqldblogger.WithConnectionIDFieldname("con_id"),                // default: conn_id
    sqldblogger.WithStatementIDFieldname("stm_id"),                 // default: stmt_id
    sqldblogger.WithTransactionIDFieldname("trx_id"),               // default: tx_id
    sqldblogger.WithWrapResult(false),                              // default: true
    sqldblogger.WithIncludeStartTime(true),                         // default: false
    sqldblogger.WithStartTimeFieldname("start_time"),               // default: start
    sqldblogger.WithPreparerLevel(sqldblogger.LevelDebug),          // default: LevelInfo
    sqldblogger.WithQueryerLevel(sqldblogger.LevelDebug),           // default: LevelInfo
    sqldblogger.WithExecerLevel(sqldblogger.LevelDebug),            // default: LevelInfo
)
```

[Click here](https://pkg.go.dev/github.com/simukti/sqldb-logger#Option) for options documentation.

## MOTIVATION

I want to:

- Keep using `*sql.DB`.
- Have configurable output field.
- Leverage structured logging.
- Fetch and log `context.Context` value if needed. 
- Re-use [pgx log interface](https://github.com/jackc/pgx/blob/f3a3ee1a0e5c8fc8991928bcd06fdbcd1ee9d05c/logger.go#L46-L49).

I haven't found Go `*sql.DB` logger with that features, so why not created myself? 

## REFERENCES

- [Stdlib sql.DB](https://github.com/golang/go/blob/master/src/database/sql/sql.go)
- [SQL driver interfaces](https://github.com/golang/go/blob/master/src/database/sql/driver/driver.go)
- [SQL driver implementation](https://github.com/golang/go/wiki/SQLDrivers)

## CONTRIBUTE

If you found a bug, typo, wrong test, idea, help with existing issue, or anything constructive.
 
Don't hesitate to create an issue or pull request.

## CREDITS

- [pgx](https://github.com/jackc/pgx) for awesome PostgreSQL driver.

## LICENSE

[MIT](./LICENSE.txt)

sqldb-logger

Stdlog is an object-oriented library providing leveled logging. It is very useful for cron jobs.

This repository contains logging packages for Go:
 - [stdlog](#stdlog) is the main package of this repository, it is a simple and
   fast logger to the standard output.
 - [buflog](#buflog) and [golog](#golog) are customizable logging class which
   can be used as a standalone or as a building block for other loggers.
   [stdlog](#stdlog) is built upon them.
 - [log](#log) just provides a common interface for logging libraries.

You are more than welcome to ask questions on the [Go mailing-list](https://groups.google.com/d/topic/golang-nuts/Gif79T-1jNQ/discussion) and open issues here if you find bugs.


# stdlog

[Documentation](http://godoc.org/github.com/alexcesaro/log/stdlog)

Package stdlog provides simple and fast logging to the standard output
(stdout) and is optimized for programs launched via a shell or cron. It can
also be used to log to a file by redirecting the standard output to a file.
This package is thread-safe.

Basic examples:

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

Will output:

    2014-04-02 18:09:15.862 INFO Connecting to the API...
    2014-04-02 18:10:14.347 ERROR Connection failed (Server is unavailable).

Log*() functions can be used to avoid evaluating arguments when it is
expensive and unnecessary:

    logger.Debug("Memory usage: %s", getMemoryUsage())
    if LogDebug() { logger.Debug("Memory usage: %s", getMemoryUsage()) }

If debug logging is off the getMemoryUsage() will be executed on the first
line while it will not be executed on the second line.

List of command-line arguments:

    -log=info
        Log events at or above this level are logged.
    -stderr=false
        Logs are written to standard error (stderr) instead of standard
        output.
    -flushlog=none
        Until this level is reached nothing is output and logs are stored
        in the memory. Once a log event is at or above this level, it
        outputs all logs in memory as well as the future log events. This
        feature should not be used with long-running processes.

The available levels are the eight ones described in RFC 5424 (debug,
info, notice, warning, error, critical, alert, emergency) and none.

Some use cases:
   - By default, all logs except debug ones are output to the stdout. Which
     is useful to follow the execution of a program launched via a shell.
   - A program launched by a crontab where the variable `MAILTO` is set
     with `-debug -flushlog=error` will send all logs generated by the
     program only if an error happens. When there is no error the email
     will not be sent.
   - `my_program > /var/log/my_program/my_program-$(date+%Y-%m-%d-%H%M%S).log`
     will create a log file in /var/log/my_program each time it is run.


# buflog

[Documentation](http://godoc.org/github.com/alexcesaro/log/buflog)

Package buflog provides a buffered logging class that accumulates logs in
memory until the flush threshold is reached which release stored logs, the
buffered logger then act as a normal logger.

Basic example:

    logger := buflog.New(os.Stdout, log.Info, log.Error)
    logger.Info("Connecting to the server...")   // Outputs nothing
    logger.Error("Connection failed")            // Outputs both lines


# golog

[Documentation](http://godoc.org/github.com/alexcesaro/log/golog)

Package golog provides a customizable logging class which can be used as a
standalone or as a building block for other loggers.

Basic example:

    logger := golog.New(os.Stdout, log.Info)
    logger.Info("Connecting to the server...")
    logger.Errorf("Connection failed: %q", err)

Will output:

    2014-04-02 18:09:15.862 INFO Connecting to the API...
    2014-04-02 18:10:14.347 ERROR Connection failed (Server is unavailable).

Log*() functions can be used to avoid evaluating arguments when it is
expensive and unnecessary:

    logger.Debug("Memory usage: %s", getMemoryUsage())
    if logger.LogDebug() { logger.Debug("Memory usage: %s", getMemoryUsage()) }

If debug logging is off getMemoryUsage() will be executed on the first line
while it will not be executed on the second line.


# log

[Documentation](http://godoc.org/github.com/alexcesaro/log)

Package log provides a common interface for logging libraries.


stdlog

Go package striving to emulate the features of the BSD tail program.

[![Build Status](https://travis-ci.org/hpcloud/tail.svg)](https://travis-ci.org/hpcloud/tail)
[![Build status](https://ci.appveyor.com/api/projects/status/vrl3paf9md0a7bgk/branch/master?svg=true)](https://ci.appveyor.com/project/Nino-K/tail/branch/master)

# Go package for tail-ing files

A Go package striving to emulate the features of the BSD `tail` program. 

```Go
t, err := tail.TailFile("/var/log/nginx.log", tail.Config{Follow: true})
for line := range t.Lines {
    fmt.Println(line.Text)
}
```

See [API documentation](http://godoc.org/github.com/hpcloud/tail).

## Log rotation

Tail comes with full support for truncation/move detection as it is
designed to work with log rotation tools.

## Installing

    go get github.com/hpcloud/tail/...

## Windows support

This package [needs assistance](https://github.com/hpcloud/tail/labels/Windows) for full Windows support.


tail

tint

Leveled and structured logging, dynamic fields, high performance, zone management, simple configuration, and readable syntax.

[![xybor founder](https://img.shields.io/badge/xybor-huykingsofm-red)](https://github.com/huykingsofm)
[![Go Reference](https://pkg.go.dev/badge/github.com/xybor-x/xylog.svg)](https://pkg.go.dev/github.com/xybor-x/xylog)
[![GitHub Repo stars](https://img.shields.io/github/stars/xybor-x/xylog?color=yellow)](https://github.com/xybor-x/xylog)
[![GitHub top language](https://img.shields.io/github/languages/top/xybor-x/xylog?color=lightblue)](https://go.dev/)
[![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/xybor-x/xylog)](https://go.dev/blog/go1.18)
[![GitHub release (release name instead of tag name)](https://img.shields.io/github/v/release/xybor-x/xylog?include_prereleases)](https://github.com/xybor-x/xylog/releases/latest)
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/e9146e2ccfd745a48a42fc723918d4cb)](https://www.codacy.com/gh/xybor-x/xylog/dashboard?utm_source=github.com&utm_medium=referral&utm_content=xybor-x/xylog&utm_campaign=Badge_Grade)
[![Codacy Badge](https://app.codacy.com/project/badge/Coverage/e9146e2ccfd745a48a42fc723918d4cb)](https://www.codacy.com/gh/xybor-x/xylog/dashboard?utm_source=github.com&utm_medium=referral&utm_content=xybor-x/xylog&utm_campaign=Badge_Coverage)
[![Go Report](https://goreportcard.com/badge/github.com/xybor-x/xylog)](https://goreportcard.com/report/github.com/xybor-x/xylog)

# Introduction

Package xylog is designed for [leveled](#logging-level) and
[structured](#structured-logging) logging, [dynamic fields](#macros),
[high performance](#benchmark), [zone management](#hierarchical-logger), simple
configuration, and readable syntax.

The library is combined by
[python logging](https://docs.python.org/3/library/logging.html) design and
[zap](https://github.com/uber-go/zap) encoding approach.

# Quick start

You can easily configure a logger with `SimpleConfig`.

There are some fields you can modify with this way (note that all fields are
optional):

-   `Name` is the name of Logger. It can be used later with `GetLogger`
    function. Default to an empty name (the root logger).

-   `Encoding` to format the output. Default to `TextEncoding`.

-   `Filename` specifies that `Logger` will write the output to a file. Do NOT
    use together with `Writer`.

-   `Filemode` specifies the mode to open file. Default to `APPEND` \| `CREATE`
    \| `WRONLY`.

-   `Fileperm` specifies the permission when creating the file. Default to 0666.

-   `Level` specifies the logging level. Default to `WARNING`.

-   `TimeLayout` when format the time string. Default to `RFC3339Nano`.

-   `Writer` specifies that Logger will write the output to a file. Do NOT use
    together with `Filename`.

```golang
var config = &xylog.SimpleConfig{
    Name:   "simple-logger",
    Level:  xylog.DEBUG,
    Writer: os.Stdout,
}

var logger, err = config.AddMacro("level", "levelname").Apply()
if err != nil {
    fmt.Println("An error occurred:", err)
    os.Exit(1)
}
defer xylog.Flush()

logger.Debug("logging message")
logger.Event("create-user").Field("username", "foo").
    Field("email", "bar@buzz.com").Field("Age", 25).Info()

// Output:
// level=DEBUG messsage="logging message"
// level=INFO event=create-user username=foo email=bar@buzz.com Age=25
```

# Full configuration

`Logger` is directly used by application code. `Logger` names are dot-separated
hierarchical names, such as "a", "a.b", "a.b.c" or similar. For "a.b.c", its
parents are "a" and "a.b".

A `Logger` is obtained using `GetLogger` method. If the `Logger` with that name
didn't exist before, the method will create a new one. The `Logger` with empty
name is the root one.

```golang
var logger = xylog.GetLogger("example")
defer xylog.Flush()
```

`Handler` is responsible for generating logging messages. Like `Logger`,
`Handler` is also identified by its name, however, the name is not hierarchical.
Every `GetHandler` call with the same name gives the same `Handler`.

_Exception: `Handlers` with the empty names are always different._

```golang
var handler = xylog.GetHandler("handler")
```

`Emitter` writes logging messages to the specified output. Currently, only
`StreamEmitter` is supported. You can use any `Writer` in this `Emitter` type.

```golang
var emitter = xylog.NewStreamEmitter(os.Stdout)
```

When a logging method is called, the `Logger` creates a `LogRecord` and sends it
to underlying `Handlers`. `Handlers` convert `LogRecord` to text and send it
to `Emitters`.

A `Logger` can have multiple `Handlers`, and a `Handler` can have multiple
`Emitters`.

```golang
handler.AddEmitter(emitter)
logger.AddHandler(handler)
```

After preparing `Logger`, `Handler`, and `Emitter`, you can log the first
messages.

```golang
logger.Debug("foo") // This message is blocked by Logger's preferred level.
logger.Warning("bar")

// Output:
// message=bar
```

# Logging level

Both `Logger` and `Handler` has its own preferred level. If a logging level is
lower than the preferred one, the message will not be logged.

By default:

-   `Handler`'s preferred level is `NOTSET` (it logs all logging levels).
-   `Logger`'s preferred level depends on its parents. When a `Logger` is newly
    created, its preferred level is the nearest parent's one. The root logger's
    preferred level is `WARNING`.

You can set a new preferred level for both `Logger` and `Handler`.

```golang
logger.SetLevel(xylog.DEBUG)

logger.Debug("foo")
logger.Warning("bar")

// Output:
// message=foo
// message=bar
```

In the following example, however, the first message with DEBUG can bypass the
`Logger`, but will be prevented by `Handler`.

```golang
logger.SetLevel(xylog.DEBUG)
handler.SetLevel(xylog.INFO)

logger.Debug("foo")
logger.Warning("bar")

// Output:
// message=bar
```

The numeric values of logging levels are given in the following table. If you
define a level with the same numeric value, it overwrites the predefined value.

| Level        | Numeric value |
| ------------ | ------------- |
| CRITICAL     | 50            |
| ERROR/FATAL  | 40            |
| WARN/WARNING | 30            |
| INFO         | 20            |
| DEBUG        | 10            |
| NOTSET       | 0             |

# Structured logging

If the logging message has more than one field, `EventLogger` can help.

```golang
logger.Event("add-user").Field("name", "david").Field("email", "david@dad.com").Info()

// Output:
// event=add-user name=david email=david@dad.com
```

You also add a field to `Logger` or `Handler` permanently. All logging messages
will always include permanent fields.

```golang
logger.AddField("host", "localhost")
handler.AddField("port", 3333)

logger.Info("start server")

// Output:
// host=localhost port=3333 message="start server"
```

_NOTE: Fixed fields added to `Handler` will log faster than the one added to `Logger`_

`Handler` can support different encoding types. By default, it is
`TextEncoding`.

You can log the message with JSON format too.

```golang
import "github.com/xybor-x/xylog/encoding"

handler.SetEncoding(encoding.NewJSONEncoding())

logger.Warning("this is a message")
logger.Event("failed").Field("id", 1).Error()

// Output:
// {"message":"this is a message"}
// {"event":"failed","id": 1}
```

# Macros

You can log special fields whose values change every time you log. These fields
called macros.

Only the `Handler` can add macros.

```golang
handler.AddMacro("level", "levelname")

logger.Warning("this is a warning message")

// Output:
// level=WARNING message="this is a warning message"
```

The following table shows supported macros.

| MACRO             | DESCRIPTION                                                                                             |
| ----------------- | ------------------------------------------------------------------------------------------------------- |
| `asctime`         | Textual time when the LogRecord was created.                                                            |
| `created`         | Time when the LogRecord was created (time.Now().Unix() return value).                                   |
| `filename`\*      | Filename portion of pathname.                                                                           |
| `funcname`\*      | Function name logged the record.                                                                        |
| `levelname`       | Text logging level for the message ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL").                   |
| `levelno`         | Numeric logging level for the message (DEBUG, INFO, WARNING, ERROR, CRITICAL).                          |
| `lineno`\*        | Source line number where the logging call was issued.                                                   |
| `module`\*        | The module called log method.                                                                           |
| `msecs`           | Millisecond portion of the creation time.                                                               |
| `name`            | Name of the logger.                                                                                     |
| `pathname`        | Full pathname of the source file where the logging call was issued.                                     |
| `process`         | Process ID.                                                                                             |
| `relativeCreated` | Time in milliseconds between the time LogRecord was created and the time the logging module was loaded. |

_\* These are macros that are only available if `xylog.SetFindCaller` is called with `true`._

# Filter

`Filter` can be used by `Handlers` and `Loggers` for more sophisticated
filtering than is provided by levels.

A `Filter` instance needs to define `Filter(LogRecord)` method, which returns
`true` if it allows logging the `LogRecord`, and vice versa.

```golang
type NameFilter struct {
    name string
}

func (f *NameFilter) Filter(record xylog.LogRecord) bool {
    return f.name == record.Name
}

handler.AddFilter(&NameFilter{"example.user"})

var userLogger = xylog.GetLogger("example.user")
var serviceLogger = xylog.GetLogger("example.service")

userLogger.Warning("this is the user logger")
serviceLogger.Warning("this is the service logger")

// Output:
// message="this is the user logger"
```

# Hierarchical logger

As the first section mentioned, the `Logger`'s name is hierarchical. With this
feature, you can setup a common `Logger` with a specified configuration and uses
in different application zones.

```golang
// common/setup.go
func init() {
    var emitter = xylog.NewStreamEmitter(os.Stderr)
    var handler = xylog.GetHandler("")
    handler.AddEmitter(emitter)
    handler.SetEncoding(encoding.NewJSONEncoding())
    handler.AddMacro("time", "asctime")
    handler.AddMacro("level", "levelname")

    var logger = xylog.GetLogger("parent")
    logger.AddHandler(handler)
    logger.SetLevel(xylog.WARNING)
}
```

```golang
// user/foo.go
import _ "common"

var logger = xylog.GetLogger("parent.user")
defer xylog.Flush()
logger.SetLevel(xylog.INFO)
logger.AddField("module", "user")

logger.Info("this is user module")
logger.Debug("this is a not logged message")

// Output:
// time=[time] level=INFO module=user message="this is user module"
```

```golang
// service/bar.go
import _ "common"

var logger = xylog.GetLogger("parent.service")
defer xylog.Flush()
logger.AddField("module", "service")
logger.AddField("service", "bar")

logger.Warning("this is service module")

// Output:
// time=[time] level=INFO module=service service=bar message="this is service module"
```

# Benchmark

CPU: AMD Ryzen 7 5800H (3.2Ghz)

These benchmark of xylog are measured with `SetFindCaller` is called with
`false`.

_NOTE: The benchmarks are run on a different CPU from the [origin](https://github.com/uber-go/zap/blob/master/README.md#performance), so the benchmark values may be different too._

Log a message and 10 fields:

| Package             |        Time | Time % to zap | Objects Allocated |
| :------------------ | ----------: | ------------: | ----------------: |
| :zap: zap           |  1707 ns/op |           +0% |       5 allocs/op |
| :zap: zap (sugared) |  2043 ns/op |          +20% |      10 allocs/op |
| zerolog             |   884 ns/op |          -48% |       1 allocs/op |
| go-kit              |  6255 ns/op |         +266% |      58 allocs/op |
| logrus              |  8384 ns/op |         +391% |      80 allocs/op |
| apex/log            | 22707 ns/op |        +1230% |      65 allocs/op |
| log15               | 25461 ns/op |        +1391% |      75 allocs/op |
| :rocket: xylog      |  3518 ns/op |         +106% |      77 allocs/op |

Log a message with a logger that already has 10 fields of context:

| Package             |        Time | Time % to zap | Objects Allocated |
| :------------------ | ----------: | ------------: | ----------------: |
| :zap: zap           |   140 ns/op |           +0% |       0 allocs/op |
| :zap: zap (sugared) |   181 ns/op |          +29% |       1 allocs/op |
| zerolog             |    89 ns/op |          -36% |       0 allocs/op |
| go-kit              |  5963 ns/op |        +4159% |      57 allocs/op |
| logrus              |  6590 ns/op |        +4607% |      69 allocs/op |
| apex/log            | 21777 ns/op |       +15455% |      54 allocs/op |
| log15               | 15124 ns/op |       +10702% |      71 allocs/op |
| :rocket: xylog      |   416 ns/op |         +197% |       6 allocs/op |

Log a static string, without any context or `printf`-style templating:

| Package             |       Time | Time % to zap | Objects Allocated |
| :------------------ | ---------: | ------------: | ----------------: |
| :zap: zap           |  154 ns/op |           +0% |       0 allocs/op |
| :zap: zap (sugared) |  195 ns/op |          +27% |       1 allocs/op |
| zerolog             |   87 ns/op |          -44% |       0 allocs/op |
| go-kit              |  382 ns/op |         +148% |      10 allocs/op |
| logrus              | 1008 ns/op |         +554% |      24 allocs/op |
| apex/log            | 1744 ns/op |        +1032% |       6 allocs/op |
| log15               | 4246 ns/op |        +2657% |      21 allocs/op |
| :rocket: xylog      |  447 ns/op |         +190% |       6 allocs/op |


xylog

Yet another minimalistic logging library.

## yell [![go report card](https://goreportcard.com/badge/github.com/jfcg/yell)](https://goreportcard.com/report/github.com/jfcg/yell) [![go.dev ref](https://raw.githubusercontent.com/jfcg/.github/main/godev.svg)](https://pkg.go.dev/github.com/jfcg/yell#pkg-overview)
yell is yet another minimalist logging library. It comes with:
- four severity levels (info, warn, error, fatal)
- simple API
- [`io.Writer`](https://pkg.go.dev/io#Writer) & [`sync.Locker`](https://pkg.go.dev/sync#Locker) support
- package-specific loggers
- customizations (severity names, time format, local or UTC time)
- easy, granular request location (file.go:line) logging
- [semantic](https://semver.org) versioning

### Example
mypkg.go:
```go
package mypkg

import (
	"os"
	"github.com/jfcg/yell"
)

// log to stdout with warn or higher severity (for example).
var Logger = yell.New(": mypkg:", os.Stdout, yell.Swarn)

// Info tries to log message list with info severity
func Info(msg ...interface{}) error {
	return Logger.Log(yell.Sinfo, msg...)
}

// Warn tries to log message list with warn severity
func Warn(msg ...interface{}) error {
	return Logger.Log(yell.Swarn, msg...)
}

// Error tries to log message list with error severity
func Error(msg ...interface{}) (err error) {
	err = Logger.Log(yell.Serror, msg...)
	// extra stuff for error severity
	return
}

// Fatal tries to log message list with fatal severity and panics
func Fatal(msg ...interface{}) (err error) {
	err = Logger.Log(yell.Sfatal, msg...)
	pm := Logger.Name() + yell.Sname[yell.Sfatal]
	if err != nil {
		pm += err.Error()
	}
	// probably panic or os.Exit(1) in a fatal situation
	panic(pm)
}
```
myApp.go:
```go
package main

import (
	"fmt"
	"mypkg"
	"github.com/jfcg/yell"
)

func log() {
	defer func() {
		fmt.Println("recovering:", recover())
	}()

	// uses mypkg.Logger. yell records calling line in file.go:line format
	mypkg.Info("some info:", 1, "more")

	// uses yell.Default Logger, minimum severity is warning by default
	yell.Warn("some warning:", "few details")

	// record log() caller instead of this line
	mypkg.Error(yell.Caller(1), "bad error", 3.5, "data")

	// Fatal() logs & panicks
	yell.Fatal("fatal mistake", 2, "hard to recover")
}

func main() {
	// minimum severity for mypkg.Logger is warning, so ignored
	mypkg.Info("some info:", 3, "more")

	// set min severity level to info
	mypkg.Logger.SetLevel(yell.Sinfo)
	log()

	// yell library uses local time by default, to get coordinated universal time
	yell.UTC = true
	log()

	// change time format
	yell.TimeFormat = yell.TimeFormat[:19]
	log()

	// customized severity names (increasing severity)
	yell.Sname = [...]string{"信息:", "警告:", "错误:", "致命的:"}
	yell.UTC = false
	log()

	// disable logging for yell.Default
	yell.Default.SetLevel(yell.Snolog)
	log()
}
```
output:
```
2021-03-28 21:48:53.591948: mypkg:info: myApp.go:15: some info: 1 more
2021-03-28 21:48:53.592051: myApp:warn: myApp.go:18: some warning: few details
2021-03-28 21:48:53.592063: mypkg:error: myApp.go:33: bad error 3.5 data
2021-03-28 21:48:53.592082: myApp:fatal: myApp.go:24: fatal mistake 2 hard to recover
recovering: myApp:fatal:
2021-03-28 18:48:53.592100: mypkg:info: myApp.go:15: some info: 1 more
2021-03-28 18:48:53.592110: myApp:warn: myApp.go:18: some warning: few details
2021-03-28 18:48:53.592118: mypkg:error: myApp.go:37: bad error 3.5 data
2021-03-28 18:48:53.592126: myApp:fatal: myApp.go:24: fatal mistake 2 hard to recover
recovering: myApp:fatal:
2021-03-28 18:48:53: mypkg:info: myApp.go:15: some info: 1 more
2021-03-28 18:48:53: myApp:warn: myApp.go:18: some warning: few details
2021-03-28 18:48:53: mypkg:error: myApp.go:41: bad error 3.5 data
2021-03-28 18:48:53: myApp:fatal: myApp.go:24: fatal mistake 2 hard to recover
recovering: myApp:fatal:
2021-03-28 21:48:53: mypkg:信息: myApp.go:15: some info: 1 more
2021-03-28 21:48:53: myApp:警告: myApp.go:18: some warning: few details
2021-03-28 21:48:53: mypkg:错误: myApp.go:46: bad error 3.5 data
2021-03-28 21:48:53: myApp:致命的: myApp.go:24: fatal mistake 2 hard to recover
recovering: myApp:致命的:
2021-03-28 21:48:53: mypkg:信息: myApp.go:15: some info: 1 more
2021-03-28 21:48:53: mypkg:错误: myApp.go:50: bad error 3.5 data
recovering: myApp:致命的:
```

### Support
If you use yell and like it, please support via:
- BTC:`bc1qr8m7n0w3xes6ckmau02s47a23e84umujej822e`
- ETH:`0x3a844321042D8f7c5BB2f7AB17e20273CA6277f6`


yell

# :zap: zap


<div align="center">

Blazing fast, structured, leveled logging in Go.

![Zap logo](assets/logo.png)

[![GoDoc][doc-img]][doc] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov]

</div>

## Installation

`go get -u go.uber.org/zap`

Note that zap only supports the two most recent minor versions of Go.

## Quick Start

In contexts where performance is nice, but not critical, use the
`SugaredLogger`. It's 4-10x faster than other structured logging
packages and includes both structured and `printf`-style APIs.

```go
logger, _ := zap.NewProduction()
defer logger.Sync() // flushes buffer, if any
sugar := logger.Sugar()
sugar.Infow("failed to fetch URL",
  // Structured context as loosely typed key-value pairs.
  "url", url,
  "attempt", 3,
  "backoff", time.Second,
)
sugar.Infof("Failed to fetch URL: %s", url)
```

When performance and type safety are critical, use the `Logger`. It's even
faster than the `SugaredLogger` and allocates far less, but it only supports
structured logging.

```go
logger, _ := zap.NewProduction()
defer logger.Sync()
logger.Info("failed to fetch URL",
  // Structured context as strongly typed Field values.
  zap.String("url", url),
  zap.Int("attempt", 3),
  zap.Duration("backoff", time.Second),
)
```

See the [documentation][doc] and [FAQ](FAQ.md) for more details.

## Performance

For applications that log in the hot path, reflection-based serialization and
string formatting are prohibitively expensive &mdash; they're CPU-intensive
and make many small allocations. Put differently, using `encoding/json` and
`fmt.Fprintf` to log tons of `interface{}`s makes your application slow.

Zap takes a different approach. It includes a reflection-free, zero-allocation
JSON encoder, and the base `Logger` strives to avoid serialization overhead
and allocations wherever possible. By building the high-level `SugaredLogger`
on that foundation, zap lets users *choose* when they need to count every
allocation and when they'd prefer a more familiar, loosely typed API.

As measured by its own [benchmarking suite][], not only is zap more performant
than comparable structured logging packages &mdash; it's also faster than the
standard library. Like all benchmarks, take these with a grain of salt.<sup
id="anchor-versions">[1](#footnote-versions)</sup>

Log a message and 10 fields:

| Package | Time | Time % to zap | Objects Allocated |
| :------ | :--: | :-----------: | :---------------: |
| :zap: zap | 656 ns/op | +0% | 5 allocs/op
| :zap: zap (sugared) | 935 ns/op | +43% | 10 allocs/op
| zerolog | 380 ns/op | -42% | 1 allocs/op
| go-kit | 2249 ns/op | +243% | 57 allocs/op
| slog (LogAttrs) | 2479 ns/op | +278% | 40 allocs/op
| slog | 2481 ns/op | +278% | 42 allocs/op
| apex/log | 9591 ns/op | +1362% | 63 allocs/op
| log15 | 11393 ns/op | +1637% | 75 allocs/op
| logrus | 11654 ns/op | +1677% | 79 allocs/op

Log a message with a logger that already has 10 fields of context:

| Package | Time | Time % to zap | Objects Allocated |
| :------ | :--: | :-----------: | :---------------: |
| :zap: zap | 67 ns/op | +0% | 0 allocs/op
| :zap: zap (sugared) | 84 ns/op | +25% | 1 allocs/op
| zerolog | 35 ns/op | -48% | 0 allocs/op
| slog | 193 ns/op | +188% | 0 allocs/op
| slog (LogAttrs) | 200 ns/op | +199% | 0 allocs/op
| go-kit | 2460 ns/op | +3572% | 56 allocs/op
| log15 | 9038 ns/op | +13390% | 70 allocs/op
| apex/log | 9068 ns/op | +13434% | 53 allocs/op
| logrus | 10521 ns/op | +15603% | 68 allocs/op

Log a static string, without any context or `printf`-style templating:

| Package | Time | Time % to zap | Objects Allocated |
| :------ | :--: | :-----------: | :---------------: |
| :zap: zap | 63 ns/op | +0% | 0 allocs/op
| :zap: zap (sugared) | 81 ns/op | +29% | 1 allocs/op
| zerolog | 32 ns/op | -49% | 0 allocs/op
| standard library | 124 ns/op | +97% | 1 allocs/op
| slog | 196 ns/op | +211% | 0 allocs/op
| slog (LogAttrs) | 200 ns/op | +217% | 0 allocs/op
| go-kit | 213 ns/op | +238% | 9 allocs/op
| apex/log | 771 ns/op | +1124% | 5 allocs/op
| logrus | 1439 ns/op | +2184% | 23 allocs/op
| log15 | 2069 ns/op | +3184% | 20 allocs/op

## Development Status: Stable

All APIs are finalized, and no breaking changes will be made in the 1.x series
of releases. Users of semver-aware dependency management systems should pin
zap to `^1`.

## Contributing

We encourage and support an active, healthy community of contributors &mdash;
including you! Details are in the [contribution guide](CONTRIBUTING.md) and
the [code of conduct](CODE_OF_CONDUCT.md). The zap maintainers keep an eye on
issues and pull requests, but you can also report any negative conduct to
oss-conduct@uber.com. That email list is a private, safe space; even the zap
maintainers don't have access, so don't hesitate to hold us to a high
standard.

<hr>

Released under the [MIT License](LICENSE).

<sup id="footnote-versions">1</sup> In particular, keep in mind that we may be
benchmarking against slightly older versions of other packages. Versions are
pinned in the [benchmarks/go.mod][] file. [↩](#anchor-versions)

[doc-img]: https://pkg.go.dev/badge/go.uber.org/zap
[doc]: https://pkg.go.dev/go.uber.org/zap
[ci-img]: https://github.com/uber-go/zap/actions/workflows/go.yml/badge.svg
[ci]: https://github.com/uber-go/zap/actions/workflows/go.yml
[cov-img]: https://codecov.io/gh/uber-go/zap/branch/master/graph/badge.svg
[cov]: https://codecov.io/gh/uber-go/zap
[benchmarking suite]: https://github.com/uber-go/zap/tree/master/benchmarks
[benchmarks/go.mod]: https://github.com/uber-go/zap/blob/master/benchmarks/go.mod



Integrate Context with Zap logger, which leads to more flexibility in Go logging.

# Zax (zap with context)
[![codecov](https://codecov.io/github/yuseferi/zax/branch/codecov-integration/graph/badge.svg?token=64IHXT3ROF)](https://codecov.io/github/yuseferi/zax)
[![CodeQL](https://github.com/yuseferi/zax/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/yuseferi/zax/actions/workflows/github-code-scanning/codeql)
[![Check & Build](https://github.com/yuseferi/zax/actions/workflows/ci.yml/badge.svg)](https://github.com/yuseferi/zax/actions/workflows/ci.yml)
[![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/yuseferi/zax)
[![Go Report Card](https://goreportcard.com/badge/github.com/yuseferi/zax)](https://goreportcard.com/report/github.com/yuseferi/zax)

Zax is a library that adds context to [Zap Logger](https://github.com/uber-go/zap) and makes it easier for Gophers to avoid generating logger boilerplates. By passing the logger as a parameter to functions, it enhances parameter functionality and avoids the need for multiple methods with explicit dependencies.

### Installation

```shell
  go get -u github.com/yuseferi/zax/v2
```

### Usage:
To add something to the context and carry it along, simply use zap.Set:

    ctx = zax.Set(ctx, []zap.Field{zap.String("trace_id", "my-trace-id")})

To retrieve stored zap fields in context, use zax.Get:

     zax.Get(ctx)  // this retrive stored zap fields in context 

To retrieve stored zap fields in context and log them :

     logger.With(zax.Get(ctx)...).Info("just a test record")

To retrieve an specific field in the context you can use zax.GetField:

     zax.GetField(ctx, "trace_id")

After that, you can use the output as a regular logger and perform logging operations:

```Go
logger.With(zax.Get(ctx)...).Info("message")
logger.With(zax.Get(ctx)...).Debug("message")
```



##### example:
Let's say you want to generate a tracer at the entry point of your system and keep it until the process finishes:

```Go
func main() {
    logger, _ := zap.NewProduction()
    ctx := context.Background()
    s := NewServiceA(logger)
    ctx = zax.Set(ctx, zap.String("trace_id", "my-trace-id"))  
    // and if you want to add multiple of them at once
    //ctx = zax.Set(ctx, []zap.Field{zap.String("trace_id", "my-trace-id"),zap.String("span_id", "my-span-id")})
    s.funcA(ctx)
}

type ServiceA struct {
logger *zap.Logger
}

func NewServiceA(logger *zap.Logger) *ServiceA {
    return &ServiceA{
        logger: logger,
    }
}

func (s *ServiceA) funcA(ctx context.Context) {
    s.logger.Info("func A") // it does not contain trace_id, you need to add it manually
	s.logger.With(zax.Get(ctx)...).Info("func A") // it will logged with "trace_id" = "my-trace-id"
}

```
### benchmark
We have benchmarked Zax V2,V1 and Zap using the same fields. Here are the benchmark results:
As you can see in **V2** (Method with storing only fields in context, has better performance than V1 ( storing the whole logger object in context))
```
pkg: github.com/yuseferi/zax/v2
BenchmarkLoggingWithOnlyZap-10          103801226               35.56 ns/op          112 B/op          1 allocs/op
BenchmarkLoggingWithOnlyZap-10          98576570                35.56 ns/op          112 B/op          1 allocs/op
BenchmarkLoggingWithOnlyZap-10          100000000               35.24 ns/op          112 B/op          1 allocs/op
BenchmarkLoggingWithOnlyZap-10          100000000               34.85 ns/op          112 B/op          1 allocs/op
BenchmarkLoggingWithOnlyZap-10          100000000               34.98 ns/op          112 B/op          1 allocs/op
BenchmarkLoggingWithZaxV2-10            64324434                56.02 ns/op           72 B/op          2 allocs/op
BenchmarkLoggingWithZaxV2-10            63939517                56.98 ns/op           72 B/op          2 allocs/op
BenchmarkLoggingWithZaxV2-10            63374052                57.60 ns/op           72 B/op          2 allocs/op
BenchmarkLoggingWithZaxV2-10            63417358                57.37 ns/op           72 B/op          2 allocs/op
BenchmarkLoggingWithZaxV2-10            57964246                57.97 ns/op           72 B/op          2 allocs/op
BenchmarkLoggingWithZaxV1-10            54062712                66.40 ns/op          160 B/op          2 allocs/op
BenchmarkLoggingWithZaxV1-10            53155524                65.61 ns/op          160 B/op          2 allocs/op
BenchmarkLoggingWithZaxV1-10            54428521                64.19 ns/op          160 B/op          2 allocs/op
BenchmarkLoggingWithZaxV1-10            55420744                64.28 ns/op          160 B/op          2 allocs/op
BenchmarkLoggingWithZaxV1-10            55199061                64.50 ns/op          160 B/op          2 allocs/op
PASS
ok      github.com/yuseferi/zax/v2      56.919s


```

### Contributing
We strongly believe in open-source ❤️😊. Please feel free to contribute by raising issues and submitting pull requests to make Zax even better!


Released under the [GNU GENERAL PUBLIC LICENSE](LICENSE).






zerolog

# ZKits Logger Library #

[![Golang Version](https://img.shields.io/badge/golang-1.18+-orange)](https://github.com/edoger/zkits-logger)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![Build Status](https://github.com/edoger/zkits-logger/workflows/CI/badge.svg?branch=master)](https://github.com/edoger/zkits-logger/actions/workflows/ci.yml)
[![Build status](https://ci.appveyor.com/api/projects/status/xpbbppv3aui8n3fb/branch/master?svg=true)](https://ci.appveyor.com/project/edoger56924/zkits-logger/branch/master)
[![Coverage Status](https://coveralls.io/repos/github/edoger/zkits-logger/badge.svg?branch=master)](https://coveralls.io/github/edoger/zkits-logger?branch=master)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/cb497bf703f44950afb43b51b3a0e581)](https://www.codacy.com/manual/edoger/zkits-logger?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=edoger/zkits-logger&amp;utm_campaign=Badge_Grade)
[![Go Report Card](https://goreportcard.com/badge/github.com/edoger/zkits-logger)](https://goreportcard.com/report/github.com/edoger/zkits-logger)

## About ##

This is a zero-dependency standard JSON log library that supports structured JSON logs and is compatible with the standard library.

 - Does not depend on any third-party libraries.
 - Provides controllable caller and stack information reporting.
 - Provides 7 log level support.
 - Compatible with standard library logger *log.Logger.
 - Support chain calls and add multiple log extension data.
 - Provides logging hook support.
 - Built-in multiple log formatters, support custom log formatters.
 - Support log output to different writers by level.
 - Supports output interceptor to easily hijack and control log output.
 - Provides a log file writer that supports log file rotation by size.
 - Can control the format and output writer of each log.

According to the plan, this library will release 2 versions every year. 
If there are new security issues or PRs, we will release new versions according to the actual situation.

![](text.png)

> Example image uses the ConsoleFormatter and disables the exit and panic functions.
> For the default Logger instance, we use the JSONFormatter.

## Install ##

```sh
   go get -u -v github.com/edoger/zkits-logger
```

## Quick Start ##

```go
    import "github.com/edoger/zkits-logger"

    // Creates a logger instance with the specified name.
    // Empty name are allowed.
    log := logger.New("app")
    // {"level":"info","message":"Hello.","name":"app","time":"2020-02-20T20:20:20+08:00"}
    log.Info("Hello.")
    // {"fields":{"field":1},"level":"info","message":"Hello.","name":"app","time":"2020-02-20T20:20:20+08:00"}
    log.WithField("field", 1).Info("Hello.")
```

## Design Concept ##

### Zero Dependencies ###

We think the logger should be lightweight enough, because the applications we develop are already complex 
enough, they often have massive third-party dependencies, so let's not add additional dependencies to the 
application, which is why I built this library one of the reasons.

### No Locker ###

For the performance of the logger, we adopt a lock-free design as a whole.
Therefore, we agree that the shared data of the logger is read-only, and we require the application 
to not modify its internal shared data after initializing the logger. (formatters, log writers, hooks, etc).

> For the logger level, it can be modified at runtime, as it is a common and meaningful operation 
> for applications to adjust the level of the logger at runtime.

We recommend initializing the logger (Logger) as soon as it is created (if required by the application), 
using the logging interface ``` Logger.AsLog() ``` to provide logging functionality.

```go
    package log
    
    import "github.com/edoger/zkits-logger"
    
    var defaultLogger = logger.New("name")

    // Initialize the logger.
    func Initialize(/* Your config */) {
        // defaultLogger.SetLevel(Level)
        // defaultLogger.SetOutput(Writer)
        // defaultLogger.SetFormatter(Formatter)
        // ... ...
    }

    // GetLogger gets the default logger instance.
    func GetLogger() logger.Log {
        // Mask the setting method of Logger.
        return defaultLogger.AsLog()
    }
```

### Chained Calls & Log Tree ###

Chained calls are more in line with the way we think when writing source code (left-to-right, continuous).
We have designed a number of ``` Log.With* ``` methods to extend the additional fields of the log, 
and through these methods, more field information can be recorded. 
At the same time, these methods will create and return new log objects, 
we can use this feature to add differentiated fields to different modules.

```go
    // Create Log instance with additional properties.
    // All SubLog inherit the properties of the BaseLog (properties with the same name will be overwritten), 
    // and they are independent of each other and no longer associated with the BaseLog.
    SubLog1 := BaseLog.WithField("key", value)
    SubLog2 := BaseLog.WithFields(map[string]interface{}{/* multiple fields */})
    SubLog3 := BaseLog.WithContext(ctx)
    // Field key-value pairs are also supported.
    SubLog4 := BaseLog.WithFieldPairs("key1", value1, "key2", value2, /* More ... */)
    /* More ... */

    // Add a logger for the submodule, the logs recorded by the submodule all have
    // the additional properties we added.
    SubModule.WithLogger(Log.WithField("module", "ModuleName"))
```

Best practices:

```go
    // Good
    Log.WithFields(map[string]interface{}{"field1": var1, "field2": var2})
    // Bad
    Log.WithField("field1", var1).WithField("field2", var2)
```

The application is not a modular design? No additional properties?

```go
    // Add a fixed prefix to log messages.
    log := Log.WithMessagePrefix("Prefix: ")

    log.Info("Step 1 is done!") // Log message: "Prefix: Step 1 is done!"
    log.Info("Step 2 is done!") // Log message: "Prefix: Step 2 is done!"
```

Need to determine if a log level is visible before logging?

```go
    if Log.IsLevelEnabled(Level) { /* Print log */ }
    // or
    if Log.IsDebugLevelEnabled() { /* Print debug log */ }
```

### Quickly Locate Bugs ###

The purpose of the log is to observe the running status of our application. 
When there is a problem with the application, the log can help us quickly find and solve the root cause of the problem.
We've designed our logger with this in mind, and for this reason we provide a very flexible and concise "scenario" grabbing capability.

**Log error:**

```go
    // Tell us the file name and line number when logging the error.
    Log.WithCaller().WithError(err).Error("Task failed!") // Log errors into separate field.
    Log.WithCaller().Errorf("Task failed: %s.", err)

    // Too troublesome? Code too verbose? Then we set it globally!
    // Callers are now automatically added to all logs that meet the level.
    Logger.EnableLevelCaller(ErrorLevel)
    Logger.EnableLevelsCaller([]Level{ErrorLevel, FatalLevel, PanicLevel})
```

**Panic:**

```go
    // Tell us the crash call stack information.
    Log.WithStack().Error("Application crash!")

    // Setting Logger.SetExitFunc(nil) disables the automatic call os.Exit. 
    Log.WithStack().Fatal("Application crash!")
    // Setting Logger.SetPanicFunc(nil) disables the automatic call panic. 
    Log.WithStack().Panic("Application crash!")
```

## Future Overview ##

### Log Hooks ###

Log hooks allow us to do some extra things before logging.
Log hooks are designed to uniformly handle log events (by Level) that we are interested in.
Log hooks should be lightweight enough, such as: counting the number of logs, triggering alarms, etc.

```go
    // Define the hook for our application.
    type AppHook struct {}

    func (*AppHook) Levels() []Level {
        return []Level{ErrorLevel, FatalLevel, PanicLevel}
    }

    func (*AppHook) Fire(s Summary) error {
        // Do something!
        return nil
    }

    // Register application log hook.
    Logger.AddHook(new(AppHook))
```

Don't want to define hook struct?

```go
    Logger.AddHookFunc([]Level{ErrorLevel}, func(s Summary) error {
        // Do something!
        return nil
    })
```

Do we have multiple hooks that need to be registered?

```go
    // Create a hook collection.
    bag := NewHookBag()

    // Add our hooks.
    bag.Add(Hook1)
    bag.Add(Hook2)
    /* ... More ... */
    bag.Add(HookN)

    // Register them all at once.
    Logger.AddHook(bag)
```

> HookBag also needs to adhere to our "No Locker" philosophy, do not continue to add hooks after registration.

### Log Formatter ###

The log formatter is used to format the log object into string data as expected.
The log formatter should be as efficient as possible, this is the most CPU-intensive component of the logger.

We have built in several common formatters, they may not be the best and most suitable, 
but they are rigorously tested and work out of the box.

**JSON Formatter**

```go
    // The default formatter, if you don't change it, that's it.
    f := DefaultJSONFormatter()

    // Create one and configure custom field names.
    // If the full parameter is true, it will always ensure that all fields exist in the top-level json object.
    f, err := NewJSONFormatter(keys map[string]string, full bool)
    f := MustNewJSONFormatter(keys map[string]string, full bool)
```

> Custom JSON field names will not benefit from the optimizations of the JSON serializer.

**Text Formatter**

```go
    f := DefaultTextFormatter()
    f := DefaultQuoteTextFormatter() // Escape invisible characters.

    // The format parameter is used to control the format of the log, and it has many control parameters.
    // For example:
    //     "[{name}][{time}][{level}] {caller} {message} {fields}"
    // The supported placeholders are:
    //     {name}      The name of the logger that recorded this log.
    //     {time}      Record the time of this log.
    //     {level}     The level of this log.
    //     {caller}    The name and line number of the file where this log was generated. (If enabled)
    //     {message}   The message of this log.
    //     {fields}    The extended fields of this log. (if it exists)
    //     {stack}     The call stack of this log. (if it exists)
    // It is worth knowing:
    //     1. For the {time} parameter, we can specify time format, like this: {time@2006-01-02 15:04:05}.
    //     2. For the {level} parameter, we can specify level format, like this: {level@sc},
    //        {level@sc} or {level@cs} will call the Level.ShortCapitalString method.
    //        {level@s} will call the Level.ShortString method.
    //        {level@c} will call the Level.CapitalString method.
    //        For other will call the Level.String method.
    //     3. Considering the aesthetics of the format, for {caller} and {fields} and {stack}, if
    //        there is non-empty data, a space will be automatically added in front.
    //        If this behavior is not needed, use {caller@?} or {fields@?} or {stack@?} parameters.
    // The quote parameter is used to escape invisible characters in the log.
    f, err := NewTextFormatter(format string, quote bool)
    f := MustNewTextFormatter(format string, quote bool)
```

**Console Formatter**

```go
    // The console formatter is very similar to the text formatter. The only difference is that
    // we output different console colors for different log levels, which is very useful when
    // outputting logs from the console.
    f := NewConsoleFormatter()
```

### Output Interceptor ###

The output interceptor can bypass the output writer of the logger binding 
(``` Logger.SetOutput ``` or ``` Logger.SetLevelOutput ``` or ``` Logger.SetLevelsOutput ```) 
and output the log to our custom system (these systems are often dynamic or cannot be wrapped 
as ``` io.Writer ```).

```go
    // The io.Writer in the interceptor parameter is the io.Writer instance bound by the logger.
    Logger.SetOutputInterceptor(func(s Summary, w io.Writer) (int, error) {
        // Do something!
        return s.Size(), nil
    })
```

> Once the output interceptor is enabled, we will no longer write logs to the log writer,
> even if the interceptor returns an error.

### Format Output ###

The ``` FormatOutput ``` allows customizing the format and writer of each log.

```go
    // The io.Writer in the interceptor parameter is the io.Writer instance bound by the logger.
    Logger.SetFormatOutput(FormatOutputFunc(func(e Entity, b *bytes.Buffer) (io.Writer, error) {
        // 1. Format the log and write to the buffer.
        // 2. Determines and returns the writer to which the log needs to be written.
        return os.Stdout, nil
    })
```

> After setting FormatOutput, the original log formatter will not be used, and when FormatOutput returns 
> the writer is not nil, the original writer will not be used either.

### Log Context & Trace ###

The log context is to support the trace technology. 
By default, we will not do any operations on the context object bound to the log. 
If you need to use the link tracking technology, you should define a custom log formatter to 
process the trace data.

```go
    // Bind the context for the log.
    Log.WithContext(ctx)

    // Register a formatter that supports parsing trace data.
    Logger.SetFormatter(FormatterFunc(func(e Entity, b *bytes.Buffer) error {
        ctx := e.Context()
        // 1. Parse trace data from Context.
        // 2. Formats the log Entity and writes the data to the Buffer.
        return nil
    }))
```

> Parsing trace data is difficult to standardize, and solutions used by different applications 
> are completely different, so we leave this function to users to implement.

> ⚠️ The custom log formatter needs to append a newline after the formatted log data is 
> written into the buffer, otherwise the log will not wrap automatically.

### Log Bridge ###

Log bridge is a concept here. Applications often have many third-party libraries and components. 
In order to adapt to the log loggers of these libraries and components, we built some log bridges 
without introducing dependencies. They are responsible for converting our loggers to loggers for 
these libraries and components.

**Standard Library Logger**

```go
    import log // Standard log package

    // Convert our logger to the standard library logger instance.
    g := Logger.AsStandardLogger() // Return *log.Logger instance.

    // You can also customize the default log level.
    log.New(NewLevelWriter(DebugLevel, Logger.AsLog()))
```

> 💣 The *log.Logger automatically exits the system and panics when logging fatal and panic level log.

## License ##

[Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)


zkits-logger

High Developer Experience, zap based logger. It offers rich functionality but is easy to configure.

# zl :technologist:
[![Go Reference](https://pkg.go.dev/badge/github.com/nkmr-jp/zl.svg)](https://pkg.go.dev/github.com/nkmr-jp/zl)
[![test](https://github.com/nkmr-jp/zl/actions/workflows/test.yml/badge.svg)](https://github.com/nkmr-jp/zl/actions/workflows/test.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/nkmr-jp/zl)](https://goreportcard.com/report/github.com/nkmr-jp/zl)
[![codecov](https://codecov.io/gh/nkmr-jp/zl/branch/main/graph/badge.svg?token=2Z6M2JYT17)](https://codecov.io/gh/nkmr-jp/zl)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

zl is a logger based on [zap](https://github.com/uber-go/zap). It provides advanced logging features.

zl is a logging package designed with the developer experience in mind.
You can choose the most suitable output format according to your purpose, such as emphasizing easy-to-read console output during development in a local environment and outputting structured detailed logs in a production environment.
It offers rich functionality but is easy to configure.

This is useful when developing systems that perform complex processing.

# Features
## Selectable output format
### PrettyOutput (Default) :technologist: 
- High Developer Experience.
- The optimal setting for a development environment.
- Output colored simple logs to the console.
- Output detail JSON logs to the logfile.
- Easy-to-read error reports and stack trace.
- It can jumps directly to the line of the file that is output to the console log (when using Goland or VSCode).

![image](https://user-images.githubusercontent.com/8490118/185822142-4667200b-8087-49f0-9e41-68ebb1731985.png)

Log messages do not have to be written in upper snake case, 
but if messages are written in a uniform manner, 
it is easy to extract specific logs using tools such as [Google Cloud Logging](https://cloud.google.com/logging) or the [jq command](https://stedolan.github.io/jq/).
It is recommended that log messages be written in a consistent manner.
By writing log messages succinctly and placing detailed information in separate fields, 
the overall clarity of the logs is improved, making it easier to understand the flow of processes.

### ConsoleOutput :zap:
- High Performance.
- The optimal setting for a production environment.
- Output detail JSON logs to the console.
- Especially suitable for cloud environments such as [Google Cloud Logging](https://cloud.google.com/logging) or [Datadog](https://www.datadoghq.com/).
- It is fast because it uses only the functions provided by [zap](https://github.com/uber-go/zap#performance) (**not sugared**) and does not perform any extra processing.

### FileOutput
- The optimal setting for a production environment.
- It is especially suitable for command line tool or on-premises environments.
- Support logfile rotation.

### ConsoleAndFileOutput
- It is a setting for the development environment.
- Output detail JSON logs to console and logfile.
- It is recommended to use with [jq command](https://stedolan.github.io/jq/) to avoid drowning in a sea of information.
- It is recommended to set PrettyOutput instead.


# Installation

```sh
go get -u github.com/nkmr-jp/zl
```

# Quick Start

code: [examples/basic/main.go](examples/basic/main.go)
```go
package main

import (
	"encoding/json"
	"os"
	"strconv"

	"github.com/nkmr-jp/zl"
	"go.uber.org/zap"
)

func main() {
	// Set Options
	zl.SetLevel(zl.DebugLevel)
	zl.SetOmitKeys(zl.HostnameKey)

	// Initialize
	zl.Init()
	defer zl.Sync() // flush log buffer

	// Write logs
	zl.Info("USER_INFO", zap.String("user_name", "Alice"), zap.Int("user_age", 20)) // can use zap fields.
	zl.Info("DISPLAY_TO_CONSOLE", zl.Console("The message you want to display to console"))
	zl.Warn("WARN_MESSAGE")
	zl.Debug("DEBUG_MESSAGE")
	_, err := os.ReadFile("test")
	zl.Err("READ_FILE_ERROR", err)
	
	// if the same error occurs multiple times in the same location, the error report will show them all together.
	for i := 0; i < 2; i++ {
		_, err = strconv.Atoi("one")
		zl.Err("A_TO_I_ERROR", err)
	}
	for i := 0; i < 3; i++ {
		v := ""
		err = json.Unmarshal([]byte("test"), &v)
		zl.Err("JSON_UNMARSHAL_ERROR", err)
	}
}
```

**Console output**. <br>
The console displays minimal information. Displays a stack trace when an error occurs.
![image](https://user-images.githubusercontent.com/8490118/185822142-4667200b-8087-49f0-9e41-68ebb1731985.png)

**File output**. <br>
Detailed information is available in the log file. You can also use jq to extract only the information you need.
```sh
$ cat log/app.jsonl | jq 'select(.message | startswith("USER_")) | select(.pid==921)'
```
```json
{
  "severity": "INFO",
  "timestamp": "2022-08-22T10:30:39.154575+09:00",
  "caller": "basic/main.go:22",
  "function": "main.main",
  "message": "USER_INFO",
  "version": "fc43f68",
  "pid": 921,
  "user_name": "Alice",
  "user_age": 20
}
   
```

# Examples
- [examples](examples)
- [example_test.go](example_test.go)


The Best Go Libraries For Logging (39)

logdump

lumberjack

structy/log

distillog

glg

glo

glog

go-cronowriter

go-log

go-log

go-log

go-log

go-logger

gomol

kemba

log

log

log

mlog

phuslu/log

pp

rollingwriter

seelog

slf4g

slog

slog-formatter

slog-multi

spew

sqldb-logger

stdlog

tail

tint

xylog

yell

zap

zax

zerolog

zkits-logger

zl