log

package
v3.2.10 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 25, 2021 License: LGPL-3.0 Imports: 19 Imported by: 204

Documentation

Overview

Package log is an output-library that can print nicely formatted messages to the screen.

There are log-level messages that will be printed according to the current debug-level set. Furthermore a set of common messages exist that are printed according to a chosen format.

The log-level messages are: 

log.Lvl1("Important information")
log.Lvl2("Less important information")
log.Lvl3("Eventually flooding information")
log.Lvl4("Definitively flooding information")
log.Lvl5("I hope you never need this")

in your program, then according to the debug-level one or more levels of output will be shown. To set the debug-level, use 

log.SetDebugVisible(3)

which will show all `Lvl1`, `Lvl2`, and `Lvl3`. If you want to turn on just one output, you can use 

log.LLvl2("Less important information")

By adding a single 'L' to the method, it *always* gets printed.

You can also add a 'f' to the name and use it like fmt.Printf: 

log.Lvlf1("Level: %d/%d", now, max)

The common messages are: 

log.Print("Simple output")
log.Info("For your information")
log.Warn("Only a warning")
log.Error("This is an error, but continues")
log.Panic("Something really went bad - calls panic")
log.Fatal("No way to continue - calls os.Exit")

These messages are printed according to the value of 'Format': - Format == FormatLvl - same as log.Lvl - Format == FormatPython - with some nice python-style formatting - Format == FormatNone - just as plain text

The log-package also takes into account the following environment-variables: 

	DEBUG_LVL // will act like SetDebugVisible
	DEBUG_TIME // if 'true' it will print the date and time
 DEBUG_FILEPATH // if 'true' it will print the absolute filepath
	DEBUG_COLOR // if 'false' it will not use colors
	DEBUG_PADDING // if 'false' it will not use padding

But for this the function ParseEnv() or AddFlags() has to be called.

Index

Examples

Constants

View Source 
const (
	// DefaultStdDebugLvl is the default debug level for the standard logger
	DefaultStdDebugLvl = 1
	// DefaultStdShowTime is the default value for 'showTime' for the standard logger
	DefaultStdShowTime = false
	// DefaultStdAbsoluteFilePath is the default to show absolute path for the standard logger
	DefaultStdAbsoluteFilePath = false
	// DefaultStdUseColors is the default value for 'useColors' for the standard logger
	DefaultStdUseColors = false
	// DefaultStdPadding is the default value for 'padding' for the standard logger
	DefaultStdPadding = true
)
View Source 
const (
	// FormatPython uses [x] and others to indicate what is shown
	FormatPython = -1
	// FormatNone is just pure print
	FormatNone = 0
)

These formats can be used in place of the debugVisible

Variables

View Source 
var LinePadding = 3

LinePadding of line-numbers for a nice debug-output - used in the same way as NamePadding. Deprecated: the caller is merged thus no line padding is necessary anymore.

View Source 
var MainTestWait = 0 * time.Minute

MainTestWait is the maximum time the MainTest-method waits before aborting and printing a stack-trace of all functions. This is deprecated and should not be used anymore.

View Source 
var NamePadding = 40

NamePadding - the padding of functions to make a nice debug-output - this is automatically updated whenever there are longer functions and kept at that new maximum. If you prefer to have a fixed output and don't remember oversized names, put a negative value in here.

View Source 
var StaticMsg = ""

StaticMsg - if this variable is set, it will be outputted between the position and the message.

Functions

func AbsoluteFilePath 

func AbsoluteFilePath() bool

AbsoluteFilePath returns the current setting for showing the absolute path inside a log.

func AddUserUninterestingGoroutine 

func AddUserUninterestingGoroutine(newGr string)

AddUserUninterestingGoroutine can be called when the environment of some specific tests leaks goroutines unknown to interestingGoroutines(). This function is not safe for concurrent execution. The caller should add all of the desired exceptions before launching any goroutines.

func AfterTest 

func AfterTest(t *testing.T)

AfterTest can be called to wait for leaking goroutines to finish. If they do not finish after a reasonable time (600ms) the test will fail.

Inspired by https://golang.org/src/net/http/main_test.go and https://github.com/coreos/etcd/blob/master/pkg/testutil/leak.go

func DebugVisible 

func DebugVisible() int

DebugVisible returns the actual visible debug-level

func ErrFatal 

func ErrFatal(err error, args ...interface{})

ErrFatal calls log.Fatal in the case err != nil

func ErrFatalf 

func ErrFatalf(err error, f string, args ...interface{})

ErrFatalf will call Fatalf when the error is non-nil

func Error 

func Error(args ...interface{})

Error prints out the error message. If the argument is an error, it will print it using "%+v".

func Errorf 

func Errorf(f string, args ...interface{})

Errorf is like Error but with a format-string

func Fatal 

func Fatal(args ...interface{})

Fatal prints out the fatal message and quits with os.Exit(1)

func Fatalf 

func Fatalf(f string, args ...interface{})

Fatalf is like Fatal but with a format-string

func GetStdErr 

func GetStdErr() string

GetStdErr returns all log.*-outputs to StdErr since the last call.

func GetStdOut 

func GetStdOut() string

GetStdOut returns all log.*-outputs to StdOut since the last call.

func Info 

func Info(args ...interface{})

Info prints the arguments given with a 'info'-format

func Infof 

func Infof(f string, args ...interface{})

Infof takes a format-string and calls Info

func LLvl1 

func LLvl1(args ...interface{})

LLvl1 *always* prints

Example 
OutputToOs()
Lvl1("Lvl output")
LLvl1("LLvl output")
Lvlf1("Lvlf output")
LLvlf1("LLvlf output")
OutputToBuf()

Output:

1 : fake_name.go:0 (log.ExampleLLvl1)        - Lvl output
1!: fake_name.go:0 (log.ExampleLLvl1)        - LLvl output
1 : fake_name.go:0 (log.ExampleLLvl1)        - Lvlf output
1!: fake_name.go:0 (log.ExampleLLvl1)        - LLvlf output

func LLvl2 

func LLvl2(args ...interface{})

LLvl2 *always* prints

func LLvl3 

func LLvl3(args ...interface{})

LLvl3 *always* prints

func LLvl4 

func LLvl4(args ...interface{})

LLvl4 *always* prints

func LLvl5 

func LLvl5(args ...interface{})

LLvl5 *always* prints

func LLvlf1 

func LLvlf1(f string, args ...interface{})

LLvlf1 *always* prints

func LLvlf2 

func LLvlf2(f string, args ...interface{})

LLvlf2 *always* prints

func LLvlf3 

func LLvlf3(f string, args ...interface{})

LLvlf3 *always* prints

func LLvlf4 

func LLvlf4(f string, args ...interface{})

LLvlf4 *always* prints

func LLvlf5 

func LLvlf5(f string, args ...interface{})

LLvlf5 *always* prints

func Lvl1 

func Lvl1(args ...interface{})

Lvl1 debug output is informational and always displayed

Example 
OutputToOs()
Lvl1("Multiple", "parameters")
OutputToBuf()

Output:

1 : fake_name.go:0 (log.ExampleLvl1)         - Multiple parameters

func Lvl2 

func Lvl2(args ...interface{})

Lvl2 is more verbose but doesn't spam the stdout in case there is a big simulation

Example 
SetDebugVisible(2)
OutputToOs()
Lvl1("Level1")
Lvl2("Level2")
Lvl3("Level3")
Lvl4("Level4")
Lvl5("Level5")
OutputToBuf()
SetDebugVisible(1)

Output:

1 : fake_name.go:0 (log.ExampleLvl2)         - Level1
2 : fake_name.go:0 (log.ExampleLvl2)         - Level2

func Lvl3 

func Lvl3(args ...interface{})

Lvl3 gives debug-output that can make it difficult to read for big simulations with more than 100 hosts

Example 
NamePadding = -1
OutputToOs()
Lvl1("Before")
thisIsAVeryLongFunctionNameThatWillOverflow()
Lvl1("After")
OutputToBuf()

Output:

1 : fake_name.go:0 (log.ExampleLvl3) - Before
1 : fake_name.go:0 (log.thisIsAVeryLongFunctionNameThatWillOverflow) - Overflow
1 : fake_name.go:0 (log.ExampleLvl3) - After

func Lvl4 

func Lvl4(args ...interface{})

Lvl4 is only good for test-runs with very limited output

func Lvl5 

func Lvl5(args ...interface{})

Lvl5 is for big data

func Lvlf1 

func Lvlf1(f string, args ...interface{})

Lvlf1 is like Lvl1 but with a format-string

Example 
OutputToOs()
Lvl1("Before")
thisIsAVeryLongFunctionNameThatWillOverflow()
Lvl1("After")
OutputToBuf()

Output:

1 : fake_name.go:0 (log.ExampleLvlf1)        - Before
1 : fake_name.go:0 (log.thisIsAVeryLongFunctionNameThatWillOverflow) - Overflow
1 : fake_name.go:0 (log.ExampleLvlf1)        - After

func Lvlf2 

func Lvlf2(f string, args ...interface{})

Lvlf2 is like Lvl2 but with a format-string

func Lvlf3 

func Lvlf3(f string, args ...interface{})

Lvlf3 is like Lvl3 but with a format-string

func Lvlf4 

func Lvlf4(f string, args ...interface{})

Lvlf4 is like Lvl4 but with a format-string

func Lvlf5 

func Lvlf5(f string, args ...interface{})

Lvlf5 is like Lvl5 but with a format-string

func MainTest 

func MainTest(m *testing.M, ls ...int)

MainTest can be called from TestMain. It will parse the flags and set the DebugVisible to defaultMainTest, then run the tests and check for remaining go-routines. For the debug-level, the following heuristic is used to set the debug-level:

  • the first ls argument given, else
  • from the environment variable, else
  • defaultMainTest (2)

Also be aware that go only outputs the stdout of the tests if the verbose flag is given.

func OutputToBuf 

func OutputToBuf()

