func (z *intLogger) IsWarn() bool {
	return z.level <= Warn
}
Indicate that the logger would emit WARN level logs
package hclog
import (
	"bufio"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"
)
var (
	_levelToBracket = map[Level]string{
		Debug: "[DEBUG]",
		Trace: "[TRACE]",
		Info:  "[INFO ]",
		Warn:  "[WARN ]",
		Error: "[ERROR]",
	}
)
func New(opts *LoggerOptions) Logger {
	if opts == nil {
		opts = &LoggerOptions{}
	}
	output := opts.Output
	if output == nil {
		output = os.Stderr
	}
	level := opts.Level
	if level == NoLevel {
		level = DefaultLevel
	}
	return &intLogger{
		m:      new(sync.Mutex),
		json:   opts.JSONFormat,
		caller: opts.IncludeLocation,
		name:   opts.Name,
		w:      bufio.NewWriter(output),
		level:  level,
	}
}
type intLogger struct {
	json   bool
	caller bool
	name   string
	m     *sync.Mutex
	w     *bufio.Writer
	level Level
	implied []interface{}
}
var _ Logger = &intLogger{}
const TimeFormat = "2006-01-02T15:04:05.000Z0700"
func (z *intLogger) Log(level Level, msg string, args ...interface{}) {
	if level < z.level {
		return
	}
	t := time.Now()
	z.m.Lock()
	defer z.m.Unlock()
	if z.json {
		z.logJson(t, level, msg, args...)
	} else {
		z.log(t, level, msg, args...)
	}
	z.w.Flush()
}
func trimCallerPath(path string) string {
	idx := strings.LastIndexByte(path, '/')
	if idx == -1 {
		return path
	}
	idx = strings.LastIndexByte(path[:idx], '/')
	if idx == -1 {
		return path
	}
	return path[idx+1:]
}
func (z *intLogger) log(t time.Time, level Level, msg string, args ...interface{}) {
	z.w.WriteString(t.Format(TimeFormat))
	z.w.WriteByte(' ')
	s, ok := _levelToBracket[level]
	if ok {
		z.w.WriteString(s)
	} else {
		z.w.WriteString("[UNKN ]")
	}
	if z.caller {
		if _, file, line, ok := runtime.Caller(3); ok {
			z.w.WriteByte(' ')
			z.w.WriteString(trimCallerPath(file))
			z.w.WriteByte(':')
			z.w.WriteString(strconv.Itoa(line))
			z.w.WriteByte(':')
		}
	}
	z.w.WriteByte(' ')
	if z.name != "" {
		z.w.WriteString(z.name)
		z.w.WriteString(": ")
	}
	z.w.WriteString(msg)
	args = append(z.implied, args...)
	var stacktrace CapturedStacktrace
	if args != nil && len(args) > 0 {
		if len(args)%2 != 0 {
			cs, ok := args[len(args)-1].(CapturedStacktrace)
			if ok {
				args = args[:len(args)-1]
				stacktrace = cs
			} else {
				args = append(args, "<unknown>")
			}
		}
		z.w.WriteByte(':')
	FOR:
		for i := 0; i < len(args); i = i + 2 {
			var val string
			switch st := args[i+1].(type) {
			case string:
				val = st
			case int:
				val = strconv.FormatInt(int64(st), 10)
			case int64:
				val = strconv.FormatInt(int64(st), 10)
			case int32:
				val = strconv.FormatInt(int64(st), 10)
			case int16:
				val = strconv.FormatInt(int64(st), 10)
			case int8:
				val = strconv.FormatInt(int64(st), 10)
			case uint:
				val = strconv.FormatUint(uint64(st), 10)
			case uint64:
				val = strconv.FormatUint(uint64(st), 10)
			case uint32:
				val = strconv.FormatUint(uint64(st), 10)
			case uint16:
				val = strconv.FormatUint(uint64(st), 10)
			case uint8:
				val = strconv.FormatUint(uint64(st), 10)
			case CapturedStacktrace:
				stacktrace = st
				continue FOR
			default:
				val = fmt.Sprintf("%v", st)
			}
			z.w.WriteByte(' ')
			z.w.WriteString(args[i].(string))
			z.w.WriteByte('=')
			if strings.ContainsAny(val, " \t\n\r") {
				z.w.WriteByte('"')
				z.w.WriteString(val)
				z.w.WriteByte('"')
			} else {
				z.w.WriteString(val)
			}
		}
	}
	z.w.WriteString("\n")
	if stacktrace != "" {
		z.w.WriteString(string(stacktrace))
	}
}
func (z *intLogger) logJson(t time.Time, level Level, msg string, args ...interface{}) {
	vals := map[string]interface{}{
		"@message":   msg,
		"@timestamp": t.Format("2006-01-02T15:04:05.000000Z07:00"),
	}
	var levelStr string
	switch level {
	case Error:
		levelStr = "error"
	case Warn:
		levelStr = "warn"
	case Info:
		levelStr = "info"
	case Debug:
		levelStr = "debug"
	case Trace:
		levelStr = "trace"
	default:
		levelStr = "all"
	}
	vals["@level"] = levelStr
	if z.name != "" {
		vals["@module"] = z.name
	}
	if z.caller {
		if _, file, line, ok := runtime.Caller(3); ok {
			vals["@caller"] = fmt.Sprintf("%s:%d", file, line)
		}
	}
	if args != nil && len(args) > 0 {
		if len(args)%2 != 0 {
			cs, ok := args[len(args)-1].(CapturedStacktrace)
			if ok {
				args = args[:len(args)-1]
				vals["stacktrace"] = cs
			} else {
				args = append(args, "<unknown>")
			}
		}
		for i := 0; i < len(args); i = i + 2 {
			if _, ok := args[i].(string); !ok {
				continue
			}
			vals[args[i].(string)] = args[i+1]
		}
	}
	err := json.NewEncoder(z.w).Encode(vals)
	if err != nil {
		panic(err)
	}
}
func (z *intLogger) Debug(msg string, args ...interface{}) {
	z.Log(Debug, msg, args...)
}
func (z *intLogger) Trace(msg string, args ...interface{}) {
	z.Log(Trace, msg, args...)
}
func (z *intLogger) Info(msg string, args ...interface{}) {
	z.Log(Info, msg, args...)
}
func (z *intLogger) Warn(msg string, args ...interface{}) {
	z.Log(Warn, msg, args...)
}
func (z *intLogger) Error(msg string, args ...interface{}) {
	z.Log(Error, msg, args...)
}
func (z *intLogger) IsTrace() bool {
	return z.level == Trace
}
func (z *intLogger) IsDebug() bool {
	return z.level <= Debug
}
func (z *intLogger) IsInfo() bool {
	return z.level <= Info
}