package log

Import Path
	log (on go.dev)

Dependency Relation
	imports 8 packages, and imported by 4 packages

Involved Source Files

	  d log.go
		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.
Code Examples

	Logger
		package main
		
		import (
			"bytes"
			"fmt"
			"log"
		)
		
		func main() {
			var (
				buf    bytes.Buffer
				logger = log.New(&buf, "logger: ", log.Lshortfile)
			)
		
			logger.Print("Hello, log file!")
		
			fmt.Print(&buf)
		}

	Logger_Output
		package main
		
		import (
			"bytes"
			"fmt"
			"log"
		)
		
		func main() {
			var (
				buf    bytes.Buffer
				logger = log.New(&buf, "INFO: ", log.Lshortfile)
		
				infof = func(info string) {
					logger.Output(2, info)
				}
			)
		
			infof("Hello world")
		
			fmt.Print(&buf)
		}


Package-Level Type Names (only one, which is exported)

	/* sort exporteds by: alphabet | popularity */
	 type Logger (struct)
		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.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			flag atomic.Int32
				// properties

			isDiscard atomic.Bool
			out io.Writer
				// destination for output

			outMu sync.Mutex
			prefix atomic.Pointer[string]
				// prefix on each line to identify the logger (but see Lmsgprefix)

		Methods (total 17, in which 16 are exported)
			(*Logger) Fatal(v ...any)
				Fatal is equivalent to l.Print() followed by a call to os.Exit(1).

			(*Logger) Fatalf(format string, v ...any)
				Fatalf is equivalent to l.Printf() followed by a call to os.Exit(1).

			(*Logger) Fatalln(v ...any)
				Fatalln is equivalent to l.Println() followed by a call to os.Exit(1).

			(*Logger) Flags() int
				Flags returns the output flags for the logger.
				The flag bits are Ldate, Ltime, and so on.

			(*Logger) Output(calldepth int, s string) error
				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.

			(*Logger) Panic(v ...any)
				Panic is equivalent to l.Print() followed by a call to panic().

			(*Logger) Panicf(format string, v ...any)
				Panicf is equivalent to l.Printf() followed by a call to panic().

			(*Logger) Panicln(v ...any)
				Panicln is equivalent to l.Println() followed by a call to panic().

			(*Logger) Prefix() string
				Prefix returns the output prefix for the logger.

			(*Logger) Print(v ...any)
				Print calls l.Output to print to the logger.
				Arguments are handled in the manner of fmt.Print.

			(*Logger) Printf(format string, v ...any)
				Printf calls l.Output to print to the logger.
				Arguments are handled in the manner of fmt.Printf.

			(*Logger) Println(v ...any)
				Println calls l.Output to print to the logger.
				Arguments are handled in the manner of fmt.Println.

			(*Logger) SetFlags(flag int)
				SetFlags sets the output flags for the logger.
				The flag bits are Ldate, Ltime, and so on.

			(*Logger) SetOutput(w io.Writer)
				SetOutput sets the output destination for the logger.

			(*Logger) SetPrefix(prefix string)
				SetPrefix sets the output prefix for the logger.

			(*Logger) Writer() io.Writer
				Writer returns the output destination for the logger.

			/* one unexported ... *//* one unexported: */
			(*Logger) output(pc uintptr, calldepth int, appendOutput func([]byte) []byte) error
				output can take either a calldepth or a pc to get source line information.
				It uses the pc if it is non-zero.

		As Outputs Of (at least 4, all are exported)
			func Default() *Logger
			func New(out io.Writer, prefix string, flag int) *Logger
			func go.uber.org/zap.NewStdLog(l *zap.Logger) *Logger
			func go.uber.org/zap.NewStdLogAt(l *zap.Logger, level zapcore.Level) (*Logger, error)
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var std *Logger


Package-Level Functions (total 23, in which 18 are exported)

	 func Default() *Logger
		Default returns the standard logger used by the package-level output functions.

	 func Fatal(v ...any)
		Fatal is equivalent to Print() followed by a call to os.Exit(1).

	 func Fatalf(format string, v ...any)
		Fatalf is equivalent to Printf() followed by a call to os.Exit(1).

	 func Fatalln(v ...any)
		Fatalln is equivalent to Println() followed by a call to os.Exit(1).

	 func Flags() int
		Flags returns the output flags for the standard logger.
		The flag bits are Ldate, Ltime, and so on.

	 func New(out io.Writer, prefix string, flag int) *Logger
		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, or
		after the log header if the Lmsgprefix flag is provided.
		The flag argument defines the logging properties.

	 func Output(calldepth int, s string) error
		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 Panic(v ...any)
		Panic is equivalent to Print() followed by a call to panic().

	 func Panicf(format string, v ...any)
		Panicf is equivalent to Printf() followed by a call to panic().

	 func Panicln(v ...any)
		Panicln is equivalent to Println() followed by a call to panic().

	 func Prefix() string
		Prefix returns the output prefix for the standard logger.

	 func Print(v ...any)
		Print calls Output to print to the standard logger.
		Arguments are handled in the manner of fmt.Print.

	 func Printf(format string, v ...any)
		Printf calls Output to print to the standard logger.
		Arguments are handled in the manner of fmt.Printf.

	 func Println(v ...any)
		Println calls Output to print to the standard logger.
		Arguments are handled in the manner of fmt.Println.

	 func SetFlags(flag int)
		SetFlags sets the output flags for the standard logger.
		The flag bits are Ldate, Ltime, and so on.

	 func SetOutput(w io.Writer)
		SetOutput sets the output destination for the standard logger.

	 func SetPrefix(prefix string)
		SetPrefix sets the output prefix for the standard logger.

	 func Writer() io.Writer
		Writer returns the output destination for the standard logger.

	/* 5 unexporteds ... *//* 5 unexporteds: */
	 func formatHeader(buf *[]byte, t time.Time, prefix string, flag int, file string, line int)
		formatHeader writes log header to buf in following order:
		  - l.prefix (if it's not blank and Lmsgprefix is unset),
		  - date and/or time (if corresponding flags are provided),
		  - file and line number (if corresponding flags are provided),
		  - l.prefix (if it's not blank and Lmsgprefix is set).

	 func getBuffer() *[]byte
	 func init()
	 func itoa(buf *[]byte, i int, wid int)
		Cheap integer to fixed-width decimal ASCII. Give a negative width to avoid zero-padding.

	 func putBuffer(p *[]byte)
Package-Level Variables (total 2, neither is exported)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	  var bufferPool sync.Pool
	  var std *Logger
Package-Level Constants (total 8, all are exported)

	const Ldate = 1 // the date in the local time zone: 2009/01/23
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

	const Llongfile = 8 // full file name and line number: /a/b/c/d.go:23
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

	const Lmicroseconds = 4 // microsecond resolution: 01:23:23.123123.  assumes Ltime.
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

	const Lmsgprefix = 64 // move the "prefix" from the beginning of the line to before the message
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

	const Lshortfile = 16 // final file name element and line number: d.go:23. overrides Llongfile
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

	const LstdFlags = 3 // initial values for the standard logger
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

	const Ltime = 2 // the time in the local time zone: 01:23:23
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

	const LUTC = 32 // if Ldate or Ltime is set, use UTC rather than the local time zone
		These flags define which text to prefix to each log entry generated by the Logger.
		Bits are or'ed together to control what's printed.
		With the exception of the Lmsgprefix flag, 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

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.