go原生log模块的简易封装

package main
import (
  "fmt"
  "io/ioutil"
  "log"
  "mime/multipart"
  "os"
  "path"
)
// Level These are the integer logging levels used by the logger
type Level int
// Comment
const (
  DEBUG Level = iota
  INFO
  WARNING
  ERROR
  FATAL
)
var (
  logPrefix  = ""
  levelFlags = []string{"DEBG", "INFO", "WARN", "ERRO", "FATL"}
  logger  *log.Logger
  loggerf *log.Logger
  // curLevel ...
  curLevel Level
  //
  logfile *os.File
)
func init() {
  curLevel = DEBUG
  logger = log.New(os.Stdout, "[default] ", log.LstdFlags)
  logger.SetFlags(log.Ldate | log.Lmicroseconds | log.Llongfile)
}
// Println ..
func Println(l *log.Logger, v ...interface{}) {
  if l != nil {
    l.Output(3, fmt.Sprintln(v...))
  }
}
// Fatalln is equivalent to l.Println() followed by a call to os.Exit(1).
func Fatalln(l *log.Logger, v ...interface{}) {
  if l != nil {
    l.Output(3, fmt.Sprintln(v...))
    os.Exit(1)
  }
}
// Debug ...
func Debug(v ...interface{}) {
  setPrefix(DEBUG)
  if DEBUG >= curLevel {
    Println(logger, v)
    Println(loggerf, v)
  }
}
// Info ...
func Info(v ...interface{}) {
  setPrefix(INFO)
  if INFO >= curLevel {
    Println(logger, v)
    Println(loggerf, v)
  }
}
// Warn ...
func Warn(v ...interface{}) {
  setPrefix(WARNING)
  if WARNING >= curLevel {
    Println(logger, v)
    Println(loggerf, v)
  }
}
// Error Warn
func Error(v ...interface{}) {
  setPrefix(ERROR)
  if ERROR >= curLevel {
    Println(logger, v)
    Println(loggerf, v)
  }
}
// Fatal ...
func Fatal(v ...interface{}) {
  setPrefix(FATAL)
  if FATAL >= curLevel {
    Fatalln(logger, v)
    Fatalln(loggerf, v)
  }
}
func setPrefix(level Level) {
  logPrefix = fmt.Sprintf("[%s] ", levelFlags[level])
  logger.SetPrefix(logPrefix)
  if loggerf != nil {
    loggerf.SetPrefix(logPrefix)
  }
}
// Config ..
func Config(level Level, lfile *os.File) {
  curLevel = level
  loggerf = log.New(lfile, "[default] ", log.LstdFlags)
  loggerf.SetFlags(log.Ldate | log.Lmicroseconds | log.Llongfile)
}
func main() {
  lgfile, err := MustOpen("log.txt", "mylog1/")
  if err != nil {
    Error("Failed to open log file:" + err.Error())
  }
  Config(DEBUG, lgfile)
  Debug("message")
  Info("message")
  Warn("message")
  Error("message")
}

func GetSize(f multipart.File) (int, error) {
  content, err := ioutil.ReadAll(f)
  return len(content), err
}
func GetExt(fileName string) string {
  return path.Ext(fileName)
}
func CheckNotExist(src string) bool {
  _, err := os.Stat(src)
  return os.IsNotExist(err)
}
func CheckPermission(src string) bool {
  _, err := os.Stat(src)
  return os.IsPermission(err)
}
func IsNotExistMkDir(src string) error {
  if notExist := CheckNotExist(src); notExist == true {
    if err := MkDir(src); err != nil {
      return err
    }
  }
  return nil
}
func MkDir(src string) error {
  err := os.MkdirAll(src, os.ModePerm)
  if err != nil {
    return err
  }
  return nil
}
func Open(name string, flag int, perm os.FileMode) (*os.File, error) {
  f, err := os.OpenFile(name, flag, perm)
  if err != nil {
    return nil, err
  }
  return f, nil
}
func MustOpen(fileName, filePath string) (*os.File, error) {
  dir, err := os.Getwd()
  if err != nil {
    return nil, fmt.Errorf("os.Getwd err: %v", err)
  }
  src := dir + "/" + filePath
  perm := CheckPermission(src)
  if perm == true {
    return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
  }
  err = IsNotExistMkDir(src)
  if err != nil {
    return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
  }
  f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
  if err != nil {
    return nil, fmt.Errorf("Fail to OpenFile :%v", err)
  }
  return f, nil
}