logruslogger.go 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235
  1. package log
  2. // import (
  3. // "fmt"
  4. // "sync"
  5. // "time"
  6. // rotatelogs "github.com/lestrrat-go/file-rotatelogs"
  7. // lfshook "github.com/rifflock/lfshook"
  8. // "github.com/sirupsen/logrus"
  9. // )
  10. // type DoubleFileLogger struct {
  11. // infoLogger *logrus.Logger
  12. // errorLogger *logrus.Logger
  13. // channel chan *logrus.Entry
  14. // wg sync.WaitGroup
  15. // }
  16. // func NewDoubleFileLogger(fileName string, logLevel logrus.Level) (Logger, error) {
  17. // initLog := func(fileName2 string, logLevel logrus.Level, rotationTime time.Duration) (*logrus.Logger, error) {
  18. // // 初始化rotatelogs
  19. // writer, err := rotatelogs.New(
  20. // fileName2+".%Y%m%d%H.log",
  21. // rotatelogs.WithLinkName(fileName2),
  22. // // WithMaxAge和WithRotationCount只能选其一
  23. // rotatelogs.WithRotationCount(7),
  24. // rotatelogs.WithRotationTime(rotationTime),
  25. // )
  26. // if err != nil {
  27. // return nil, err
  28. // }
  29. // // 设置lfshook
  30. // writeMap := lfshook.WriterMap{
  31. // logrus.DebugLevel: writer,
  32. // logrus.InfoLevel: writer,
  33. // logrus.WarnLevel: writer,
  34. // logrus.ErrorLevel: writer,
  35. // logrus.FatalLevel: writer,
  36. // logrus.PanicLevel: writer,
  37. // }
  38. // hook := lfshook.NewHook(writeMap, &logrus.TextFormatter{
  39. // TimestampFormat: "2006-01-02 15:04:05",
  40. // })
  41. // // 初始化logrus并添加hook
  42. // logger := logrus.New()
  43. // logger.SetLevel(logrus.Level(logLevel))
  44. // logger.Hooks.Add(hook)
  45. // // 屏蔽logrus的日志输出,只使用HOOKS
  46. // logger.SetFormatter(&NilFormatter{})
  47. // logger.SetOutput(&NilWriter{})
  48. // return logger, nil
  49. // }
  50. // log1, err1 := initLog(fileName, logLevel, time.Hour*24)
  51. // log2, err2 := initLog(fileName+".error", ErrorLevel, time.Hour*24*10)
  52. // if err1 != nil {
  53. // return nil, err1
  54. // }
  55. // if err2 != nil {
  56. // return nil, err2
  57. // }
  58. // channel := make(chan *logrus.Entry, 100) // 有缓冲的通道,防止阻塞
  59. // log3 := &DoubleFileLogger{
  60. // infoLogger: log1,
  61. // errorLogger: log2,
  62. // channel: channel,
  63. // }
  64. // log3.wg.Add(1)
  65. // go log3.startWorker()
  66. // return log3, nil
  67. // }
  68. // func (dfl *DoubleFileLogger) startWorker() {
  69. // defer dfl.wg.Done()
  70. // for entry := range dfl.channel {
  71. // entry.Log(entry.Level, entry.Message)
  72. // }
  73. // // dfl.infoLogger.Info("log worker exit")
  74. // }
  75. // func (dfl *DoubleFileLogger) Close() {
  76. // close(dfl.channel)
  77. // dfl.wg.Wait()
  78. // }
  79. // func (dfl *DoubleFileLogger) Log(level Level, msg string) {
  80. // if dfl.infoLogger.IsLevelEnabled(logrus.Level(level)) {
  81. // entry := logrus.NewEntry(dfl.infoLogger)
  82. // entry.Level = logrus.Level(level)
  83. // entry.Message = msg
  84. // dfl.channel <- entry
  85. // }
  86. // if dfl.errorLogger.IsLevelEnabled(logrus.Level(level)) {
  87. // dfl.errorLogger.Log(logrus.Level(level), msg)
  88. // }
  89. // }
  90. // func (dfl *DoubleFileLogger) Logf(level Level, format string, args ...interface{}) {
  91. // if dfl.infoLogger.IsLevelEnabled(logrus.Level(level)) {
  92. // entry := logrus.NewEntry(dfl.infoLogger)
  93. // entry.Level = logrus.Level(level)
  94. // entry.Message = fmt.Sprintf(format, args...)
  95. // dfl.channel <- entry
  96. // }
  97. // if dfl.errorLogger.IsLevelEnabled(logrus.Level(level)) {
  98. // dfl.errorLogger.Logf(logrus.Level(level), format, args...)
  99. // }
  100. // }
  101. // func sprintlnn(args ...interface{}) string {
  102. // msg := fmt.Sprintln(args...)
  103. // return msg[:len(msg)-1]
  104. // }
  105. // func (dfl *DoubleFileLogger) Logln(level Level, args ...interface{}) {
  106. // if dfl.infoLogger.IsLevelEnabled(logrus.Level(level)) {
  107. // entry := logrus.NewEntry(dfl.infoLogger)
  108. // entry.Level = logrus.Level(level)
  109. // entry.Message = sprintlnn(args...)
  110. // dfl.channel <- entry
  111. // }
  112. // if dfl.errorLogger.IsLevelEnabled(logrus.Level(level)) {
  113. // dfl.errorLogger.Logln(logrus.Level(level), args...)
  114. // }
  115. // }
  116. // func (dfl *DoubleFileLogger) Info(msg string) {
  117. // dfl.Log(InfoLevel, msg)
  118. // }
  119. // func (dfl *DoubleFileLogger) Infof(format string, args ...interface{}) {
  120. // dfl.Logf(InfoLevel, format, args...)
  121. // }
  122. // func (dfl *DoubleFileLogger) Infoln(args ...interface{}) {
  123. // dfl.Logln(InfoLevel, args...)
  124. // }
  125. // func (dfl *DoubleFileLogger) Warn(msg string) {
  126. // dfl.Log(WarnLevel, msg)
  127. // }
  128. // func (dfl *DoubleFileLogger) Warnf(format string, args ...interface{}) {
  129. // dfl.Logf(WarnLevel, format, args...)
  130. // }
  131. // func (dfl *DoubleFileLogger) Warnln(args ...interface{}) {
  132. // dfl.Logln(WarnLevel, args...)
  133. // }
  134. // func (dfl *DoubleFileLogger) Error(msg string) {
  135. // dfl.Log(ErrorLevel, msg)
  136. // }
  137. // func (dfl *DoubleFileLogger) Errorf(format string, args ...interface{}) {
  138. // dfl.Logf(ErrorLevel, format, args...)
  139. // }
  140. // func (dfl *DoubleFileLogger) Errorln(args ...interface{}) {
  141. // dfl.Logln(ErrorLevel, args...)
  142. // }
  143. // func (dfl *DoubleFileLogger) Debug(msg string) {
  144. // dfl.Log(DebugLevel, msg)
  145. // }
  146. // func (dfl *DoubleFileLogger) Debugf(format string, args ...interface{}) {
  147. // dfl.Logf(DebugLevel, format, args...)
  148. // }
  149. // func (dfl *DoubleFileLogger) Debugln(args ...interface{}) {
  150. // dfl.Logln(DebugLevel, args...)
  151. // }
  152. // func (dfl *DoubleFileLogger) Fatal(msg string) {
  153. // dfl.Log(FatalLevel, msg)
  154. // }
  155. // func (dfl *DoubleFileLogger) Fatalf(format string, args ...interface{}) {
  156. // dfl.Logf(FatalLevel, format, args...)
  157. // }
  158. // func (dfl *DoubleFileLogger) Fatalln(args ...interface{}) {
  159. // dfl.Logln(FatalLevel, args...)
  160. // }
  161. // func (dfl *DoubleFileLogger) Panic(msg string) {
  162. // dfl.Log(PanicLevel, msg)
  163. // }
  164. // func (dfl *DoubleFileLogger) Panicf(format string, args ...interface{}) {
  165. // dfl.Logf(PanicLevel, format, args...)
  166. // }
  167. // func (dfl *DoubleFileLogger) Panicln(args ...interface{}) {
  168. // dfl.Logln(PanicLevel, args...)
  169. // }
  170. // type NilFormatter struct {
  171. // }
  172. // func (nf *NilFormatter) Format(*logrus.Entry) ([]byte, error) {
  173. // return nil, nil
  174. // }
  175. // type NilWriter struct {
  176. // }
  177. // func (nf *NilWriter) Write(p []byte) (n int, err error) {
  178. // return 0, nil
  179. // }
  180. // func testDoubleFileLogger() {
  181. // logger, err := NewDoubleFileLogger("./logs/test.log", InfoLevel)
  182. // if err != nil {
  183. // panic(err)
  184. // }
  185. // // 记录日志
  186. // logger.Debug("这是一条调试日志,使用lfshook")
  187. // logger.Info("这是一条信息日志,使用lfshook")
  188. // // ... 其他日志
  189. // }