From 564eb72b40a32626cae26fd5a98c61dfc06d78da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felippe=20Dura=CC=81n?= Date: Tue, 15 Sep 2020 14:31:08 -0300 Subject: [PATCH 1/2] Remove logrus from eventsgateway API and use a generic logger interface instead --- README.md | 6 +- app/app.go | 7 +-- app/server.go | 6 +- app/server_suite_test.go | 9 +-- app/server_test.go | 4 +- client/async.go | 20 +++---- client/client.go | 14 ++--- client/client_suite_test.go | 9 +-- client/client_test.go | 10 ++-- client/client_whitebox_test.go | 3 +- client/sync.go | 14 ++--- client/sync_test.go | 4 +- cmd/load-test.go | 3 +- cmd/producer.go | 3 +- cmd/start.go | 3 +- loadtest/loadtest.go | 7 +-- loadtest/runner.go | 7 +-- logger/logger.go | 32 ++++++++++ logger/logrus/logrus.go | 105 +++++++++++++++++++++++++++++++++ logger/null.go | 73 +++++++++++++++++++++++ producer/producer.go | 7 +-- sender/kafka.go | 10 ++-- 22 files changed, 280 insertions(+), 76 deletions(-) create mode 100644 logger/logger.go create mode 100644 logger/logrus/logrus.go create mode 100644 logger/null.go diff --git a/README.md b/README.md index 49e5294..7257e3f 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ About client.NewClient(...) arguments: * configPrefix: whatever comes just before `client` portion of your config * config: a viper config with at least a `client` key holding Events Gateway settings -* logger: a logrus.FieldLogger instance +* logger: a logger.Logger instance * client: should be nil for most cases, except for unit testing * opts: extra []grpc.DialOption objects @@ -45,14 +45,14 @@ import ( "github.com/spf13/viper" "github.com/topfreegames/eventsgateway" - "github.com/sirupsen/logrus" + "github.com/topfreegames/eventsgateway/logger" ) func ConfigureEventsGateway() (*eventsgateway.Client, error) { config := viper.New() // empty Viper config config.Set("eventsgateway.client.async", true) config.Set("eventsgateway.client.kafkatopic", "my-client-default-topic") - logger := logrus.WithFields(logrus.Fields{"some": "field"}) + logger := &logger.NullLogger{} // Initialize you logger.Logger implementation here client, err := eventsgateway.NewClient("eventsgateway", config, logger, nil) if err != nil { return nil, err diff --git a/app/app.go b/app/app.go index 7bd15b1..9079661 100644 --- a/app/app.go +++ b/app/app.go @@ -32,6 +32,7 @@ import ( "time" goMetrics "github.com/rcrowley/go-metrics" + "github.com/topfreegames/eventsgateway/logger" "github.com/topfreegames/eventsgateway/metrics" "github.com/topfreegames/eventsgateway/sender" "github.com/topfreegames/extensions/jaeger" @@ -46,8 +47,6 @@ import ( "github.com/spf13/viper" kafka "github.com/topfreegames/go-extensions-kafka" pb "github.com/topfreegames/protos/eventsgateway/grpc/generated" - - "github.com/sirupsen/logrus" ) // App is the app structure @@ -56,12 +55,12 @@ type App struct { config *viper.Viper grpcServer *grpc.Server host string - log logrus.FieldLogger + log logger.Logger port int } // NewApp creates a new App object -func NewApp(host string, port int, log logrus.FieldLogger, config *viper.Viper) (*App, error) { +func NewApp(host string, port int, log logger.Logger, config *viper.Viper) (*App, error) { a := &App{ host: host, port: port, diff --git a/app/server.go b/app/server.go index 67a72c6..51c4ab4 100644 --- a/app/server.go +++ b/app/server.go @@ -25,19 +25,19 @@ package app import ( "context" - "github.com/sirupsen/logrus" + "github.com/topfreegames/eventsgateway/logger" "github.com/topfreegames/eventsgateway/sender" pb "github.com/topfreegames/protos/eventsgateway/grpc/generated" ) // Server struct type Server struct { - logger logrus.FieldLogger + logger logger.Logger sender sender.Sender } // NewServer returns a new grpc server -func NewServer(sender sender.Sender, logger logrus.FieldLogger) *Server { +func NewServer(sender sender.Sender, logger logger.Logger) *Server { s := &Server{ logger: logger, sender: sender, diff --git a/app/server_suite_test.go b/app/server_suite_test.go index 131c6f9..30f1fd3 100644 --- a/app/server_suite_test.go +++ b/app/server_suite_test.go @@ -27,12 +27,11 @@ import ( "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" - "github.com/sirupsen/logrus" - "github.com/sirupsen/logrus/hooks/test" "github.com/spf13/viper" "testing" + "github.com/topfreegames/eventsgateway/logger" "github.com/topfreegames/eventsgateway/mocks" . "github.com/topfreegames/eventsgateway/testing" mockpb "github.com/topfreegames/protos/eventsgateway/grpc/mock" @@ -45,16 +44,14 @@ func TestClient(t *testing.T) { var ( config *viper.Viper - hook *test.Hook - logger *logrus.Logger + log logger.Logger mockCtrl *gomock.Controller mockGRPCServer *mockpb.MockGRPCForwarderServer mockForwarder *mocks.MockForwarder ) var _ = BeforeEach(func() { - logger, hook = test.NewNullLogger() - logger.Level = logrus.DebugLevel + log = &logger.NullLogger{} config, _ = GetDefaultConfig() mockCtrl = gomock.NewController(GinkgoT()) diff --git a/app/server_test.go b/app/server_test.go index 7257044..f602c57 100644 --- a/app/server_test.go +++ b/app/server_test.go @@ -24,8 +24,8 @@ var _ = Describe("Client", func() { BeforeEach(func() { nowMs = time.Now().UnixNano() / 1000000 - sender := sender.NewKafkaSender(mockForwarder, logger, config) - s = app.NewServer(sender, logger) + sender := sender.NewKafkaSender(mockForwarder, log, config) + s = app.NewServer(sender, log) Expect(s).NotTo(BeNil()) }) diff --git a/client/async.go b/client/async.go index 7f2ccfc..9bc3727 100644 --- a/client/async.go +++ b/client/async.go @@ -17,8 +17,8 @@ import ( "github.com/grpc-ecosystem/grpc-opentracing/go/otgrpc" "github.com/opentracing/opentracing-go" uuid "github.com/satori/go.uuid" - "github.com/sirupsen/logrus" "github.com/spf13/viper" + "github.com/topfreegames/eventsgateway/logger" "github.com/topfreegames/eventsgateway/metrics" pb "github.com/topfreegames/protos/eventsgateway/grpc/generated" "google.golang.org/grpc" @@ -31,7 +31,7 @@ type gRPCClientAsync struct { eventsChannel chan *pb.Event lingerInterval time.Duration batchSize int - logger logrus.FieldLogger + logger logger.Logger maxRetries int retryInterval time.Duration timeout time.Duration @@ -41,7 +41,7 @@ type gRPCClientAsync struct { func newGRPCClientAsync( configPrefix string, config *viper.Viper, - logger logrus.FieldLogger, + logger logger.Logger, serverAddress string, client pb.GRPCForwarderClient, opts ...grpc.DialOption, @@ -76,7 +76,7 @@ func newGRPCClientAsync( a.config.SetDefault(timeoutConf, 500*time.Millisecond) a.timeout = a.config.GetDuration(timeoutConf) - a.logger = a.logger.WithFields(logrus.Fields{ + a.logger = a.logger.WithFields(map[string]interface{}{ "lingerInterval": a.lingerInterval, "batchSize": a.batchSize, "channelBuffer": channelBuffer, @@ -91,7 +91,7 @@ func newGRPCClientAsync( a.config.SetDefault(numRoutinesConf, 5) numSendRoutines := a.config.GetInt(numRoutinesConf) - a.logger = a.logger.WithFields(logrus.Fields{ + a.logger = a.logger.WithFields(map[string]interface{}{ "numRoutines": numSendRoutines, }) @@ -111,7 +111,7 @@ func (a *gRPCClientAsync) configureGRPCForwarderClient( a.client = client return nil } - a.logger.WithFields(logrus.Fields{ + a.logger.WithFields(map[string]interface{}{ "operation": "configureGRPCForwarderClient", }).Info("connecting to grpc server") tracer := opentracing.GlobalTracer() @@ -144,7 +144,7 @@ func (a *gRPCClientAsync) metricsReporterInterceptor( invoker grpc.UnaryInvoker, opts ...grpc.CallOption, ) error { - l := a.logger.WithFields(logrus.Fields{ + l := a.logger.WithFields(map[string]interface{}{ "method": method, }) @@ -160,7 +160,7 @@ func (a *gRPCClientAsync) metricsReporterInterceptor( retry, ).Observe(elapsedTime) } - l.WithFields(logrus.Fields{ + l.WithFields(map[string]interface{}{ "elapsedTime": elapsedTime, "reply": reply.(*pb.SendEventsResponse), }).Debug("request processed") @@ -240,7 +240,7 @@ func (a *gRPCClientAsync) sendRoutine() { } func (a *gRPCClientAsync) sendEvents(req *pb.SendEventsRequest, retryCount int) { - l := a.logger.WithFields(logrus.Fields{ + l := a.logger.WithFields(map[string]interface{}{ "operation": "sendEvents", "requestId": req.Id, "retryCount": retryCount, @@ -273,7 +273,7 @@ func (a *gRPCClientAsync) sendEvents(req *pb.SendEventsRequest, retryCount int) return } if res != nil && len(res.FailureIndexes) != 0 { - l.WithFields(logrus.Fields{ + l.WithFields(map[string]interface{}{ "failureIndexes": res.FailureIndexes, }).Error("failed to send events") time.Sleep(time.Duration(math.Pow(2, float64(retryCount))) * a.retryInterval) diff --git a/client/client.go b/client/client.go index 457c729..8c582de 100644 --- a/client/client.go +++ b/client/client.go @@ -15,8 +15,8 @@ import ( "time" uuid "github.com/satori/go.uuid" - "github.com/sirupsen/logrus" "github.com/spf13/viper" + "github.com/topfreegames/eventsgateway/logger" pb "github.com/topfreegames/protos/eventsgateway/grpc/generated" "google.golang.org/grpc" ) @@ -25,7 +25,7 @@ import ( type Client struct { client GRPCClient config *viper.Viper - logger logrus.FieldLogger + logger logger.Logger topic string wg sync.WaitGroup serverAddress string @@ -36,7 +36,7 @@ type Client struct { func NewClient( configPrefix string, config *viper.Viper, - logger logrus.FieldLogger, + logger logger.Logger, client pb.GRPCForwarderClient, opts ...grpc.DialOption, ) (*Client, error) { @@ -52,7 +52,7 @@ func NewClient( if c.topic == "" { return nil, fmt.Errorf("no kafka topic informed at %s", topicConf) } - c.logger = c.logger.WithFields(logrus.Fields{ + c.logger = c.logger.WithFields(map[string]interface{}{ "source": "eventsgateway/client", "topic": c.topic, }) @@ -76,7 +76,7 @@ func (c *Client) newGRPCClient( asyncConf := fmt.Sprintf("%sclient.async", configPrefix) c.config.SetDefault(asyncConf, false) async := c.config.GetBool(asyncConf) - c.logger = c.logger.WithFields(logrus.Fields{ + c.logger = c.logger.WithFields(map[string]interface{}{ "serverAddress": c.serverAddress, "async": async, }) @@ -92,7 +92,7 @@ func (c *Client) Send( name string, props map[string]string, ) error { - l := c.logger.WithFields(logrus.Fields{ + l := c.logger.WithFields(map[string]interface{}{ "operation": "send", "event": name, }) @@ -111,7 +111,7 @@ func (c *Client) SendToTopic( props map[string]string, topic string, ) error { - l := c.logger.WithFields(logrus.Fields{ + l := c.logger.WithFields(map[string]interface{}{ "operation": "sendToTopic", "event": name, "topic": topic, diff --git a/client/client_suite_test.go b/client/client_suite_test.go index 6f2b476..6be8270 100644 --- a/client/client_suite_test.go +++ b/client/client_suite_test.go @@ -12,9 +12,8 @@ import ( "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" - "github.com/sirupsen/logrus" - "github.com/sirupsen/logrus/hooks/test" "github.com/spf13/viper" + "github.com/topfreegames/eventsgateway/logger" "testing" @@ -29,15 +28,13 @@ func TestClient(t *testing.T) { var ( config *viper.Viper - hook *test.Hook - logger *logrus.Logger + log logger.Logger mockCtrl *gomock.Controller mockGRPCClient *mockpb.MockGRPCForwarderClient ) var _ = BeforeEach(func() { - logger, hook = test.NewNullLogger() - logger.Level = logrus.DebugLevel + log = &logger.NullLogger{} config, _ = GetDefaultConfig() mockCtrl = gomock.NewController(GinkgoT()) diff --git a/client/client_test.go b/client/client_test.go index 58c3f1b..409c41d 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -34,21 +34,21 @@ var _ = Describe("Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, logger, mockGRPCClient) + c, err = client.NewClient("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / 1000000 }) Describe("NewClient", func() { It("should return client if no error", func() { - c, err := client.NewClient("", config, logger, mockGRPCClient) + c, err := client.NewClient("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) Expect(c).NotTo(BeNil()) }) It("should return an error if no kafka topic", func() { config.Set("client.kafkatopic", "") - c, err := client.NewClient("", config, logger, mockGRPCClient) + c, err := client.NewClient("", config, log, mockGRPCClient) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("no kafka topic informed")) Expect(c).To(BeNil()) @@ -56,7 +56,7 @@ var _ = Describe("Client", func() { It("should return an error if no server address", func() { config.Set("client.grpc.serveraddress", "") - c, err := client.NewClient("", config, logger, mockGRPCClient) + c, err := client.NewClient("", config, log, mockGRPCClient) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("no grpc server address informed")) Expect(c).To(BeNil()) @@ -76,7 +76,7 @@ var _ = Describe("Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, logger, mockGRPCClient) + c, err = client.NewClient("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / int64(time.Millisecond) }) diff --git a/client/client_whitebox_test.go b/client/client_whitebox_test.go index 82ba1a1..868e9a5 100644 --- a/client/client_whitebox_test.go +++ b/client/client_whitebox_test.go @@ -15,6 +15,7 @@ import ( . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" + logruswrapper "github.com/topfreegames/eventsgateway/logger/logrus" . "github.com/topfreegames/eventsgateway/testing" mockpb "github.com/topfreegames/protos/eventsgateway/grpc/mock" ) @@ -36,7 +37,7 @@ var _ = Describe("Client Whitebox", func() { c, err = NewClient( "", config, - logger, + logruswrapper.NewWithLogger(logger), mockGRPCClient, ) Expect(err).NotTo(HaveOccurred()) diff --git a/client/sync.go b/client/sync.go index 7c4a2a5..53ab87f 100644 --- a/client/sync.go +++ b/client/sync.go @@ -14,8 +14,8 @@ import ( "github.com/grpc-ecosystem/grpc-opentracing/go/otgrpc" opentracing "github.com/opentracing/opentracing-go" - "github.com/sirupsen/logrus" "github.com/spf13/viper" + "github.com/topfreegames/eventsgateway/logger" "github.com/topfreegames/eventsgateway/metrics" pb "github.com/topfreegames/protos/eventsgateway/grpc/generated" "google.golang.org/grpc" @@ -25,14 +25,14 @@ type gRPCClientSync struct { client pb.GRPCForwarderClient config *viper.Viper conn *grpc.ClientConn - logger logrus.FieldLogger + logger logger.Logger timeout time.Duration } func newGRPCClientSync( configPrefix string, config *viper.Viper, - logger logrus.FieldLogger, + logger logger.Logger, serverAddress string, client pb.GRPCForwarderClient, opts ...grpc.DialOption, @@ -44,7 +44,7 @@ func newGRPCClientSync( timeoutConf := fmt.Sprintf("%sclient.grpc.timeout", configPrefix) s.config.SetDefault(timeoutConf, 500*time.Millisecond) s.timeout = s.config.GetDuration(timeoutConf) - s.logger = logger.WithFields(logrus.Fields{ + s.logger = logger.WithFields(map[string]interface{}{ "timeout": s.timeout, }) if err := s.configureGRPCForwarderClient( @@ -66,7 +66,7 @@ func (s *gRPCClientSync) configureGRPCForwarderClient( s.client = client return nil } - s.logger.WithFields(logrus.Fields{ + s.logger.WithFields(map[string]interface{}{ "operation": "configureGRPCForwarderClient", }).Info("connecting to grpc server") tracer := opentracing.GlobalTracer() @@ -99,7 +99,7 @@ func (s *gRPCClientSync) metricsReporterInterceptor( invoker grpc.UnaryInvoker, opts ...grpc.CallOption, ) error { - l := s.logger.WithFields(logrus.Fields{ + l := s.logger.WithFields(map[string]interface{}{ "method": method, }) @@ -112,7 +112,7 @@ func (s *gRPCClientSync) metricsReporterInterceptor( event.Topic, "0", ).Observe(elapsedTime) - l.WithFields(logrus.Fields{ + l.WithFields(map[string]interface{}{ "elapsedTime": elapsedTime, "reply": reply.(*pb.SendEventResponse), }).Debug("request processed") diff --git a/client/sync_test.go b/client/sync_test.go index d927ddb..20422d1 100644 --- a/client/sync_test.go +++ b/client/sync_test.go @@ -34,7 +34,7 @@ var _ = Describe("Sync Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, logger, mockGRPCClient) + c, err = client.NewClient("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / 1000000 }) @@ -52,7 +52,7 @@ var _ = Describe("Sync Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, logger, mockGRPCClient) + c, err = client.NewClient("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / 1000000 }) diff --git a/cmd/load-test.go b/cmd/load-test.go index 55f6813..433de08 100644 --- a/cmd/load-test.go +++ b/cmd/load-test.go @@ -26,6 +26,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" "github.com/topfreegames/eventsgateway/loadtest" + logruswrapper "github.com/topfreegames/eventsgateway/logger/logrus" ) // loadTest represents the testclient command @@ -41,7 +42,7 @@ var loadTest = &cobra.Command{ if json { log.Formatter = new(logrus.JSONFormatter) } - tc, err := loadtest.NewLoadTest(log, config) + tc, err := loadtest.NewLoadTest(logruswrapper.NewWithLogger(log), config) if err != nil { log.Panic(err) } diff --git a/cmd/producer.go b/cmd/producer.go index 63afd1f..f6b9032 100644 --- a/cmd/producer.go +++ b/cmd/producer.go @@ -25,6 +25,7 @@ package cmd import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" + logruswrapper "github.com/topfreegames/eventsgateway/logger/logrus" "github.com/topfreegames/eventsgateway/producer" ) @@ -41,7 +42,7 @@ var producerCMD = &cobra.Command{ if json { log.Formatter = new(logrus.JSONFormatter) } - p, err := producer.NewProducer(log, config) + p, err := producer.NewProducer(logruswrapper.NewWithLogger(log), config) if err != nil { log.Panic(err) } diff --git a/cmd/start.go b/cmd/start.go index 48c7ed7..38000a5 100644 --- a/cmd/start.go +++ b/cmd/start.go @@ -26,6 +26,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/cobra" "github.com/topfreegames/eventsgateway/app" + logruswrapper "github.com/topfreegames/eventsgateway/logger/logrus" ) var host string @@ -44,7 +45,7 @@ var startCmd = &cobra.Command{ if json { log.Formatter = new(logrus.JSONFormatter) } - a, err := app.NewApp(host, port, log, config) + a, err := app.NewApp(host, port, logruswrapper.NewWithLogger(log), config) if err != nil { log.Panic(err) } diff --git a/loadtest/loadtest.go b/loadtest/loadtest.go index 040bd4d..04957e4 100644 --- a/loadtest/loadtest.go +++ b/loadtest/loadtest.go @@ -31,22 +31,21 @@ import ( "time" "github.com/spf13/viper" - - "github.com/sirupsen/logrus" + "github.com/topfreegames/eventsgateway/logger" ) // LoadTest holds runners clients type LoadTest struct { config *viper.Viper duration time.Duration - log logrus.FieldLogger + log logger.Logger threads int runners []*runner wg sync.WaitGroup } // NewLoadTest ctor -func NewLoadTest(log logrus.FieldLogger, config *viper.Viper) (*LoadTest, error) { +func NewLoadTest(log logger.Logger, config *viper.Viper) (*LoadTest, error) { rand.Seed(time.Now().Unix()) lt := &LoadTest{ log: log, diff --git a/loadtest/runner.go b/loadtest/runner.go index b70e328..b8c2c93 100644 --- a/loadtest/runner.go +++ b/loadtest/runner.go @@ -30,15 +30,14 @@ import ( uuid "github.com/satori/go.uuid" "github.com/spf13/viper" "github.com/topfreegames/eventsgateway/client" - - "github.com/sirupsen/logrus" + "github.com/topfreegames/eventsgateway/logger" ) type runner struct { client *client.Client config *viper.Viper duration time.Duration - log logrus.FieldLogger + log logger.Logger randPropsSize string randSleepCeilingMs int sentCounter uint64 @@ -46,7 +45,7 @@ type runner struct { } func newRunner( - log logrus.FieldLogger, config *viper.Viper, + log logger.Logger, config *viper.Viper, ) (*runner, error) { rand.Seed(time.Now().Unix()) r := &runner{ diff --git a/logger/logger.go b/logger/logger.go new file mode 100644 index 0000000..d27ba39 --- /dev/null +++ b/logger/logger.go @@ -0,0 +1,32 @@ +package logger + +// Logger interface for loggers +type Logger interface { + Fatal(format ...interface{}) + Fatalf(format string, args ...interface{}) + Fatalln(args ...interface{}) + + Debug(args ...interface{}) + Debugf(format string, args ...interface{}) + Debugln(args ...interface{}) + + Error(args ...interface{}) + Errorf(format string, args ...interface{}) + Errorln(args ...interface{}) + + Info(args ...interface{}) + Infof(format string, args ...interface{}) + Infoln(args ...interface{}) + + Warn(args ...interface{}) + Warnf(format string, args ...interface{}) + Warnln(args ...interface{}) + + Panic(args ...interface{}) + Panicf(format string, args ...interface{}) + Panicln(args ...interface{}) + + WithFields(fields map[string]interface{}) Logger + WithField(key string, value interface{}) Logger + WithError(err error) Logger +} diff --git a/logger/logrus/logrus.go b/logger/logrus/logrus.go new file mode 100644 index 0000000..3e11e67 --- /dev/null +++ b/logger/logrus/logrus.go @@ -0,0 +1,105 @@ +package logrus + +import ( + "github.com/sirupsen/logrus" + "github.com/topfreegames/eventsgateway/logger" +) + +type logrusImpl struct { + impl logrus.FieldLogger +} + +// New returns a new logger.Logger implementation based on logrus +func New() logger.Logger { + log := logrus.New() + return NewWithLogger(log) +} + +// NewWithLogger returns a new logger.Logger implementation based on a provided logrus instance +func NewWithLogger(logger logrus.FieldLogger) logger.Logger { + return &logrusImpl{impl: logger} +} + +func (l *logrusImpl) Fatal(format ...interface{}) { + l.impl.Fatal(format...) +} + +func (l *logrusImpl) Fatalf(format string, args ...interface{}) { + l.impl.Fatalf(format, args...) +} + +func (l *logrusImpl) Fatalln(args ...interface{}) { + l.impl.Fatalln(args...) +} + +func (l *logrusImpl) Debug(args ...interface{}) { + l.impl.Debug(args...) +} + +func (l *logrusImpl) Debugf(format string, args ...interface{}) { + l.impl.Debugf(format, args...) +} + +func (l *logrusImpl) Debugln(args ...interface{}) { + l.impl.Debugln(args...) +} + +func (l *logrusImpl) Error(args ...interface{}) { + l.impl.Error(args...) +} + +func (l *logrusImpl) Errorf(format string, args ...interface{}) { + l.impl.Errorf(format, args...) +} + +func (l *logrusImpl) Errorln(args ...interface{}) { + l.impl.Errorln(args...) +} + +func (l *logrusImpl) Info(args ...interface{}) { + l.impl.Info(args...) +} + +func (l *logrusImpl) Infof(format string, args ...interface{}) { + l.impl.Infof(format, args...) +} + +func (l *logrusImpl) Infoln(args ...interface{}) { + l.impl.Infoln(args...) +} + +func (l *logrusImpl) Warn(args ...interface{}) { + l.impl.Warn(args...) +} + +func (l *logrusImpl) Warnf(format string, args ...interface{}) { + l.impl.Warnf(format, args...) +} + +func (l *logrusImpl) Warnln(args ...interface{}) { + l.impl.Warnln(args...) +} + +func (l *logrusImpl) Panic(args ...interface{}) { + l.impl.Panic(args...) +} + +func (l *logrusImpl) Panicf(format string, args ...interface{}) { + l.impl.Panicf(format, args...) +} + +func (l *logrusImpl) Panicln(args ...interface{}) { + l.impl.Panicln(args...) +} + +func (l *logrusImpl) WithFields(fields map[string]interface{}) logger.Logger { + return &logrusImpl{impl: l.impl.WithFields(fields)} + +} +func (l *logrusImpl) WithField(key string, value interface{}) logger.Logger { + return &logrusImpl{impl: l.impl.WithField(key, value)} +} + +func (l *logrusImpl) WithError(err error) logger.Logger { + return &logrusImpl{impl: l.impl.WithError(err)} +} diff --git a/logger/null.go b/logger/null.go new file mode 100644 index 0000000..74a8579 --- /dev/null +++ b/logger/null.go @@ -0,0 +1,73 @@ +package logger + +// NullLogger ... +type NullLogger struct{} + +// Fatal ... +func (n *NullLogger) Fatal(format ...interface{}) {} + +// Fatalf ... +func (n *NullLogger) Fatalf(format string, args ...interface{}) {} + +// Fatalln ... +func (n *NullLogger) Fatalln(args ...interface{}) {} + +// Debug ... +func (n *NullLogger) Debug(args ...interface{}) {} + +// Debugf ... +func (n *NullLogger) Debugf(format string, args ...interface{}) {} + +// Debugln ... +func (n *NullLogger) Debugln(args ...interface{}) {} + +// Error ... +func (n *NullLogger) Error(args ...interface{}) {} + +// Errorf ... +func (n *NullLogger) Errorf(format string, args ...interface{}) {} + +// Errorln ... +func (n *NullLogger) Errorln(args ...interface{}) {} + +// Info ... +func (n *NullLogger) Info(args ...interface{}) {} + +// Infof ... +func (n *NullLogger) Infof(format string, args ...interface{}) {} + +// Infoln ... +func (n *NullLogger) Infoln(args ...interface{}) {} + +// Warn ... +func (n *NullLogger) Warn(args ...interface{}) {} + +// Warnf ... +func (n *NullLogger) Warnf(format string, args ...interface{}) {} + +// Warnln ... +func (n *NullLogger) Warnln(args ...interface{}) {} + +// Panic ... +func (n *NullLogger) Panic(args ...interface{}) {} + +// Panicf ... +func (n *NullLogger) Panicf(format string, args ...interface{}) {} + +// Panicln ... +func (n *NullLogger) Panicln(args ...interface{}) {} + +// WithFields ... +func (n *NullLogger) WithFields(fields map[string]interface{}) Logger { + return n +} + +// WithField ... +func (n *NullLogger) WithField(key string, value interface{}) Logger { + return n +} + +// WithError ... +func (n *NullLogger) WithError(err error) Logger { + return n +} diff --git a/producer/producer.go b/producer/producer.go index 3c70fbb..e5fa856 100644 --- a/producer/producer.go +++ b/producer/producer.go @@ -28,20 +28,19 @@ import ( "github.com/spf13/viper" "github.com/topfreegames/eventsgateway/client" - - "github.com/sirupsen/logrus" + "github.com/topfreegames/eventsgateway/logger" ) // Producer is the app strupure type Producer struct { - log logrus.FieldLogger + log logger.Logger config *viper.Viper client *client.Client } // NewProducer creates test client func NewProducer( - log logrus.FieldLogger, config *viper.Viper, + log logger.Logger, config *viper.Viper, ) (*Producer, error) { p := &Producer{ log: log, diff --git a/sender/kafka.go b/sender/kafka.go index cc09f77..6d3355b 100644 --- a/sender/kafka.go +++ b/sender/kafka.go @@ -14,10 +14,10 @@ import ( "sync" "time" - "github.com/sirupsen/logrus" "github.com/spf13/viper" avro "github.com/topfreegames/avro/go/eventsgateway/generated" "github.com/topfreegames/eventsgateway/forwarder" + "github.com/topfreegames/eventsgateway/logger" kafka "github.com/topfreegames/go-extensions-kafka" pb "github.com/topfreegames/protos/eventsgateway/grpc/generated" "google.golang.org/grpc/codes" @@ -26,14 +26,14 @@ import ( type KafkaSender struct { config *viper.Viper - logger logrus.FieldLogger + logger logger.Logger producer forwarder.Forwarder topicPrefix string } func NewKafkaSender( producer forwarder.Forwarder, - logger logrus.FieldLogger, + logger logger.Logger, config *viper.Viper, ) *KafkaSender { k := &KafkaSender{producer: producer, logger: logger, config: config} @@ -69,7 +69,7 @@ func (k *KafkaSender) SendEvent( ctx context.Context, event *pb.Event, ) error { - l := k.logger.WithFields(logrus.Fields{ + l := k.logger.WithFields(map[string]interface{}{ "topic": event.GetTopic(), "event": event, }) @@ -114,7 +114,7 @@ func (k *KafkaSender) SendEvent( if err != nil { return err } - l.WithFields(logrus.Fields{ + l.WithFields(map[string]interface{}{ "partition": partition, "offset": offset, }).Debug("event sent to kafka") From 1c43a0b742f7f207f82e5bb00a1a4cc9db2c9cdb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felippe=20Dura=CC=81n?= Date: Tue, 15 Sep 2020 14:51:40 -0300 Subject: [PATCH 2/2] Add old constructor for retro compatibility --- client/client.go | 16 +++++++++++++++- client/client_test.go | 10 +++++----- client/client_whitebox_test.go | 2 +- client/sync_test.go | 4 ++-- loadtest/runner.go | 2 +- producer/producer.go | 2 +- 6 files changed, 25 insertions(+), 11 deletions(-) diff --git a/client/client.go b/client/client.go index 8c582de..411ca12 100644 --- a/client/client.go +++ b/client/client.go @@ -15,8 +15,10 @@ import ( "time" uuid "github.com/satori/go.uuid" + "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/topfreegames/eventsgateway/logger" + logruswrapper "github.com/topfreegames/eventsgateway/logger/logrus" pb "github.com/topfreegames/protos/eventsgateway/grpc/generated" "google.golang.org/grpc" ) @@ -31,9 +33,21 @@ type Client struct { serverAddress string } -// NewClient ctor +// NewClient ctor (DEPRECATED, use New() instead) // configPrefix is whatever comes before `client` subpart of config func NewClient( + configPrefix string, + config *viper.Viper, + logger logrus.FieldLogger, + client pb.GRPCForwarderClient, + opts ...grpc.DialOption, +) (*Client, error) { + return New(configPrefix, config, logruswrapper.NewWithLogger(logger), client, opts...) +} + +// New ctor +// configPrefix is whatever comes before `client` subpart of config +func New( configPrefix string, config *viper.Viper, logger logger.Logger, diff --git a/client/client_test.go b/client/client_test.go index 409c41d..2e76cf1 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -34,21 +34,21 @@ var _ = Describe("Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, log, mockGRPCClient) + c, err = client.New("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / 1000000 }) Describe("NewClient", func() { It("should return client if no error", func() { - c, err := client.NewClient("", config, log, mockGRPCClient) + c, err := client.New("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) Expect(c).NotTo(BeNil()) }) It("should return an error if no kafka topic", func() { config.Set("client.kafkatopic", "") - c, err := client.NewClient("", config, log, mockGRPCClient) + c, err := client.New("", config, log, mockGRPCClient) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("no kafka topic informed")) Expect(c).To(BeNil()) @@ -56,7 +56,7 @@ var _ = Describe("Client", func() { It("should return an error if no server address", func() { config.Set("client.grpc.serveraddress", "") - c, err := client.NewClient("", config, log, mockGRPCClient) + c, err := client.New("", config, log, mockGRPCClient) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("no grpc server address informed")) Expect(c).To(BeNil()) @@ -76,7 +76,7 @@ var _ = Describe("Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, log, mockGRPCClient) + c, err = client.New("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / int64(time.Millisecond) }) diff --git a/client/client_whitebox_test.go b/client/client_whitebox_test.go index 868e9a5..7c8cd71 100644 --- a/client/client_whitebox_test.go +++ b/client/client_whitebox_test.go @@ -34,7 +34,7 @@ var _ = Describe("Client Whitebox", func() { mockCtrl := gomock.NewController(GinkgoT()) mockGRPCClient := mockpb.NewMockGRPCForwarderClient(mockCtrl) config.Set("client.async", true) - c, err = NewClient( + c, err = New( "", config, logruswrapper.NewWithLogger(logger), diff --git a/client/sync_test.go b/client/sync_test.go index 20422d1..d14cb48 100644 --- a/client/sync_test.go +++ b/client/sync_test.go @@ -34,7 +34,7 @@ var _ = Describe("Sync Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, log, mockGRPCClient) + c, err = client.New("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / 1000000 }) @@ -52,7 +52,7 @@ var _ = Describe("Sync Client", func() { BeforeEach(func() { var err error - c, err = client.NewClient("", config, log, mockGRPCClient) + c, err = client.New("", config, log, mockGRPCClient) Expect(err).NotTo(HaveOccurred()) now = time.Now().UnixNano() / 1000000 }) diff --git a/loadtest/runner.go b/loadtest/runner.go index b8c2c93..bbb89ed 100644 --- a/loadtest/runner.go +++ b/loadtest/runner.go @@ -58,7 +58,7 @@ func newRunner( func (r *runner) configure() error { r.config.Set("client.kafkatopic", randomTopic()) - c, err := client.NewClient("", r.config, r.log, nil) + c, err := client.New("", r.config, r.log, nil) if err != nil { return err } diff --git a/producer/producer.go b/producer/producer.go index e5fa856..7929ebf 100644 --- a/producer/producer.go +++ b/producer/producer.go @@ -51,7 +51,7 @@ func NewProducer( } func (p *Producer) configure() error { - c, err := client.NewClient("", p.config, p.log, nil) + c, err := client.New("", p.config, p.log, nil) if err != nil { return err }