OutputToBuf is called for sending all the log.*-outputs to internal buffers that can be used for checking what the logger would've written. This is mostly used for tests. The buffers are zeroed after this call.

func OutputToOs 

func OutputToOs()

OutputToOs redirects the output of the log.*-outputs again to the os.

func Padding 

func Padding() bool

Padding returns the actual setting of the padding in log

func Panic 

func Panic(args ...interface{})

Panic prints out the panic message and panics

func Panicf 

func Panicf(f string, args ...interface{})

Panicf is like Panic but with a format-string

func ParseEnv 

func ParseEnv()

ParseEnv looks at the following environment-variables: 

DEBUG_LVL - for the actual debug-lvl - default is 1
DEBUG_TIME - whether to show the timestamp - default is false
DEBUG_COLOR - whether to color the output - default is false
DEBUG_PADDING - whether to pad the output nicely - default is true

func Print 

func Print(args ...interface{})

Print directly sends the arguments to the stdout

func Printf 

func Printf(f string, args ...interface{})

Printf is like Print but takes a formatting-argument first

func RegisterFlags 

func RegisterFlags()

RegisterFlags adds the flags and the variables for the debug-control (standard logger) using the standard flag-package.

func RegisterLogger 

func RegisterLogger(l Logger) int

RegisterLogger will register a callback that will receive a copy of every message, fully formatted. It returns the key assigned to the logger (used to unregister the logger).

func SetAbsoluteFilePath 

func SetAbsoluteFilePath(absolute bool)

SetAbsoluteFilePath allows to print the absolute file path for logging calls.

func SetDebugVisible 

func SetDebugVisible(lvl int)

SetDebugVisible set the global debug output level in a go-rountine-safe way

func SetPadding 

func SetPadding(padding bool)

SetPadding can turn off or turn on the use of padding in log

func SetShowTime 

func SetShowTime(show bool)

SetShowTime allows for turning on the flag that adds the current time to the debug-output

func SetUseColors 

func SetUseColors(useColors bool)

SetUseColors can turn off or turn on the use of colors in the debug-output

func ShowTime 

func ShowTime() bool

ShowTime returns the current setting for showing the time in the debug output

func Stack 

func Stack() string

Stack converts []byte to string

func TestOutput 

func TestOutput(show bool, level int)

TestOutput sets the DebugVisible to 0 if 'show' is false, else it will set DebugVisible to 'level'

Usage: TestOutput( test.Verbose(), 2 ) DEPRECATED: write your own if/else

func TraceID 

func TraceID(id []byte)

TraceID helps the tracing-simulation to know which trace it should attach to. The TraceID will be stored with the corresponding go-routine, and any new go-routines spawned from the method will be attached to the same TraceID.

func UnregisterLogger 

func UnregisterLogger(key int)

UnregisterLogger takes the key it was assigned and returned by 'RegisterLogger', closes the corresponding Logger and removes it from the loggers.

func UseColors 

func UseColors() bool

UseColors returns the actual setting of the color-usage in log

func Warn 

func Warn(args ...interface{})

Warn prints out the warning message and quits

func Warnf 

func Warnf(f string, args ...interface{})

Warnf is like Warn but with a format-string

Types

type Logger 

type Logger interface {
	Log(level int, msg string)
	Close()
	GetLoggerInfo() *LoggerInfo
}

Logger is the interface that specifies how loggers will receive and display messages.

func NewFileLogger 

func NewFileLogger(lInfo *LoggerInfo, path string) (Logger, error)

NewFileLogger creates a logger that writes into the file with the given path and is using the given LoggerInfo. It returns the logger.

func NewSyslogLogger 

func NewSyslogLogger(lInfo *LoggerInfo, priority syslog.Priority, tag string) (Logger, error)

NewSyslogLogger creates a logger that writes into syslog with the given priority and tag, and is using the given LoggerInfo (without the Logger). It returns the logger.

type LoggerInfo 

type LoggerInfo struct {
	// These are information-debugging levels that can be turned on or off.
	// Every logging greater than 'debugLvl' will be discarded . So you can
	// Log at different levels and easily turn on or off the amount of logging
	// generated by adjusting the 'debugLvl' variable.
	DebugLvl int
	// If 'showTime' is true, it will print the time for each line displayed
	// by the logger.
	ShowTime bool
	// If 'AbsoluteFilePath' is true, it will print the absolute file path
	// instead of the base.
	AbsoluteFilePath bool
	// If 'useColors' is true, logs will be colored (defaults to monochrome
	// output). It also controls padding, since colorful output is higly
	// correlated with humans who like their log lines padded.
	UseColors bool
	// If 'padding' is true, it will nicely pad the line that is written.
	Padding bool
	// If true, it will only send the raw message to the logger
	RawMessage bool
}

LoggerInfo is a structure that should be used when creating a logger. It contains parameters about how to log (with time, colors, ...) and embeds the Logger interface, which should define how the logger should log.

type Tracer 

type Tracer interface {
	TraceID(id []byte)
}

Tracer is an additional interface that specifies a tracer extension to onet/log.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.