package log

Import Path
	log (on go.dev)

Dependency Relation
	imports 8 packages, and imported by 14 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)

	/* sort 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.

		Methods (total 16)
			(*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.

		As Outputs Of (at least 4)
			func Default() *Logger
			func New(out io.Writer, prefix string, flag int) *Logger
			func log/slog.NewLogLogger(h slog.Handler, level slog.Level) *Logger
			func log/syslog.NewLogger(p syslog.Priority, logFlag int) (*Logger, error)


Package-Level Functions (total 18)

	 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.


Package-Level Constants (total 8)

	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.7.0-preview. (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 @zigo_101 (reachable from the left QR code) to get the latest news of Golds.