feat: omc原始代码

lib/log/logger.go

@@ -0,0 +1,338 @@
+// logger for omc/ems
+
+package log
+
+import (
+	"fmt"
+	"io"
+	"log"
+)
+
+// LogLevel defines a log level
+type LogLevel int
+
+// enum all LogLevels
+const (
+	// following level also match syslog.Priority value
+	LOG_TRACE LogLevel = iota
+	LOG_DEBUG
+	LOG_INFO
+	LOG_WARN
+	LOG_ERROR
+	LOG_FATAL
+	LOG_OFF
+	LOG_NODEF
+)
+
+// default log options
+const (
+	DEFAULT_LOG_PREFIX = "omc"
+	DEFAULT_LOG_FLAG   = log.Lshortfile | log.Ldate | log.Lmicroseconds
+	DEFAULT_LOG_LEVEL  = LOG_DEBUG
+	DEFAULT_CALL_DEPTH = 3
+)
+
+// Logger is a logger interface
+type Logger interface {
+	Fatal(v ...interface{})
+	Fatalf(format string, v ...interface{})
+	Error(v ...interface{})
+	Errorf(format string, v ...interface{})
+	Warn(v ...interface{})
+	Warnf(format string, v ...interface{})
+	Info(v ...interface{})
+	Infof(format string, v ...interface{})
+	Debug(v ...interface{})
+	Debugf(format string, v ...interface{})
+	Trace(v ...interface{})
+	Tracef(format string, v ...interface{})
+
+	Level() LogLevel
+	LevelString() string
+	SetLevel(l LogLevel)
+}
+
+var _ Logger = DiscardLogger{}
+
+// DiscardLogger don't log implementation for ILogger
+type DiscardLogger struct{}
+
+// Trace empty implementation
+func (DiscardLogger) Trace(v ...interface{}) {}
+
+// Tracef empty implementation
+func (DiscardLogger) Tracef(format string, v ...interface{}) {}
+
+// Debug empty implementation
+func (DiscardLogger) Debug(v ...interface{}) {}
+
+// Debugf empty implementation
+func (DiscardLogger) Debugf(format string, v ...interface{}) {}
+
+// Info empty implementation
+func (DiscardLogger) Info(v ...interface{}) {}
+
+// Infof empty implementation
+func (DiscardLogger) Infof(format string, v ...interface{}) {}
+
+// Warn empty implementation
+func (DiscardLogger) Warn(v ...interface{}) {}
+
+// Warnf empty implementation
+func (DiscardLogger) Warnf(format string, v ...interface{}) {}
+
+// Error empty implementation
+func (DiscardLogger) Error(v ...interface{}) {}
+
+// Errorf empty implementation
+func (DiscardLogger) Errorf(format string, v ...interface{}) {}
+
+// Fatal empty implementation
+func (DiscardLogger) Fatal(v ...interface{}) {}
+
+// Fatalf empty implementation
+func (DiscardLogger) Fatalf(format string, v ...interface{}) {}
+
+// Level empty implementation
+func (DiscardLogger) Level() LogLevel {
+	return LOG_NODEF
+}
+
+// Level empty implementation
+func (DiscardLogger) LevelString() string {
+	return ""
+}
+
+// SetLevel empty implementation
+func (DiscardLogger) SetLevel(l LogLevel) {}
+
+// EmsLogger is the default implment of ILogger
+type EmsLogger struct {
+	TRACE       *log.Logger
+	DEBUG       *log.Logger
+	INFO        *log.Logger
+	WARN        *log.Logger
+	ERROR       *log.Logger
+	FATAL       *log.Logger
+	level       LogLevel
+	levelString []string
+	depth       int
+}
+
+var _ Logger = &EmsLogger{}
+
+// NewEmsLogger use a special io.Writer as logger output
+func NewEmsLogger(out io.Writer) *EmsLogger {
+	return NewEmsLogger2(out, DEFAULT_LOG_PREFIX, DEFAULT_LOG_FLAG)
+}
+
+// NewEmsLogger2 let you customrize your logger prefix and flag
+func NewEmsLogger2(out io.Writer, prefix string, flag int) *EmsLogger {
+	return NewEmsLogger3(out, prefix, flag, DEFAULT_LOG_LEVEL)
+}
+
+// NewEmsLogger3 let you customrize your logger prefix and flag and logLevel
+func NewEmsLogger3(out io.Writer, prefix string, flag int, l LogLevel) *EmsLogger {
+	return &EmsLogger{
+		TRACE:       log.New(out, fmt.Sprintf("[%s] [trace] ", prefix), flag),
+		DEBUG:       log.New(out, fmt.Sprintf("[%s] [debug] ", prefix), flag),
+		INFO:        log.New(out, fmt.Sprintf("[%s] [info ] ", prefix), flag),
+		WARN:        log.New(out, fmt.Sprintf("[%s] [warn ] ", prefix), flag),
+		ERROR:       log.New(out, fmt.Sprintf("[%s] [error] ", prefix), flag),
+		FATAL:       log.New(out, fmt.Sprintf("[%s] [fatal] ", prefix), flag),
+		level:       l,
+		levelString: []string{"trace", "debug", "info", "warn", "error", "fatal"},
+		depth:       DEFAULT_CALL_DEPTH,
+	}
+}
+
+// Trace implement ILogger
+func (s *EmsLogger) Trace(v ...interface{}) {
+	if s.level <= LOG_TRACE {
+		_ = s.TRACE.Output(s.depth, fmt.Sprintln(v...))
+	}
+}
+
+// Tracef implement ILogger
+func (s *EmsLogger) Tracef(format string, v ...interface{}) {
+	if s.level <= LOG_TRACE {
+		_ = s.TRACE.Output(s.depth, fmt.Sprintf(format, v...))
+	}
+}
+
+// Debug implement ILogger
+func (s *EmsLogger) Debug(v ...interface{}) {
+	if s.level <= LOG_DEBUG {
+		_ = s.DEBUG.Output(s.depth, fmt.Sprintln(v...))
+	}
+}
+
+// Debugf implement ILogger
+func (s *EmsLogger) Debugf(format string, v ...interface{}) {
+	if s.level <= LOG_DEBUG {
+		_ = s.DEBUG.Output(s.depth, fmt.Sprintf(format, v...))
+	}
+}
+
+// Info implement ILogger
+func (s *EmsLogger) Info(v ...interface{}) {
+	if s.level <= LOG_INFO {
+		_ = s.INFO.Output(s.depth, fmt.Sprintln(v...))
+	}
+}
+
+// Infof implement ILogger
+func (s *EmsLogger) Infof(format string, v ...interface{}) {
+	if s.level <= LOG_INFO {
+		_ = s.INFO.Output(s.depth, fmt.Sprintf(format, v...))
+	}
+}
+
+// Warn implement ILogger
+func (s *EmsLogger) Warn(v ...interface{}) {
+	if s.level <= LOG_WARN {
+		_ = s.WARN.Output(s.depth, fmt.Sprintln(v...))
+	}
+}
+
+// Warnf implement ILogger
+func (s *EmsLogger) Warnf(format string, v ...interface{}) {
+	if s.level <= LOG_WARN {
+		_ = s.WARN.Output(s.depth, fmt.Sprintf(format, v...))
+	}
+}
+
+// Error implement ILogger
+func (s *EmsLogger) Error(v ...interface{}) {
+	if s.level <= LOG_ERROR {
+		_ = s.ERROR.Output(s.depth, fmt.Sprintln(v...))
+	}
+}
+
+// Errorf implement ILogger
+func (s *EmsLogger) Errorf(format string, v ...interface{}) {
+	if s.level <= LOG_ERROR {
+		_ = s.ERROR.Output(s.depth, fmt.Sprintf(format, v...))
+	}
+}
+
+// Warn implement ILogger
+func (s *EmsLogger) Fatal(v ...interface{}) {
+	if s.level <= LOG_FATAL {
+		_ = s.FATAL.Output(s.depth, fmt.Sprintln(v...))
+	}
+}
+
+// Warnf implement ILogger
+func (s *EmsLogger) Fatalf(format string, v ...interface{}) {
+	if s.level <= LOG_FATAL {
+		_ = s.FATAL.Output(s.depth, fmt.Sprintf(format, v...))
+	}
+}
+
+// Level implement ILogger
+func (s *EmsLogger) Level() LogLevel {
+	return s.level
+}
+
+// Level implement ILogger
+func (s *EmsLogger) LevelString() string {
+	return s.levelString[s.level]
+}
+
+// SetLevel implement ILogger
+func (s *EmsLogger) SetLevel(l LogLevel) {
+	s.level = l
+}
+
+var Elogger Logger
+
+func InitLogger(logFile string, period int, count int, prefix string, logLevel LogLevel) io.Writer {
+
+	/*
+		logFile, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
+		if err != nil {
+			panic(err)
+		}
+	*/
+
+	logWriter := getLogWriter(logFile, period, count)
+	Elogger = NewEmsLogger3(logWriter, prefix, DEFAULT_LOG_FLAG, logLevel)
+	fmt.Printf("logFile=%s, period=%d, count=%d, prefix=%s, logLevel=%s\n", logFile, period, count, prefix, GetLevelString())
+	return logWriter
+}
+
+// Trace implement ILogger
+func Trace(v ...interface{}) {
+	Elogger.Trace(v...)
+}
+
+// Tracef implement ILogger
+func Tracef(format string, v ...interface{}) {
+	Elogger.Tracef(format, v...)
+}
+
+// Debug implement ILogger
+func Debug(v ...interface{}) {
+	Elogger.Debug(v...)
+}
+
+// Debugf implement ILogger
+func Debugf(format string, v ...interface{}) {
+	Elogger.Debugf(format, v...)
+}
+
+// Info implement ILogger
+func Info(v ...interface{}) {
+	Elogger.Info(v...)
+}
+
+// Infof implement ILogger
+func Infof(format string, v ...interface{}) {
+	Elogger.Infof(format, v...)
+}
+
+// Warn implement ILogger
+func Warn(v ...interface{}) {
+	Elogger.Warn(v...)
+}
+
+// Warnf implement ILogger
+func Warnf(format string, v ...interface{}) {
+	Elogger.Warnf(format, v...)
+}
+
+// Error implement ILogger
+func Error(v ...interface{}) {
+	Elogger.Error(v...)
+}
+
+// Errorf implement ILogger
+func Errorf(format string, v ...interface{}) {
+	Elogger.Errorf(format, v...)
+}
+
+// Warn implement ILogger
+func Fatal(v ...interface{}) {
+	Elogger.Fatal(v...)
+}
+
+// Warnf implement ILogger
+func Fatalf(format string, v ...interface{}) {
+	Elogger.Fatalf(format, v...)
+}
+
+// Level implement ILogger
+func GetLevel() LogLevel {
+	return Elogger.Level()
+}
+
+// Level implement ILogger
+func GetLevelString() string {
+	return Elogger.LevelString()
+}
+
+// SetLevel implement ILogger
+func SetLevel(l LogLevel) {
+	Elogger.SetLevel(l)
+}

