log

package
v0.19.4 Latest Latest
Warning

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

 Go to latest Published: May 24, 2023 License: MIT Imports: 20 Imported by: 0

Documentation

Overview

Package log provides logging capabilities for Gitea. Concepts:

* Logger: a Logger provides logging functions and dispatches log events to all its writers

* EventWriter: written log Event to a destination (eg: file, console)

  • EventWriterBase: the base struct of a writer, it contains common fields and functions for all writers
  • WriterType: the type name of a writer, eg: console, file
  • WriterName: aka Mode Name in document, the name of a writer instance, it's usually defined by the config file. It is called "mode name" because old code use MODE as config key, to keep compatibility, keep this concept.

* WriterMode: the common options for all writers, eg: log level.

  • WriterConsoleOption and others: the specified options for a writer, eg: file path, remote address.

Call graph: -> log.Info() -> LoggerImpl.Log() -> LoggerImpl.SendLogEvent, then the event goes into writer's goroutines -> EventWriter.Run() handles the events

Index

Constants

View Source 
const (
	Ldate          uint32 = 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/logger/c/d.go:23
	Lshortfile                        // final file name element and line number: d.go:23. overrides Llongfile
	Lfuncname                         // function name of the caller: runtime.Caller()
	Lshortfuncname                    // last part of the function name
	LUTC                              // if Ldate or Ltime is set, use UTC rather than the local time zone
	Llevelinitial                     // Initial character of the provided level in brackets, eg. [I] for info
	Llevel                            // Provided level in brackets [INFO]
	Lgopid                            // the Goroutine-PID of the context

	Lmedfile  = Lshortfile | Llongfile                                    // last 20 characters of the filename
	LstdFlags = Ldate | Ltime | Lmedfile | Lshortfuncname | Llevelinitial // default
)

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. 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 if more than time is stated is specified. For example, flags Ldate | Ltime produce, 2009/01/23 01:23:23 message. The standard is: 2009/01/23 01:23:23 ...a/logger/c/d.go:23:runtime.Caller() [I]: message

View Source 
const CRITICAL = ERROR // most logger frameworks doesn't support CRITICAL, and it doesn't seem useful
View Source 
const DEFAULT = "default"
View Source 
const Ldefault = LstdFlags

Variables

View Source 
var CanColorStderr = true

CanColorStderr reports if we can color the Stderr

View Source 
var CanColorStdout = true

CanColorStdout reports if we can color the Stdout Although we could do terminal sniffing and the like - in reality most tools on *nix are happy to display ansi colors. We will terminal sniff on Windows in console_windows.go

Functions

func ColorBytes 

func ColorBytes(attrs ...ColorAttribute) []byte

ColorBytes converts a list of ColorAttributes to a byte array

func Critical 

func Critical(format string, v ...any)

func Debug 

func Debug(format string, v ...any)

func Error 

func Error(format string, v ...any)

func ErrorWithSkip 

func ErrorWithSkip(skip int, format string, v ...any)

func EventFormatTextMessage 

func EventFormatTextMessage(mode *WriterMode, event *Event, msgFormat string, msgArgs ...any) []byte

EventFormatTextMessage makes the log message for a writer with its mode. This function is a copy of the original package

func FallbackErrorf 

func FallbackErrorf(format string, args ...any)

FallbackErrorf is the last chance to show an error if the logger has internal errors

func Fatal 

func Fatal(format string, v ...any)

Fatal records fatal log and exit process

func HasEventWriter 

func HasEventWriter(writerType string) bool

func Info 

func Info(format string, v ...any)

func IsDebug 

func IsDebug() bool

func IsLoggerEnabled 

func IsLoggerEnabled(name string) bool

func IsTrace 

func IsTrace() bool

func Log 

func Log(skip int, level Level, format string, v ...any)

func LoggerToWriter 

func LoggerToWriter(logf func(format string, args ...any)) io.Writer

LoggerToWriter wraps a log function to an io.Writer

func RegisterEventWriter 

func RegisterEventWriter(writerType string, p EventWriterProvider)

func SetConsoleLogger 

