INtegrated efs in logger/ees + ers changes

engine/kafka_logger.go

@@ -0,0 +1,268 @@
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://.gnu.org/licenses/>
+*/
+
+package engine
+
+import (
+	"fmt"
+	"log/syslog"
+	"sync"
+	"time"
+
+	"github.com/cgrates/birpc/context"
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/utils"
+	"github.com/segmentio/kafka-go"
+)
+
+func NewLogger(loggerType, tnt, nodeID string,
+	connMgr *ConnManager, cfg *config.CGRConfig) (utils.LoggerInterface, error) {
+	switch loggerType {
+	case utils.MetaKafkaLog:
+		return NewExportLogger(nodeID, tnt, cfg.LoggerCfg().Level, connMgr, cfg), nil
+	case utils.MetaStdLog, utils.MetaSysLog:
+		return utils.NewLogger(loggerType, nodeID, cfg.LoggerCfg().Level)
+	default:
+		return nil, fmt.Errorf("unsupported logger: <%+s>", loggerType)
+	}
+}
+
+// Logs to kafka
+type ExportLogger struct {
+	sync.Mutex
+	cfg     *config.CGRConfig
+	connMgr *ConnManager
+
+	LogLevel   int
+	FldPostDir string
+	Writer     *kafka.Writer
+	NodeID     string
+	Tenant     string
+}
+
+// NewExportLogger will export loggers to kafka
+func NewExportLogger(nodeID, tenant string, level int,
+	connMgr *ConnManager, cfg *config.CGRConfig) (el *ExportLogger) {
+	el = &ExportLogger{
+		connMgr:    connMgr,
+		cfg:        cfg,
+		LogLevel:   level,
+		FldPostDir: cfg.LoggerCfg().Opts.FailedPostsDir,
+		NodeID:     nodeID,
+		Tenant:     tenant,
+		Writer: &kafka.Writer{
+			Addr:        kafka.TCP(cfg.LoggerCfg().Opts.KafkaConn),
+			Topic:       cfg.LoggerCfg().Opts.KafkaTopic,
+			MaxAttempts: cfg.LoggerCfg().Opts.KafkaAttempts,
+		},
+	}
+	return
+}
+
+func (el *ExportLogger) Close() (err error) {
+	if el.Writer != nil {
+		err = el.Writer.Close()
+		el.Writer = nil
+	}
+	return
+}
+
+func (el *ExportLogger) call(m string, level int) (err error) {
+	eventExport := &utils.CGREvent{
+		Tenant: el.Tenant,
+		Event: map[string]interface{}{
+			utils.NodeID:    el.NodeID,
+			utils.Message:   m,
+			utils.Severity:  level,
+			utils.Timestamp: time.Now().Format("2006-01-02 15:04:05"),
+		},
+	}
+	// event will be exported through kafka as json format
+	var content []byte
+	if content, err = utils.ToUnescapedJSON(eventExport); err != nil {
+		return
+	}
+	if err = el.Writer.WriteMessages(context.Background(), kafka.Message{
+		Key:   []byte(utils.GenUUID()),
+		Value: content,
+	}); err != nil {
+		// if there are any errors in kafka, we will post in FailedPostDirectory
+		args := &utils.ArgsFailedPosts{
+			Tenant:    el.Tenant,
+			Path:      el.Writer.Addr.String(),
+			Event:     eventExport,
+			FailedDir: el.FldPostDir,
+			Module:    utils.Kafka,
+			APIOpts:   el.GetMeta(),
+		}
+		var reply string
+		if err = el.connMgr.Call(context.Background(), el.cfg.LoggerCfg().EFsConns,
+			utils.EfSv1ProcessEvent, args, &reply); err != nil {
+			utils.Logger.Warning(
+				fmt.Sprintf("<%s> Exporter could not writte failed event with <%s> service because err: <%s>",
+					utils.Logger, utils.EFs, err.Error()))
+		}
+		// also the content should be printed as a stdout logger type
+		return utils.ErrLoggerChanged
+	}
+	return
+}
+
+func (el *ExportLogger) Write(p []byte) (n int, err error) {
+	n = len(p)
+	err = el.call(string(p), 8)
+	return
+}
+
+func (sl *ExportLogger) GetSyslog() *syslog.Writer {
+	return nil
+}
+
+// GetLogLevel() returns the level logger number for the server
+func (el *ExportLogger) GetLogLevel() int {
+	return el.LogLevel
+}
+
+// SetLogLevel changes the log level
+func (el *ExportLogger) SetLogLevel(level int) {
+	el.LogLevel = level
+}
+
+// Alert logs to EEs with alert level
+func (el *ExportLogger) Alert(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_ALERT {
+		return nil
+	}
+	if err = el.call(m, utils.LOGLEVEL_ALERT); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Alert(m)
+			err = nil
+		}
+	}
+	return
+}
+
+// Crit logs to EEs with critical level
+func (el *ExportLogger) Crit(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_CRITICAL {
+		return nil
+	}
+	if el.call(m, utils.LOGLEVEL_CRITICAL); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Crit(m)
+			err = nil
+		}
+	}
+	return
+}
+
+// Debug logs to EEs with debug level
+func (el *ExportLogger) Debug(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_DEBUG {
+		return nil
+	}
+	if err = el.call(m, utils.LOGLEVEL_DEBUG); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Debug(m)
+			err = nil
+		}
+	}
+	return
+}
+
+// Emerg logs to EEs with emergency level
+func (el *ExportLogger) Emerg(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_EMERGENCY {
+		return nil
+	}
+	if err = el.call(m, utils.LOGLEVEL_EMERGENCY); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Emerg(m)
+			err = nil
+		}
+	}
+	return
+}
+
+// Err logs to EEs with error level
+func (el *ExportLogger) Err(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_ERROR {
+		return nil
+	}
+	if err = el.call(m, utils.LOGLEVEL_ERROR); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Err(m)
+			err = nil
+		}
+	}
+	return
+}
+
+// Info logs to EEs with info level
+func (el *ExportLogger) Info(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_INFO {
+		return nil
+	}
+	if err = el.call(m, utils.LOGLEVEL_INFO); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Info(m)
+			err = nil
+		}
+	}
+	return
+}
+
+// Notice logs to EEs with notice level
+func (el *ExportLogger) Notice(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_NOTICE {
+		return nil
+	}
+	if err = el.call(m, utils.LOGLEVEL_NOTICE); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Notice(m)
+			err = nil
+		}
+	}
+	return
+}
+
+// Warning logs to EEs with warning level
+func (el *ExportLogger) Warning(m string) (err error) {
+	if el.LogLevel < utils.LOGLEVEL_WARNING {
+		return nil
+	}
+	if err = el.call(m, utils.LOGLEVEL_WARNING); err != nil {
+		if err == utils.ErrLoggerChanged {
+			utils.NewStdLogger(el.NodeID, el.LogLevel).Warning(m)
+			err = nil
+		}
+	}
+	return
+}
+
+func (el *ExportLogger) GetMeta() map[string]interface{} {
+	return map[string]interface{}{
+		utils.Tenant:         el.Tenant,
+		utils.NodeID:         el.NodeID,
+		utils.Level:          el.LogLevel,
+		utils.Format:         el.Writer.Topic,
+		utils.Conn:           el.Writer.Addr.String(),
+		utils.FailedPostsDir: el.FldPostDir,
+		utils.Attempts:       el.Writer.MaxAttempts,
+	}
+}

