mirror of https://github.com/bcicen/ctop.git
134 lines
2.8 KiB
Go
134 lines
2.8 KiB
Go
package logging
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/op/go-logging"
|
|
)
|
|
|
|
const (
|
|
size = 1024
|
|
)
|
|
|
|
var (
|
|
Log *CTopLogger
|
|
exited bool
|
|
level = logging.INFO // default level
|
|
format = logging.MustStringFormatter(
|
|
`%{color}%{time:15:04:05.000} ▶ %{level:.4s} %{id:03x}%{color:reset} %{message}`,
|
|
)
|
|
)
|
|
|
|
type statusMsg struct {
|
|
Text string
|
|
IsError bool
|
|
}
|
|
|
|
type CTopLogger struct {
|
|
*logging.Logger
|
|
backend *logging.MemoryBackend
|
|
logFile *os.File
|
|
sLog []statusMsg
|
|
}
|
|
|
|
func (c *CTopLogger) FlushStatus() chan statusMsg {
|
|
ch := make(chan statusMsg)
|
|
go func() {
|
|
for _, sm := range c.sLog {
|
|
ch <- sm
|
|
}
|
|
close(ch)
|
|
c.sLog = []statusMsg{}
|
|
}()
|
|
return ch
|
|
}
|
|
|
|
func (c *CTopLogger) StatusQueued() bool { return len(c.sLog) > 0 }
|
|
func (c *CTopLogger) Status(s string) { c.addStatus(statusMsg{s, false}) }
|
|
func (c *CTopLogger) StatusErr(err error) { c.addStatus(statusMsg{err.Error(), true}) }
|
|
func (c *CTopLogger) addStatus(sm statusMsg) { c.sLog = append(c.sLog, sm) }
|
|
|
|
func (c *CTopLogger) Statusf(s string, a ...interface{}) { c.Status(fmt.Sprintf(s, a...)) }
|
|
|
|
func Init() *CTopLogger {
|
|
if Log == nil {
|
|
logging.SetFormatter(format) // setup default formatter
|
|
|
|
Log = &CTopLogger{
|
|
logging.MustGetLogger("ctop"),
|
|
logging.NewMemoryBackend(size),
|
|
nil,
|
|
[]statusMsg{},
|
|
}
|
|
|
|
debugMode := debugMode()
|
|
if debugMode {
|
|
level = logging.DEBUG
|
|
}
|
|
backendLvl := logging.AddModuleLevel(Log.backend)
|
|
backendLvl.SetLevel(level, "")
|
|
|
|
logFilePath := debugModeFile()
|
|
if logFilePath == "" {
|
|
logging.SetBackend(backendLvl)
|
|
} else {
|
|
logFile, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
|
|
if err != nil {
|
|
logging.SetBackend(backendLvl)
|
|
Log.Error("Unable to create log file: %s", err.Error())
|
|
} else {
|
|
backendFile := logging.NewLogBackend(logFile, "", 0)
|
|
backendFileLvl := logging.AddModuleLevel(backendFile)
|
|
backendFileLvl.SetLevel(level, "")
|
|
logging.SetBackend(backendLvl, backendFileLvl)
|
|
Log.logFile = logFile
|
|
}
|
|
}
|
|
|
|
if debugMode {
|
|
StartServer()
|
|
}
|
|
Log.Notice("logger initialized")
|
|
}
|
|
return Log
|
|
}
|
|
|
|
func (log *CTopLogger) tail() chan string {
|
|
stream := make(chan string)
|
|
|
|
node := log.backend.Head()
|
|
go func() {
|
|
for {
|
|
stream <- node.Record.Formatted(0)
|
|
for {
|
|
nnode := node.Next()
|
|
if nnode != nil {
|
|
node = nnode
|
|
break
|
|
}
|
|
if exited {
|
|
close(stream)
|
|
return
|
|
}
|
|
time.Sleep(1 * time.Second)
|
|
}
|
|
}
|
|
}()
|
|
|
|
return stream
|
|
}
|
|
|
|
func (log *CTopLogger) Exit() {
|
|
exited = true
|
|
if log.logFile != nil {
|
|
_ = log.logFile.Close()
|
|
}
|
|
StopServer()
|
|
}
|
|
|
|
func debugMode() bool { return os.Getenv("CTOP_DEBUG") == "1" }
|
|
func debugModeTCP() bool { return os.Getenv("CTOP_DEBUG_TCP") == "1" }
|
|
func debugModeFile() string { return os.Getenv("CTOP_DEBUG_FILE") }
|