2009-01-26 10:28:07 -07:00
|
|
|
// 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.
|
|
|
|
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Simple logging package. It defines a type, Logger, with simple
|
|
|
|
// methods for formatting output to one or two destinations. It also
|
|
|
|
// has a predefined 'standard' Logger accessible through helper
|
|
|
|
// functions Print[f|ln], Exit[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.
|
|
|
|
// The Exit functions call os.Exit(1) after writing the log message.
|
|
|
|
// The Panic functions call panic after writing the log message.
|
2009-01-26 10:28:07 -07:00
|
|
|
package log
|
|
|
|
|
|
|
|
import (
|
2009-12-15 16:35:38 -07:00
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"runtime"
|
|
|
|
"os"
|
|
|
|
"time"
|
2009-01-26 10:28:07 -07:00
|
|
|
)
|
|
|
|
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// These flags define the output Loggers produce.
|
2009-01-26 10:28:07 -07:00
|
|
|
const (
|
2009-01-26 16:34:16 -07:00
|
|
|
// 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). A colon appears after these items:
|
|
|
|
// 2009/0123 01:23:23.123123 /a/b/c/d.go:23: message
|
2009-12-15 16:35:38 -07:00
|
|
|
Ldate = 1 << iota // the date: 2009/0123
|
2010-03-16 17:45:54 -06:00
|
|
|
Ltime // the time: 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
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
lallBits = Ldate | Ltime | Lmicroseconds | Llongfile | Lshortfile
|
2009-01-26 10:28:07 -07:00
|
|
|
)
|
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Logger represents an active logging object.
|
2009-01-26 10:28:07 -07:00
|
|
|
type Logger struct {
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
out io.Writer // destination for output
|
2009-12-15 16:35:38 -07:00
|
|
|
prefix string // prefix to write at beginning of each line
|
|
|
|
flag int // properties
|
2009-01-26 10:28:07 -07:00
|
|
|
}
|
|
|
|
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// New creates a new Logger. The out variable sets the
|
|
|
|
// destination to which log data will be written.
|
2009-03-04 23:46:44 -07:00
|
|
|
// The prefix appears at the beginning of each generated log line.
|
|
|
|
// The flag argument defines the logging properties.
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
func New(out io.Writer, prefix string, flag int) *Logger {
|
|
|
|
return &Logger{out, prefix, flag}
|
2009-01-26 10:28:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
std = New(os.Stderr, "", Ldate|Ltime)
|
|
|
|
stdout = New(os.Stdout, "", Ldate|Ltime) // Deprecated.
|
2009-01-26 10:28:07 -07:00
|
|
|
)
|
|
|
|
|
2009-01-26 16:34:16 -07:00
|
|
|
// Cheap integer to fixed-width decimal ASCII. Use a negative width to avoid zero-padding
|
|
|
|
func itoa(i int, wid int) string {
|
2009-12-15 16:35:38 -07:00
|
|
|
var u uint = uint(i)
|
2009-01-26 16:34:16 -07:00
|
|
|
if u == 0 && wid <= 1 {
|
2009-11-09 13:07:39 -07:00
|
|
|
return "0"
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Assemble decimal in reverse order.
|
2009-12-15 16:35:38 -07:00
|
|
|
var b [32]byte
|
|
|
|
bp := len(b)
|
2009-01-26 16:34:16 -07:00
|
|
|
for ; u > 0 || wid > 0; u /= 10 {
|
2009-12-15 16:35:38 -07:00
|
|
|
bp--
|
|
|
|
wid--
|
|
|
|
b[bp] = byte(u%10) + '0'
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
|
|
|
|
2009-12-15 16:35:38 -07:00
|
|
|
return string(b[bp:])
|
2009-01-26 10:28:07 -07:00
|
|
|
}
|
|
|
|
|
2009-01-26 16:34:16 -07:00
|
|
|
func (l *Logger) formatHeader(ns int64, calldepth int) string {
|
2009-12-15 16:35:38 -07:00
|
|
|
h := l.prefix
|
2009-11-09 22:23:52 -07:00
|
|
|
if l.flag&(Ldate|Ltime|Lmicroseconds) != 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
t := time.SecondsToLocalTime(ns / 1e9)
|
2009-11-09 22:23:52 -07:00
|
|
|
if l.flag&(Ldate) != 0 {
|
2010-09-11 22:06:45 -06:00
|
|
|
h += itoa(int(t.Year), 4) + "/" + itoa(t.Month, 2) + "/" + itoa(t.Day, 2) + " "
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
2009-11-09 22:23:52 -07:00
|
|
|
if l.flag&(Ltime|Lmicroseconds) != 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
h += itoa(t.Hour, 2) + ":" + itoa(t.Minute, 2) + ":" + itoa(t.Second, 2)
|
2009-11-09 22:23:52 -07:00
|
|
|
if l.flag&Lmicroseconds != 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
h += "." + itoa(int(ns%1e9)/1e3, 6)
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
h += " "
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
|
|
|
}
|
2009-11-09 22:23:52 -07:00
|
|
|
if l.flag&(Lshortfile|Llongfile) != 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
_, file, line, ok := runtime.Caller(calldepth)
|
2009-01-26 16:34:16 -07:00
|
|
|
if ok {
|
2009-11-09 22:23:52 -07:00
|
|
|
if l.flag&Lshortfile != 0 {
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
short := file
|
|
|
|
for i := len(file) - 1; i > 0; i-- {
|
|
|
|
if file[i] == '/' {
|
|
|
|
short = file[i+1:]
|
|
|
|
break
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
file = short
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
|
|
|
} else {
|
2009-12-15 16:35:38 -07:00
|
|
|
file = "???"
|
|
|
|
line = 0
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
h += file + ":" + itoa(line, -1) + ": "
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return h
|
2009-01-26 16:34:16 -07:00
|
|
|
}
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Output writes the output for a logging event. The string s contains the text to print after
|
|
|
|
// the time stamp; calldepth is used to recover the PC. It is provided for generality, although
|
|
|
|
// at the moment on all pre-defined paths it will be 2.
|
2009-12-11 13:41:51 -07:00
|
|
|
func (l *Logger) Output(calldepth int, s string) os.Error {
|
2009-12-15 16:35:38 -07:00
|
|
|
now := time.Nanoseconds() // get this early.
|
|
|
|
newline := "\n"
|
2009-01-26 10:28:07 -07:00
|
|
|
if len(s) > 0 && s[len(s)-1] == '\n' {
|
2009-11-09 13:07:39 -07:00
|
|
|
newline = ""
|
2009-01-26 10:28:07 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
s = l.formatHeader(now, calldepth+1) + s + newline
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
_, err := io.WriteString(l.out, s)
|
2009-12-15 16:35:38 -07:00
|
|
|
return err
|
2009-01-26 10:28:07 -07:00
|
|
|
}
|
|
|
|
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Printf prints to the logger in the manner of fmt.Printf.
|
|
|
|
func (l *Logger) Printf(format string, v ...interface{}) {
|
|
|
|
l.Output(2, fmt.Sprintf(format, v...))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print prints to the logger in the manner of fmt.Print.
|
|
|
|
func (l *Logger) Print(v ...interface{}) { l.Output(2, fmt.Sprint(v...)) }
|
|
|
|
|
|
|
|
// Println prints to the logger in the manner of fmt.Println.
|
|
|
|
func (l *Logger) Println(v ...interface{}) { l.Output(2, fmt.Sprintln(v...)) }
|
|
|
|
|
|
|
|
// SetOutput sets the output destination for the standard logger.
|
|
|
|
func SetOutput(w io.Writer) {
|
|
|
|
std.out = w
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetFlags sets the output flags for the standard logger.
|
|
|
|
func SetFlags(flag int) {
|
|
|
|
std.flag = flag & lallBits
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetPrefix sets the output prefix for the standard logger.
|
|
|
|
func SetPrefix(prefix string) {
|
|
|
|
std.prefix = prefix
|
|
|
|
}
|
|
|
|
|
|
|
|
// These functions write to the standard logger.
|
|
|
|
|
|
|
|
// Print prints to the standard logger in the manner of fmt.Print.
|
|
|
|
func Print(v ...interface{}) {
|
|
|
|
std.Output(2, fmt.Sprint(v...))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Printf prints to the standard logger in the manner of fmt.Printf.
|
|
|
|
func Printf(format string, v ...interface{}) {
|
|
|
|
std.Output(2, fmt.Sprintf(format, v...))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Println prints to the standard logger in the manner of fmt.Println.
|
|
|
|
func Println(v ...interface{}) {
|
|
|
|
std.Output(2, fmt.Sprintln(v...))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Exit is equivalent to Print() followed by a call to os.Exit(1).
|
|
|
|
func Exit(v ...interface{}) {
|
|
|
|
std.Output(2, fmt.Sprint(v...))
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Exitf is equivalent to Printf() followed by a call to os.Exit(1).
|
|
|
|
func Exitf(format string, v ...interface{}) {
|
|
|
|
std.Output(2, fmt.Sprintf(format, v...))
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Exitln is equivalent to Println() followed by a call to os.Exit(1).
|
|
|
|
func Exitln(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)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Everything from here on is deprecated and will be removed after the next release.
|
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Logf is analogous to Printf() for a Logger.
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
2010-02-01 16:53:37 -07:00
|
|
|
func (l *Logger) Logf(format string, v ...interface{}) {
|
2010-09-24 09:55:48 -06:00
|
|
|
l.Output(2, fmt.Sprintf(format, v...))
|
2010-02-01 16:53:37 -07:00
|
|
|
}
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-11-06 19:43:57 -07:00
|
|
|
// Log is analogous to Print() for a Logger.
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
2010-09-24 09:55:48 -06:00
|
|
|
func (l *Logger) Log(v ...interface{}) { l.Output(2, fmt.Sprintln(v...)) }
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Stdout is a helper function for easy logging to stdout. It is analogous to Print().
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
2010-09-24 09:55:48 -06:00
|
|
|
func Stdout(v ...interface{}) { stdout.Output(2, fmt.Sprint(v...)) }
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Stderr is a helper function for easy logging to stderr. It is analogous to Fprint(os.Stderr).
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
|
|
|
func Stderr(v ...interface{}) { std.Output(2, fmt.Sprintln(v...)) }
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Stdoutf is a helper functions for easy formatted logging to stdout. It is analogous to Printf().
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
2010-09-24 09:55:48 -06:00
|
|
|
func Stdoutf(format string, v ...interface{}) { stdout.Output(2, fmt.Sprintf(format, v...)) }
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Stderrf is a helper function for easy formatted logging to stderr. It is analogous to Fprintf(os.Stderr).
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
|
|
|
func Stderrf(format string, v ...interface{}) { std.Output(2, fmt.Sprintf(format, v...)) }
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-08-13 16:14:41 -06:00
|
|
|
// Crash is equivalent to Stderr() followed by a call to panic().
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
|
|
|
func Crash(v ...interface{}) { Panicln(v...) }
|
2009-01-26 10:28:07 -07:00
|
|
|
|
2009-03-04 23:46:44 -07:00
|
|
|
// Crashf is equivalent to Stderrf() followed by a call to panic().
|
log: new interface
New logging interface simplifies and generalizes.
1) Loggers now have only one output.
2) log.Stdout, Stderr, Crash and friends are gone.
Logging is now always to standard error by default.
3) log.Panic* replaces log.Crash*.
4) Exiting and panicking are not part of the logger's state; instead
the functions Exit* and Panic* simply call Exit or panic after
printing.
5) There is now one 'standard logger'. Instead of calling Stderr,
use Print etc. There are now triples, by analogy with fmt:
Print, Println, Printf
What was log.Stderr is now best represented by log.Println,
since there are now separate Print and Println functions
(and methods).
6) New functions SetOutput, SetFlags, and SetPrefix allow global
editing of the standard logger's properties. This is new
functionality. For instance, one can call
log.SetFlags(log.Lshortfile|log.Ltime|log.Lmicroseconds)
to get all logging output to show file name, line number, and
time stamp.
In short, for most purposes
log.Stderr -> log.Println or log.Print
log.Stderrf -> log.Printf
log.Crash -> log.Panicln or log.Panic
log.Crashf -> log.Panicf
log.Exit -> log.Exitln or log.Exit
log.Exitf -> log.Exitf (no change)
This has a slight breakage: since loggers now write only to one
output, existing calls to log.New() need to delete the second argument.
Also, custom loggers with exit or panic properties will need to be
reworked.
All package code updated to new interface.
The test has been reworked somewhat.
The old interface will be removed after the new release.
For now, its elements are marked 'deprecated' in their comments.
Fixes #1184.
R=rsc
CC=golang-dev
https://golang.org/cl/2419042
2010-10-12 13:59:18 -06:00
|
|
|
// Deprecated.
|
|
|
|
func Crashf(format string, v ...interface{}) { Panicf(format, v...) }
|