@@ -20,113 +20,114 @@ import (
2020 "bytes"
2121 "fmt"
2222 "os"
23- "path"
24- "path/filepath"
2523 "strings"
2624
25+ "github.com/pkg/errors"
2726 "github.com/sirupsen/logrus"
27+ "gopkg.in/natefinch/lumberjack.v2"
2828)
2929
3030// DefaultLogTimeFormat defines the timestamp format.
3131const DefaultLogTimeFormat = "2006-01-02 15:04:05.000"
3232
33- // InitLog initializes the file logger for process.
34- // logfile is used to stored generated log in local filesystem.
35- func InitLog (debug bool , logFilePath string , sign string ) error {
36- // set the log level
37- logLevel := logrus .InfoLevel
38- if debug {
39- logLevel = logrus .DebugLevel
40- }
33+ // Option is a functional configuration for the given logrus logger
34+ type Option func (l * logrus.Logger ) error
4135
42- // create and log file
43- if err := os . MkdirAll ( filepath . Dir ( logFilePath ), 0755 ); err != nil {
44- return fmt . Errorf ( "failed to create log file %s: %v" , logFilePath , err )
45- }
46- logFile , err := os . OpenFile ( logFilePath , os . O_CREATE | os . O_RDWR | os . O_APPEND , 0644 )
47- if err != nil {
48- return err
36+ // WithDebug sets the log level to debug
37+ func WithDebug ( debug bool ) Option {
38+ return func ( l * logrus. Logger ) error {
39+ if debug {
40+ l . SetLevel ( logrus . DebugLevel )
41+ }
42+ return nil
4943 }
50- logFile . Seek ( 0 , 2 )
44+ }
5145
52- // create formatter for default log Logger
53- formatter := & DragonflyFormatter {
54- TimestampFormat : DefaultLogTimeFormat ,
55- Sign : sign ,
46+ func getLumberjack (l * logrus.Logger ) * lumberjack.Logger {
47+ if logger , ok := l .Out .(* lumberjack.Logger ); ok {
48+ return logger
5649 }
57-
58- // set all details in log default logger
59- logrus .SetLevel (logLevel )
60- logrus .SetOutput (logFile )
61- logrus .SetFormatter (formatter )
6250 return nil
6351}
6452
65- // InitConsoleLog initializes console logger for process.
66- // console log will output the dfget client's log in console/terminal for
67- // debugging usage.
68- func InitConsoleLog (debug bool , sign string ) {
69- formatter := & DragonflyFormatter {
70- TimestampFormat : DefaultLogTimeFormat ,
71- Sign : sign ,
72- }
53+ // WithLogFile sets the logger to output to the given file, with log rotation.
54+ // If the given file is empty, nothing will be done.
55+ func WithLogFile (f string ) Option {
56+ return func (l * logrus.Logger ) error {
57+ if f == "" {
58+ return nil
59+ }
7360
74- logLevel := logrus .InfoLevel
75- if debug {
76- logLevel = logrus .DebugLevel
77- }
61+ if logger := getLumberjack (l ); logger == nil {
62+ l .SetOutput (& lumberjack.Logger {
63+ Filename : f ,
64+ MaxSize : 20 , // mb
65+ MaxBackups : 1 ,
66+ })
67+ } else {
68+ logger .Filename = f
69+ }
7870
79- consoleLog := & logrus.Logger {
80- Out : os .Stdout ,
81- Formatter : formatter ,
82- Hooks : make (logrus.LevelHooks ),
83- Level : logLevel ,
71+ return nil
8472 }
85- hook := & ConsoleHook {
86- logger : consoleLog ,
87- levels : logrus .AllLevels ,
88- }
89- logrus .AddHook (hook )
9073}
9174
92- // CreateLogger creates a Logger.
93- func CreateLogger (logPath string , logName string , logLevel string , sign string ) (* logrus.Logger , error ) {
94- // parse log level
95- level , err := logrus .ParseLevel (logLevel )
96- if err != nil {
97- level = logrus .InfoLevel
75+ // WithMaxSizeMB sets the max size of log files in MB. If the logger is not configured
76+ // to use a log file, an error is returned.
77+ func WithMaxSizeMB (max uint ) Option {
78+ return func (l * logrus.Logger ) error {
79+ if logger := getLumberjack (l ); logger != nil {
80+ logger .MaxSize = int (max )
81+ return nil
82+ }
83+ return errors .Errorf ("lumberjack is not configured" )
9884 }
85+ }
9986
100- // create log file path
101- logFilePath := path .Join (logPath , logName )
102- if err := os .MkdirAll (filepath .Dir (logFilePath ), 0755 ); err != nil {
103- return nil , err
87+ // WithConsole add a hook to output logs to stdout
88+ func WithConsole () Option {
89+ return func (l * logrus.Logger ) error {
90+ consoleLog := & logrus.Logger {
91+ Out : os .Stdout ,
92+ Formatter : l .Formatter ,
93+ Hooks : make (logrus.LevelHooks ),
94+ Level : l .Level ,
95+ }
96+ hook := & ConsoleHook {
97+ logger : consoleLog ,
98+ levels : logrus .AllLevels ,
99+ }
100+ l .AddHook (hook )
101+ return nil
104102 }
103+ }
105104
106- // open log file
107- logFile , err := os .OpenFile (logFilePath , os .O_CREATE | os .O_WRONLY | os .O_APPEND , 0644 )
108- if err != nil {
109- return nil , err
105+ // WithSign sets the sign in formatter
106+ func WithSign (sign string ) Option {
107+ return func (l * logrus.Logger ) error {
108+ l .Formatter = & DragonflyFormatter {
109+ TimestampFormat : DefaultLogTimeFormat ,
110+ Sign : sign ,
111+ }
112+ return nil
110113 }
111-
112- logFile .Seek (0 , 2 )
113- Logger := logrus .New ()
114- Logger .Out = logFile
115- Logger .Formatter = & DragonflyFormatter {TimestampFormat : DefaultLogTimeFormat , Sign : sign }
116- Logger .Level = level
117- return Logger , nil
118114}
119115
120- // AddConsoleLog will add a ConsoleLog into Logger's hooks.
121- // It will output logs to console when Logger's outputting logs.
122- func AddConsoleLog (Logger * logrus.Logger ) {
123- consoleLog := & logrus.Logger {
124- Out : os .Stdout ,
125- Formatter : Logger .Formatter ,
126- Hooks : make (logrus.LevelHooks ),
127- Level : Logger .Level ,
116+ // Init initializes the logger with given options. If no option is provided,
117+ // the logger's formatter will be set with an empty sign.
118+ func Init (l * logrus.Logger , opts ... Option ) error {
119+ opts = append ([]Option {
120+ WithSign ("" ),
121+ }, opts ... )
122+ for _ , opt := range opts {
123+ if err := opt (l ); err != nil {
124+ return err
125+ }
128126 }
129- Logger .Hooks .Add (& ConsoleHook {logger : consoleLog , levels : logrus .AllLevels })
127+ if logger , ok := l .Out .(* lumberjack.Logger ); ok {
128+ return logger .Rotate ()
129+ }
130+ return nil
130131}
131132
132133// ConsoleHook shows logs on console.
@@ -207,10 +208,3 @@ func (f *DragonflyFormatter) appendValue(b *bytes.Buffer, value interface{}, wit
207208 b .WriteByte (' ' )
208209 }
209210}
210-
211- // ----------------------------------------------------------------------------
212-
213- // IsDebug returns the log level is debug.
214- func IsDebug (level logrus.Level ) bool {
215- return level >= logrus .DebugLevel
216- }
0 commit comments