func LazyHandler(h LogHandler) LogHandler {
	return FuncHandler(func(r *Record) error {
		for k, v := range r.Context {
			if lz, ok := v.(Lazy); ok {
				value, err := evaluateLazy(lz)
				if err != nil {
					r.Context[errorKey] = "bad lazy " + k
				} else {
					v = value
				}
			}
		}
		return h.Log(r)
	})
}
LazyHandler writes all values to the wrapped handler after evaluating
any lazy functions in the record's context. It is already wrapped
around StreamHandler and SyslogHandler in this library, you'll only need
it if you write your own Handler.
package logger
import (
	"fmt"
	"reflect"
	"sync"
	"time"
)
func FuncHandler(fn func(r *Record) error) LogHandler {
	return funcHandler(fn)
}
type funcHandler func(r *Record) error
func (h funcHandler) Log(r *Record) error {
	return h(r)
}
func HandlerFunc(log func(message string, time time.Time, level LogLevel, call CallStack, context ContextMap) error) LogHandler {
	return remoteHandler(log)
}
type remoteHandler func(message string, time time.Time, level LogLevel, call CallStack, context ContextMap) error
func (c remoteHandler) Log(record *Record) error {
	return c(record.Message, record.Time, record.Level, record.Call, record.Context)
}
func SyncHandler(h LogHandler) LogHandler {
	var mu sync.Mutex
	return FuncHandler(func(r *Record) error {
		defer mu.Unlock()
		mu.Lock()
		return h.Log(r)
	})
}