546 lines
16 KiB
Go
546 lines
16 KiB
Go
package ulog
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log/syslog"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"regexp"
|
|
"runtime"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
"unsafe"
|
|
)
|
|
|
|
const (
|
|
TIME_NONE int = iota
|
|
TIME_DATETIME
|
|
TIME_MSDATETIME
|
|
TIME_TIMESTAMP
|
|
TIME_MSTIMESTAMP
|
|
)
|
|
|
|
var (
|
|
cores int
|
|
facilities = map[string]syslog.Priority{
|
|
"user": syslog.LOG_USER,
|
|
"daemon": syslog.LOG_DAEMON,
|
|
"local0": syslog.LOG_LOCAL0,
|
|
"local1": syslog.LOG_LOCAL1,
|
|
"local2": syslog.LOG_LOCAL2,
|
|
"local3": syslog.LOG_LOCAL3,
|
|
"local4": syslog.LOG_LOCAL4,
|
|
"local5": syslog.LOG_LOCAL5,
|
|
"local6": syslog.LOG_LOCAL6,
|
|
"local7": syslog.LOG_LOCAL7,
|
|
}
|
|
severities = map[string]syslog.Priority{
|
|
"error": syslog.LOG_ERR,
|
|
"warning": syslog.LOG_WARNING,
|
|
"info": syslog.LOG_INFO,
|
|
"debug": syslog.LOG_DEBUG,
|
|
}
|
|
severityLabels = map[syslog.Priority]string{
|
|
syslog.LOG_ERR: "ERRO ",
|
|
syslog.LOG_WARNING: "WARN ",
|
|
syslog.LOG_INFO: "INFO ",
|
|
syslog.LOG_DEBUG: "DBUG ",
|
|
}
|
|
severityColors = map[syslog.Priority]string{
|
|
syslog.LOG_ERR: "\x1b[31m",
|
|
syslog.LOG_WARNING: "\x1b[33m",
|
|
syslog.LOG_INFO: "\x1b[36m",
|
|
syslog.LOG_DEBUG: "\x1b[32m",
|
|
}
|
|
)
|
|
|
|
type FileOutput struct {
|
|
handle *os.File
|
|
last time.Time
|
|
}
|
|
type ULog struct {
|
|
file, console, syslog bool
|
|
fileOutputs map[string]*FileOutput
|
|
filePath string
|
|
fileTime int
|
|
fileLast time.Time
|
|
fileSeverity bool
|
|
consoleHandle io.Writer
|
|
consoleTime int
|
|
consoleSeverity bool
|
|
consoleColors bool
|
|
syslogHandle *syslog.Writer
|
|
syslogRemote string
|
|
syslogName string
|
|
syslogFacility syslog.Priority
|
|
optionUTC bool
|
|
level syslog.Priority
|
|
sync.Mutex
|
|
}
|
|
|
|
func New(target string) *ULog {
|
|
if cores == 0 {
|
|
cores = runtime.NumCPU()
|
|
}
|
|
log := &ULog{
|
|
fileOutputs: map[string]*FileOutput{},
|
|
syslogHandle: nil,
|
|
}
|
|
return log.Load(target)
|
|
}
|
|
|
|
func (this *ULog) Load(target string) *ULog {
|
|
this.Close()
|
|
if cores > 1 {
|
|
this.Lock()
|
|
defer this.Unlock()
|
|
}
|
|
|
|
this.file = false
|
|
this.filePath = ""
|
|
this.fileTime = TIME_DATETIME
|
|
this.fileSeverity = true
|
|
this.console = false
|
|
this.consoleTime = TIME_DATETIME
|
|
this.consoleSeverity = true
|
|
this.consoleColors = true
|
|
this.consoleHandle = os.Stderr
|
|
this.syslog = false
|
|
this.syslogRemote = ""
|
|
this.syslogName = filepath.Base(os.Args[0])
|
|
this.syslogFacility = syslog.LOG_DAEMON
|
|
this.optionUTC = false
|
|
this.level = syslog.LOG_INFO
|
|
for _, target := range regexp.MustCompile("(file|console|syslog|option)\\s*\\(([^\\)]*)\\)").FindAllStringSubmatch(target, -1) {
|
|
switch strings.ToLower(target[1]) {
|
|
case "file":
|
|
this.file = true
|
|
for _, option := range regexp.MustCompile("([^:=,\\s]+)\\s*[:=]\\s*([^,\\s]+)").FindAllStringSubmatch(target[2], -1) {
|
|
switch strings.ToLower(option[1]) {
|
|
case "path":
|
|
this.filePath = option[2]
|
|
case "time":
|
|
option[2] = strings.ToLower(option[2])
|
|
switch {
|
|
case option[2] == "datetime":
|
|
this.fileTime = TIME_DATETIME
|
|
case option[2] == "msdatetime":
|
|
this.fileTime = TIME_MSDATETIME
|
|
case option[2] == "stamp" || option[2] == "timestamp":
|
|
this.fileTime = TIME_TIMESTAMP
|
|
case option[2] == "msstamp" || option[2] == "mstimestamp":
|
|
this.fileTime = TIME_MSTIMESTAMP
|
|
case option[2] != "1" && option[2] != "true" && option[2] != "on" && option[2] != "yes":
|
|
this.fileTime = TIME_NONE
|
|
}
|
|
case "severity":
|
|
option[2] = strings.ToLower(option[2])
|
|
if option[2] != "1" && option[2] != "true" && option[2] != "on" && option[2] != "yes" {
|
|
this.fileSeverity = false
|
|
}
|
|
}
|
|
}
|
|
if this.filePath == "" {
|
|
this.file = false
|
|
}
|
|
case "console":
|
|
this.console = true
|
|
for _, option := range regexp.MustCompile("([^:=,\\s]+)\\s*[:=]\\s*([^,\\s]+)").FindAllStringSubmatch(target[2], -1) {
|
|
option[2] = strings.ToLower(option[2])
|
|
switch strings.ToLower(option[1]) {
|
|
case "output":
|
|
if option[2] == "stdout" {
|
|
this.consoleHandle = os.Stdout
|
|
}
|
|
case "time":
|
|
switch {
|
|
case option[2] == "datetime":
|
|
this.consoleTime = TIME_DATETIME
|
|
case option[2] == "msdatetime":
|
|
this.consoleTime = TIME_MSDATETIME
|
|
case option[2] == "stamp" || option[2] == "timestamp":
|
|
this.consoleTime = TIME_TIMESTAMP
|
|
case option[2] == "msstamp" || option[2] == "mstimestamp":
|
|
this.consoleTime = TIME_MSTIMESTAMP
|
|
case option[2] != "1" && option[2] != "true" && option[2] != "on" && option[2] != "yes":
|
|
this.consoleTime = TIME_NONE
|
|
}
|
|
case "severity":
|
|
if option[2] != "1" && option[2] != "true" && option[2] != "on" && option[2] != "yes" {
|
|
this.consoleSeverity = false
|
|
}
|
|
case "colors":
|
|
if option[2] != "1" && option[2] != "true" && option[2] != "on" && option[2] != "yes" {
|
|
this.consoleColors = false
|
|
}
|
|
}
|
|
}
|
|
case "syslog":
|
|
this.syslog = true
|
|
for _, option := range regexp.MustCompile("([^:=,\\s]+)\\s*[:=]\\s*([^,\\s]+)").FindAllStringSubmatch(target[2], -1) {
|
|
switch strings.ToLower(option[1]) {
|
|
case "remote":
|
|
this.syslogRemote = option[2]
|
|
if !regexp.MustCompile(":\\d+$").MatchString(this.syslogRemote) {
|
|
this.syslogRemote += ":514"
|
|
}
|
|
case "name":
|
|
this.syslogName = option[2]
|
|
case "facility":
|
|
this.syslogFacility = facilities[strings.ToLower(option[2])]
|
|
}
|
|
}
|
|
case "option":
|
|
for _, option := range regexp.MustCompile("([^:=,\\s]+)\\s*[:=]\\s*([^,\\s]+)").FindAllStringSubmatch(target[2], -1) {
|
|
option[2] = strings.ToLower(option[2])
|
|
switch strings.ToLower(option[1]) {
|
|
case "utc":
|
|
if option[2] == "1" || option[2] == "true" || option[2] == "on" || option[2] == "yes" {
|
|
this.optionUTC = true
|
|
}
|
|
case "level":
|
|
this.level = severities[strings.ToLower(option[2])]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var info syscall.Termios
|
|
if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, this.consoleHandle.(*os.File).Fd(), syscall.TCGETS, uintptr(unsafe.Pointer(&info)), 0, 0, 0); err != 0 {
|
|
this.consoleColors = false
|
|
}
|
|
return this
|
|
}
|
|
|
|
func (this *ULog) Close() {
|
|
if cores > 1 {
|
|
this.Lock()
|
|
defer this.Unlock()
|
|
}
|
|
if this.syslogHandle != nil {
|
|
this.syslogHandle.Close()
|
|
this.syslogHandle = nil
|
|
}
|
|
for path, output := range this.fileOutputs {
|
|
if output.handle != nil {
|
|
output.handle.Close()
|
|
}
|
|
delete(this.fileOutputs, path)
|
|
}
|
|
}
|
|
|
|
func (this *ULog) SetLevel(level string) {
|
|
level = strings.ToLower(level)
|
|
switch level {
|
|
case "error":
|
|
this.level = syslog.LOG_ERR
|
|
case "warning":
|
|
this.level = syslog.LOG_WARNING
|
|
case "info":
|
|
this.level = syslog.LOG_INFO
|
|
case "debug":
|
|
this.level = syslog.LOG_DEBUG
|
|
}
|
|
}
|
|
|
|
func strftime(layout string, base time.Time) string {
|
|
var output []string
|
|
|
|
length := len(layout)
|
|
for index := 0; index < length; index++ {
|
|
switch layout[index] {
|
|
case '%':
|
|
if index < length-1 {
|
|
switch layout[index+1] {
|
|
case 'a':
|
|
output = append(output, base.Format("Mon"))
|
|
case 'A':
|
|
output = append(output, base.Format("Monday"))
|
|
case 'b':
|
|
output = append(output, base.Format("Jan"))
|
|
case 'B':
|
|
output = append(output, base.Format("January"))
|
|
case 'c':
|
|
output = append(output, base.Format("Mon Jan 2 15:04:05 2006"))
|
|
case 'C':
|
|
output = append(output, fmt.Sprintf("%02d", base.Year()/100))
|
|
case 'd':
|
|
output = append(output, fmt.Sprintf("%02d", base.Day()))
|
|
case 'D':
|
|
output = append(output, fmt.Sprintf("%02d/%02d/%02d", base.Month(), base.Day(), base.Year()%100))
|
|
case 'e':
|
|
output = append(output, fmt.Sprintf("%2d", base.Day()))
|
|
case 'f':
|
|
output = append(output, fmt.Sprintf("%06d", base.Nanosecond()/1000))
|
|
case 'F':
|
|
output = append(output, fmt.Sprintf("%04d-%02d-%02d", base.Year(), base.Month(), base.Day()))
|
|
case 'g':
|
|
year, _ := base.ISOWeek()
|
|
output = append(output, fmt.Sprintf("%02d", year%100))
|
|
case 'G':
|
|
year, _ := base.ISOWeek()
|
|
output = append(output, fmt.Sprintf("%04d", year))
|
|
case 'h':
|
|
output = append(output, base.Format("Jan"))
|
|
case 'H':
|
|
output = append(output, fmt.Sprintf("%02d", base.Hour()))
|
|
case 'I':
|
|
if base.Hour() == 0 || base.Hour() == 12 {
|
|
output = append(output, "12")
|
|
} else {
|
|
output = append(output, fmt.Sprintf("%02d", base.Hour()%12))
|
|
}
|
|
case 'j':
|
|
output = append(output, fmt.Sprintf("%03d", base.YearDay()))
|
|
case 'k':
|
|
output = append(output, fmt.Sprintf("%2d", base.Hour()))
|
|
case 'l':
|
|
if base.Hour() == 0 || base.Hour() == 12 {
|
|
output = append(output, "12")
|
|
} else {
|
|
output = append(output, fmt.Sprintf("%2d", base.Hour()%12))
|
|
}
|
|
case 'm':
|
|
output = append(output, fmt.Sprintf("%02d", base.Month()))
|
|
case 'M':
|
|
output = append(output, fmt.Sprintf("%02d", base.Minute()))
|
|
case 'n':
|
|
output = append(output, "\n")
|
|
case 'p':
|
|
if base.Hour() < 12 {
|
|
output = append(output, "AM")
|
|
} else {
|
|
output = append(output, "PM")
|
|
}
|
|
case 'P':
|
|
if base.Hour() < 12 {
|
|
output = append(output, "am")
|
|
} else {
|
|
output = append(output, "pm")
|
|
}
|
|
case 'r':
|
|
if base.Hour() == 0 || base.Hour() == 12 {
|
|
output = append(output, "12")
|
|
} else {
|
|
output = append(output, fmt.Sprintf("%02d", base.Hour()%12))
|
|
}
|
|
output = append(output, fmt.Sprintf(":%02d:%02d", base.Minute(), base.Second()))
|
|
if base.Hour() < 12 {
|
|
output = append(output, " AM")
|
|
} else {
|
|
output = append(output, " PM")
|
|
}
|
|
case 'R':
|
|
output = append(output, fmt.Sprintf("%02d:%02d", base.Hour(), base.Minute()))
|
|
case 's':
|
|
output = append(output, fmt.Sprintf("%d", base.Unix()))
|
|
case 'S':
|
|
output = append(output, fmt.Sprintf("%02d", base.Second()))
|
|
case 't':
|
|
output = append(output, "\t")
|
|
case 'T':
|
|
output = append(output, fmt.Sprintf("%02d:%02d:%02d", base.Hour(), base.Minute(), base.Second()))
|
|
case 'u':
|
|
day := base.Weekday()
|
|
if day == 0 {
|
|
day = 7
|
|
}
|
|
output = append(output, fmt.Sprintf("%d", day))
|
|
case 'U':
|
|
output = append(output, fmt.Sprintf("%d", (base.YearDay()+6-int(base.Weekday()))/7))
|
|
case 'V':
|
|
_, week := base.ISOWeek()
|
|
output = append(output, fmt.Sprintf("%02d", week))
|
|
case 'w':
|
|
output = append(output, fmt.Sprintf("%d", base.Weekday()))
|
|
case 'W':
|
|
day := int(base.Weekday())
|
|
if day == 0 {
|
|
day = 6
|
|
} else {
|
|
day -= 1
|
|
}
|
|
output = append(output, fmt.Sprintf("%d", (base.YearDay()+6-day)/7))
|
|
case 'x':
|
|
output = append(output, fmt.Sprintf("%02d/%02d/%02d", base.Month(), base.Day(), base.Year()%100))
|
|
case 'X':
|
|
output = append(output, fmt.Sprintf("%02d:%02d:%02d", base.Hour(), base.Minute(), base.Second()))
|
|
case 'y':
|
|
output = append(output, fmt.Sprintf("%02d", base.Year()%100))
|
|
case 'Y':
|
|
output = append(output, fmt.Sprintf("%04d", base.Year()))
|
|
case 'z':
|
|
output = append(output, base.Format("-0700"))
|
|
case 'Z':
|
|
output = append(output, base.Format("MST"))
|
|
case '%':
|
|
output = append(output, "%")
|
|
}
|
|
index++
|
|
}
|
|
default:
|
|
output = append(output, string(layout[index]))
|
|
}
|
|
}
|
|
return strings.Join(output, "")
|
|
}
|
|
|
|
func (this *ULog) log(now time.Time, severity syslog.Priority, xlayout interface{}, a ...interface{}) {
|
|
var err error
|
|
if this.level < severity || (!this.syslog && !this.file && !this.console) {
|
|
return
|
|
}
|
|
layout := ""
|
|
switch reflect.TypeOf(xlayout).Kind() {
|
|
case reflect.Map:
|
|
var buffer bytes.Buffer
|
|
|
|
encoder := json.NewEncoder(&buffer)
|
|
encoder.SetEscapeHTML(false)
|
|
if err := encoder.Encode(xlayout); err == nil {
|
|
layout = "%s"
|
|
a = []interface{}{bytes.TrimSpace(buffer.Bytes())}
|
|
}
|
|
case reflect.String:
|
|
layout = xlayout.(string)
|
|
}
|
|
layout = strings.TrimSpace(layout)
|
|
if this.syslog {
|
|
if this.syslogHandle == nil {
|
|
if cores > 1 {
|
|
this.Lock()
|
|
}
|
|
if this.syslogHandle == nil {
|
|
protocol := ""
|
|
if this.syslogRemote != "" {
|
|
protocol = "udp"
|
|
}
|
|
if this.syslogHandle, err = syslog.Dial(protocol, this.syslogRemote, this.syslogFacility, this.syslogName); err != nil {
|
|
this.syslogHandle = nil
|
|
}
|
|
}
|
|
if cores > 1 {
|
|
this.Unlock()
|
|
}
|
|
}
|
|
if this.syslogHandle != nil {
|
|
switch severity {
|
|
case syslog.LOG_ERR:
|
|
this.syslogHandle.Err(fmt.Sprintf(layout, a...))
|
|
case syslog.LOG_WARNING:
|
|
this.syslogHandle.Warning(fmt.Sprintf(layout, a...))
|
|
case syslog.LOG_INFO:
|
|
this.syslogHandle.Info(fmt.Sprintf(layout, a...))
|
|
case syslog.LOG_DEBUG:
|
|
this.syslogHandle.Debug(fmt.Sprintf(layout, a...))
|
|
}
|
|
}
|
|
}
|
|
if this.optionUTC {
|
|
now = now.UTC()
|
|
} else {
|
|
now = now.Local()
|
|
}
|
|
if this.file {
|
|
path := strftime(this.filePath, now)
|
|
if cores > 1 {
|
|
this.Lock()
|
|
}
|
|
if this.fileOutputs[path] == nil {
|
|
os.MkdirAll(filepath.Dir(path), 0755)
|
|
if handle, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644); err == nil {
|
|
this.fileOutputs[path] = &FileOutput{handle: handle}
|
|
}
|
|
}
|
|
if this.fileOutputs[path] != nil && this.fileOutputs[path].handle != nil {
|
|
prefix := ""
|
|
switch this.fileTime {
|
|
case TIME_DATETIME:
|
|
prefix = fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d ", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
|
|
case TIME_MSDATETIME:
|
|
prefix = fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d.%03d ", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second(), now.Nanosecond()/int(time.Millisecond))
|
|
case TIME_TIMESTAMP:
|
|
prefix = fmt.Sprintf("%d ", now.Unix())
|
|
case TIME_MSTIMESTAMP:
|
|
prefix = fmt.Sprintf("%d ", now.UnixNano()/int64(time.Millisecond))
|
|
}
|
|
if this.fileSeverity {
|
|
prefix += severityLabels[severity]
|
|
}
|
|
this.fileOutputs[path].handle.WriteString(fmt.Sprintf(prefix+layout+"\n", a...))
|
|
this.fileOutputs[path].last = now
|
|
}
|
|
if now.Sub(this.fileLast) >= 5*time.Second {
|
|
this.fileLast = now
|
|
for path, output := range this.fileOutputs {
|
|
if now.Sub(output.last) >= 5*time.Second {
|
|
output.handle.Close()
|
|
delete(this.fileOutputs, path)
|
|
}
|
|
}
|
|
}
|
|
if cores > 1 {
|
|
this.Unlock()
|
|
}
|
|
}
|
|
if this.console {
|
|
prefix := ""
|
|
switch this.consoleTime {
|
|
case TIME_DATETIME:
|
|
prefix = fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d ", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
|
|
case TIME_MSDATETIME:
|
|
prefix = fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d.%03d ", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second(), now.Nanosecond()/int(time.Millisecond))
|
|
case TIME_TIMESTAMP:
|
|
prefix = fmt.Sprintf("%d ", now.Unix())
|
|
case TIME_MSTIMESTAMP:
|
|
prefix = fmt.Sprintf("%d ", now.UnixNano()/int64(time.Millisecond))
|
|
}
|
|
if this.consoleSeverity {
|
|
if this.consoleColors {
|
|
prefix += fmt.Sprintf("%s%s\x1b[0m", severityColors[severity], severityLabels[severity])
|
|
} else {
|
|
prefix += severityLabels[severity]
|
|
}
|
|
}
|
|
if cores > 1 {
|
|
this.Lock()
|
|
}
|
|
fmt.Fprintf(this.consoleHandle, prefix+layout+"\n", a...)
|
|
if cores > 1 {
|
|
this.Unlock()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (this *ULog) Error(layout interface{}, a ...interface{}) {
|
|
this.log(time.Now(), syslog.LOG_ERR, layout, a...)
|
|
}
|
|
func (this *ULog) Warn(layout interface{}, a ...interface{}) {
|
|
this.log(time.Now(), syslog.LOG_WARNING, layout, a...)
|
|
}
|
|
func (this *ULog) Info(layout interface{}, a ...interface{}) {
|
|
this.log(time.Now(), syslog.LOG_INFO, layout, a...)
|
|
}
|
|
func (this *ULog) Debug(layout interface{}, a ...interface{}) {
|
|
this.log(time.Now(), syslog.LOG_DEBUG, layout, a...)
|
|
}
|
|
|
|
func (this *ULog) ErrorTime(now time.Time, layout interface{}, a ...interface{}) {
|
|
this.log(now, syslog.LOG_ERR, layout, a...)
|
|
}
|
|
func (this *ULog) WarnTime(now time.Time, layout interface{}, a ...interface{}) {
|
|
this.log(now, syslog.LOG_WARNING, layout, a...)
|
|
}
|
|
func (this *ULog) InfoTime(now time.Time, layout interface{}, a ...interface{}) {
|
|
this.log(now, syslog.LOG_INFO, layout, a...)
|
|
}
|
|
func (this *ULog) DebugTime(now time.Time, layout interface{}, a ...interface{}) {
|
|
this.log(now, syslog.LOG_DEBUG, layout, a...)
|
|
}
|