Log パッケージで遊ぶ

package main

import (
    "log"
)

func main() {
    log.Println("Hello, World")
}

2009/11/10 23:00:00 Hello, World

// A Logger represents an active logging object that generates lines of
// output to an io.Writer. Each logging operation makes a single call to
// the Writer's Write method. A Logger can be used simultaneously from
// multiple goroutines; it guarantees to serialize access to the Writer.
type Logger struct {
    mu     sync.Mutex // ensures atomic writes; protects the following fields
    prefix string     // prefix to write at beginning of each line
    flag   int        // properties
    out    io.Writer  // destination for output
    buf    []byte     // for accumulating text to write
}

// Printf calls l.Output to print to the logger.
// Arguments are handled in the manner of fmt.Printf.
func (l *Logger) Printf(format string, v ...interface{}) {
    l.Output(2, fmt.Sprintf(format, v...))
}

// Output writes the output for a logging event. The string s contains
// the text to print after the prefix specified by the flags of the
// Logger. A newline is appended if the last character of s is not
// already a newline. Calldepth is used to recover the PC and is
// provided for generality, although at the moment on all pre-defined
// paths it will be 2.
func (l *Logger) Output(calldepth int, s string) error {
    now := time.Now() // get this early.
    var file string
    var line int
    l.mu.Lock()
    defer l.mu.Unlock()
    if l.flag&(Lshortfile|Llongfile) != 0 {
        // Release lock while getting caller info - it's expensive.
        l.mu.Unlock()
        var ok bool
        _, file, line, ok = runtime.Caller(calldepth)
        if !ok {
            file = "???"
            line = 0
        }
        l.mu.Lock()
    }
    l.buf = l.buf[:0]
    l.formatHeader(&l.buf, now, file, line)
    l.buf = append(l.buf, s...)
    if len(s) == 0 || s[len(s)-1] != '\n' {
        l.buf = append(l.buf, '\n')
    }
    _, err := l.out.Write(l.buf)
    return err
}

package main

import (
    "log"
    "os"
)

func main() {
    log.SetFlags(log.LstdFlags | log.Lmicroseconds | log.Lshortfile)
    log.SetOutput(os.Stdout)
    log.SetPrefix("[Hello] ")

    log.Println("Hello, World")
}

[Hello] 2009/11/10 23:00:00.000000 main.go:13: Hello, World

package main

import (
    "log"
    "os"
)

func main() {
    l := log.New(os.Stdout, "[Hello] ", log.LstdFlags|log.Lmicroseconds|log.Lshortfile)

    l.Println("Hello, World")
}

package main

import (
    "log"
    "os"

    "github.com/hashicorp/logutils"
)

func main() {
    filter := &logutils.LevelFilter{
        Levels:   []logutils.LogLevel{"DEBUG", "WARN", "ERROR"},
        MinLevel: logutils.LogLevel("WARN"),
        Writer:   os.Stderr,
    }
    log.SetOutput(filter)

    log.Print("[DEBUG] Debugging")         // this will not print
    log.Print("[WARN] Warning")            // this will
    log.Print("[ERROR] Erroring")          // and so will this
    log.Print("Message I haven't updated") // and so will this
}

2009/11/10 23:00:00 [WARN] Warning
2009/11/10 23:00:00 [ERROR] Erroring
2009/11/10 23:00:00 Message I haven't updated

//Logger is logger class
type Logger struct {
    lg   *log.Logger // logger
    mu   sync.Mutex  // ensures atomic writes; protects the following fields
    flag int         // properties
    min  Level
}

//Output writes the output for a logging event.
func (l *Logger) Output(lv Level, calldepth int, s string) error {
    if lv >= l.min {
        if (l.flag & Llevel) != 0 {
            return l.lg.Output(calldepth, fmt.Sprintf("[%v] %s", lv, s))
        }
        return l.lg.Output(calldepth, s)
    }
    return nil
}

package main

import (
    "os"

    "github.com/spiegel-im-spiegel/logf"
)

func main() {
    logf.SetOutput(os.Stdout)
    logf.SetMinLevel(logf.WARN)

    logf.Debug("Debugging")   // this will not print
    logf.Print("Information") // this will not print
    logf.Warn("Warning")      // this will
    logf.Error("Erroring")    // and so will this
}

2009/11/10 23:00:00 [WARN] Warning
2009/11/10 23:00:00 [ERROR] Erroring

package main

import (
    rotatelogs "github.com/lestrrat-go/file-rotatelogs"
    "github.com/spiegel-im-spiegel/logf"
)

func main() {
    logf.SetMinLevel(logf.WARN)
    rl, err := rotatelogs.New("./log.%Y%m%d%H%M.txt")
    if err != nil {
        logf.Fatal(err)
        return
    }
    logf.SetOutput(rl)

    logf.Debug("Debugging")   // this will not print
    logf.Print("Information") // this will not print
    logf.Warn("Warning")      // this will
    logf.Error("Erroring")    // and so will this
}