lib/log/partition.go

@@ -0,0 +1,71 @@
+package log
+
+import (
+	"io"
+	"time"
+
+	rotatelogs "github.com/lestrrat/go-file-rotatelogs"
+)
+
+type WriteSyncer interface {
+	io.Writer
+	Sync() error
+}
+
+// 得到LogWriter
+func getLogWriter(filePath string, period, count int) WriteSyncer {
+	warnIoWriter := getWriter(filePath, period, count)
+	return addSync(warnIoWriter)
+}
+
+// 日志文件切割
+func getWriter(filename string, period, count int) io.Writer {
+	// 保存日志count天，每period小时分割一次日志
+	duration := time.Hour * time.Duration(period)
+	var logfile string
+	if period >= 24 {
+		logfile = filename + "-%Y%m%d"
+	} else {
+		logfile = filename + "-%Y%m%d%H"
+	}
+	hook, err := rotatelogs.New(
+
+		logfile,
+		rotatelogs.WithLinkName(filename),
+		//		rotatelogs.WithMaxAge(duration),
+		rotatelogs.WithRotationCount(count),
+		rotatelogs.WithRotationTime(duration),
+		rotatelogs.WithLocation(time.Local),
+	)
+
+	//保存日志30天，每1分钟分割一次日志
+	/*
+		hook, err := rotatelogs.New(
+			filename+"_%Y%m%d%H%M.log",
+			rotatelogs.WithLinkName(filename),
+			rotatelogs.WithMaxAge(time.Hour*24*30),
+			rotatelogs.WithRotationTime(time.Minute*1),
+		)
+	*/
+	if err != nil {
+		panic(err)
+	}
+	return hook
+}
+
+func addSync(w io.Writer) WriteSyncer {
+	switch w := w.(type) {
+	case WriteSyncer:
+		return w
+	default:
+		return writerWrapper{w}
+	}
+}
+
+type writerWrapper struct {
+	io.Writer
+}
+
+func (w writerWrapper) Sync() error {
+	return nil
+}