func SetConsoleLogger(loggerName, writerName string, level Level)

func Stack 

func Stack(skip int) string

Stack will skip back the provided number of frames and return a stack trace with source code. Although we could just use debug.Stack(), this routine will return the source code and skip back the provided number of frames - i.e. allowing us to ignore preceding function calls. A skip of 0 returns the stack trace for the calling function, not including this call. If the problem is a lack of memory of course all this is not going to work...

func Trace 

func Trace(format string, v ...any)

func Warn 

func Warn(format string, v ...any)

Types

type BaseLogger 

type BaseLogger interface {
	Log(skip int, level Level, format string, v ...any)
	GetLevel() Level
}

BaseLogger provides the basic logging functions

type ColorAttribute 

type ColorAttribute int

ColorAttribute defines a single SGR Code 

const (
	Reset ColorAttribute = iota
	Bold
	Faint
	Italic
	Underline
	BlinkSlow
	BlinkRapid
	ReverseVideo
	Concealed
	CrossedOut
)

Base ColorAttributes 

const (
	FgBlack ColorAttribute = iota + 30
	FgRed
	FgGreen
	FgYellow
	FgBlue
	FgMagenta
	FgCyan
	FgWhite
)

Foreground text colors 

const (
	FgHiBlack ColorAttribute = iota + 90
	FgHiRed
	FgHiGreen
	FgHiYellow
	FgHiBlue
	FgHiMagenta
	FgHiCyan
	FgHiWhite
)

Foreground Hi-Intensity text colors 

const (
	BgBlack ColorAttribute = iota + 40
	BgRed
	BgGreen
	BgYellow
	BgBlue
	BgMagenta
	BgCyan
	BgWhite
)

Background text colors 

const (
	BgHiBlack ColorAttribute = iota + 100
	BgHiRed
	BgHiGreen
	BgHiYellow
	BgHiBlue
	BgHiMagenta
	BgHiCyan
	BgHiWhite
)

Background Hi-Intensity text colors

type ColoredValue 

type ColoredValue struct {
	// contains filtered or unexported fields
}

func ColoredMethod 

func ColoredMethod(method string) *ColoredValue

ColoredMethod adds colors for HTTP methods on log

func ColoredStatus 

func ColoredStatus(status int, s ...string) *ColoredValue

ColoredStatus adds colors for HTTP status

func ColoredTime 

func ColoredTime(duration time.Duration) *ColoredValue

ColoredTime converts the provided time to a ColoredValue for logging. The duration is always formatted in milliseconds.

func NewColoredValue 

func NewColoredValue(v any, color ...ColorAttribute) *ColoredValue

func (*ColoredValue) Format 

func (c *ColoredValue) Format(f fmt.State, verb rune)

type Event 

type Event struct {
	Time time.Time

	GoroutinePid string
	Caller       string
	Filename     string
	Line         int

	Level Level

	MsgSimpleText string

	Stacktrace string
	// contains filtered or unexported fields
}

type EventFormatted 

type EventFormatted struct {
	Origin *Event
	Msg    any // the message formatted by the writer's formatter, the writer knows its type
}

type EventFormatter 

type EventFormatter func(mode *WriterMode, event *Event, msgFormat string, msgArgs ...any) []byte

type EventWriter 

type EventWriter interface {
	EventWriterBase
}

EventWriter is the general interface for all event writers EventWriterBase is only used as its base interface A writer implementation could override the default EventWriterBase functions eg: a writer can override the Run to handle events in its own way with its own goroutine

func NewEventWriter 

func NewEventWriter(name, writerType string, mode WriterMode) (EventWriter, error)

func NewEventWriterConn 

func NewEventWriterConn(writerName string, writerMode WriterMode) EventWriter

func NewEventWriterConsole 

func NewEventWriterConsole(name string, mode WriterMode) EventWriter

func NewEventWriterFile 

func NewEventWriterFile(name string, mode WriterMode) EventWriter

type EventWriterBase 

type EventWriterBase interface {
	Base() *EventWriterBaseImpl
	GetWriterType() string
	GetWriterName() string
	GetLevel() Level

	Run(ctx context.Context)
}

