From 0ff058bd255a27de4b11e9b539a505281b799f45 Mon Sep 17 00:00:00 2001 From: fuxiaohei Date: Fri, 11 Jul 2014 10:01:49 +0800 Subject: [PATCH 1/3] code style simplify --- cache/memory.go | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/cache/memory.go b/cache/memory.go index 68147d96..cc4835c1 100644 --- a/cache/memory.go +++ b/cache/memory.go @@ -49,15 +49,14 @@ func NewMemoryCache() *MemoryCache { func (bc *MemoryCache) Get(name string) interface{} { bc.lock.RLock() defer bc.lock.RUnlock() - itm, ok := bc.items[name] - if !ok { - return nil + if itm, ok := bc.items[name]; ok { + if (time.Now().Unix() - itm.Lastaccess.Unix()) > itm.expired { + go bc.Delete(name) + return nil + } + return itm.val } - if (time.Now().Unix() - itm.Lastaccess.Unix()) > itm.expired { - go bc.Delete(name) - return nil - } - return itm.val + return nil } // Put cache to memory. @@ -65,12 +64,11 @@ func (bc *MemoryCache) Get(name string) interface{} { func (bc *MemoryCache) Put(name string, value interface{}, expired int64) error { bc.lock.Lock() defer bc.lock.Unlock() - t := MemoryItem{ + bc.items[name] = &MemoryItem{ val: value, Lastaccess: time.Now(), expired: expired, } - bc.items[name] = &t return nil } @@ -82,8 +80,7 @@ func (bc *MemoryCache) Delete(name string) error { return errors.New("key not exist") } delete(bc.items, name) - _, valid := bc.items[name] - if valid { + if _, ok := bc.items[name]; ok { return errors.New("delete key error") } return nil @@ -214,8 +211,7 @@ func (bc *MemoryCache) item_expired(name string) bool { if !ok { return true } - sec := time.Now().Unix() - itm.Lastaccess.Unix() - if sec >= itm.expired { + if time.Now().Unix()-itm.Lastaccess.Unix() >= itm.expired { delete(bc.items, name) return true } From a906bf1174dd79d6817fb1688d1e3f4a12e37069 Mon Sep 17 00:00:00 2001 From: fuxiaohei Date: Sat, 12 Jul 2014 09:52:15 +0800 Subject: [PATCH 2/3] code style simplify --- cache/memcache/memcache.go | 80 +++++++++++++++----------------------- 1 file changed, 31 insertions(+), 49 deletions(-) diff --git a/cache/memcache/memcache.go b/cache/memcache/memcache.go index a7c9f197..2cb478b9 100644 --- a/cache/memcache/memcache.go +++ b/cache/memcache/memcache.go @@ -7,7 +7,7 @@ // @license http://github.com/astaxie/beego/blob/master/LICENSE // // @authors astaxie -package cache +package memcache import ( "encoding/json" @@ -20,7 +20,7 @@ import ( // Memcache adapter. type MemcacheCache struct { - c *memcache.Connection + conn *memcache.Connection conninfo string } @@ -31,32 +31,23 @@ func NewMemCache() *MemcacheCache { // get value from memcache. func (rc *MemcacheCache) Get(key string) interface{} { - if rc.c == nil { - var err error - rc.c, err = rc.connectInit() - if err != nil { + if rc.conn == nil { + if err := rc.connectInit(); err != nil { return err } } - v, err := rc.c.Get(key) - if err != nil { - return nil + if v, err := rc.conn.Get(key); err == nil { + if len(v) > 0 { + return string(v[0].Value) + } } - var contain interface{} - if len(v) > 0 { - contain = string(v[0].Value) - } else { - contain = nil - } - return contain + return nil } // put value to memcache. only support string. func (rc *MemcacheCache) Put(key string, val interface{}, timeout int64) error { - if rc.c == nil { - var err error - rc.c, err = rc.connectInit() - if err != nil { + if rc.conn == nil { + if err := rc.connectInit(); err != nil { return err } } @@ -64,7 +55,7 @@ func (rc *MemcacheCache) Put(key string, val interface{}, timeout int64) error { if !ok { return errors.New("val must string") } - stored, err := rc.c.Set(key, 0, uint64(timeout), []byte(v)) + stored, err := rc.conn.Set(key, 0, uint64(timeout), []byte(v)) if err == nil && stored == false { return errors.New("stored fail") } @@ -73,60 +64,52 @@ func (rc *MemcacheCache) Put(key string, val interface{}, timeout int64) error { // delete value in memcache. func (rc *MemcacheCache) Delete(key string) error { - if rc.c == nil { - var err error - rc.c, err = rc.connectInit() - if err != nil { + if rc.conn == nil { + if err := rc.connectInit(); err != nil { return err } } - _, err := rc.c.Delete(key) + _, err := rc.conn.Delete(key) return err } // [Not Support] // increase counter. -func (rc *MemcacheCache) Incr(key string) error { +func (rc *MemcacheCache) Incr(_ string) error { return errors.New("not support in memcache") } // [Not Support] // decrease counter. -func (rc *MemcacheCache) Decr(key string) error { +func (rc *MemcacheCache) Decr(_ string) error { return errors.New("not support in memcache") } // check value exists in memcache. func (rc *MemcacheCache) IsExist(key string) bool { - if rc.c == nil { - var err error - rc.c, err = rc.connectInit() - if err != nil { + if rc.conn == nil { + if err := rc.connectInit(); err != nil { return false } } - v, err := rc.c.Get(key) + v, err := rc.conn.Get(key) if err != nil { return false } if len(v) == 0 { return false - } else { - return true } + return true } // clear all cached in memcache. func (rc *MemcacheCache) ClearAll() error { - if rc.c == nil { - var err error - rc.c, err = rc.connectInit() - if err != nil { + if rc.conn == nil { + if err := rc.connectInit(); err != nil { return err } } - err := rc.c.FlushAll() - return err + return rc.conn.FlushAll() } // start memcache adapter. @@ -139,23 +122,22 @@ func (rc *MemcacheCache) StartAndGC(config string) error { return errors.New("config has no conn key") } rc.conninfo = cf["conn"] - var err error - if rc.c != nil { - rc.c, err = rc.connectInit() - if err != nil { - return errors.New("dial tcp conn error") + if rc.conn == nil { + if err := rc.connectInit(); err != nil { + return err } } return nil } // connect to memcache and keep the connection. -func (rc *MemcacheCache) connectInit() (*memcache.Connection, error) { +func (rc *MemcacheCache) connectInit() error { c, err := memcache.Connect(rc.conninfo) if err != nil { - return nil, err + return err } - return c, nil + rc.conn = c + return nil } func init() { From 0e3e22efbea4eab1ae3b373339fc4ef26114595b Mon Sep 17 00:00:00 2001 From: fuxiaohei Date: Sat, 12 Jul 2014 09:57:43 +0800 Subject: [PATCH 3/3] merge update --- logs/conn.go | 2 +- logs/conn_test.go | 2 +- logs/console.go | 16 ++++--- logs/console_test.go | 37 +++++++++------ logs/file.go | 2 +- logs/file_test.go | 41 +++++++++------- logs/log.go | 109 +++++++++++++++++++++++++++++++------------ logs/smtp.go | 2 +- 8 files changed, 138 insertions(+), 73 deletions(-) diff --git a/logs/conn.go b/logs/conn.go index e7b0464f..b7255b5c 100644 --- a/logs/conn.go +++ b/logs/conn.go @@ -48,7 +48,7 @@ func (c *ConnWriter) Init(jsonconfig string) error { // write message in connection. // if connection is down, try to re-connect. func (c *ConnWriter) WriteMsg(msg string, level int) error { - if level < c.Level { + if level > c.Level { return nil } if c.neddedConnectOnMsg() { diff --git a/logs/conn_test.go b/logs/conn_test.go index 3108ca15..4e200424 100644 --- a/logs/conn_test.go +++ b/logs/conn_test.go @@ -16,5 +16,5 @@ import ( func TestConn(t *testing.T) { log := NewLogger(1000) log.SetLogger("conn", `{"net":"tcp","addr":":7020"}`) - log.Info("info") + log.Informational("informational") } diff --git a/logs/console.go b/logs/console.go index e552c92d..96a34c0f 100644 --- a/logs/console.go +++ b/logs/console.go @@ -27,12 +27,14 @@ func NewBrush(color string) Brush { } var colors = []Brush{ - NewBrush("1;36"), // Trace cyan - NewBrush("1;34"), // Debug blue - NewBrush("1;32"), // Info green - NewBrush("1;33"), // Warn yellow + NewBrush("1;37"), // Emergency white + NewBrush("1;36"), // Alert cyan + NewBrush("1;35"), // Critical magenta NewBrush("1;31"), // Error red - NewBrush("1;35"), // Critical purple + NewBrush("1;33"), // Warning yellow + NewBrush("1;32"), // Notice green + NewBrush("1;34"), // Informational green + NewBrush("1;30"), // Debug black } // ConsoleWriter implements LoggerInterface and writes messages to terminal. @@ -45,7 +47,7 @@ type ConsoleWriter struct { func NewConsole() LoggerInterface { cw := new(ConsoleWriter) cw.lg = log.New(os.Stdout, "", log.Ldate|log.Ltime) - cw.Level = LevelTrace + cw.Level = LevelDebug return cw } @@ -64,7 +66,7 @@ func (c *ConsoleWriter) Init(jsonconfig string) error { // write message in console. func (c *ConsoleWriter) WriteMsg(msg string, level int) error { - if level < c.Level { + if level > c.Level { return nil } if goos := runtime.GOOS; goos == "windows" { diff --git a/logs/console_test.go b/logs/console_test.go index fe08d4f8..8b775baa 100644 --- a/logs/console_test.go +++ b/logs/console_test.go @@ -13,22 +13,29 @@ import ( "testing" ) +// Try each log level in decreasing order of priority. +func testConsoleCalls(bl *BeeLogger) { + bl.Emergency("emergency") + bl.Alert("alert") + bl.Critical("critical") + bl.Error("error") + bl.Warning("warning") + bl.Notice("notice") + bl.Informational("informational") + bl.Debug("debug") +} + +// Test console logging by visually comparing the lines being output with and +// without a log level specification. func TestConsole(t *testing.T) { - log := NewLogger(10000) - log.EnableFuncCallDepth(true) - log.SetLogger("console", "") - log.Trace("trace") - log.Info("info") - log.Warn("warning") - log.Debug("debug") - log.Critical("critical") + log1 := NewLogger(10000) + log1.EnableFuncCallDepth(true) + log1.SetLogger("console", "") + testConsoleCalls(log1) + log2 := NewLogger(100) - log2.SetLogger("console", `{"level":1}`) - log.Trace("trace") - log.Info("info") - log.Warn("warning") - log.Debug("debug") - log.Critical("critical") + log2.SetLogger("console", `{"level":3}`) + testConsoleCalls(log2) } func BenchmarkConsole(b *testing.B) { @@ -36,6 +43,6 @@ func BenchmarkConsole(b *testing.B) { log.EnableFuncCallDepth(true) log.SetLogger("console", "") for i := 0; i < b.N; i++ { - log.Trace("trace") + log.Debug("debug") } } diff --git a/logs/file.go b/logs/file.go index 512df983..2d371a1e 100644 --- a/logs/file.go +++ b/logs/file.go @@ -141,7 +141,7 @@ func (w *FileLogWriter) docheck(size int) { // write logger message into file. func (w *FileLogWriter) WriteMsg(msg string, level int) error { - if level < w.Level { + if level > w.Level { return nil } n := 24 + len(msg) // 24 stand for the length "2013/06/23 21:00:22 [T] " diff --git a/logs/file_test.go b/logs/file_test.go index bc88d607..66ebb01c 100644 --- a/logs/file_test.go +++ b/logs/file_test.go @@ -13,6 +13,7 @@ import ( "bufio" "fmt" "os" + "strconv" "testing" "time" ) @@ -20,12 +21,14 @@ import ( func TestFile(t *testing.T) { log := NewLogger(10000) log.SetLogger("file", `{"filename":"test.log"}`) - log.Trace("test") - log.Info("info") log.Debug("debug") - log.Warn("warning") + log.Informational("info") + log.Notice("notice") + log.Warning("warning") log.Error("error") + log.Alert("alert") log.Critical("critical") + log.Emergency("emergency") time.Sleep(time.Second * 4) f, err := os.Open("test.log") if err != nil { @@ -42,21 +45,24 @@ func TestFile(t *testing.T) { linenum++ } } - if linenum != 6 { - t.Fatal(linenum, "not line 6") + var expected = LevelDebug + 1 + if linenum != expected { + t.Fatal(linenum, "not "+strconv.Itoa(expected)+" lines") } os.Remove("test.log") } func TestFile2(t *testing.T) { log := NewLogger(10000) - log.SetLogger("file", `{"filename":"test2.log","level":2}`) - log.Trace("test") - log.Info("info") + log.SetLogger("file", fmt.Sprintf(`{"filename":"test2.log","level":%d}`, LevelError)) log.Debug("debug") - log.Warn("warning") + log.Info("info") + log.Notice("notice") + log.Warning("warning") log.Error("error") + log.Alert("alert") log.Critical("critical") + log.Emergency("emergency") time.Sleep(time.Second * 4) f, err := os.Open("test2.log") if err != nil { @@ -73,8 +79,9 @@ func TestFile2(t *testing.T) { linenum++ } } - if linenum != 4 { - t.Fatal(linenum, "not line 4") + var expected = LevelError + 1 + if linenum != expected { + t.Fatal(linenum, "not "+strconv.Itoa(expected)+" lines") } os.Remove("test2.log") } @@ -82,17 +89,19 @@ func TestFile2(t *testing.T) { func TestFileRotate(t *testing.T) { log := NewLogger(10000) log.SetLogger("file", `{"filename":"test3.log","maxlines":4}`) - log.Trace("test") - log.Info("info") log.Debug("debug") - log.Warn("warning") + log.Info("info") + log.Notice("notice") + log.Warning("warning") log.Error("error") + log.Alert("alert") log.Critical("critical") + log.Emergency("emergency") time.Sleep(time.Second * 4) rotatename := "test3.log" + fmt.Sprintf(".%s.%03d", time.Now().Format("2006-01-02"), 1) b, err := exists(rotatename) if !b || err != nil { - t.Fatal("rotate not gen") + t.Fatal("rotate not generated") } os.Remove(rotatename) os.Remove("test3.log") @@ -113,7 +122,7 @@ func BenchmarkFile(b *testing.B) { log := NewLogger(100000) log.SetLogger("file", `{"filename":"test4.log"}`) for i := 0; i < b.N; i++ { - log.Trace("trace") + log.Debug("debug") } os.Remove("test4.log") } diff --git a/logs/log.go b/logs/log.go index b62105ec..bb737bfe 100644 --- a/logs/log.go +++ b/logs/log.go @@ -16,14 +16,25 @@ import ( "sync" ) +// RFC5424 log message levels. const ( - // log message levels - LevelTrace = iota - LevelDebug - LevelInfo - LevelWarn - LevelError + LevelEmergency = iota + LevelAlert LevelCritical + LevelError + LevelWarning + LevelNotice + LevelInformational + LevelDebug +) + +// Legacy loglevel constants to ensure backwards compatibility. +// +// Deprecated: will be removed in 1.5.0. +const ( + LevelInfo = LevelInformational + LevelTrace = LevelDebug + LevelWarn = LevelWarning ) type loggerType func() LoggerInterface @@ -72,6 +83,7 @@ type logMsg struct { // if the buffering chan is full, logger adapters write to file or other way. func NewLogger(channellen int64) *BeeLogger { bl := new(BeeLogger) + bl.level = LevelDebug bl.loggerFuncCallDepth = 2 bl.msg = make(chan *logMsg, channellen) bl.outputs = make(map[string]LoggerInterface) @@ -113,7 +125,7 @@ func (bl *BeeLogger) DelLogger(adaptername string) error { } func (bl *BeeLogger) writerMsg(loglevel int, msg string) error { - if bl.level > loglevel { + if loglevel > bl.level { return nil } lm := new(logMsg) @@ -133,8 +145,10 @@ func (bl *BeeLogger) writerMsg(loglevel int, msg string) error { return nil } -// set log message level. -// if message level (such as LevelTrace) is less than logger level (such as LevelWarn), ignore message. +// Set log message level. +// +// If message level (such as LevelDebug) is higher than logger level (such as LevelWarning), +// log providers will not even be sent the message. func (bl *BeeLogger) SetLevel(l int) { bl.level = l } @@ -162,40 +176,73 @@ func (bl *BeeLogger) startLogger() { } } -// log trace level message. -func (bl *BeeLogger) Trace(format string, v ...interface{}) { - msg := fmt.Sprintf("[T] "+format, v...) - bl.writerMsg(LevelTrace, msg) -} - -// log debug level message. -func (bl *BeeLogger) Debug(format string, v ...interface{}) { +// Log EMERGENCY level message. +func (bl *BeeLogger) Emergency(format string, v ...interface{}) { msg := fmt.Sprintf("[D] "+format, v...) - bl.writerMsg(LevelDebug, msg) + bl.writerMsg(LevelEmergency, msg) } -// log info level message. -func (bl *BeeLogger) Info(format string, v ...interface{}) { - msg := fmt.Sprintf("[I] "+format, v...) - bl.writerMsg(LevelInfo, msg) +// Log ALERT level message. +func (bl *BeeLogger) Alert(format string, v ...interface{}) { + msg := fmt.Sprintf("[D] "+format, v...) + bl.writerMsg(LevelAlert, msg) } -// log warn level message. -func (bl *BeeLogger) Warn(format string, v ...interface{}) { - msg := fmt.Sprintf("[W] "+format, v...) - bl.writerMsg(LevelWarn, msg) +// Log CRITICAL level message. +func (bl *BeeLogger) Critical(format string, v ...interface{}) { + msg := fmt.Sprintf("[C] "+format, v...) + bl.writerMsg(LevelCritical, msg) } -// log error level message. +// Log ERROR level message. func (bl *BeeLogger) Error(format string, v ...interface{}) { msg := fmt.Sprintf("[E] "+format, v...) bl.writerMsg(LevelError, msg) } -// log critical level message. -func (bl *BeeLogger) Critical(format string, v ...interface{}) { - msg := fmt.Sprintf("[C] "+format, v...) - bl.writerMsg(LevelCritical, msg) +// Log WARNING level message. +func (bl *BeeLogger) Warning(format string, v ...interface{}) { + msg := fmt.Sprintf("[W] "+format, v...) + bl.writerMsg(LevelWarning, msg) +} + +// Log NOTICE level message. +func (bl *BeeLogger) Notice(format string, v ...interface{}) { + msg := fmt.Sprintf("[W] "+format, v...) + bl.writerMsg(LevelNotice, msg) +} + +// Log INFORMATIONAL level message. +func (bl *BeeLogger) Informational(format string, v ...interface{}) { + msg := fmt.Sprintf("[I] "+format, v...) + bl.writerMsg(LevelInformational, msg) +} + +// Log DEBUG level message. +func (bl *BeeLogger) Debug(format string, v ...interface{}) { + msg := fmt.Sprintf("[D] "+format, v...) + bl.writerMsg(LevelDebug, msg) +} + +// Log WARN level message. +// +// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0. +func (bl *BeeLogger) Warn(format string, v ...interface{}) { + bl.Warning(format, v...) +} + +// Log INFO level message. +// +// Deprecated: compatibility alias for Informational(), Will be removed in 1.5.0. +func (bl *BeeLogger) Info(format string, v ...interface{}) { + bl.Informational(format, v...) +} + +// Log TRACE level message. +// +// Deprecated: compatibility alias for Debug(), Will be removed in 1.5.0. +func (bl *BeeLogger) Trace(format string, v ...interface{}) { + bl.Debug(format, v...) } // flush all chan data. diff --git a/logs/smtp.go b/logs/smtp.go index b45b2fbb..d492a61a 100644 --- a/logs/smtp.go +++ b/logs/smtp.go @@ -57,7 +57,7 @@ func (s *SmtpWriter) Init(jsonconfig string) error { // write message in smtp writer. // it will send an email with subject and only this message. func (s *SmtpWriter) WriteMsg(msg string, level int) error { - if level < s.Level { + if level > s.Level { return nil }