engine/kafka_logger_test.go

@@ -0,0 +1,507 @@
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package engine
+
+/*
+func TestLoggerNewLoggerExport(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	exp := &ExportLogger{
+		logLevel: 6,
+		nodeID:   "123",
+		tenant:   "cgrates.org",
+		loggOpts: cfg.LoggerCfg().Opts,
+		writer: &kafka.Writer{
+			Addr:        kafka.TCP(cfg.LoggerCfg().Opts.KafkaConn),
+			Topic:       cfg.LoggerCfg().Opts.KafkaTopic,
+			MaxAttempts: cfg.LoggerCfg().Opts.Attempts,
+		},
+	}
+	if rcv, err := NewLogger(utils.MetaKafka, "cgrates.org", "123", cfg.LoggerCfg()); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(rcv.(*ExportLogger), exp) {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
+	}
+}
+
+func TestLoggerNewLoggerDefault(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	experr := `unsupported logger: <invalid>`
+	if _, err := NewLogger("invalid", "cgrates.org", "123", cfg.LoggerCfg()); err == nil ||
+		err.Error() != experr {
+		t.Errorf("expected: <%s>, \nreceived: <%s>", experr, err)
+	}
+}
+
+func TestLoggerNewExportLogger(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	exp := &ExportLogger{
+		logLevel: 7,
+		nodeID:   "123",
+		tenant:   "cgrates.org",
+		loggOpts: cfg.LoggerCfg().Opts,
+		writer: &kafka.Writer{
+			Addr:        kafka.TCP(cfg.LoggerCfg().Opts.KafkaConn),
+			Topic:       cfg.LoggerCfg().Opts.KafkaTopic,
+			MaxAttempts: cfg.LoggerCfg().Opts.Attempts,
+		},
+	}
+	if rcv := NewExportLogger("123", "cgrates.org", 7, cfg.LoggerCfg().Opts); !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
+	}
+}
+
+func TestLoggerExportEmerg(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Emergency message",
+							"Severity":   utils.LOGLEVEL_EMERGENCY,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", -1, cfg.LoggerCfg().Opts)
+
+	if err := el.Emerg("Emergency message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(0)
+	if err := el.Emerg("Emergency message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerExportAlert(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Alert message",
+							"Severity":   utils.LOGLEVEL_ALERT,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 0, cfg.LoggerCfg().Opts)
+
+	if err := el.Alert("Alert message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(1)
+	if err := el.Alert("Alert message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerExportCrit(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Critical message",
+							"Severity":   utils.LOGLEVEL_CRITICAL,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 1, cfg.LoggerCfg().Opts)
+
+	if err := el.Crit("Critical message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(2)
+	if err := el.Crit("Critical message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerExportErr(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Error message",
+							"Severity":   utils.LOGLEVEL_ERROR,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 2, cfg.LoggerCfg().Opts)
+
+	if err := el.Err("Error message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(3)
+	if err := el.Err("Error message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerExportWarning(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Warning message",
+							"Severity":   utils.LOGLEVEL_WARNING,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 3, cfg.LoggerCfg().Opts)
+
+	if err := el.Warning("Warning message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(4)
+	if err := el.Warning("Warning message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerExportNotice(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Notice message",
+							"Severity":   utils.LOGLEVEL_NOTICE,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 4, cfg.LoggerCfg().Opts)
+
+	if err := el.Notice("Notice message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(5)
+	if err := el.Notice("Notice message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerExportInfo(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Info message",
+							"Severity":   utils.LOGLEVEL_INFO,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 5, cfg.LoggerCfg().Opts)
+
+	if err := el.Info("Info message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(6)
+	if err := el.Info("Info message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerExportDebug(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "Debug message",
+							"Severity":   utils.LOGLEVEL_DEBUG,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 6, cfg.LoggerCfg().Opts)
+
+	if err := el.Debug("Debug message"); err != nil {
+		t.Error(err)
+	}
+	el.SetLogLevel(7)
+	if err := el.Debug("Debug message"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLoggerSetGetLogLevel(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	el := NewExportLogger("123", "cgrates.org", 6, cfg.LoggerCfg().Opts)
+	if rcv := el.GetLogLevel(); rcv != 6 {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", 6, rcv)
+	}
+	el.SetLogLevel(3)
+	if rcv := el.GetLogLevel(); rcv != 3 {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", 3, rcv)
+	}
+}
+
+func TestLoggerGetSyslog(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	el := NewExportLogger("123", "cgrates.org", 6, cfg.LoggerCfg().Opts)
+	if el.GetSyslog() != nil {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", nil, el.GetSyslog())
+	}
+}
+
+func TestLoggerExportWrite(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CoreSCfg().EEsConns = []string{eesConn}
+	Cache = NewCacheS(cfg, nil, nil)
+	cM := NewConnManager(cfg)
+	ccM := &ccMock{
+		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+				delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
+				exp := &utils.CGREventWithEeIDs{
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						Event: map[string]interface{}{
+							utils.NodeID: "123",
+							"Message":    "message",
+							"Severity":   8,
+						},
+					},
+				}
+				if !reflect.DeepEqual(exp, args) {
+					return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
+						utils.ToJSON(exp), utils.ToJSON(args))
+				}
+				return nil
+			},
+		},
+	}
+	rpcInternal := make(chan birpc.ClientConnector, 1)
+	rpcInternal <- ccM
+	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+
+	el := NewExportLogger("123", "cgrates.org", 8, cfg.LoggerCfg().Opts)
+
+	if _, err := el.Write([]byte("message")); err != nil {
+		t.Error(err)
+	}
+	el.Close()
+} */