EventWriterBase is the base interface for most event writers It provides default implementations for most methods

type EventWriterBaseImpl 

type EventWriterBaseImpl struct {
	Name  string
	Mode  *WriterMode
	Queue chan *EventFormatted

	FormatMessage     EventFormatter // format the Event to a message and write it to output
	OutputWriteCloser io.WriteCloser // it will be closed when the event writer is stopped
	GetPauseChan      func() chan struct{}
	// contains filtered or unexported fields
}

func NewEventWriterBase 

func NewEventWriterBase(name, writerType string, mode WriterMode) *EventWriterBaseImpl

func (*EventWriterBaseImpl) Base 

func (b *EventWriterBaseImpl) Base() *EventWriterBaseImpl

func (*EventWriterBaseImpl) GetLevel 

func (b *EventWriterBaseImpl) GetLevel() Level

func (*EventWriterBaseImpl) GetWriterName 

func (b *EventWriterBaseImpl) GetWriterName() string

func (*EventWriterBaseImpl) GetWriterType 

func (b *EventWriterBaseImpl) GetWriterType() string

func (*EventWriterBaseImpl) Run 

func (b *EventWriterBaseImpl) Run(ctx context.Context)

Run is the default implementation for EventWriter.Run

type EventWriterProvider 

type EventWriterProvider func(writerName string, writerMode WriterMode) EventWriter

EventWriterProvider is the function for creating a new EventWriter

type Flags 

type Flags struct {
	// contains filtered or unexported fields
}

func FlagsFromBits 

func FlagsFromBits(flags uint32) Flags

func FlagsFromString 

func FlagsFromString(from string, def ...uint32) Flags

func (Flags) Bits 

func (f Flags) Bits() uint32

func (Flags) MarshalJSON 

func (f Flags) MarshalJSON() ([]byte, error)

func (Flags) String 

func (f Flags) String() string

func (*Flags) UnmarshalJSON 

func (f *Flags) UnmarshalJSON(bytes []byte) error

type Level 

type Level int

Level is the level of the logger 

const (
	UNDEFINED Level = iota
	TRACE
	DEBUG
	INFO
	WARN
	ERROR
	FATAL
	NONE
)

func GetLevel 

func GetLevel() Level

func LevelFromString 

func LevelFromString(level string) Level

LevelFromString takes a level string and returns a Level

func (Level) ColorAttributes 

func (l Level) ColorAttributes() []ColorAttribute

func (Level) MarshalJSON 

func (l Level) MarshalJSON() ([]byte, error)

MarshalJSON takes a Level and turns it into text

func (Level) String 

func (l Level) String() string

func (*Level) UnmarshalJSON 

func (l *Level) UnmarshalJSON(b []byte) error

UnmarshalJSON takes text and turns it into a Level

type LevelLogger 

type LevelLogger interface {
	LevelEnabled(level Level) bool

	Trace(format string, v ...any)
	Debug(format string, v ...any)
	Info(format string, v ...any)
	Warn(format string, v ...any)
	Error(format string, v ...any)
	Critical(format string, v ...any)
}

LevelLogger provides level-related logging functions

type LogStringer 

type LogStringer interface {
	LogString() string
}

type Logger 

type Logger interface {
	BaseLogger
	LevelLogger
}

func BaseLoggerToGeneralLogger 

func BaseLoggerToGeneralLogger(b BaseLogger) Logger

BaseLoggerToGeneralLogger wraps a BaseLogger (which only has Log() function) to a Logger (which has Info() function)

func GetLogger 

func GetLogger(name string) Logger

type LoggerImpl 

type LoggerImpl struct {
	LevelLogger
	// contains filtered or unexported fields
}

func NewLoggerWithWriters 

func NewLoggerWithWriters(ctx context.Context, writer ...EventWriter) *LoggerImpl

func (*LoggerImpl) AddWriters 

func (l *LoggerImpl) AddWriters(writer ...EventWriter)

AddWriters adds writers to the logger, and starts them. Existing writers will be replaced by new ones.

func (*LoggerImpl) Close 

