func (l *Logger) InstallStd(logger StdLogger) {
	l.Handle(integrateStdLogger(logger))
}
InstallStd receives  a standard logger
and automatically adapts its print functions.

Install adds a golog handler to support third-party integrations,
it can be used only once per `golog#Logger` instance.

Example Code:
import "log"
myLogger := log.New(os.Stdout, "", 0)
InstallStd(myLogger)

Look `golog#Logger.Handle` for more.
package golog
import (
	"fmt"
	"io"
	"os"
	"sync"
	"time"
	"github.com/kataras/pio"
)
type Handler func(value *Log) (handled bool)
type Logger struct {
	Prefix     []byte
	Level      Level
	TimeFormat string
	NewLine  bool
	mu       sync.Mutex
	Printer  *pio.Printer
	handlers []Handler
	once     sync.Once
	logs     sync.Pool
	children *loggerMap
}
func New() *Logger {
	return &Logger{
		Level:      InfoLevel,
		TimeFormat: "2006/01/02 15:04",
		NewLine:    true,
		Printer:    pio.NewPrinter("", os.Stdout).EnableDirectOutput().Hijack(logHijacker),
		children:   newLoggerMap(),
	}
}
func (l *Logger) acquireLog(level Level, msg string, withPrintln bool) *Log {
	log, ok := l.logs.Get().(*Log)
	if !ok {
		log = &Log{
			Logger: l,
		}
	}
	log.NewLine = withPrintln
	log.Time = time.Now()
	log.Level = level
	log.Message = msg
	return log
}
func (l *Logger) releaseLog(log *Log) {
	l.logs.Put(log)
}
var logHijacker = func(ctx *pio.Ctx) {
	l, ok := ctx.Value.(*Log)
	if !ok {
		ctx.Next()
		return
	}
	line := GetTextForLevel(l.Level, ctx.Printer.IsTerminal)
	if line != "" {
		line += " "
	}
	if t := l.FormatTime(); t != "" {
		line += t + " "
	}
	line += l.Message
	var b []byte
	if pref := l.Logger.Prefix; len(pref) > 0 {
		b = append(pref, []byte(line)...)
	} else {
		b = []byte(line)
	}
	ctx.Store(b, nil)
	ctx.Next()
}
var NopOutput = pio.NopOutput()
func (l *Logger) SetOutput(w io.Writer) *Logger {
	l.Printer.SetOutput(w)
	return l
}
func (l *Logger) AddOutput(writers ...io.Writer) *Logger {
	l.Printer.AddOutput(writers...)
	return l
}
func (l *Logger) SetPrefix(s string) *Logger {
	l.mu.Lock()
	l.Prefix = []byte(s)
	l.mu.Unlock()
	return l
}
func (l *Logger) SetTimeFormat(s string) *Logger {
	l.mu.Lock()
	l.TimeFormat = s
	l.mu.Unlock()
	return l
}
func (l *Logger) DisableNewLine() *Logger {
	l.mu.Lock()
	l.NewLine = false
	l.mu.Unlock()
	return l
}
func (l *Logger) SetLevel(levelName string) *Logger {
	l.mu.Lock()
	l.Level = fromLevelName(levelName)
	l.mu.Unlock()
	return l
}
func (l *Logger) print(level Level, msg string, newLine bool) {
	if l.Level >= level {
		log := l.acquireLog(level, msg, newLine)
		if !l.handled(log) {
			if newLine {
				l.Printer.Println(log)
			} else {
				l.Printer.Print(log)
			}
		}
		l.releaseLog(log)
	}
	if level == FatalLevel {
		os.Exit(1)
	}
}
func (l *Logger) Print(v ...interface{}) {
	l.print(DisableLevel, fmt.Sprint(v...), l.NewLine)
}
func (l *Logger) Printf(format string, args ...interface{}) {
	l.print(DisableLevel, fmt.Sprintf(format, args...), l.NewLine)
}
func (l *Logger) Println(v ...interface{}) {
	l.print(DisableLevel, fmt.Sprint(v...), true)
}
func (l *Logger) Log(level Level, v ...interface{}) {
	l.print(level, fmt.Sprint(v...), l.NewLine)
}
func (l *Logger) Logf(level Level, format string, args ...interface{}) {
	msg := fmt.Sprintf(format, args...)
	l.Log(level, msg)
}
func (l *Logger) Fatal(v ...interface{}) {
	l.Log(FatalLevel, v...)
}
func (l *Logger) Fatalf(format string, args ...interface{}) {
	msg := fmt.Sprintf(format, args...)
	l.Fatal(msg)
}
func (l *Logger) Error(v ...interface{}) {
	l.Log(ErrorLevel, v...)
}
func (l *Logger) Errorf(format string, args ...interface{}) {
	msg := fmt.Sprintf(format, args...)
	l.Error(msg)
}
func (l *Logger) Warn(v ...interface{}) {
	l.Log(WarnLevel, v...)
}
func (l *Logger) Warnf(format string, args ...interface{}) {
	msg := fmt.Sprintf(format, args...)
	l.Warn(msg)
}
func (l *Logger) Info(v ...interface{}) {
	l.Log(InfoLevel, v...)
}
func (l *Logger) Infof(format string, args ...interface{}) {
	msg := fmt.Sprintf(format, args...)
	l.Info(msg)
}
func (l *Logger) Debug(v ...interface{}) {
	l.Log(DebugLevel, v...)
}
func (l *Logger) Debugf(format string, args ...interface{}) {
	if l.Level >= DebugLevel {
		msg := fmt.Sprintf(format, args...)
		l.Debug(msg)
	}
}
func (l *Logger) Install(logger ExternalLogger) {
	l.Handle(integrateExternalLogger(logger))
}