lib/log/syslogger.go.bak

@@ -0,0 +1,89 @@
+//go:build !windows && !nacl && !plan9
+// +build !windows,!nacl,!plan9
+
+package log
+
+import (
+	"fmt"
+	"log/syslog"
+)
+
+var _ Logger = &SyslogLogger{}
+
+// SyslogLogger will be depricated
+type SyslogLogger struct {
+	w *syslog.Writer
+}
+
+// NewSyslogLogger implements Logger
+func NewSyslogLogger(w *syslog.Writer) *SyslogLogger {
+	return &SyslogLogger{w: w}
+}
+
+// Trace log content as Trace
+func (s *SyslogLogger) Trace(v ...interface{}) {
+	_ = s.w.Trace(fmt.Sprint(v...))
+}
+
+// Tracef log content as Trace and format
+func (s *SyslogLogger) Tracef(format string, v ...interface{}) {
+	_ = s.w.Trace(fmt.Sprintf(format, v...))
+}
+
+// Debug log content as Debug
+func (s *SyslogLogger) Debug(v ...interface{}) {
+	_ = s.w.Debug(fmt.Sprint(v...))
+}
+
+// Debugf log content as Debug and format
+func (s *SyslogLogger) Debugf(format string, v ...interface{}) {
+	_ = s.w.Debug(fmt.Sprintf(format, v...))
+}
+
+// Error log content as Error
+func (s *SyslogLogger) Error(v ...interface{}) {
+	_ = s.w.Err(fmt.Sprint(v...))
+}
+
+// Errorf log content as Errorf and format
+func (s *SyslogLogger) Errorf(format string, v ...interface{}) {
+	_ = s.w.Err(fmt.Sprintf(format, v...))
+}
+
+// Info log content as Info
+func (s *SyslogLogger) Info(v ...interface{}) {
+	_ = s.w.Info(fmt.Sprint(v...))
+}
+
+// Infof log content as Infof and format
+func (s *SyslogLogger) Infof(format string, v ...interface{}) {
+	_ = s.w.Info(fmt.Sprintf(format, v...))
+}
+
+// Warn log content as Warn
+func (s *SyslogLogger) Warn(v ...interface{}) {
+	_ = s.w.Warn(fmt.Sprint(v...))
+}
+
+// Warnf log content as Warnf and format
+func (s *SyslogLogger) Warnf(format string, v ...interface{}) {
+	_ = s.w.Warn(fmt.Sprintf(format, v...))
+}
+
+// Fatal log content as Fatal
+func (s *SyslogLogger) Fatal(v ...interface{}) {
+	_ = s.w.Fatal(fmt.Sprint(v...))
+}
+
+// Fatalf log content as Fatalf and format
+func (s *SyslogLogger) Fatalf(format string, v ...interface{}) {
+	_ = s.w.Fatal(fmt.Sprintf(format, v...))
+}
+
+// Level shows log level
+func (s *SyslogLogger) Level() LogLevel {
+	return LOG_NODEF
+}
+
+// SetLevel always return error, as current log/syslog package doesn't allow to set priority level after syslog.Writer created
+func (s *SyslogLogger) SetLevel(l LogLevel) {}