| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package log implements a simple logging package. It defines a type, Logger, |
| // with methods for formatting output. It also has a predefined 'standard' |
| // Logger accessible through helper functions Print[f|ln], Fatal[f|ln], and |
| // Panic[f|ln], which are easier to use than creating a Logger manually. |
| // That logger writes to standard error and prints the date and time |
| // of each logged message. |
| // Every log message is output on a separate line: if the message being |
| // printed does not end in a newline, the logger will add one. |
| // The Fatal functions call os.Exit(1) after writing the log message. |
| // The Panic functions call panic after writing the log message. |
| package log |
| |
| import ( |
| "fmt" |
| "io" |
| "os" |
| "runtime" |
| "sync" |
| "time" |
| ) |
| |
| // These flags define which text to prefix to each log entry generated by the Logger. |
| const ( |
| // Bits or'ed together to control what's printed. |
| // There is no control over the order they appear (the order listed |
| // here) or the format they present (as described in the comments). |
| // The prefix is followed by a colon only when Llongfile or Lshortfile |
| // is specified. |
| // For example, flags Ldate | Ltime (or LstdFlags) produce, |
| // 2009/01/23 01:23:23 message |
| // while flags Ldate | Ltime | Lmicroseconds | Llongfile produce, |
| // 2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message |
| Ldate = 1 << iota // the date in the local time zone: 2009/01/23 |
| Ltime // the time in the local time zone: 01:23:23 |
| Lmicroseconds // microsecond resolution: 01:23:23.123123. assumes Ltime. |
| Llongfile // full file name and line number: /a/b/c/d.go:23 |
| Lshortfile // final file name element and line number: d.go:23. overrides Llongfile |
| LUTC // if Ldate or Ltime is set, use UTC rather than the local time zone |
| LstdFlags = Ldate | Ltime // initial values for the standard logger |
| ) |
| |
| // 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 |
| } |
| |
| // New creates a new Logger. The out variable sets the |
| // destination to which log data will be written. |
| // The prefix appears at the beginning of each generated log line. |
| // The flag argument defines the logging properties. |
| func New(out io.Writer, prefix string, flag int) *Logger { |
| return &Logger{out: out, prefix: prefix, flag: flag} |
| } |
| |
| // SetOutput sets the output destination for the logger. |
| func (l *Logger) SetOutput(w io.Writer) { |
| l.mu.Lock() |
| defer l.mu.Unlock() |
| l.out = w |
| } |
| |
| var std = New(os.Stderr, "", LstdFlags) |
| |
| // Cheap integer to fixed-width decimal ASCII. Give a negative width to avoid zero-padding. |
| func itoa(buf *[]byte, i int, wid int) { |
| // Assemble decimal in reverse order. |
| var b [20]byte |
| bp := len(b) - 1 |
| for i >= 10 || wid > 1 { |
| wid-- |
| q := i / 10 |
| b[bp] = byte('0' + i - q*10) |
| bp-- |
| i = q |
| } |
| // i < 10 |
| b[bp] = byte('0' + i) |
| *buf = append(*buf, b[bp:]...) |
| } |
| |
| // formatHeader writes log header to buf in following order: |
| // * l.prefix (if it's not blank), |
| // * date and/or time (if corresponding flags are provided), |
| // * file and line number (if corresponding flags are provided). |
| func (l *Logger) formatHeader(buf *[]byte, t time.Time, file string, line int) { |
| *buf = append(*buf, l.prefix...) |
| if l.flag&(Ldate|Ltime|Lmicroseconds) != 0 { |
| if l.flag&LUTC != 0 { |
| t = t.UTC() |
| } |
| if l.flag&Ldate != 0 { |
| year, month, day := t.Date() |
| itoa(buf, year, 4) |
| *buf = append(*buf, '/') |
| itoa(buf, int(month), 2) |
| *buf = append(*buf, '/') |
| itoa(buf, day, 2) |
| *buf = append(*buf, ' ') |
| } |
| if l.flag&(Ltime|Lmicroseconds) != 0 { |
| hour, min, sec := t.Clock() |
| itoa(buf, hour, 2) |
| *buf = append(*buf, ':') |
| itoa(buf, min, 2) |
| *buf = append(*buf, ':') |
| itoa(buf, sec, 2) |
| if l.flag&Lmicroseconds != 0 { |
| *buf = append(*buf, '.') |
| itoa(buf, t.Nanosecond()/1e3, 6) |
| } |
| *buf = append(*buf, ' ') |
| } |
| } |
| if l.flag&(Lshortfile|Llongfile) != 0 { |
| if l.flag&Lshortfile != 0 { |
| short := file |
| for i := len(file) - 1; i > 0; i-- { |
| if file[i] == '/' { |
| short = file[i+1:] |
| break |
| } |
| } |
| file = short |
| } |
| *buf = append(*buf, file...) |
| *buf = append(*buf, ':') |
| itoa(buf, line, -1) |
| *buf = append(*buf, ": "...) |
| } |
| } |
| |
| // 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 |
| } |
| |
| // 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...)) |
| } |
| |
| // Print calls l.Output to print to the logger. |
| // Arguments are handled in the manner of fmt.Print. |
| func (l *Logger) Print(v ...interface{}) { l.Output(2, fmt.Sprint(v...)) } |
| |
| // Println calls l.Output to print to the logger. |
| // Arguments are handled in the manner of fmt.Println. |
| func (l *Logger) Println(v ...interface{}) { l.Output(2, fmt.Sprintln(v...)) } |
| |
| // Fatal is equivalent to l.Print() followed by a call to os.Exit(1). |
| func (l *Logger) Fatal(v ...interface{}) { |
| l.Output(2, fmt.Sprint(v...)) |
| os.Exit(1) |
| } |
| |
| // Fatalf is equivalent to l.Printf() followed by a call to os.Exit(1). |
| func (l *Logger) Fatalf(format string, v ...interface{}) { |
| l.Output(2, fmt.Sprintf(format, v...)) |
| os.Exit(1) |
| } |
| |
| // Fatalln is equivalent to l.Println() followed by a call to os.Exit(1). |
| func (l *Logger) Fatalln(v ...interface{}) { |
| l.Output(2, fmt.Sprintln(v...)) |
| os.Exit(1) |
| } |
| |
| // Panic is equivalent to l.Print() followed by a call to panic(). |
| func (l *Logger) Panic(v ...interface{}) { |
| s := fmt.Sprint(v...) |
| l.Output(2, s) |
| panic(s) |
| } |
| |
| // Panicf is equivalent to l.Printf() followed by a call to panic(). |
| func (l *Logger) Panicf(format string, v ...interface{}) { |
| s := fmt.Sprintf(format, v...) |
| l.Output(2, s) |
| panic(s) |
| } |
| |
| // Panicln is equivalent to l.Println() followed by a call to panic(). |
| func (l *Logger) Panicln(v ...interface{}) { |
| s := fmt.Sprintln(v...) |
| l.Output(2, s) |
| panic(s) |
| } |
| |
| // Flags returns the output flags for the logger. |
| func (l *Logger) Flags() int { |
| l.mu.Lock() |
| defer l.mu.Unlock() |
| return l.flag |
| } |
| |
| // SetFlags sets the output flags for the logger. |
| func (l *Logger) SetFlags(flag int) { |
| l.mu.Lock() |
| defer l.mu.Unlock() |
| l.flag = flag |
| } |
| |
| // Prefix returns the output prefix for the logger. |
| func (l *Logger) Prefix() string { |
| l.mu.Lock() |
| defer l.mu.Unlock() |
| return l.prefix |
| } |
| |
| // SetPrefix sets the output prefix for the logger. |
| func (l *Logger) SetPrefix(prefix string) { |
| l.mu.Lock() |
| defer l.mu.Unlock() |
| l.prefix = prefix |
| } |
| |
| // SetOutput sets the output destination for the standard logger. |
| func SetOutput(w io.Writer) { |
| std.mu.Lock() |
| defer std.mu.Unlock() |
| std.out = w |
| } |
| |
| // Flags returns the output flags for the standard logger. |
| func Flags() int { |
| return std.Flags() |
| } |
| |
| // SetFlags sets the output flags for the standard logger. |
| func SetFlags(flag int) { |
| std.SetFlags(flag) |
| } |
| |
| // Prefix returns the output prefix for the standard logger. |
| func Prefix() string { |
| return std.Prefix() |
| } |
| |
| // SetPrefix sets the output prefix for the standard logger. |
| func SetPrefix(prefix string) { |
| std.SetPrefix(prefix) |
| } |
| |
| // These functions write to the standard logger. |
| |
| // Print calls Output to print to the standard logger. |
| // Arguments are handled in the manner of fmt.Print. |
| func Print(v ...interface{}) { |
| std.Output(2, fmt.Sprint(v...)) |
| } |
| |
| // Printf calls Output to print to the standard logger. |
| // Arguments are handled in the manner of fmt.Printf. |
| func Printf(format string, v ...interface{}) { |
| std.Output(2, fmt.Sprintf(format, v...)) |
| } |
| |
| // Println calls Output to print to the standard logger. |
| // Arguments are handled in the manner of fmt.Println. |
| func Println(v ...interface{}) { |
| std.Output(2, fmt.Sprintln(v...)) |
| } |
| |
| // Fatal is equivalent to Print() followed by a call to os.Exit(1). |
| func Fatal(v ...interface{}) { |
| std.Output(2, fmt.Sprint(v...)) |
| os.Exit(1) |
| } |
| |
| // Fatalf is equivalent to Printf() followed by a call to os.Exit(1). |
| func Fatalf(format string, v ...interface{}) { |
| std.Output(2, fmt.Sprintf(format, v...)) |
| os.Exit(1) |
| } |
| |
| // Fatalln is equivalent to Println() followed by a call to os.Exit(1). |
| func Fatalln(v ...interface{}) { |
| std.Output(2, fmt.Sprintln(v...)) |
| os.Exit(1) |
| } |
| |
| // Panic is equivalent to Print() followed by a call to panic(). |
| func Panic(v ...interface{}) { |
| s := fmt.Sprint(v...) |
| std.Output(2, s) |
| panic(s) |
| } |
| |
| // Panicf is equivalent to Printf() followed by a call to panic(). |
| func Panicf(format string, v ...interface{}) { |
| s := fmt.Sprintf(format, v...) |
| std.Output(2, s) |
| panic(s) |
| } |
| |
| // Panicln is equivalent to Println() followed by a call to panic(). |
| func Panicln(v ...interface{}) { |
| s := fmt.Sprintln(v...) |
| std.Output(2, s) |
| panic(s) |
| } |
| |
| // 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 the count of the number of |
| // frames to skip when computing the file name and line number |
| // if Llongfile or Lshortfile is set; a value of 1 will print the details |
| // for the caller of Output. |
| func Output(calldepth int, s string) error { |
| return std.Output(calldepth+1, s) // +1 for this frame. |
| } |