Refactoring: change logger library

aopoltorzhicky · aopoltorzhicky · commit 65c27aa17cf4 · 2021-12-07T15:25:25.000+03:00
diff --git a/database/db.go b/database/db.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/dipdup-net/go-lib/config"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
+	"github.com/rs/zerolog/log"
 )
 
 // Database -
@@ -29,7 +29,7 @@ var (
 
 // Wait -
 func Wait(ctx context.Context, db driver.Pinger, checkPeriod time.Duration) {
-	logrus.Info("Waiting database is up and runnning")
+	log.Info().Msg("Waiting database is up and runnning")
 	if err := db.Ping(ctx); err == nil {
 		return
 	}
@@ -41,7 +41,7 @@ func Wait(ctx context.Context, db driver.Pinger, checkPeriod time.Duration) {
 			return
 		case <-ticker.C:
 			if err := db.Ping(ctx); err == nil {
-				logrus.Warn(err)
+				log.Warn().Err(err).Msg("")
 				continue
 			}
 			return
diff --git a/go.mod b/go.mod
@@ -12,19 +12,18 @@ require (
 	github.com/json-iterator/go v1.1.12
 	github.com/pkg/errors v0.9.1
 	github.com/prometheus/client_golang v1.11.0
+	github.com/rs/zerolog v1.26.0
 	github.com/sergi/go-diff v1.2.0
-	github.com/shopspring/decimal v0.0.0-20200227202807-02e2044944cc
-	github.com/sirupsen/logrus v1.7.0
+	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.7.0
-	github.com/tidwall/gjson v1.9.3
-	github.com/yhirose/go-peg v0.0.0-20210119023502-a1af152bac31
-	golang.org/x/crypto v0.0.0-20210921155107-089bfa567519
-	golang.org/x/sys v0.0.0-20211031064116-611d5d643895 // indirect
+	github.com/tidwall/gjson v1.12.1
+	github.com/yhirose/go-peg v0.0.0-20210804202551-de25d6753cf1
+	golang.org/x/crypto v0.0.0-20211202192323-5770296d904e
+	golang.org/x/sys v0.0.0-20211205182925-97ca703d548d // indirect
 	golang.org/x/text v0.3.7
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/yaml.v2 v2.4.0
-	gorm.io/driver/mysql v1.0.5
-	gorm.io/driver/postgres v1.0.8
-	gorm.io/driver/sqlite v1.1.4
-	gorm.io/gorm v1.21.8
+	gorm.io/driver/mysql v1.2.1
+	gorm.io/driver/postgres v1.2.3
+	gorm.io/driver/sqlite v1.2.6
+	gorm.io/gorm v1.22.4
 )
diff --git a/go.sum b/go.sum
diff --git a/hasura/hasura.go b/hasura/hasura.go
@@ -13,15 +13,15 @@ import (
 	"github.com/iancoleman/strcase"
 	"github.com/pkg/errors"
 
-	log "github.com/sirupsen/logrus"
+	"github.com/rs/zerolog/log"
 )
 
 const (
 	allowedQueries = "allowed-queries"
 )
 
 func checkHealth(ctx context.Context, api *API) {
-	log.Info("Waiting hasura is up and running")
+	log.Info().Msg("Waiting hasura is up and running")
 	if err := api.Health(ctx); err != nil {
 		return
 	}
@@ -32,7 +32,7 @@ func checkHealth(ctx context.Context, api *API) {
 			return
 		case <-ticker.C:
 			if err := api.Health(ctx); err != nil {
-				log.Warn(err)
+				log.Warn().Err(err).Msg("")
 				continue
 			}
 			return
@@ -54,13 +54,13 @@ func Create(ctx context.Context, hasura *config.Hasura, cfg config.Database, vie
 		return err
 	}
 
-	log.Info("Fetching existing metadata...")
+	log.Info().Msg("Fetching existing metadata...")
 	export, err := api.ExportMetadata(ctx, metadata)
 	if err != nil {
 		return err
 	}
 
-	log.Info("Merging metadata...")
+	log.Info().Msg("Merging metadata...")
 	tables := make(map[string]struct{})
 	for i := range metadata.Tables {
 		tables[metadata.Tables[i].Schema.Name] = struct{}{}
@@ -76,13 +76,13 @@ func Create(ctx context.Context, hasura *config.Hasura, cfg config.Database, vie
 		return err
 	}
 
-	log.Info("Replacing metadata...")
+	log.Info().Msg("Replacing metadata...")
 	if err := api.ReplaceMetadata(ctx, metadata); err != nil {
 		return err
 	}
 
 	if len(metadata.QueryCollections) > 0 && (hasura.Rest == nil || *hasura.Rest) {
-		log.Info("Creating REST endpoints...")
+		log.Info().Msg("Creating REST endpoints...")
 		for _, query := range metadata.QueryCollections[0].Definition.Queries {
 			if err := api.CreateRestEndpoint(ctx, query.Name, query.Name, query.Name, allowedQueries); err != nil {
 				if e, ok := err.(APIError); !ok || !e.AlreadyExists() {
@@ -92,15 +92,15 @@ func Create(ctx context.Context, hasura *config.Hasura, cfg config.Database, vie
 		}
 	}
 
-	log.Info("Tracking views...")
+	log.Info().Msg("Tracking views...")
 	for i := range views {
 		if err := api.TrackTable(ctx, "public", views[i]); err != nil {
 			if !strings.Contains(err.Error(), "view/table already tracked") {
 				return err
 			}
 		}
 		if err := api.DropSelectPermissions(ctx, views[i], "user"); err != nil {
-			log.Warn(err)
+			log.Warn().Err(err).Msg("")
 		}
 		if err := api.CreateSelectPermissions(ctx, views[i], "user", Permission{
 			Limit:     hasura.RowsLimit,
diff --git a/node/monitor.go b/node/monitor.go
@@ -10,7 +10,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
+	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -137,7 +137,7 @@ func (monitor *Monitor) pollingMempool(ctx context.Context, filter string) {
 			return
 		default:
 			if err := monitor.process(ctx, filter, url); err != nil {
-				log.Error(err)
+				log.Err(err).Msg("")
 				continue
 			}
 
diff --git a/tzkt/events/signalr/hub.go b/tzkt/events/signalr/hub.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/gorilla/websocket"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
+	"github.com/rs/zerolog/log"
 )
 
 var (
@@ -62,7 +62,7 @@ func (hub *Hub) Connect() error {
 }
 
 func (hub *Hub) handshake() error {
-	log.Tracef("connecting to %s...", hub.url.String())
+	log.Trace().Msgf("connecting to %s...", hub.url.String())
 
 	c, _, err := websocket.DefaultDialer.Dial(hub.url.String(), nil)
 	if err != nil {
@@ -82,7 +82,7 @@ func (hub *Hub) handshake() error {
 	if resp.Error != "" {
 		return errors.Wrap(ErrHandshake, resp.Error)
 	}
-	log.Trace("connected")
+	log.Trace().Msg("connected")
 
 	return nil
 }
@@ -106,16 +106,16 @@ func (hub *Hub) Close() error {
 }
 
 func (hub *Hub) reconnect() error {
-	log.Warn("reconnecting...")
+	log.Warn().Msg("reconnecting...")
 
 	if err := hub.Send(newCloseMessage()); err != nil {
-		log.Error(err)
+		log.Err(err).Msg("send")
 	}
 
 	if err := hub.conn.Close(); err != nil {
-		log.Error(err)
+		log.Err(err).Msg("close")
 	}
-	log.Trace("connection closed")
+	log.Trace().Msg("connection closed")
 	if err := hub.handshake(); err != nil {
 		return err
 	}
@@ -140,13 +140,13 @@ func (hub *Hub) listen() {
 					switch {
 					case errors.Is(err, ErrTimeout) || websocket.IsCloseError(err, websocket.CloseAbnormalClosure):
 						if err := hub.reconnect(); err != nil {
-							log.Errorf("reconnect: %s", err.Error())
-							log.Warn("retry after 5 seconds")
+							log.Err(err).Msg("reconnect")
+							log.Warn().Msg("retry after 5 seconds")
 							time.Sleep(time.Second * 5)
 						}
 					case errors.Is(err, ErrEmptyResponse):
 					default:
-						log.Errorf("readAllMessages: %s", err.Error())
+						log.Err(err).Msg("readAllMessages")
 					}
 				}
 			}
@@ -198,7 +198,7 @@ func (hub *Hub) readAllMessages() error {
 		return err
 	}
 	if scanner == nil {
-		log.Warn("No messages during read timeout")
+		log.Warn().Msg("no messages during read timeout")
 		return ErrEmptyResponse
 	}
 	if err := scanner.Scan(); err != nil {
@@ -233,7 +233,7 @@ func (hub *Hub) readAllMessages() error {
 
 func (hub *Hub) closeMessageHandler(msg CloseMessage) error {
 	if msg.Error != "" {
-		log.Error(msg.Error)
+		log.Error().Msg(msg.Error)
 	}
 	if !msg.AllowReconnect {
 		return ErrConnectionClose
diff --git a/tzkt/events/signalr/json.go b/tzkt/events/signalr/json.go
@@ -7,7 +7,7 @@ import (
 
 	jsoniter "github.com/json-iterator/go"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
+	"github.com/rs/zerolog/log"
 )
 
 var json = jsoniter.ConfigCompatibleWithStandardLibrary
@@ -28,7 +28,7 @@ func NewJSONEncoding() *JSONEncoding {
 
 // Decode -
 func (e *JSONEncoding) Decode(data []byte) (interface{}, error) {
-	log.Trace(string(data))
+	log.Trace().Msg(string(data))
 
 	var typ Type
 	if err := json.Unmarshal(data, &typ); err != nil {
diff --git a/tzkt/events/signalr/transport.go b/tzkt/events/signalr/transport.go
@@ -4,7 +4,7 @@ import (
 	"net/http"
 	"net/url"
 
-	log "github.com/sirupsen/logrus"
+	"github.com/rs/zerolog/log"
 
 	"github.com/pkg/errors"
 )
@@ -41,7 +41,7 @@ func (t *Transport) Negotiate(version Version) (response NegotiateResponse, err
 	q.Set("negotiateVersion", string(version))
 	u.RawQuery = q.Encode()
 
-	log.WithField("url", u.String()).Trace("Send negotiate request...")
+	log.Trace().Str("url", u.String()).Msg("send negotiate request...")
 
 	req, err := http.NewRequest(http.MethodPost, u.String(), nil)
 	if err != nil {
diff --git a/tzkt/events/tzkt.go b/tzkt/events/tzkt.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/dipdup-net/go-lib/tzkt/events/signalr"
 	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
+	"github.com/rs/zerolog/log"
 )
 
 // TzKT - struct that used for connection to TzKT events server
@@ -141,13 +141,13 @@ func (tzkt *TzKT) listen() {
 				switch typ := msg.(type) {
 				case signalr.Invocation:
 					if len(typ.Arguments) == 0 {
-						log.Warnf("Empty arguments of invocation: %v", typ)
+						log.Warn().Msgf("empty arguments of invocation: %v", typ)
 						continue
 					}
 
 					var packet Packet
 					if err := json.Unmarshal(typ.Arguments[0], &packet); err != nil {
-						log.WithError(err).Error("invalid invocation argument")
+						log.Err(err).Msg("invalid invocation argument")
 						continue
 					}
 
@@ -160,7 +160,7 @@ func (tzkt *TzKT) listen() {
 					if packet.Data != nil {
 						data, err := parseData(typ.Target, packet.Data)
 						if err != nil {
-							log.WithError(err).Error("error during parsing data")
+							log.Err(err).Msg("error during parsing data")
 							continue
 						}
 						message.Body = data

Original file line number	Diff line number	Diff line change
`@@ -13,15 +13,15 @@ import (`
`13`	`13`	`"github.com/iancoleman/strcase"`
`14`	`14`	`"github.com/pkg/errors"`
`15`	`15`
`16`		`- log "github.com/sirupsen/logrus"`
	`16`	`+ "github.com/rs/zerolog/log"`
`17`	`17`	`)`
`18`	`18`
`19`	`19`	`const (`
`20`	`20`	`allowedQueries = "allowed-queries"`
`21`	`21`	`)`
`22`	`22`
`23`	`23`	`func checkHealth(ctx context.Context, api *API) {`
`24`		`- log.Info("Waiting hasura is up and running")`
	`24`	`+ log.Info().Msg("Waiting hasura is up and running")`
`25`	`25`	`if err := api.Health(ctx); err != nil {`
`26`	`26`	`return`
`27`	`27`	`}`
`@@ -32,7 +32,7 @@ func checkHealth(ctx context.Context, api *API) {`
`32`	`32`	`return`
`33`	`33`	`case <-ticker.C:`
`34`	`34`	`if err := api.Health(ctx); err != nil {`
`35`		`- log.Warn(err)`
	`35`	`+ log.Warn().Err(err).Msg("")`
`36`	`36`	`continue`
`37`	`37`	`}`
`38`	`38`	`return`
`@@ -54,13 +54,13 @@ func Create(ctx context.Context, hasura *config.Hasura, cfg config.Database, vie`
`54`	`54`	`return err`
`55`	`55`	`}`
`56`	`56`
`57`		`- log.Info("Fetching existing metadata...")`
	`57`	`+ log.Info().Msg("Fetching existing metadata...")`
`58`	`58`	`export, err := api.ExportMetadata(ctx, metadata)`
`59`	`59`	`if err != nil {`
`60`	`60`	`return err`
`61`	`61`	`}`
`62`	`62`
`63`		`- log.Info("Merging metadata...")`
	`63`	`+ log.Info().Msg("Merging metadata...")`
`64`	`64`	`tables := make(map[string]struct{})`
`65`	`65`	`for i := range metadata.Tables {`
`66`	`66`	`tables[metadata.Tables[i].Schema.Name] = struct{}{}`
`@@ -76,13 +76,13 @@ func Create(ctx context.Context, hasura *config.Hasura, cfg config.Database, vie`
`76`	`76`	`return err`
`77`	`77`	`}`
`78`	`78`
`79`		`- log.Info("Replacing metadata...")`
	`79`	`+ log.Info().Msg("Replacing metadata...")`
`80`	`80`	`if err := api.ReplaceMetadata(ctx, metadata); err != nil {`
`81`	`81`	`return err`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`if len(metadata.QueryCollections) > 0 && (hasura.Rest == nil \|\| *hasura.Rest) {`
`85`		`- log.Info("Creating REST endpoints...")`
	`85`	`+ log.Info().Msg("Creating REST endpoints...")`
`86`	`86`	`for _, query := range metadata.QueryCollections[0].Definition.Queries {`
`87`	`87`	`if err := api.CreateRestEndpoint(ctx, query.Name, query.Name, query.Name, allowedQueries); err != nil {`
`88`	`88`	`if e, ok := err.(APIError); !ok \|\| !e.AlreadyExists() {`
`@@ -92,15 +92,15 @@ func Create(ctx context.Context, hasura *config.Hasura, cfg config.Database, vie`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`		`- log.Info("Tracking views...")`
	`95`	`+ log.Info().Msg("Tracking views...")`
`96`	`96`	`for i := range views {`
`97`	`97`	`if err := api.TrackTable(ctx, "public", views[i]); err != nil {`
`98`	`98`	`if !strings.Contains(err.Error(), "view/table already tracked") {`
`99`	`99`	`return err`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`	`if err := api.DropSelectPermissions(ctx, views[i], "user"); err != nil {`
`103`		`- log.Warn(err)`
	`103`	`+ log.Warn().Err(err).Msg("")`
`104`	`104`	`}`
`105`	`105`	`if err := api.CreateSelectPermissions(ctx, views[i], "user", Permission{`
`106`	`106`	`Limit: hasura.RowsLimit,`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ import (`
`10`	`10`	`"time"`
`11`	`11`
`12`	`12`	`"github.com/pkg/errors"`
`13`		`- log "github.com/sirupsen/logrus"`
	`13`	`+ "github.com/rs/zerolog/log"`
`14`	`14`	`)`
`15`	`15`
`16`	`16`	`const (`
`@@ -137,7 +137,7 @@ func (monitor *Monitor) pollingMempool(ctx context.Context, filter string) {`
`137`	`137`	`return`
`138`	`138`	`default:`
`139`	`139`	`if err := monitor.process(ctx, filter, url); err != nil {`
`140`		`- log.Error(err)`
	`140`	`+ log.Err(err).Msg("")`
`141`	`141`	`continue`
`142`	`142`	`}`
`143`	`143`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ import (`
`8`	`8`
`9`	`9`	`"github.com/gorilla/websocket"`
`10`	`10`	`"github.com/pkg/errors"`
`11`		`- log "github.com/sirupsen/logrus"`
	`11`	`+ "github.com/rs/zerolog/log"`
`12`	`12`	`)`
`13`	`13`
`14`	`14`	`var (`
`@@ -62,7 +62,7 @@ func (hub *Hub) Connect() error {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`func (hub *Hub) handshake() error {`
`65`		`- log.Tracef("connecting to %s...", hub.url.String())`
	`65`	`+ log.Trace().Msgf("connecting to %s...", hub.url.String())`
`66`	`66`
`67`	`67`	`c, _, err := websocket.DefaultDialer.Dial(hub.url.String(), nil)`
`68`	`68`	`if err != nil {`
`@@ -82,7 +82,7 @@ func (hub *Hub) handshake() error {`
`82`	`82`	`if resp.Error != "" {`
`83`	`83`	`return errors.Wrap(ErrHandshake, resp.Error)`
`84`	`84`	`}`
`85`		`- log.Trace("connected")`
	`85`	`+ log.Trace().Msg("connected")`
`86`	`86`
`87`	`87`	`return nil`
`88`	`88`	`}`
`@@ -106,16 +106,16 @@ func (hub *Hub) Close() error {`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`func (hub *Hub) reconnect() error {`
`109`		`- log.Warn("reconnecting...")`
	`109`	`+ log.Warn().Msg("reconnecting...")`
`110`	`110`
`111`	`111`	`if err := hub.Send(newCloseMessage()); err != nil {`
`112`		`- log.Error(err)`
	`112`	`+ log.Err(err).Msg("send")`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`if err := hub.conn.Close(); err != nil {`
`116`		`- log.Error(err)`
	`116`	`+ log.Err(err).Msg("close")`
`117`	`117`	`}`
`118`		`- log.Trace("connection closed")`
	`118`	`+ log.Trace().Msg("connection closed")`
`119`	`119`	`if err := hub.handshake(); err != nil {`
`120`	`120`	`return err`
`121`	`121`	`}`
`@@ -140,13 +140,13 @@ func (hub *Hub) listen() {`
`140`	`140`	`switch {`
`141`	`141`	`case errors.Is(err, ErrTimeout) \|\| websocket.IsCloseError(err, websocket.CloseAbnormalClosure):`
`142`	`142`	`if err := hub.reconnect(); err != nil {`
`143`		`- log.Errorf("reconnect: %s", err.Error())`
`144`		`- log.Warn("retry after 5 seconds")`
	`143`	`+ log.Err(err).Msg("reconnect")`
	`144`	`+ log.Warn().Msg("retry after 5 seconds")`
`145`	`145`	`time.Sleep(time.Second * 5)`
`146`	`146`	`}`
`147`	`147`	`case errors.Is(err, ErrEmptyResponse):`
`148`	`148`	`default:`
`149`		`- log.Errorf("readAllMessages: %s", err.Error())`
	`149`	`+ log.Err(err).Msg("readAllMessages")`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`	`}`
`@@ -198,7 +198,7 @@ func (hub *Hub) readAllMessages() error {`
`198`	`198`	`return err`
`199`	`199`	`}`
`200`	`200`	`if scanner == nil {`
`201`		`- log.Warn("No messages during read timeout")`
	`201`	`+ log.Warn().Msg("no messages during read timeout")`
`202`	`202`	`return ErrEmptyResponse`
`203`	`203`	`}`
`204`	`204`	`if err := scanner.Scan(); err != nil {`
`@@ -233,7 +233,7 @@ func (hub *Hub) readAllMessages() error {`
`233`	`233`
`234`	`234`	`func (hub *Hub) closeMessageHandler(msg CloseMessage) error {`
`235`	`235`	`if msg.Error != "" {`
`236`		`- log.Error(msg.Error)`
	`236`	`+ log.Error().Msg(msg.Error)`
`237`	`237`	`}`
`238`	`238`	`if !msg.AllowReconnect {`
`239`	`239`	`return ErrConnectionClose`