vendor: update all dependencies to latest versions
This commit is contained in:
Nick Craig-Wood
parent
8e83fb6fb9
commit
7d3a17725d
4878 changed files with 1974229 additions and 201215 deletions
327
vendor/github.com/pengsrc/go-shared/log/logger.go
generated
vendored
Normal file
327
vendor/github.com/pengsrc/go-shared/log/logger.go
generated
vendored
Normal file
|
|
@ -0,0 +1,327 @@
|
|||
// Package log provides support for logging to stdout, stderr and file.
|
||||
package log
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/pengsrc/go-shared/check"
|
||||
"github.com/pengsrc/go-shared/reopen"
|
||||
)
|
||||
|
||||
// Logger presents a logger.
|
||||
// The only way to initialize a logger is using the convention construct
|
||||
// functions like NewLogger().
|
||||
type Logger struct {
|
||||
level Level
|
||||
lw LevelWriter
|
||||
|
||||
// Interested context keys.
|
||||
ctxKeys []interface{}
|
||||
ctxKeysMap map[interface{}]string
|
||||
|
||||
// isCallerEnabled sets whether to annotating logs with the calling
|
||||
// function's file name and line number. By default, all logs are annotated.
|
||||
isCallerEnabled bool
|
||||
}
|
||||
|
||||
// GetLevel get the log level string.
|
||||
func (l *Logger) GetLevel() string {
|
||||
return l.level.String()
|
||||
}
|
||||
|
||||
// SetLevel sets the log level.
|
||||
// Valid levels are "debug", "info", "warn", "error", and "fatal".
|
||||
func (l *Logger) SetLevel(level string) (err error) {
|
||||
levelFlag, err := ParseLevel(level)
|
||||
if err == nil {
|
||||
l.level = levelFlag
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// SetInterestContextKeys sets the contexts keys that the logger should be
|
||||
// interested in. Value of the interested context key will extract and print as
|
||||
// newEvent filed.
|
||||
func (l *Logger) SetInterestContextKeys(keys []interface{}) {
|
||||
l.ctxKeys = keys
|
||||
|
||||
l.ctxKeysMap = make(map[interface{}]string)
|
||||
for _, key := range l.ctxKeys {
|
||||
l.ctxKeysMap[key] = fmt.Sprintf("%v", key)
|
||||
}
|
||||
}
|
||||
|
||||
// SetCallerFlag sets whether to annotating logs with the caller.
|
||||
func (l *Logger) SetCallerFlag(isEnabled bool) {
|
||||
l.isCallerEnabled = isEnabled
|
||||
}
|
||||
|
||||
// Flush writes buffered logs.
|
||||
func (l *Logger) Flush() {
|
||||
if flusher, ok := l.lw.(Flusher); ok {
|
||||
flusher.Flush()
|
||||
}
|
||||
}
|
||||
|
||||
// Fatal logs a message with severity FATAL followed by a call to os.Exit(1).
|
||||
func (l *Logger) Fatal(ctx context.Context, v ...interface{}) {
|
||||
l.event(ctx, FatalLevel).write("", v...)
|
||||
}
|
||||
|
||||
// Panic logs a message with severity PANIC followed by a call to panic().
|
||||
func (l *Logger) Panic(ctx context.Context, v ...interface{}) {
|
||||
l.event(ctx, PanicLevel).write("", v...)
|
||||
}
|
||||
|
||||
// Error logs a message with severity ERROR.
|
||||
func (l *Logger) Error(ctx context.Context, v ...interface{}) {
|
||||
l.event(ctx, ErrorLevel).write("", v...)
|
||||
}
|
||||
|
||||
// Warn logs a message with severity WARN.
|
||||
func (l *Logger) Warn(ctx context.Context, v ...interface{}) {
|
||||
l.event(ctx, WarnLevel).write("", v...)
|
||||
}
|
||||
|
||||
// Info logs a message with severity INFO.
|
||||
func (l *Logger) Info(ctx context.Context, v ...interface{}) {
|
||||
l.event(ctx, InfoLevel).write("", v...)
|
||||
}
|
||||
|
||||
// Debug logs a message with severity DEBUG.
|
||||
func (l *Logger) Debug(ctx context.Context, v ...interface{}) {
|
||||
l.event(ctx, DebugLevel).write("", v...)
|
||||
}
|
||||
|
||||
// Fatalf logs a message with severity FATAL in format followed by a call to
|
||||
// os.Exit(1).
|
||||
func (l *Logger) Fatalf(ctx context.Context, format string, v ...interface{}) {
|
||||
l.event(ctx, FatalLevel).write(format, v...)
|
||||
}
|
||||
|
||||
// Panicf logs a message with severity PANIC in format followed by a call to
|
||||
// panic().
|
||||
func (l *Logger) Panicf(ctx context.Context, format string, v ...interface{}) {
|
||||
l.event(ctx, PanicLevel).write(format, v...)
|
||||
}
|
||||
|
||||
// Errorf logs a message with severity ERROR in format.
|
||||
func (l *Logger) Errorf(ctx context.Context, format string, v ...interface{}) {
|
||||
l.event(ctx, ErrorLevel).write(format, v...)
|
||||
}
|
||||
|
||||
// Warnf logs a message with severity WARN in format.
|
||||
func (l *Logger) Warnf(ctx context.Context, format string, v ...interface{}) {
|
||||
l.event(ctx, WarnLevel).write(format, v...)
|
||||
}
|
||||
|
||||
// Infof logs a message with severity INFO in format.
|
||||
func (l *Logger) Infof(ctx context.Context, format string, v ...interface{}) {
|
||||
l.event(ctx, InfoLevel).write(format, v...)
|
||||
}
|
||||
|
||||
// Debugf logs a message with severity DEBUG in format.
|
||||
func (l *Logger) Debugf(ctx context.Context, format string, v ...interface{}) {
|
||||
l.event(ctx, DebugLevel).write(format, v...)
|
||||
}
|
||||
|
||||
// FatalEvent returns a log event with severity FATAL.
|
||||
func (l *Logger) FatalEvent(ctx context.Context) *Event {
|
||||
return l.event(ctx, FatalLevel)
|
||||
}
|
||||
|
||||
// PanicEvent returns a log event with severity PANIC.
|
||||
func (l *Logger) PanicEvent(ctx context.Context) *Event {
|
||||
return l.event(ctx, PanicLevel)
|
||||
}
|
||||
|
||||
// ErrorEvent returns a log event with severity ERROR.
|
||||
func (l *Logger) ErrorEvent(ctx context.Context) *Event {
|
||||
return l.event(ctx, ErrorLevel)
|
||||
}
|
||||
|
||||
// WarnEvent returns a log event with severity WARN.
|
||||
func (l *Logger) WarnEvent(ctx context.Context) *Event {
|
||||
return l.event(ctx, WarnLevel)
|
||||
}
|
||||
|
||||
// InfoEvent returns a log event with severity INFO.
|
||||
func (l *Logger) InfoEvent(ctx context.Context) *Event {
|
||||
return l.event(ctx, InfoLevel)
|
||||
}
|
||||
|
||||
// DebugEvent returns a log event with severity DEBUG.
|
||||
func (l *Logger) DebugEvent(ctx context.Context) *Event {
|
||||
return l.event(ctx, DebugLevel)
|
||||
}
|
||||
|
||||
func (l *Logger) event(ctx context.Context, level Level) (e *Event) {
|
||||
var ctxKeys *[]interface{}
|
||||
var ctxKeysMap *map[interface{}]string
|
||||
|
||||
if len(l.ctxKeys) > 0 {
|
||||
ctxKeys = &l.ctxKeys
|
||||
}
|
||||
if len(l.ctxKeysMap) > 0 {
|
||||
ctxKeysMap = &l.ctxKeysMap
|
||||
}
|
||||
|
||||
return newEvent(ctx, ctxKeys, ctxKeysMap, level, l.lw, level <= l.level, l.isCallerEnabled)
|
||||
}
|
||||
|
||||
// NewLogger creates a new logger for given out and level, and the level is
|
||||
// optional.
|
||||
func NewLogger(out io.Writer, level ...string) (*Logger, error) {
|
||||
return NewLoggerWithError(out, nil, level...)
|
||||
}
|
||||
|
||||
// NewLoggerWithError creates a new logger for given out, err out, level, and the
|
||||
// err out can be nil, and the level is optional.
|
||||
func NewLoggerWithError(out, errOut io.Writer, level ...string) (l *Logger, err error) {
|
||||
if out == nil {
|
||||
return nil, errors.New("logger output must specified")
|
||||
}
|
||||
|
||||
sw := &StandardWriter{w: out, ew: errOut, pid: os.Getpid()}
|
||||
l = &Logger{lw: sw}
|
||||
|
||||
if len(level) == 1 {
|
||||
if err = l.SetLevel(level[0]); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
return l, nil
|
||||
}
|
||||
|
||||
// NewTerminalLogger creates a logger that write into terminal.
|
||||
func NewTerminalLogger(level ...string) (*Logger, error) {
|
||||
return NewLogger(os.Stdout, level...)
|
||||
}
|
||||
|
||||
// NewBufferedTerminalLogger creates a buffered logger that write into terminal.
|
||||
func NewBufferedTerminalLogger(level ...string) (*Logger, error) {
|
||||
return NewLogger(bufio.NewWriter(os.Stdout), level...)
|
||||
}
|
||||
|
||||
// NewFileLogger creates a logger that write into file.
|
||||
func NewFileLogger(filePath string, level ...string) (*Logger, error) {
|
||||
return NewFileLoggerWithError(filePath, "", level...)
|
||||
}
|
||||
|
||||
// NewFileLoggerWithError creates a logger that write into files.
|
||||
func NewFileLoggerWithError(filePath, errFilePath string, level ...string) (*Logger, error) {
|
||||
if err := check.Dir(path.Dir(filePath)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if errFilePath != "" {
|
||||
if err := check.Dir(path.Dir(errFilePath)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
out, err := reopen.NewFileWriter(filePath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var errOut *reopen.FileWriter
|
||||
if errFilePath != "" {
|
||||
errOut, err = reopen.NewFileWriter(errFilePath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
c := make(chan os.Signal)
|
||||
go func() {
|
||||
for {
|
||||
select {
|
||||
case <-c:
|
||||
out.Reopen()
|
||||
if errOut != nil {
|
||||
errOut.Reopen()
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
signal.Notify(c, syscall.SIGHUP)
|
||||
|
||||
if errOut == nil {
|
||||
return NewLoggerWithError(out, nil, level...)
|
||||
}
|
||||
return NewLoggerWithError(out, errOut, level...)
|
||||
}
|
||||
|
||||
// NewBufferedFileLogger creates a logger that write into file with buffer.
|
||||
// The flushSeconds's unit is second.
|
||||
func NewBufferedFileLogger(filePath string, flushInterval int, level ...string) (*Logger, error) {
|
||||
return NewBufferedFileLoggerWithError(filePath, "", flushInterval, level...)
|
||||
}
|
||||
|
||||
// NewBufferedFileLoggerWithError creates a logger that write into files with buffer.
|
||||
// The flushSeconds's unit is second.
|
||||
func NewBufferedFileLoggerWithError(filePath, errFilePath string, flushInterval int, level ...string) (*Logger, error) {
|
||||
if err := check.Dir(path.Dir(filePath)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if errFilePath != "" {
|
||||
if err := check.Dir(path.Dir(errFilePath)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
if flushInterval == 0 {
|
||||
flushInterval = 10
|
||||
}
|
||||
|
||||
out, err := reopen.NewFileWriter(filePath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var errOut *reopen.FileWriter
|
||||
if errFilePath != "" {
|
||||
errOut, err = reopen.NewFileWriter(errFilePath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
bufferedOut := reopen.NewBufferedFileWriter(out)
|
||||
var bufferedErrOut *reopen.BufferedFileWriter
|
||||
if errOut != nil {
|
||||
bufferedErrOut = reopen.NewBufferedFileWriter(errOut)
|
||||
}
|
||||
|
||||
c := make(chan os.Signal)
|
||||
go func() {
|
||||
for {
|
||||
select {
|
||||
case <-c:
|
||||
bufferedOut.Reopen()
|
||||
if bufferedErrOut != nil {
|
||||
bufferedErrOut.Reopen()
|
||||
}
|
||||
case <-time.After(time.Duration(flushInterval) * time.Second):
|
||||
bufferedOut.Flush()
|
||||
if bufferedErrOut != nil {
|
||||
bufferedErrOut.Flush()
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
signal.Notify(c, syscall.SIGHUP)
|
||||
|
||||
if bufferedErrOut == nil {
|
||||
return NewLoggerWithError(bufferedOut, nil, level...)
|
||||
}
|
||||
return NewLoggerWithError(bufferedOut, bufferedErrOut, level...)
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue