Knowledge log log

demo_log Package 

Import ( 
   "FMT" 
   "log" 
   "OS" 
   "path / filepath" 
   "Runtime" 
   "strings" 
   "Time" 
) 

FUNC main () { 
   const ( 
      info = IOTA 
      The warn 
      error 
      fatal 
   ) 
   // The first method will be printed information is written to the file 
   //logrus.Println ( "Print log information") 
   //logrus.Panicln ( "Print panic log information") 
   //logrus.Fatal ( "Fatal Print log information") // with automatic exit feature 
   / / AA: = "C: \\ \\ 10,241,874 the Users the src \\ \\ \\ Go awesomeProject the src \\ \\ \\ log.txt the Log" 
   //fmt.Println(aa) 
   // F, _: OS = .OpenFile (aa, os.O_APPEND | os.O_CREATE,0777)
   //Logger := log.New(f, "[info]", log.Ltime)
   //Logger.Println("dayinkaishi ") 
   //f.Close () 

   // The second way to print information written to a file (see the proposal directly src / log folder log.go file) 
   AA: =" C : 10,241,874 \\ \\ \\ Go the Users \\ src \\ src \\ \\ awesomeProject log_ the Log \\ "+ Time.now () the Format. (" 2006-01-02 ") +" .txt " 
   fmt. println (AA) 
   fmt.Println (The warn, error, fatal) 
   f, _: = os.OpenFile (AA, os.O_APPEND | os.O_CREATE, 0777) 
   f.WriteString ( "dayinkaishi") 
   f.close () 

   call0 ( "") 
} 

//log.SetOutput(file) // set the output stream 
//log.SetPrefix("[Error] ") // log prefix 
//log.SetFlags(log.Llongfile | log.Ldate | log.Ltime ) // log output style 
FUNC call0 (funcname String) { 
   PC, filename, Line, OK: = Runtime.Caller (1) // and the information corresponding to the output layer 
   if ok {
      funcname = runtime.FuncForPC(pc).Name() //FuncForPC（）返回函数的指针类型
      log.Println("00", funcname)
      funcname = filepath.Ext(funcname) //删除.之前的部分
      log.Println("11", funcname)
      funcname = strings.TrimPrefix(funcname, ".")
      log.Println("22", funcname)

      filename = filepath.Base(filename)
   }
   logPrefix := fmt.Sprintf("%s %d %s ", filename, line, funcname)
   log.Println(logPrefix)
   log.Println(pc)
}





log.go

package log

import (
   "fmt"
   "log"
   "os"
   "path/filepath"
   "strings"
   //"sync"
   "runtime"
   "time"
)

const (
   debug = iota
   info
   warn
   error
   fatal
)

type Log struct {
   logLevel int

   logChannel chan string
}

var (
   logObj             = Log{logLevel: info, logChannel: make(chan string, 1024)}
   levelMap           = make(map[string]int)
   levelStrMap        = make(map[int]string)
   LogPath     string = "../log/"Under // windows debug mode FUNC initLevelMap () {
)


   levelMap["fatal"] = fatal
   levelMap["error"] = error
   levelMap["warn"] = warn
   levelMap["info"] = info
   levelMap["debug"] = debug

   levelStrMap[fatal] = "fatal"
   levelStrMap[error] = "error"
   levelStrMap[warn] = "warn"
   levelStrMap[info] = "info"
   levelStrMap[debug] = "debug"
   if strings.Contains(runtime.GOOS, "linux") {
      //linux 发布模式
      LogPath = `/home/parameterCheckww/parameterCheckService2/src/log/`
   }
}

func init() {
   initLevelMap()
}

func Fatal(v ...interface{}) {
   logObj.Fatal(v...)
}

func Error(v ...interface{}) {
   logObj.Error(v...)
}

func Warn(v ...interface{}) {
   logObj.Warn(v...)
}

func Info(v ...interface{}) {
   logObj.Info(v...)
}

func Debug(v ...interface{}) {
   logObj.Debug(v...)
}

func SetLogLevel(level string) {
   logObj.SetLogLevel(level)

}
func GetLogLevel() int {
   return logObj.GetLogLevel()
}

func RunLogFileThread() {

   logObj.RunLogFileThread()
}

func (self *Log) SetLogLevel(level string) {
   _, ok := levelMap[level]
   if ok {
      self.logLevel = levelMap[level]
      log.Println("logLevel has changed:" + level)
   } else {
      log.Println("loglevel is error")
   }

}
func (self *Log) GetLogLevel() int {
   return self.logLevel
}

func (self *Log) Fatal(v ...interface{}) {
   self.printWithCheckLevel(fatal, v...)
}

func (self *Log) Error(v ...interface{}) {
   self.printWithCheckLevel(error, v...)
}

func (self *Log) Warn(v ...interface{}) {
   self.printWithCheckLevel(warn, v...)
}

func (self *Log) Info(v ...interface{}) {
   self.printWithCheckLevel(info, v...)
}

func (self *Log) Debug(v ...interface{}) {
   self.printWithCheckLevel(debug, v...)
}

func (self *Log) printWithCheckLevel(logLevel int, v ...interface{}) {
   if self.logLevel > logLevel {
      self.logChannel <- ""
      return
   }

   filename, line, funcname := "???", 0, "???"
   pc, filename, line, ok := runtime.Caller(3)
   if ok {
      funcname = runtime.FuncForPC(pc).Name()
      funcname = filepath.Ext(funcname)
      funcname = strings.TrimPrefix(funcname, ".")

      filename = filepath.Base(filename)
   }
   logPrefix := fmt.Sprintf("%s %s %d %s", time.Now().Format("2006-01-02 15:04:05.000"), filename, line, funcname)

   str := strings.TrimRight(strings.TrimPrefix(strings.TrimSpace(fmt.Sprintln(v)), "["), "]")
   str = logPrefix + "[" + levelStrMap[logLevel] + "] " + strings.TrimSpace(str)

   log.Println(str)

   self.logChannel <- str + "\n"
}

func (self *Log) WriteLogFile(log string) {
   // logFile, err := os.OpenFile("../log/log_"+time.Now().Format("2006-01-02")+".txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
   logFile, err := os.OpenFile(LogPath+"log_"+time.Now().Format("2006-01-02")+".txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
   if err != nil {
      fmt.Println("open log file failed!!!")
      return
   }
   logFile.WriteString(log)
   logFile.Close()
}

func (self *Log) RunLogFileThread() {
   for {
      strlog := <-self.logChannel
      self.WriteLogFile(strlog)

   }

}