func (l *LoggerImpl) Close()

Close closes the logger, non-shared writers are closed and flushed

func (*LoggerImpl) DumpWriters 

func (l *LoggerImpl) DumpWriters() map[string]any

DumpWriters dumps the writers as a JSON map, it's used for debugging and display purposes.

func (*LoggerImpl) GetLevel 

func (l *LoggerImpl) GetLevel() Level

func (*LoggerImpl) IsEnabled 

func (l *LoggerImpl) IsEnabled() bool

IsEnabled returns true if the logger is enabled: it has a working level and has writers Fatal is not considered as enabled, because it's a special case and the process just exits

func (*LoggerImpl) Log 

func (l *LoggerImpl) Log(skip int, level Level, format string, logArgs ...any)

Log prepares the log event, if the level matches, the event will be sent to the writers

func (*LoggerImpl) RemoveAllWriters 

func (l *LoggerImpl) RemoveAllWriters() *LoggerImpl

RemoveAllWriters removes all writers from the logger, non-shared writers are closed and flushed

func (*LoggerImpl) RemoveWriter 

func (l *LoggerImpl) RemoveWriter(modeName string) error

RemoveWriter removes a writer from the logger, and the writer is closed and flushed if it is not shared

func (*LoggerImpl) SendLogEvent 

func (l *LoggerImpl) SendLogEvent(event *Event)

SendLogEvent sends a log event to all writers

type LoggerManager 

type LoggerManager struct {
	// contains filtered or unexported fields
}

LoggerManager manages loggers and shared event writers

func GetManager 

func GetManager() *LoggerManager

func NewManager 

func NewManager() *LoggerManager

func (*LoggerManager) Close 

func (m *LoggerManager) Close()

Close closes the logger manager, all loggers and writers will be closed, the messages are flushed.

func (*LoggerManager) DumpLoggers 

func (m *LoggerManager) DumpLoggers() map[string]any

DumpLoggers returns a map of all loggers and their event writers, for debugging and display purposes.

func (*LoggerManager) GetLogger 

func (m *LoggerManager) GetLogger(name string) *LoggerImpl

GetLogger returns a logger with the given name. If the logger doesn't exist, a new empty one will be created.

func (*LoggerManager) GetPauseChan 

func (m *LoggerManager) GetPauseChan() chan struct{}

GetPauseChan returns a channel for writer pausing

func (*LoggerManager) GetSharedWriter 

func (m *LoggerManager) GetSharedWriter(writerName string) EventWriter

func (*LoggerManager) NewSharedWriter 

func (m *LoggerManager) NewSharedWriter(writerName, writerType string, mode WriterMode) (writer EventWriter, err error)

NewSharedWriter creates a new shared event writer, it can be used by multiple loggers, and a shared writer won't be closed if a logger is closed.

func (*LoggerManager) PauseAll 

func (m *LoggerManager) PauseAll()

PauseAll pauses all event writers

func (*LoggerManager) ResumeAll 

func (m *LoggerManager) ResumeAll()

ResumeAll resumes all event writers

type PrintfLogger 

type PrintfLogger struct {
	Logf func(format string, args ...any)
}

func (*PrintfLogger) Printf 

func (p *PrintfLogger) Printf(format string, args ...any)

type WriterConnOption 

type WriterConnOption struct {
	Addr           string
	Protocol       string
	Reconnect      bool
	ReconnectOnMsg bool
}

type WriterConsoleOption 

type WriterConsoleOption struct {
	Stderr bool
}

type WriterFileOption 

type WriterFileOption struct {
	FileName         string
	MaxSize          int64
	LogRotate        bool
	DailyRotate      bool
	MaxDays          int
	Compress         bool
	CompressionLevel int
}

type WriterMode 

type WriterMode struct {
	BufferLen int

	Level    Level
	Prefix   string
	Colorize bool
	Flags    Flags

	Expression string

	StacktraceLevel Level

	WriterOption any
}

WriterMode is the mode for creating a new EventWriter, it contains common options for all writers Its WriterOption field is the specified options for a writer, it should be passed by value but not by pointer

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.