updated GHA

Update to v2 SDK
updated dependencies

vendor/github.com/hashicorp/go-hclog/README.md

@@ -17,11 +17,8 @@ JSON output mode for production.
 
 ## Stability Note
 
-While this library is fully open source and HashiCorp will be maintaining it
-(since we are and will be making extensive use of it), the API and output
-format is subject to minor changes as we fully bake and vet it in our projects.
-This notice will be removed once it's fully integrated into our major projects
-and no further changes are anticipated.
+This library has reached 1.0 stability. Its API can be considered solidified
+and promised through future versions.
 
 ## Installation and Docs
 
@@ -102,7 +99,7 @@ into all the callers.
 ### Using `hclog.Fmt()`
 
 ```go
-var int totalBandwidth = 200
+totalBandwidth := 200
 appLogger.Info("total bandwidth exceeded", "bandwidth", hclog.Fmt("%d GB/s", totalBandwidth))
 ```
 
@@ -132,7 +129,7 @@ Alternatively, you may configure the system-wide logger:
 
 ```go
 // log the standard logger from 'import "log"'
-log.SetOutput(appLogger.Writer(&hclog.StandardLoggerOptions{InferLevels: true}))
+log.SetOutput(appLogger.StandardWriter(&hclog.StandardLoggerOptions{InferLevels: true}))
 log.SetPrefix("")
 log.SetFlags(0)
 
@@ -146,3 +143,6 @@ log.Printf("[DEBUG] %d", 42)
 Notice that if `appLogger` is initialized with the `INFO` log level _and_ you
 specify `InferLevels: true`, you will not see any output here. You must change
 `appLogger` to `DEBUG` to see output. See the docs for more information.
+
+If the log lines start with a timestamp you can use the
+`InferLevelsWithTimestamp` option to try and ignore them.

vendor/github.com/hashicorp/go-hclog/colorize_unix.go

@@ -0,0 +1,29 @@
+//go:build !windows
+// +build !windows
+
+package hclog
+
+import (
+	"github.com/mattn/go-isatty"
+)
+
+// setColorization will mutate the values of this logger
+// to approperately configure colorization options. It provides
+// a wrapper to the output stream on Windows systems.
+func (l *intLogger) setColorization(opts *LoggerOptions) {
+	switch opts.Color {
+	case ColorOff:
+		fallthrough
+	case ForceColor:
+		return
+	case AutoColor:
+		fi := l.checkWriterIsFile()
+		isUnixTerm := isatty.IsTerminal(fi.Fd())
+		isCygwinTerm := isatty.IsCygwinTerminal(fi.Fd())
+		isTerm := isUnixTerm || isCygwinTerm
+		if !isTerm {
+			l.headerColor = ColorOff
+			l.writer.color = ColorOff
+		}
+	}
+}

vendor/github.com/hashicorp/go-hclog/colorize_windows.go

@@ -0,0 +1,38 @@
+//go:build windows
+// +build windows
+
+package hclog
+
+import (
+	"os"
+
+	colorable "github.com/mattn/go-colorable"
+	"github.com/mattn/go-isatty"
+)
+
+// setColorization will mutate the values of this logger
+// to approperately configure colorization options. It provides
+// a wrapper to the output stream on Windows systems.
+func (l *intLogger) setColorization(opts *LoggerOptions) {
+	switch opts.Color {
+	case ColorOff:
+		return
+	case ForceColor:
+		fi := l.checkWriterIsFile()
+		l.writer.w = colorable.NewColorable(fi)
+	case AutoColor:
+		fi := l.checkWriterIsFile()
+		isUnixTerm := isatty.IsTerminal(os.Stdout.Fd())
+		isCygwinTerm := isatty.IsCygwinTerminal(os.Stdout.Fd())
+		isTerm := isUnixTerm || isCygwinTerm
+		if !isTerm {
+			l.writer.color = ColorOff
+			l.headerColor = ColorOff
+			return
+		}
+
+		if l.headerColor == ColorOff {
+			l.writer.w = colorable.NewColorable(fi)
+		}
+	}
+}

vendor/github.com/hashicorp/go-hclog/exclude.go

@@ -0,0 +1,71 @@
+package hclog
+
+import (
+	"regexp"
+	"strings"
+)
+
+// ExcludeByMessage provides a simple way to build a list of log messages that
+// can be queried and matched. This is meant to be used with the Exclude
+// option on Options to suppress log messages. This does not hold any mutexs
+// within itself, so normal usage would be to Add entries at setup and none after
+// Exclude is going to be called. Exclude is called with a mutex held within
+// the Logger, so that doesn't need to use a mutex. Example usage:
+//
+//	f := new(ExcludeByMessage)
+//	f.Add("Noisy log message text")
+//	appLogger.Exclude = f.Exclude
+type ExcludeByMessage struct {
+	messages map[string]struct{}
+}
+
+// Add a message to be filtered. Do not call this after Exclude is to be called
+// due to concurrency issues.
+func (f *ExcludeByMessage) Add(msg string) {
+	if f.messages == nil {
+		f.messages = make(map[string]struct{})
+	}
+
+	f.messages[msg] = struct{}{}
+}
+
+// Return true if the given message should be included
+func (f *ExcludeByMessage) Exclude(level Level, msg string, args ...interface{}) bool {
+	_, ok := f.messages[msg]
+	return ok
+}
+
+// ExcludeByPrefix is a simple type to match a message string that has a common prefix.
+type ExcludeByPrefix string
+
+// Matches an message that starts with the prefix.
+func (p ExcludeByPrefix) Exclude(level Level, msg string, args ...interface{}) bool {
+	return strings.HasPrefix(msg, string(p))
+}
+
+// ExcludeByRegexp takes a regexp and uses it to match a log message string. If it matches
+// the log entry is excluded.
+type ExcludeByRegexp struct {
+	Regexp *regexp.Regexp
+}
+
+// Exclude the log message if the message string matches the regexp
+func (e ExcludeByRegexp) Exclude(level Level, msg string, args ...interface{}) bool {
+	return e.Regexp.MatchString(msg)
+}
+
+// ExcludeFuncs is a slice of functions that will called to see if a log entry
+// should be filtered or not. It stops calling functions once at least one returns
+// true.
+type ExcludeFuncs []func(level Level, msg string, args ...interface{}) bool
+
+// Calls each function until one of them returns true
+func (ff ExcludeFuncs) Exclude(level Level, msg string, args ...interface{}) bool {
+	for _, f := range ff {
+		if f(level, msg, args...) {
+			return true
+		}
+	}
+
+	return false
+}

vendor/github.com/hashicorp/go-hclog/global.go

@@ -2,6 +2,7 @@ package hclog
 
 import (
 	"sync"
+	"time"
 )
 
 var (
@@ -14,12 +15,20 @@ var (
 	DefaultOptions = &LoggerOptions{
 		Level:  DefaultLevel,
 		Output: DefaultOutput,
+		TimeFn: time.Now,
 	}
 )
 
 // Default returns a globally held logger. This can be a good starting
 // place, and then you can use .With() and .Name() to create sub-loggers
 // to be used in more specific contexts.
+// The value of the Default logger can be set via SetDefault() or by
+// changing the options in DefaultOptions.
+//
+// This method is goroutine safe, returning a global from memory, but
+// cause should be used if SetDefault() is called it random times
+// in the program as that may result in race conditions and an unexpected
+// Logger being returned.
 func Default() Logger {
 	protect.Do(func() {
 		// If SetDefault was used before Default() was called, we need to
@@ -41,6 +50,13 @@ func L() Logger {
 // to the one given. This allows packages to use the default logger
 // and have higher level packages change it to match the execution
 // environment. It returns any old default if there is one.
+//
+// NOTE: This is expected to be called early in the program to setup
+// a default logger. As such, it does not attempt to make itself
+// not racy with regard to the value of the default logger. Ergo
+// if it is called in goroutines, you may experience race conditions
+// with other goroutines retrieving the default logger. Basically,
+// don't do that.
 func SetDefault(log Logger) Logger {
 	old := def
 	def = log

vendor/github.com/hashicorp/go-hclog/interceptlogger.go

@@ -0,0 +1,204 @@
+package hclog
+
+import (
+	"io"
+	"log"
+	"sync"
+	"sync/atomic"
+)
+
+var _ Logger = &interceptLogger{}
+
+type interceptLogger struct {
+	Logger
+
+	mu        *sync.Mutex
+	sinkCount *int32
+	Sinks     map[SinkAdapter]struct{}
+}
+
+func NewInterceptLogger(opts *LoggerOptions) InterceptLogger {
+	l := newLogger(opts)
+	if l.callerOffset > 0 {
+		// extra frames for interceptLogger.{Warn,Info,Log,etc...}, and interceptLogger.log
+		l.callerOffset += 2
+	}
+	intercept := &interceptLogger{
+		Logger:    l,
+		mu:        new(sync.Mutex),
+		sinkCount: new(int32),
+		Sinks:     make(map[SinkAdapter]struct{}),
+	}
+
+	atomic.StoreInt32(intercept.sinkCount, 0)
+
+	return intercept
+}
+
+func (i *interceptLogger) Log(level Level, msg string, args ...interface{}) {
+	i.log(level, msg, args...)
+}
+
+// log is used to make the caller stack frame lookup consistent. If Warn,Info,etc
+// all called Log then direct calls to Log would have a different stack frame
+// depth. By having all the methods call the same helper we ensure the stack
+// frame depth is the same.
+func (i *interceptLogger) log(level Level, msg string, args ...interface{}) {
+	i.Logger.Log(level, msg, args...)
+	if atomic.LoadInt32(i.sinkCount) == 0 {
+		return
+	}
+
+	i.mu.Lock()
+	defer i.mu.Unlock()
+	for s := range i.Sinks {
+		s.Accept(i.Name(), level, msg, i.retrieveImplied(args...)...)
+	}
+}
+
+// Emit the message and args at TRACE level to log and sinks
+func (i *interceptLogger) Trace(msg string, args ...interface{}) {
+	i.log(Trace, msg, args...)
+}
+
+// Emit the message and args at DEBUG level to log and sinks
+func (i *interceptLogger) Debug(msg string, args ...interface{}) {
+	i.log(Debug, msg, args...)
+}
+
+// Emit the message and args at INFO level to log and sinks
+func (i *interceptLogger) Info(msg string, args ...interface{}) {
+	i.log(Info, msg, args...)
+}
+
+// Emit the message and args at WARN level to log and sinks
+func (i *interceptLogger) Warn(msg string, args ...interface{}) {
+	i.log(Warn, msg, args...)
+}
+
+// Emit the message and args at ERROR level to log and sinks
+func (i *interceptLogger) Error(msg string, args ...interface{}) {
+	i.log(Error, msg, args...)
+}
+
+func (i *interceptLogger) retrieveImplied(args ...interface{}) []interface{} {
+	top := i.Logger.ImpliedArgs()
+
+	cp := make([]interface{}, len(top)+len(args))
+	copy(cp, top)
+	copy(cp[len(top):], args)
+
+	return cp
+}
+
+// Create a new sub-Logger that a name descending from the current name.
+// This is used to create a subsystem specific Logger.
+// Registered sinks will subscribe to these messages as well.
+func (i *interceptLogger) Named(name string) Logger {
+	return i.NamedIntercept(name)
+}
+
+// Create a new sub-Logger with an explicit name. This ignores the current
+// name. This is used to create a standalone logger that doesn't fall
+// within the normal hierarchy. Registered sinks will subscribe
+// to these messages as well.
+func (i *interceptLogger) ResetNamed(name string) Logger {
+	return i.ResetNamedIntercept(name)
+}
+
+// Create a new sub-Logger that a name decending from the current name.
+// This is used to create a subsystem specific Logger.
+// Registered sinks will subscribe to these messages as well.
+func (i *interceptLogger) NamedIntercept(name string) InterceptLogger {
+	var sub interceptLogger
+
+	sub = *i
+	sub.Logger = i.Logger.Named(name)
+	return &sub
+}
+
+// Create a new sub-Logger with an explicit name. This ignores the current
+// name. This is used to create a standalone logger that doesn't fall
+// within the normal hierarchy. Registered sinks will subscribe
+// to these messages as well.
+func (i *interceptLogger) ResetNamedIntercept(name string) InterceptLogger {
+	var sub interceptLogger
+
+	sub = *i
+	sub.Logger = i.Logger.ResetNamed(name)
+	return &sub
+}
+
+// Return a sub-Logger for which every emitted log message will contain
+// the given key/value pairs. This is used to create a context specific
+// Logger.
+func (i *interceptLogger) With(args ...interface{}) Logger {
+	var sub interceptLogger
+
+	sub = *i
+
+	sub.Logger = i.Logger.With(args...)
+
+	return &sub
+}
+
+// RegisterSink attaches a SinkAdapter to interceptLoggers sinks.
+func (i *interceptLogger) RegisterSink(sink SinkAdapter) {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+
+	i.Sinks[sink] = struct{}{}
+
+	atomic.AddInt32(i.sinkCount, 1)
+}
+
+// DeregisterSink removes a SinkAdapter from interceptLoggers sinks.
+func (i *interceptLogger) DeregisterSink(sink SinkAdapter) {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+
+	delete(i.Sinks, sink)
+
+	atomic.AddInt32(i.sinkCount, -1)
+}
+
+func (i *interceptLogger) StandardLoggerIntercept(opts *StandardLoggerOptions) *log.Logger {
+	return i.StandardLogger(opts)
+}
+
+func (i *interceptLogger) StandardLogger(opts *StandardLoggerOptions) *log.Logger {
+	if opts == nil {
+		opts = &StandardLoggerOptions{}
+	}
+
+	return log.New(i.StandardWriter(opts), "", 0)
+}
+
+func (i *interceptLogger) StandardWriterIntercept(opts *StandardLoggerOptions) io.Writer {
+	return i.StandardWriter(opts)
+}
+
+func (i *interceptLogger) StandardWriter(opts *StandardLoggerOptions) io.Writer {
+	return &stdlogAdapter{
+		log:                      i,
+		inferLevels:              opts.InferLevels,
+		inferLevelsWithTimestamp: opts.InferLevelsWithTimestamp,
+		forceLevel:               opts.ForceLevel,
+	}
+}
+
+func (i *interceptLogger) ResetOutput(opts *LoggerOptions) error {
+	if or, ok := i.Logger.(OutputResettable); ok {
+		return or.ResetOutput(opts)
+	} else {
+		return nil
+	}
+}
+
+func (i *interceptLogger) ResetOutputWithFlush(opts *LoggerOptions, flushable Flushable) error {
+	if or, ok := i.Logger.(OutputResettable); ok {
+		return or.ResetOutputWithFlush(opts, flushable)
+	} else {
+		return nil
+	}
+}

vendor/github.com/hashicorp/go-hclog/intlogger.go

@@ -4,9 +4,11 @@ import (
 	"bytes"
 	"encoding"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"log"
+	"os"
 	"reflect"
 	"runtime"
 	"sort"
@@ -15,12 +17,18 @@ import (
 	"sync"
 	"sync/atomic"
 	"time"
+
+	"github.com/fatih/color"
 )
 
-// TimeFormat to use for logging. This is a version of RFC3339 that contains
-// contains millisecond precision
+// TimeFormat is the time format to use for plain (non-JSON) output.
+// This is a version of RFC3339 that contains millisecond precision.
 const TimeFormat = "2006-01-02T15:04:05.000Z0700"
 
+// TimeFormatJSON is the time format to use for JSON output.
+// This is a version of RFC3339 that contains microsecond precision.
+const TimeFormatJSON = "2006-01-02T15:04:05.000000Z07:00"
+
 // errJsonUnsupportedTypeMsg is included in log json entries, if an arg cannot be serialized to json
 const errJsonUnsupportedTypeMsg = "logging contained values that don't serialize to json"
 
@@ -32,6 +40,14 @@ var (
 		Warn:  "[WARN] ",
 		Error: "[ERROR]",
 	}
+
+	_levelToColor = map[Level]*color.Color{
+		Debug: color.New(color.FgHiWhite),
+		Trace: color.New(color.FgHiGreen),
+		Info:  color.New(color.FgHiBlue),
+		Warn:  color.New(color.FgHiYellow),
+		Error: color.New(color.FgHiRed),
+	}
 )
 
 // Make sure that intLogger is a Logger
@@ -40,22 +56,46 @@ var _ Logger = &intLogger{}
 // intLogger is an internal logger implementation. Internal in that it is
 // defined entirely by this package.
 type intLogger struct {
-	json       bool
-	caller     bool
-	name       string
-	timeFormat string
+	json         bool
+	callerOffset int
+	name         string
+	timeFormat   string
+	timeFn       TimeFunction
+	disableTime  bool
 
-	// This is a pointer so that it's shared by any derived loggers, since
+	// This is an interface so that it's shared by any derived loggers, since
 	// those derived loggers share the bufio.Writer as well.
-	mutex  *sync.Mutex
+	mutex  Locker
 	writer *writer
 	level  *int32
 
+	headerColor ColorOption
+
 	implied []interface{}
+
+	exclude func(level Level, msg string, args ...interface{}) bool
+
+	// create subloggers with their own level setting
+	independentLevels bool
 }
 
 // New returns a configured logger.
 func New(opts *LoggerOptions) Logger {
+	return newLogger(opts)
+}
+
+// NewSinkAdapter returns a SinkAdapter with configured settings
+// defined by LoggerOptions
+func NewSinkAdapter(opts *LoggerOptions) SinkAdapter {
+	l := newLogger(opts)
+	if l.callerOffset > 0 {
+		// extra frames for interceptLogger.{Warn,Info,Log,etc...}, and SinkAdapter.Accept
+		l.callerOffset += 2
+	}
+	return l
+}
+
+func newLogger(opts *LoggerOptions) *intLogger {
 	if opts == nil {
 		opts = &LoggerOptions{}
 	}
@@ -75,41 +115,74 @@ func New(opts *LoggerOptions) Logger {
 		mutex = new(sync.Mutex)
 	}
 
-	l := &intLogger{
-		json:       opts.JSONFormat,
-		caller:     opts.IncludeLocation,
-		name:       opts.Name,
-		timeFormat: TimeFormat,
-		mutex:      mutex,
-		writer:     newWriter(output),
-		level:      new(int32),
+	var primaryColor, headerColor ColorOption
+
+	if opts.ColorHeaderOnly {
+		primaryColor = ColorOff
+		headerColor = opts.Color
+	} else {
+		primaryColor = opts.Color
+		headerColor = ColorOff
 	}
 
+	l := &intLogger{
+		json:              opts.JSONFormat,
+		name:              opts.Name,
+		timeFormat:        TimeFormat,
+		timeFn:            time.Now,
+		disableTime:       opts.DisableTime,
+		mutex:             mutex,
+		writer:            newWriter(output, primaryColor),
+		level:             new(int32),
+		exclude:           opts.Exclude,
+		independentLevels: opts.IndependentLevels,
+		headerColor:       headerColor,
+	}
+	if opts.IncludeLocation {
+		l.callerOffset = offsetIntLogger + opts.AdditionalLocationOffset
+	}
+
+	if l.json {
+		l.timeFormat = TimeFormatJSON
+	}
+	if opts.TimeFn != nil {
+		l.timeFn = opts.TimeFn
+	}
 	if opts.TimeFormat != "" {
 		l.timeFormat = opts.TimeFormat
 	}
 
+	l.setColorization(opts)
+
 	atomic.StoreInt32(l.level, int32(level))
 
 	return l
 }
 
+// offsetIntLogger is the stack frame offset in the call stack for the caller to
+// one of the Warn,Info,Log,etc methods.
+const offsetIntLogger = 3
+
 // Log a message and a set of key/value pairs if the given level is at
 // or more severe that the threshold configured in the Logger.
-func (l *intLogger) Log(level Level, msg string, args ...interface{}) {
+func (l *intLogger) log(name string, level Level, msg string, args ...interface{}) {
 	if level < Level(atomic.LoadInt32(l.level)) {
 		return
 	}
 
-	t := time.Now()
+	t := l.timeFn()
 
 	l.mutex.Lock()
 	defer l.mutex.Unlock()
 
+	if l.exclude != nil && l.exclude(level, msg, args...) {
+		return
+	}
+
 	if l.json {
-		l.logJSON(t, level, msg, args...)
+		l.logJSON(t, name, level, msg, args...)
 	} else {
-		l.log(t, level, msg, args...)
+		l.logPlain(t, name, level, msg, args...)
 	}
 
 	l.writer.Flush(level)
@@ -144,20 +217,46 @@ func trimCallerPath(path string) string {
 	return path[idx+1:]
 }
 
+// isNormal indicates if the rune is one allowed to exist as an unquoted
+// string value. This is a subset of ASCII, `-` through `~`.
+func isNormal(r rune) bool {
+	return 0x2D <= r && r <= 0x7E // - through ~
+}
+
+// needsQuoting returns false if all the runes in string are normal, according
+// to isNormal
+func needsQuoting(str string) bool {
+	for _, r := range str {
+		if !isNormal(r) {
+			return true
+		}
+	}
+
+	return false
+}
+
 // Non-JSON logging format function
-func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{}) {
-	l.writer.WriteString(t.Format(l.timeFormat))
-	l.writer.WriteByte(' ')
+func (l *intLogger) logPlain(t time.Time, name string, level Level, msg string, args ...interface{}) {
+
+	if !l.disableTime {
+		l.writer.WriteString(t.Format(l.timeFormat))
+		l.writer.WriteByte(' ')
+	}
 
 	s, ok := _levelToBracket[level]
 	if ok {
-		l.writer.WriteString(s)
+		if l.headerColor != ColorOff {
+			color := _levelToColor[level]
+			color.Fprint(l.writer, s)
+		} else {
+			l.writer.WriteString(s)
+		}
 	} else {
 		l.writer.WriteString("[?????]")
 	}
 
-	if l.caller {
-		if _, file, line, ok := runtime.Caller(3); ok {
+	if l.callerOffset > 0 {
+		if _, file, line, ok := runtime.Caller(l.callerOffset); ok {
 			l.writer.WriteByte(' ')
 			l.writer.WriteString(trimCallerPath(file))
 			l.writer.WriteByte(':')
@@ -168,8 +267,8 @@ func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{
 
 	l.writer.WriteByte(' ')
 
-	if l.name != "" {
-		l.writer.WriteString(l.name)
+	if name != "" {
+		l.writer.WriteString(name)
 		l.writer.WriteString(": ")
 	}
 
@@ -186,7 +285,8 @@ func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{
 				args = args[:len(args)-1]
 				stacktrace = cs
 			} else {
-				args = append(args, "<unknown>")
+				extra := args[len(args)-1]
+				args = append(args[:len(args)-1], MissingKey, extra)
 			}
 		}
 
@@ -202,6 +302,10 @@ func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{
 			switch st := args[i+1].(type) {
 			case string:
 				val = st
+				if st == "" {
+					val = `""`
+					raw = true
+				}
 			case int:
 				val = strconv.FormatInt(int64(st), 10)
 			case int64:
@@ -222,11 +326,20 @@ func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{
 				val = strconv.FormatUint(uint64(st), 10)
 			case uint8:
 				val = strconv.FormatUint(uint64(st), 10)
+			case Hex:
+				val = "0x" + strconv.FormatUint(uint64(st), 16)
+			case Octal:
+				val = "0" + strconv.FormatUint(uint64(st), 8)
+			case Binary:
+				val = "0b" + strconv.FormatUint(uint64(st), 2)
 			case CapturedStacktrace:
 				stacktrace = st
 				continue FOR
 			case Format:
 				val = fmt.Sprintf(st[0].(string), st[1:]...)
+			case Quote:
+				raw = true
+				val = strconv.Quote(string(st))
 			default:
 				v := reflect.ValueOf(st)
 				if v.Kind() == reflect.Slice {
@@ -237,15 +350,30 @@ func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{
 				}
 			}
 
-			l.writer.WriteByte(' ')
-			l.writer.WriteString(args[i].(string))
-			l.writer.WriteByte('=')
+			var key string
 
-			if !raw && strings.ContainsAny(val, " \t\n\r") {
-				l.writer.WriteByte('"')
-				l.writer.WriteString(val)
-				l.writer.WriteByte('"')
+			switch st := args[i].(type) {
+			case string:
+				key = st
+			default:
+				key = fmt.Sprintf("%s", st)
+			}
+
+			if strings.Contains(val, "\n") {
+				l.writer.WriteString("\n  ")
+				l.writer.WriteString(key)
+				l.writer.WriteString("=\n")
+				writeIndent(l.writer, val, "  | ")
+				l.writer.WriteString("  ")
+			} else if !raw && needsQuoting(val) {
+				l.writer.WriteByte(' ')
+				l.writer.WriteString(key)
+				l.writer.WriteByte('=')
+				l.writer.WriteString(strconv.Quote(val))
 			} else {
+				l.writer.WriteByte(' ')
+				l.writer.WriteString(key)
+				l.writer.WriteByte('=')
 				l.writer.WriteString(val)
 			}
 		}
@@ -255,6 +383,26 @@ func (l *intLogger) log(t time.Time, level Level, msg string, args ...interface{
 
 	if stacktrace != "" {
 		l.writer.WriteString(string(stacktrace))
+		l.writer.WriteString("\n")
+	}
+}
+
+func writeIndent(w *writer, str string, indent string) {
+	for {
+		nl := strings.IndexByte(str, "\n"[0])
+		if nl == -1 {
+			if str != "" {
+				w.WriteString(indent)
+				w.WriteString(str)
+				w.WriteString("\n")
+			}
+			return
+		}
+
+		w.WriteString(indent)
+		w.WriteString(str[:nl])
+		w.WriteString("\n")
+		str = str[nl+1:]
 	}
 }
 
@@ -274,22 +422,19 @@ func (l *intLogger) renderSlice(v reflect.Value) string {
 
 		switch sv.Kind() {
 		case reflect.String:
-			val = sv.String()
+			val = strconv.Quote(sv.String())
 		case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
 			val = strconv.FormatInt(sv.Int(), 10)
 		case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 			val = strconv.FormatUint(sv.Uint(), 10)
 		default:
 			val = fmt.Sprintf("%v", sv.Interface())
+			if strings.ContainsAny(val, " \t\n\r") {
+				val = strconv.Quote(val)
+			}
 		}
 
-		if strings.ContainsAny(val, " \t\n\r") {
-			buf.WriteByte('"')
-			buf.WriteString(val)
-			buf.WriteByte('"')
-		} else {
-			buf.WriteString(val)
-		}
+		buf.WriteString(val)
 	}
 
 	buf.WriteRune(']')
@@ -298,8 +443,8 @@ func (l *intLogger) renderSlice(v reflect.Value) string {
 }
 
 // JSON logging function
-func (l *intLogger) logJSON(t time.Time, level Level, msg string, args ...interface{}) {
-	vals := l.jsonMapEntry(t, level, msg)
+func (l *intLogger) logJSON(t time.Time, name string, level Level, msg string, args ...interface{}) {
+	vals := l.jsonMapEntry(t, name, level, msg)
 	args = append(l.implied, args...)
 
 	if args != nil && len(args) > 0 {
@@ -309,16 +454,12 @@ func (l *intLogger) logJSON(t time.Time, level Level, msg string, args ...interf
 				args = args[:len(args)-1]
 				vals["stacktrace"] = cs
 			} else {
-				args = append(args, "<unknown>")
+				extra := args[len(args)-1]
+				args = append(args[:len(args)-1], MissingKey, extra)
 			}
 		}
 
 		for i := 0; i < len(args); i = i + 2 {
-			if _, ok := args[i].(string); !ok {
-				// As this is the logging function not much we can do here
-				// without injecting into logs...
-				continue
-			}
 			val := args[i+1]
 			switch sv := val.(type) {
 			case error:
@@ -334,14 +475,22 @@ func (l *intLogger) logJSON(t time.Time, level Level, msg string, args ...interf
 				val = fmt.Sprintf(sv[0].(string), sv[1:]...)
 			}
 
-			vals[args[i].(string)] = val
+			var key string
+
+			switch st := args[i].(type) {
+			case string:
+				key = st
+			default:
+				key = fmt.Sprintf("%s", st)
+			}
+			vals[key] = val
 		}
 	}
 
 	err := json.NewEncoder(l.writer).Encode(vals)
 	if err != nil {
 		if _, ok := err.(*json.UnsupportedTypeError); ok {
-			plainVal := l.jsonMapEntry(t, level, msg)
+			plainVal := l.jsonMapEntry(t, name, level, msg)
 			plainVal["@warn"] = errJsonUnsupportedTypeMsg
 
 			json.NewEncoder(l.writer).Encode(plainVal)
@@ -349,10 +498,12 @@ func (l *intLogger) logJSON(t time.Time, level Level, msg string, args ...interf
 	}
 }
 
-func (l intLogger) jsonMapEntry(t time.Time, level Level, msg string) map[string]interface{} {
+func (l intLogger) jsonMapEntry(t time.Time, name string, level Level, msg string) map[string]interface{} {
 	vals := map[string]interface{}{
-		"@message":   msg,
-		"@timestamp": t.Format("2006-01-02T15:04:05.000000Z07:00"),
+		"@message": msg,
+	}
+	if !l.disableTime {
+		vals["@timestamp"] = t.Format(l.timeFormat)
 	}
 
 	var levelStr string
@@ -373,41 +524,46 @@ func (l intLogger) jsonMapEntry(t time.Time, level Level, msg string) map[string
 
 	vals["@level"] = levelStr
 
-	if l.name != "" {
-		vals["@module"] = l.name
+	if name != "" {
+		vals["@module"] = name
 	}
 
-	if l.caller {
-		if _, file, line, ok := runtime.Caller(4); ok {
+	if l.callerOffset > 0 {
+		if _, file, line, ok := runtime.Caller(l.callerOffset + 1); ok {
 			vals["@caller"] = fmt.Sprintf("%s:%d", file, line)
 		}
 	}
 	return vals
 }
 
+// Emit the message and args at the provided level
+func (l *intLogger) Log(level Level, msg string, args ...interface{}) {
+	l.log(l.Name(), level, msg, args...)
+}
+
 // Emit the message and args at DEBUG level
 func (l *intLogger) Debug(msg string, args ...interface{}) {
-	l.Log(Debug, msg, args...)
+	l.log(l.Name(), Debug, msg, args...)
 }
 
 // Emit the message and args at TRACE level
 func (l *intLogger) Trace(msg string, args ...interface{}) {
-	l.Log(Trace, msg, args...)
+	l.log(l.Name(), Trace, msg, args...)
 }
 
 // Emit the message and args at INFO level
 func (l *intLogger) Info(msg string, args ...interface{}) {
-	l.Log(Info, msg, args...)
+	l.log(l.Name(), Info, msg, args...)
 }
 
 // Emit the message and args at WARN level
 func (l *intLogger) Warn(msg string, args ...interface{}) {
-	l.Log(Warn, msg, args...)
+	l.log(l.Name(), Warn, msg, args...)
 }
 
 // Emit the message and args at ERROR level
 func (l *intLogger) Error(msg string, args ...interface{}) {
-	l.Log(Error, msg, args...)
+	l.log(l.Name(), Error, msg, args...)
 }
 
 // Indicate that the logger would emit TRACE level logs
@@ -435,15 +591,20 @@ func (l *intLogger) IsError() bool {
 	return Level(atomic.LoadInt32(l.level)) <= Error
 }
 
+const MissingKey = "EXTRA_VALUE_AT_END"
+
 // Return a sub-Logger for which every emitted log message will contain
 // the given key/value pairs. This is used to create a context specific
 // Logger.
 func (l *intLogger) With(args ...interface{}) Logger {
+	var extra interface{}
+
 	if len(args)%2 != 0 {
-		panic("With() call requires paired arguments")
+		extra = args[len(args)-1]
+		args = args[:len(args)-1]
 	}
 
-	sl := *l
+	sl := l.copy()
 
 	result := make(map[string]interface{}, len(l.implied)+len(args))
 	keys := make([]string, 0, len(l.implied)+len(args))
@@ -473,13 +634,17 @@ func (l *intLogger) With(args ...interface{}) Logger {
 		sl.implied = append(sl.implied, result[k])
 	}
 
-	return &sl
+	if extra != nil {
+		sl.implied = append(sl.implied, MissingKey, extra)
+	}
+
+	return sl
 }
 
 // Create a new sub-Logger that a name decending from the current name.
 // This is used to create a subsystem specific Logger.
 func (l *intLogger) Named(name string) Logger {
-	sl := *l
+	sl := l.copy()
 
 	if sl.name != "" {
 		sl.name = sl.name + "." + name
@@ -487,18 +652,53 @@ func (l *intLogger) Named(name string) Logger {
 		sl.name = name
 	}
 
-	return &sl
+	return sl
 }
 
 // Create a new sub-Logger with an explicit name. This ignores the current
 // name. This is used to create a standalone logger that doesn't fall
 // within the normal hierarchy.
 func (l *intLogger) ResetNamed(name string) Logger {
-	sl := *l
+	sl := l.copy()
 
 	sl.name = name
 
-	return &sl
+	return sl
+}
+
+func (l *intLogger) ResetOutput(opts *LoggerOptions) error {
+	if opts.Output == nil {
+		return errors.New("given output is nil")
+	}
+
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	return l.resetOutput(opts)
+}
+
+func (l *intLogger) ResetOutputWithFlush(opts *LoggerOptions, flushable Flushable) error {
+	if opts.Output == nil {
+		return errors.New("given output is nil")
+	}
+	if flushable == nil {
+		return errors.New("flushable is nil")
+	}
+
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if err := flushable.Flush(); err != nil {
+		return err
+	}
+
+	return l.resetOutput(opts)
+}
+
+func (l *intLogger) resetOutput(opts *LoggerOptions) error {
+	l.writer = newWriter(opts.Output, opts.Color)
+	l.setColorization(opts)
+	return nil
 }
 
 // Update the logging level on-the-fly. This will affect all subloggers as
@@ -519,9 +719,55 @@ func (l *intLogger) StandardLogger(opts *StandardLoggerOptions) *log.Logger {
 }
 
 func (l *intLogger) StandardWriter(opts *StandardLoggerOptions) io.Writer {
+	newLog := *l
+	if l.callerOffset > 0 {
+		// the stack is
+		// logger.printf() -> l.Output() ->l.out.writer(hclog:stdlogAdaptor.write) -> hclog:stdlogAdaptor.dispatch()
+		// So plus 4.
+		newLog.callerOffset = l.callerOffset + 4
+	}
 	return &stdlogAdapter{
-		log:         l,
-		inferLevels: opts.InferLevels,
-		forceLevel:  opts.ForceLevel,
+		log:                      &newLog,
+		inferLevels:              opts.InferLevels,
+		inferLevelsWithTimestamp: opts.InferLevelsWithTimestamp,
+		forceLevel:               opts.ForceLevel,
 	}
 }
+
+// checks if the underlying io.Writer is a file, and
+// panics if not. For use by colorization.
+func (l *intLogger) checkWriterIsFile() *os.File {
+	fi, ok := l.writer.w.(*os.File)
+	if !ok {
+		panic("Cannot enable coloring of non-file Writers")
+	}
+	return fi
+}
+
+// Accept implements the SinkAdapter interface
+func (i *intLogger) Accept(name string, level Level, msg string, args ...interface{}) {
+	i.log(name, level, msg, args...)
+}
+
+// ImpliedArgs returns the loggers implied args
+func (i *intLogger) ImpliedArgs() []interface{} {
+	return i.implied
+}
+
+// Name returns the loggers name
+func (i *intLogger) Name() string {
+	return i.name
+}
+
+// copy returns a shallow copy of the intLogger, replacing the level pointer
+// when necessary
+func (l *intLogger) copy() *intLogger {
+	sl := *l
+
+	if l.independentLevels {
+		sl.level = new(int32)
+		*sl.level = *l.level
+	}
+
+	return &sl
+}

vendor/github.com/hashicorp/go-hclog/logger.go

@@ -5,7 +5,7 @@ import (
 	"log"
 	"os"
 	"strings"
-	"sync"
+	"time"
 )
 
 var (
@@ -39,6 +39,9 @@ const (
 
 	// Error information about unrecoverable events.
 	Error Level = 5
+
+	// Off disables all logging output.
+	Off Level = 6
 )
 
 // Format is a simple convience type for when formatting is required. When
@@ -53,6 +56,39 @@ func Fmt(str string, args ...interface{}) Format {
 	return append(Format{str}, args...)
 }
 
+// A simple shortcut to format numbers in hex when displayed with the normal
+// text output. For example: L.Info("header value", Hex(17))
+type Hex int
+
+// A simple shortcut to format numbers in octal when displayed with the normal
+// text output. For example: L.Info("perms", Octal(17))
+type Octal int
+
+// A simple shortcut to format numbers in binary when displayed with the normal
+// text output. For example: L.Info("bits", Binary(17))
+type Binary int
+
+// A simple shortcut to format strings with Go quoting. Control and
+// non-printable characters will be escaped with their backslash equivalents in
+// output. Intended for untrusted or multiline strings which should be logged
+// as concisely as possible.
+type Quote string
+
+// ColorOption expresses how the output should be colored, if at all.
+type ColorOption uint8
+
+const (
+	// ColorOff is the default coloration, and does not
+	// inject color codes into the io.Writer.
+	ColorOff ColorOption = iota
+	// AutoColor checks if the io.Writer is a tty,
+	// and if so enables coloring.
+	AutoColor
+	// ForceColor will enable coloring, regardless of whether
+	// the io.Writer is a tty or not.
+	ForceColor
+)
+
 // LevelFromString returns a Level type for the named log level, or "NoLevel" if
 // the level string is invalid. This facilitates setting the log level via
 // config or environment variable by name in a predictable way.
@@ -70,16 +106,42 @@ func LevelFromString(levelStr string) Level {
 		return Warn
 	case "error":
 		return Error
+	case "off":
+		return Off
 	default:
 		return NoLevel
 	}
 }
 
+func (l Level) String() string {
+	switch l {
+	case Trace:
+		return "trace"
+	case Debug:
+		return "debug"
+	case Info:
+		return "info"
+	case Warn:
+		return "warn"
+	case Error:
+		return "error"
+	case NoLevel:
+		return "none"
+	case Off:
+		return "off"
+	default:
+		return "unknown"
+	}
+}
+
 // Logger describes the interface that must be implemeted by all loggers.
 type Logger interface {
 	// Args are alternating key, val pairs
 	// keys must be strings
 	// vals can be any type, but display is implementation specific
+	// Emit a message and key/value pairs at a provided log level
+	Log(level Level, msg string, args ...interface{})
+
 	// Emit a message and key/value pairs at the TRACE level
 	Trace(msg string, args ...interface{})
 
@@ -111,9 +173,15 @@ type Logger interface {
 	// Indicate if ERROR logs would be emitted. This and the other Is* guards
 	IsError() bool
 
+	// ImpliedArgs returns With key/value pairs
+	ImpliedArgs() []interface{}
+
 	// Creates a sublogger that will always have the given key/value pairs
 	With(args ...interface{}) Logger
 
+	// Returns the Name of the logger
+	Name() string
+
 	// Create a logger that will prepend the name string on the front of all messages.
 	// If the logger already has a name, the new value will be appended to the current
 	// name. That way, a major subsystem can use this to decorate all it's own logs
@@ -125,7 +193,8 @@ type Logger interface {
 	// the current name as well.
 	ResetNamed(name string) Logger
 
-	// Updates the level. This should affect all sub-loggers as well. If an
+	// Updates the level. This should affect all related loggers as well,
+	// unless they were created with IndependentLevels. If an
 	// implementation cannot update the level on the fly, it should no-op.
 	SetLevel(level Level)
 
@@ -144,6 +213,15 @@ type StandardLoggerOptions struct {
 	// [DEBUG] and strip it off before reapplying it.
 	InferLevels bool
 
+	// Indicate that some minimal parsing should be done on strings to try
+	// and detect their level and re-emit them while ignoring possible
+	// timestamp values in the beginning of the string.
+	// This supports the strings like [ERROR], [ERR] [TRACE], [WARN], [INFO],
+	// [DEBUG] and strip it off before reapplying it.
+	// The timestamp detection may result in false positives and incomplete
+	// string outputs.
+	InferLevelsWithTimestamp bool
+
 	// ForceLevel is used to force all output from the standard logger to be at
 	// the specified level. Similar to InferLevels, this will strip any level
 	// prefix contained in the logged string before applying the forced level.
@@ -151,6 +229,8 @@ type StandardLoggerOptions struct {
 	ForceLevel Level
 }
 
+type TimeFunction = func() time.Time
+
 // LoggerOptions can be used to configure a new logger.
 type LoggerOptions struct {
 	// Name of the subsystem to prefix logs with
@@ -162,8 +242,10 @@ type LoggerOptions struct {
 	// Where to write the logs to. Defaults to os.Stderr if nil
 	Output io.Writer
 
-	// An optional mutex pointer in case Output is shared
-	Mutex *sync.Mutex
+	// An optional Locker in case Output is shared. This can be a sync.Mutex or
+	// a NoopLocker if the caller wants control over output, e.g. for batching
+	// log lines.
+	Mutex Locker
 
 	// Control if the output should be in JSON.
 	JSONFormat bool
@@ -171,6 +253,117 @@ type LoggerOptions struct {
 	// Include file and line information in each log line
 	IncludeLocation bool
 
+	// AdditionalLocationOffset is the number of additional stack levels to skip
+	// when finding the file and line information for the log line
+	AdditionalLocationOffset int
+
 	// The time format to use instead of the default
 	TimeFormat string
+
+	// A function which is called to get the time object that is formatted using `TimeFormat`
+	TimeFn TimeFunction
+
+	// Control whether or not to display the time at all. This is required
+	// because setting TimeFormat to empty assumes the default format.
+	DisableTime bool
+
+	// Color the output. On Windows, colored logs are only avaiable for io.Writers that
+	// are concretely instances of *os.File.
+	Color ColorOption
+
+	// Only color the header, not the body. This can help with readability of long messages.
+	ColorHeaderOnly bool
+
+	// A function which is called with the log information and if it returns true the value
+	// should not be logged.
+	// This is useful when interacting with a system that you wish to suppress the log
+	// message for (because it's too noisy, etc)
+	Exclude func(level Level, msg string, args ...interface{}) bool
+
+	// IndependentLevels causes subloggers to be created with an independent
+	// copy of this logger's level. This means that using SetLevel on this
+	// logger will not effect any subloggers, and SetLevel on any subloggers
+	// will not effect the parent or sibling loggers.
+	IndependentLevels bool
 }
+
+// InterceptLogger describes the interface for using a logger
+// that can register different output sinks.
+// This is useful for sending lower level log messages
+// to a different output while keeping the root logger
+// at a higher one.
+type InterceptLogger interface {
+	// Logger is the root logger for an InterceptLogger
+	Logger
+
+	// RegisterSink adds a SinkAdapter to the InterceptLogger
+	RegisterSink(sink SinkAdapter)
+
+	// DeregisterSink removes a SinkAdapter from the InterceptLogger
+	DeregisterSink(sink SinkAdapter)
+
+	// Create a interceptlogger that will prepend the name string on the front of all messages.
+	// If the logger already has a name, the new value will be appended to the current
+	// name. That way, a major subsystem can use this to decorate all it's own logs
+	// without losing context.
+	NamedIntercept(name string) InterceptLogger
+
+	// Create a interceptlogger that will prepend the name string on the front of all messages.
+	// This sets the name of the logger to the value directly, unlike Named which honor
+	// the current name as well.
+	ResetNamedIntercept(name string) InterceptLogger
+
+	// Deprecated: use StandardLogger
+	StandardLoggerIntercept(opts *StandardLoggerOptions) *log.Logger
+
+	// Deprecated: use StandardWriter
+	StandardWriterIntercept(opts *StandardLoggerOptions) io.Writer
+}
+
+// SinkAdapter describes the interface that must be implemented
+// in order to Register a new sink to an InterceptLogger
+type SinkAdapter interface {
+	Accept(name string, level Level, msg string, args ...interface{})
+}
+
+// Flushable represents a method for flushing an output buffer. It can be used
+// if Resetting the log to use a new output, in order to flush the writes to
+// the existing output beforehand.
+type Flushable interface {
+	Flush() error
+}
+
+// OutputResettable provides ways to swap the output in use at runtime
+type OutputResettable interface {
+	// ResetOutput swaps the current output writer with the one given in the
+	// opts. Color options given in opts will be used for the new output.
+	ResetOutput(opts *LoggerOptions) error
+
+	// ResetOutputWithFlush swaps the current output writer with the one given
+	// in the opts, first calling Flush on the given Flushable. Color options
+	// given in opts will be used for the new output.
+	ResetOutputWithFlush(opts *LoggerOptions, flushable Flushable) error
+}
+
+// Locker is used for locking output. If not set when creating a logger, a
+// sync.Mutex will be used internally.
+type Locker interface {
+	// Lock is called when the output is going to be changed or written to
+	Lock()
+
+	// Unlock is called when the operation that called Lock() completes
+	Unlock()
+}
+
+// NoopLocker implements locker but does nothing. This is useful if the client
+// wants tight control over locking, in order to provide grouping of log
+// entries or other functionality.
+type NoopLocker struct{}
+
+// Lock does nothing
+func (n NoopLocker) Lock() {}
+
+// Unlock does nothing
+func (n NoopLocker) Unlock() {}
+
+var _ Locker = (*NoopLocker)(nil)

vendor/github.com/hashicorp/go-hclog/nulllogger.go

@@ -15,6 +15,8 @@ func NewNullLogger() Logger {
 
 type nullLogger struct{}
 
+func (l *nullLogger) Log(level Level, msg string, args ...interface{}) {}
+
 func (l *nullLogger) Trace(msg string, args ...interface{}) {}
 
 func (l *nullLogger) Debug(msg string, args ...interface{}) {}
@@ -35,8 +37,12 @@ func (l *nullLogger) IsWarn() bool { return false }
 
 func (l *nullLogger) IsError() bool { return false }
 
+func (l *nullLogger) ImpliedArgs() []interface{} { return []interface{}{} }
+
 func (l *nullLogger) With(args ...interface{}) Logger { return l }
 
+func (l *nullLogger) Name() string { return "" }
+
 func (l *nullLogger) Named(name string) Logger { return l }
 
 func (l *nullLogger) ResetNamed(name string) Logger { return l }

vendor/github.com/hashicorp/go-hclog/stdlog.go

@@ -2,16 +2,23 @@ package hclog
 
 import (
 	"bytes"
+	"log"
+	"regexp"
 	"strings"
 )
 
+// Regex to ignore characters commonly found in timestamp formats from the
+// beginning of inputs.
+var logTimestampRegexp = regexp.MustCompile(`^[\d\s\:\/\.\+-TZ]*`)
+
 // Provides a io.Writer to shim the data out of *log.Logger
 // and back into our Logger. This is basically the only way to
 // build upon *log.Logger.
 type stdlogAdapter struct {
-	log         Logger
-	inferLevels bool
-	forceLevel  Level
+	log                      Logger
+	inferLevels              bool
+	inferLevelsWithTimestamp bool
+	forceLevel               Level
 }
 
 // Take the data, infer the levels if configured, and send it through
@@ -25,36 +32,14 @@ func (s *stdlogAdapter) Write(data []byte) (int, error) {
 		_, str := s.pickLevel(str)
 
 		// Log at the forced level
-		switch s.forceLevel {
-		case Trace:
-			s.log.Trace(str)
-		case Debug:
-			s.log.Debug(str)
-		case Info:
-			s.log.Info(str)
-		case Warn:
-			s.log.Warn(str)
-		case Error:
-			s.log.Error(str)
-		default:
-			s.log.Info(str)
-		}
+		s.dispatch(str, s.forceLevel)
 	} else if s.inferLevels {
-		level, str := s.pickLevel(str)
-		switch level {
-		case Trace:
-			s.log.Trace(str)
-		case Debug:
-			s.log.Debug(str)
-		case Info:
-			s.log.Info(str)
-		case Warn:
-			s.log.Warn(str)
-		case Error:
-			s.log.Error(str)
-		default:
-			s.log.Info(str)
+		if s.inferLevelsWithTimestamp {
+			str = s.trimTimestamp(str)
 		}
+
+		level, str := s.pickLevel(str)
+		s.dispatch(str, level)
 	} else {
 		s.log.Info(str)
 	}
@@ -62,6 +47,23 @@ func (s *stdlogAdapter) Write(data []byte) (int, error) {
 	return len(data), nil
 }
 
+func (s *stdlogAdapter) dispatch(str string, level Level) {
+	switch level {
+	case Trace:
+		s.log.Trace(str)
+	case Debug:
+		s.log.Debug(str)
+	case Info:
+		s.log.Info(str)
+	case Warn:
+		s.log.Warn(str)
+	case Error:
+		s.log.Error(str)
+	default:
+		s.log.Info(str)
+	}
+}
+
 // Detect, based on conventions, what log level this is.
 func (s *stdlogAdapter) pickLevel(str string) (Level, string) {
 	switch {
@@ -72,7 +74,7 @@ func (s *stdlogAdapter) pickLevel(str string) (Level, string) {
 	case strings.HasPrefix(str, "[INFO]"):
 		return Info, strings.TrimSpace(str[6:])
 	case strings.HasPrefix(str, "[WARN]"):
-		return Warn, strings.TrimSpace(str[7:])
+		return Warn, strings.TrimSpace(str[6:])
 	case strings.HasPrefix(str, "[ERROR]"):
 		return Error, strings.TrimSpace(str[7:])
 	case strings.HasPrefix(str, "[ERR]"):
@@ -81,3 +83,28 @@ func (s *stdlogAdapter) pickLevel(str string) (Level, string) {
 		return Info, str
 	}
 }
+
+func (s *stdlogAdapter) trimTimestamp(str string) string {
+	idx := logTimestampRegexp.FindStringIndex(str)
+	return str[idx[1]:]
+}
+
+type logWriter struct {
+	l *log.Logger
+}
+
+func (l *logWriter) Write(b []byte) (int, error) {
+	l.l.Println(string(bytes.TrimRight(b, " \n\t")))
+	return len(b), nil
+}
+
+// Takes a standard library logger and returns a Logger that will write to it
+func FromStandardLogger(l *log.Logger, opts *LoggerOptions) Logger {
+	var dl LoggerOptions = *opts
+
+	// Use the time format that log.Logger uses
+	dl.DisableTime = true
+	dl.Output = &logWriter{l}
+
+	return New(&dl)
+}

vendor/github.com/hashicorp/go-hclog/writer.go

@@ -6,19 +6,27 @@ import (
 )
 
 type writer struct {
-	b bytes.Buffer
-	w io.Writer
+	b     bytes.Buffer
+	w     io.Writer
+	color ColorOption
 }
 
-func newWriter(w io.Writer) *writer {
-	return &writer{w: w}
+func newWriter(w io.Writer, color ColorOption) *writer {
+	return &writer{w: w, color: color}
 }
 
 func (w *writer) Flush(level Level) (err error) {
+	var unwritten = w.b.Bytes()
+
+	if w.color != ColorOff {
+		color := _levelToColor[level]
+		unwritten = []byte(color.Sprintf("%s", unwritten))
+	}
+
 	if lw, ok := w.w.(LevelWriter); ok {
-		_, err = lw.LevelWrite(level, w.b.Bytes())
+		_, err = lw.LevelWrite(level, unwritten)
 	} else {
-		_, err = w.w.Write(w.b.Bytes())
+		_, err = w.w.Write(unwritten)
 	}
 	w.b.Reset()
 	return err