| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package logger provides methods for logging with different levels. |
| package logger |
| |
| import ( |
| "context" |
| "fmt" |
| "io" |
| goLog "log" |
| "os" |
| |
| "go.fuchsia.dev/fuchsia/tools/lib/color" |
| ) |
| |
| type globalLoggerKeyType struct{} |
| |
| // WithLogger returns the context with its logger set as the provided Logger. |
| func WithLogger(ctx context.Context, logger *Logger) context.Context { |
| return context.WithValue(ctx, globalLoggerKeyType{}, logger) |
| } |
| |
| // LoggerFromContext returns the context logger if configured, otherwise nil. |
| func LoggerFromContext(ctx context.Context) *Logger { |
| if v, ok := ctx.Value(globalLoggerKeyType{}).(*Logger); ok && v != nil { |
| return v |
| } |
| return nil |
| } |
| |
| // Logger represents a specific LogLevel with a specified color and prefix. |
| type Logger struct { |
| LoggerLevel LogLevel |
| goLogger *goLog.Logger |
| goErrorLogger *goLog.Logger |
| color color.Color |
| prefix interface{} |
| } |
| |
| // LogLevel represents different levels for logging depending on the amount of detail wanted. |
| type LogLevel int |
| |
| const ( |
| NoLogLevel LogLevel = iota |
| FatalLevel |
| ErrorLevel |
| WarningLevel |
| InfoLevel |
| DebugLevel |
| TraceLevel |
| ) |
| |
| var levelToName = map[LogLevel]string{ |
| NoLogLevel: "no", |
| FatalLevel: "fatal", |
| ErrorLevel: "error", |
| WarningLevel: "warning", |
| InfoLevel: "info", |
| DebugLevel: "debug", |
| TraceLevel: "trace", |
| } |
| |
| // Populated at runtime by init() by inverting levelToName. |
| var nameToLevel = map[string]LogLevel{} |
| |
| func init() { |
| for level, name := range levelToName { |
| nameToLevel[name] = level |
| } |
| } |
| |
| // Copied from Go log so callers don't need to also import log. |
| const ( |
| Ldate = 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/b/c/d.go:23 |
| Lshortfile // final file name element and line number: d.go:23. overrides Llongfile |
| LUTC // if Ldate or Ltime is set, use UTC rather than the local time zone |
| Lmsgprefix // move the "prefix" from the beginning of the line to before the message |
| LstdFlags = Ldate | Lmicroseconds // initial values for the standard logger |
| ) |
| |
| // StartDepth defines the starting point for the call depth when entering the logger. |
| const startDepth = 2 |
| |
| // String returns the string representation of the LogLevel, or an empty string |
| // if the LogLevel has no string representation specified. |
| func (l *LogLevel) String() string { |
| return levelToName[*l] |
| } |
| |
| // Set sets the LogLevel based on its string value. |
| func (l *LogLevel) Set(s string) error { |
| level, ok := nameToLevel[s] |
| if !ok { |
| return fmt.Errorf("%s is not a valid level", s) |
| } |
| *l = level |
| return nil |
| } |
| |
| // NewLogger creates a new logger instance. The loggerLevel variable sets the log level for the logger. |
| // The color variable specifies the visual color of displayed log output. |
| // The outWriter and errWriter variables set the destination to which non-error and error data will be written. |
| // The prefix appears on the same line directly preceding any log data. It should be thread-safe to format this value. |
| func NewLogger(loggerLevel LogLevel, color color.Color, outWriter, errWriter io.Writer, prefix interface{}) *Logger { |
| if outWriter == nil { |
| outWriter = os.Stdout |
| } |
| if errWriter == nil { |
| errWriter = os.Stderr |
| } |
| l := &Logger{ |
| LoggerLevel: loggerLevel, |
| goLogger: goLog.New(outWriter, "", LstdFlags), |
| goErrorLogger: goLog.New(errWriter, "", LstdFlags), |
| color: color, |
| prefix: prefix, |
| } |
| return l |
| } |
| |
| func (l *Logger) SetFlags(flags int) { |
| l.goLogger.SetFlags(flags) |
| l.goErrorLogger.SetFlags(flags) |
| } |
| |
| func (l *Logger) log(callDepth int, prefix, format string, a ...interface{}) { |
| l.goLogger.Output(callDepth+1, fmt.Sprintf("%s%s%s", l.prefix, prefix, fmt.Sprintf(format, a...))) |
| } |
| |
| // Logf logs the string based on the loglevel of the string and the LogLevel of the logger. |
| func (l *Logger) logf(callDepth int, logLevel LogLevel, format string, a ...interface{}) { |
| switch logLevel { |
| case InfoLevel: |
| l.infof(callDepth+1, format, a...) |
| case DebugLevel: |
| l.debugf(callDepth+1, format, a...) |
| case TraceLevel: |
| l.tracef(callDepth+1, format, a...) |
| case WarningLevel: |
| l.warningf(callDepth+1, format, a...) |
| case ErrorLevel: |
| l.errorf(callDepth+1, format, a...) |
| case FatalLevel: |
| l.fatalf(callDepth+1, format, a...) |
| default: |
| panic(fmt.Sprintf("Undefined loglevel: %v, log message: %s", logLevel, fmt.Sprintf(format, a...))) |
| } |
| } |
| |
| func Logf(ctx context.Context, logLevel LogLevel, format string, a ...interface{}) { |
| logf(startDepth, ctx, logLevel, format, a...) |
| } |
| |
| func logf(callDepth int, ctx context.Context, logLevel LogLevel, format string, a ...interface{}) { |
| if v := LoggerFromContext(ctx); v != nil { |
| v.logf(callDepth+1, logLevel, format, a...) |
| return |
| } |
| switch logLevel { |
| case InfoLevel: |
| case DebugLevel: |
| case TraceLevel: |
| case WarningLevel: |
| case ErrorLevel: |
| goLog.Output(callDepth+1, fmt.Sprintf(format, a...)) |
| case FatalLevel: |
| goLog.Output(callDepth+1, fmt.Sprintf(format, a...)) |
| os.Exit(1) |
| default: |
| panic(fmt.Sprintf("Undefined loglevel: %v, log message: %s", logLevel, fmt.Sprintf(format, a...))) |
| } |
| } |
| |
| // Infof logs the string if the logger is at least InfoLevel. |
| func (l *Logger) Infof(format string, a ...interface{}) { |
| l.infof(startDepth, format, a...) |
| } |
| |
| // infof logs the string if the logger is at least InfoLevel. |
| func (l *Logger) infof(callDepth int, format string, a ...interface{}) { |
| if l.LoggerLevel >= InfoLevel { |
| l.log(callDepth+1, "", format, a...) |
| } |
| } |
| |
| func Infof(ctx context.Context, format string, a ...interface{}) { |
| logf(startDepth, ctx, InfoLevel, format, a...) |
| } |
| |
| // Debugf logs the string if the logger is at least DebugLevel. |
| func (l *Logger) Debugf(format string, a ...interface{}) { |
| l.debugf(startDepth, format, a...) |
| } |
| |
| // Debugf logs the string if the logger is at least DebugLevel. |
| func (l *Logger) debugf(callDepth int, format string, a ...interface{}) { |
| if l.LoggerLevel >= DebugLevel { |
| l.log(callDepth+1, l.color.Cyan("DEBUG: "), format, a...) |
| } |
| } |
| |
| func Debugf(ctx context.Context, format string, a ...interface{}) { |
| logf(startDepth, ctx, DebugLevel, format, a...) |
| } |
| |
| // Tracef logs the string if the logger is at least TraceLevel. |
| func (l *Logger) Tracef(format string, a ...interface{}) { |
| l.tracef(startDepth, format, a...) |
| } |
| |
| // Tracef logs the string if the logger is at least TraceLevel. |
| func (l *Logger) tracef(callDepth int, format string, a ...interface{}) { |
| if l.LoggerLevel >= TraceLevel { |
| l.log(callDepth+1, l.color.Blue("TRACE: "), format, a...) |
| } |
| } |
| |
| func Tracef(ctx context.Context, format string, a ...interface{}) { |
| logf(startDepth, ctx, TraceLevel, format, a...) |
| } |
| |
| // Warningf logs the string if the logger is at least WarningLevel. |
| func (l *Logger) Warningf(format string, a ...interface{}) { |
| l.warningf(startDepth, format, a...) |
| } |
| |
| // Warningf logs the string if the logger is at least WarningLevel. |
| func (l *Logger) warningf(callDepth int, format string, a ...interface{}) { |
| if l.LoggerLevel >= WarningLevel { |
| l.log(callDepth+1, l.color.Yellow("WARN: "), format, a...) |
| } |
| } |
| |
| func Warningf(ctx context.Context, format string, a ...interface{}) { |
| logf(startDepth, ctx, WarningLevel, format, a...) |
| } |
| |
| // Errorf logs the string if the logger is at least ErrorLevel. |
| func (l *Logger) Errorf(format string, a ...interface{}) { |
| l.errorf(startDepth, format, a...) |
| } |
| |
| // Errorf logs the string if the logger is at least ErrorLevel. |
| func (l *Logger) errorf(callDepth int, format string, a ...interface{}) { |
| if l.LoggerLevel >= ErrorLevel { |
| l.goErrorLogger.Output(callDepth+1, fmt.Sprintf("%s%s%s", l.prefix, l.color.Red("ERROR: "), fmt.Sprintf(format, a...))) |
| } |
| } |
| |
| func Errorf(ctx context.Context, format string, a ...interface{}) { |
| logf(startDepth, ctx, ErrorLevel, format, a...) |
| } |
| |
| // Fatalf logs the string if the logger is at least FatalLevel. |
| func (l *Logger) Fatalf(format string, a ...interface{}) { |
| l.fatalf(startDepth, format, a...) |
| } |
| |
| // Fatalf logs the string if the logger is at least FatalLevel. |
| func (l *Logger) fatalf(callDepth int, format string, a ...interface{}) { |
| if l.LoggerLevel >= FatalLevel { |
| l.goErrorLogger.Output(callDepth+1, fmt.Sprintf("%s%s%s", l.prefix, l.color.Red("FATAL: "), fmt.Sprintf(format, a...))) |
| } |
| os.Exit(1) |
| } |
| |
| func Fatalf(ctx context.Context, format string, a ...interface{}) { |
| logf(startDepth, ctx, FatalLevel, format, a...) |
| } |