From 6c05c42c445ea1e8cf6bcb949a21042feaff97da Mon Sep 17 00:00:00 2001
From: Shane Neuerburg <shaneneuerburg@gmail.com>
Date: Fri, 21 Oct 2016 19:31:24 -0600
Subject: [PATCH] Add command line flag to cgr-engine for logging levels

This adds a new -log_level flag to cgr-engine, defaulting to 5 (INFO). The logger has been extended to drop log messages that do not meet or exceed the log level requested.
---
 CONTRIBUTORS.md                    |   1 +
 cmd/cgr-engine/cgr-engine.go       |   2 +
 sessionmanager/fssessionmanager.go |   5 +-
 sessionmanager/kamailiosm.go       |   3 +-
 utils/logger.go                    | 124 ++++++++++++++++++++++++++---
 5 files changed, 118 insertions(+), 17 deletions(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 07cec5b9b..2b41cf331 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -50,6 +50,7 @@ information, please see the [`CONTRIBUTING.md`](CONTRIBUTING.md) file.
 | @andmar | André Maricato |
 | @brendangilmore | Brendan Gilmore |
 | @afone-lboue | Ludovic Boué |
+| @shaneneuerburg | Shane Neuerburg |
 
 <!-- to sign, include a single line above this comment containing the following text:
 | @username | First Last |
diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go
index 089a8f222..077eed670 100644
--- a/cmd/cgr-engine/cgr-engine.go
+++ b/cmd/cgr-engine/cgr-engine.go
@@ -66,6 +66,7 @@ var (
 	cpuprofile        = flag.String("cpuprofile", "", "write cpu profile to file")
 	scheduledShutdown = flag.String("scheduled_shutdown", "", "shutdown the engine after this duration")
 	singlecpu         = flag.Bool("singlecpu", false, "Run on single CPU core")
+	logLevel          = flag.Int("log_level", 8, "Log level (2-alert to 9-debug)")
 
 	cfg   *config.CGRConfig
 	smRpc *v1.SessionManagerV1
@@ -568,6 +569,7 @@ func main() {
 			exitChan <- true
 		}()
 	}
+	utils.Logger.SetLogLevel(*logLevel)
 	cfg, err = config.NewCGRConfigFromFolder(*cfgDir)
 	if err != nil {
 		utils.Logger.Crit(fmt.Sprintf("Could not parse config: %s exiting!", err))
diff --git a/sessionmanager/fssessionmanager.go b/sessionmanager/fssessionmanager.go
index c74ceca15..1219a0860 100644
--- a/sessionmanager/fssessionmanager.go
+++ b/sessionmanager/fssessionmanager.go
@@ -20,7 +20,6 @@ package sessionmanager
 import (
 	"errors"
 	"fmt"
-	"log/syslog"
 	"reflect"
 	"strconv"
 	"strings"
@@ -270,7 +269,7 @@ func (sm *FSSessionManager) Connect() error {
 	errChan := make(chan error)
 	for _, connCfg := range sm.cfg.EventSocketConns {
 		connId := utils.GenUUID()
-		fSock, err := fsock.NewFSock(connCfg.Address, connCfg.Password, connCfg.Reconnects, sm.createHandlers(), eventFilters, utils.Logger.(*syslog.Writer), connId)
+		fSock, err := fsock.NewFSock(connCfg.Address, connCfg.Password, connCfg.Reconnects, sm.createHandlers(), eventFilters, utils.Logger.GetSyslog(), connId)
 		if err != nil {
 			return err
 		} else if !fSock.Connected() {
@@ -284,7 +283,7 @@ func (sm *FSSessionManager) Connect() error {
 			}
 		}()
 		if fsSenderPool, err := fsock.NewFSockPool(5, connCfg.Address, connCfg.Password, 1, sm.cfg.MaxWaitConnection,
-			make(map[string][]func(string, string)), make(map[string]string), utils.Logger.(*syslog.Writer), connId); err != nil {
+			make(map[string][]func(string, string)), make(map[string]string), utils.Logger.GetSyslog(), connId); err != nil {
 			return fmt.Errorf("Cannot connect FreeSWITCH senders pool, error: %s", err.Error())
 		} else if fsSenderPool == nil {
 			return errors.New("Cannot connect FreeSWITCH senders pool.")
diff --git a/sessionmanager/kamailiosm.go b/sessionmanager/kamailiosm.go
index ff87abfa2..a9966e29f 100644
--- a/sessionmanager/kamailiosm.go
+++ b/sessionmanager/kamailiosm.go
@@ -20,7 +20,6 @@ package sessionmanager
 import (
 	"errors"
 	"fmt"
-	"log/syslog"
 	"regexp"
 	"time"
 
@@ -171,7 +170,7 @@ func (self *KamailioSessionManager) Connect() error {
 	errChan := make(chan error)
 	for _, connCfg := range self.cfg.EvapiConns {
 		connId := utils.GenUUID()
-		if self.conns[connId], err = kamevapi.NewKamEvapi(connCfg.Address, connId, connCfg.Reconnects, eventHandlers, utils.Logger.(*syslog.Writer)); err != nil {
+		if self.conns[connId], err = kamevapi.NewKamEvapi(connCfg.Address, connId, connCfg.Reconnects, eventHandlers, utils.Logger.GetSyslog()); err != nil {
 			return err
 		}
 		go func() { // Start reading in own goroutine, return on error
diff --git a/utils/logger.go b/utils/logger.go
index 4e84c1a2e..3acc9460a 100644
--- a/utils/logger.go
+++ b/utils/logger.go
@@ -27,15 +27,25 @@ import (
 var Logger LoggerInterface
 
 func init() {
+	Logger = new(StdLogger)
+
+	// Attempt to connect to syslog. We'll fallback to `log` otherwise.
 	var err error
-	Logger, err = syslog.New(syslog.LOG_INFO, "CGRateS")
+	var l *syslog.Writer
+	l, err = syslog.New(syslog.LOG_INFO, "CGRateS")
 	if err != nil {
-		Logger = new(StdLogger)
 		Logger.Err(fmt.Sprintf("Could not connect to syslog: %v", err))
+	} else {
+		Logger.SetSyslog(l)
 	}
 }
 
 type LoggerInterface interface {
+	SetSyslog(log *syslog.Writer)
+	SetLogLevel(level int)
+
+	GetSyslog() *syslog.Writer
+
 	Alert(m string) error
 	Close() error
 	Crit(m string) error
@@ -47,42 +57,132 @@ type LoggerInterface interface {
 	Warning(m string) error
 }
 
-// Logs to standard output
-type StdLogger struct{}
+const (
+	LOGLEVEL_DEBUG     = 9
+	LOGLEVEL_INFO      = 8
+	LOGLEVEL_NOTICE    = 7
+	LOGLEVEL_WARNING   = 6
+	LOGLEVEL_ERROR     = 5
+	LOGLEVEL_CRITICAL  = 4
+	LOGLEVEL_EMERGENCY = 3
+	LOGLEVEL_ALERT     = 2
+)
 
+// Logs to standard output
+type StdLogger struct {
+	logLevel int
+	syslog   *syslog.Writer
+}
+
+func (sl *StdLogger) SetSyslog(l *syslog.Writer) {
+	sl.syslog = l
+}
+func (sl *StdLogger) GetSyslog() *syslog.Writer {
+	return sl.syslog
+}
+func (sl *StdLogger) SetLogLevel(level int) {
+	sl.logLevel = level
+}
 func (sl *StdLogger) Alert(m string) (err error) {
-	log.Print("[ALERT]" + m)
+	if sl.logLevel < LOGLEVEL_ALERT {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Alert(m)
+	} else {
+		log.Print("[ALERT]" + m)
+	}
 	return
 }
 func (sl *StdLogger) Close() (err error) {
+	if sl.syslog != nil {
+		sl.Close()
+	}
 	return
 }
 func (sl *StdLogger) Crit(m string) (err error) {
-	log.Print("[CRITICAL]" + m)
+	if sl.logLevel < LOGLEVEL_CRITICAL {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Crit(m)
+	} else {
+		log.Print("[CRITICAL]" + m)
+	}
 	return
 }
 func (sl *StdLogger) Debug(m string) (err error) {
-	log.Print("[DEBUG]" + m)
+	if sl.logLevel < LOGLEVEL_DEBUG {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Debug(m)
+	} else {
+		log.Print("[DEBUG]" + m)
+	}
 	return
 }
 func (sl *StdLogger) Emerg(m string) (err error) {
-	log.Print("[EMERGENCY]" + m)
+	if sl.logLevel < LOGLEVEL_EMERGENCY {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Emerg(m)
+	} else {
+		log.Print("[EMERGENCY]" + m)
+	}
 	return
 }
 func (sl *StdLogger) Err(m string) (err error) {
-	log.Print("[ERROR]" + m)
+	if sl.logLevel < LOGLEVEL_ERROR {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Err(m)
+	} else {
+		log.Print("[ERROR]" + m)
+	}
 	return
 }
 func (sl *StdLogger) Info(m string) (err error) {
-	log.Print("[INFO]" + m)
+	if sl.logLevel < LOGLEVEL_INFO {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Info(m)
+	} else {
+		log.Print("[INFO]" + m)
+	}
 	return
 }
 func (sl *StdLogger) Notice(m string) (err error) {
-	log.Print("[NOTICE]" + m)
+	if sl.logLevel < LOGLEVEL_NOTICE {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Notice(m)
+	} else {
+		log.Print("[NOTICE]" + m)
+	}
 	return
 }
 func (sl *StdLogger) Warning(m string) (err error) {
-	log.Print("[WARNING]" + m)
+	if sl.logLevel < LOGLEVEL_WARNING {
+		return
+	}
+
+	if sl.syslog != nil {
+		sl.syslog.Warning(m)
+	} else {
+		log.Print("[WARNING]" + m)
+	}
 	return
 }