From c0c72491ff75b7964e949c85aeae726877f9a2c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Du=C5=A1an=20Borov=C4=8Danin?= Date: Wed, 22 Feb 2023 20:50:51 +0100 Subject: [PATCH] NOISSUE - Logger Fatal method returns no value (#1728) * Make Fatal return no value Signed-off-by: dusanb94 * Add Fatal test Signed-off-by: dusanb94 * Rename logger imports Signed-off-by: dusanb94 * Replace Fatal with Fatalf Signed-off-by: dusanb94 * Refactor Logger tests Signed-off-by: dusanb94 * Fix expected and actual order inversion Signed-off-by: dusanb94 * Update dependencies Signed-off-by: dusanb94 --------- Signed-off-by: dusanb94 --- cmd/auth/main.go | 24 +- cmd/bootstrap/main.go | 22 +- cmd/cassandra-reader/main.go | 18 +- cmd/cassandra-writer/main.go | 17 +- cmd/certs/main.go | 24 +- cmd/coap/main.go | 16 +- cmd/http/main.go | 18 +- cmd/influxdb-reader/main.go | 20 +- cmd/influxdb-writer/main.go | 20 +- cmd/lora/main.go | 32 +-- cmd/mongodb-reader/main.go | 19 +- cmd/mongodb-writer/main.go | 18 +- cmd/mqtt/main.go | 20 +- cmd/opcua/main.go | 26 +- cmd/postgres-reader/main.go | 20 +- cmd/postgres-writer/main.go | 18 +- cmd/provision/main.go | 1 + cmd/smpp-notifier/main.go | 26 +- cmd/smtp-notifier/main.go | 28 +-- cmd/things/main.go | 30 +-- cmd/timescale-reader/main.go | 20 +- cmd/timescale-writer/main.go | 18 +- cmd/twins/main.go | 33 +-- cmd/users/main.go | 40 +-- cmd/ws/main.go | 16 +- consumers/writers/cassandra/setup_test.go | 2 +- go.mod | 2 +- logger/level_test.go | 182 +++++++++++--- logger/logger.go | 10 +- logger/logger_test.go | 227 ++++++++++++++---- logger/mock.go | 3 +- pkg/errors/errors.go | 1 - readers/cassandra/setup_test.go | 2 +- things/service.go | 2 +- tools/mqtt-bench/cmd/main.go | 2 +- vendor/github.com/go-kit/kit/log/README.md | 160 ------------ vendor/github.com/go-kit/kit/log/doc.go | 118 --------- .../github.com/go-kit/kit/log/json_logger.go | 15 -- vendor/github.com/go-kit/kit/log/log.go | 51 ---- .../go-kit/kit/log/logfmt_logger.go | 15 -- .../github.com/go-kit/kit/log/nop_logger.go | 8 - vendor/github.com/go-kit/kit/log/stdlib.go | 54 ----- vendor/github.com/go-kit/kit/log/sync.go | 37 --- vendor/github.com/go-kit/kit/log/value.go | 52 ---- vendor/modules.txt | 1 - 45 files changed, 611 insertions(+), 877 deletions(-) delete mode 100644 vendor/github.com/go-kit/kit/log/README.md delete mode 100644 vendor/github.com/go-kit/kit/log/doc.go delete mode 100644 vendor/github.com/go-kit/kit/log/json_logger.go delete mode 100644 vendor/github.com/go-kit/kit/log/log.go delete mode 100644 vendor/github.com/go-kit/kit/log/logfmt_logger.go delete mode 100644 vendor/github.com/go-kit/kit/log/nop_logger.go delete mode 100644 vendor/github.com/go-kit/kit/log/stdlib.go delete mode 100644 vendor/github.com/go-kit/kit/log/sync.go delete mode 100644 vendor/github.com/go-kit/kit/log/value.go diff --git a/cmd/auth/main.go b/cmd/auth/main.go index 81d8aa0fb5..573a4d8bd9 100644 --- a/cmd/auth/main.go +++ b/cmd/auth/main.go @@ -25,7 +25,7 @@ import ( "github.com/mainflux/mainflux/internal/server" grpcserver "github.com/mainflux/mainflux/internal/server/grpc" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/uuid" "github.com/opentracing/opentracing-go" acl "github.com/ory/keto/proto/ory/keto/acl/v1alpha1" @@ -61,39 +61,39 @@ func main() { // Create auth service configurations cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } // Create new postgres client dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *authPg.Migration(), dbConfig) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup postgres database : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup postgres database : %s", err)) } defer db.Close() // Create new tracer for database dbTracer, dbCloser, err := jaegerClient.NewTracer("auth_db", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer dbCloser.Close() // Create new keto reader grpc client readerConn, _, err := grpcClient.Connect(grpcClient.Config{ClientTLS: false, URL: fmt.Sprintf("%s:%s", cfg.KetoReadHost, cfg.KetoReadPort)}) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to keto gRPC: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to keto gRPC: %s", err)) } // Create new keto writer grpc client writerConn, _, err := grpcClient.Connect(grpcClient.Config{ClientTLS: false, URL: fmt.Sprintf("%s:%s", cfg.KetoWriteHost, cfg.KetoWritePort)}) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to keto gRPC: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to keto gRPC: %s", err)) } svc := newService(db, dbTracer, cfg.Secret, logger, readerConn, writerConn, cfg.LoginDuration) @@ -101,14 +101,14 @@ func main() { // Create new HTTP Server tracer, closer, err := jaegerClient.NewTracer("auth", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer closer.Close() httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, httpapi.MakeHandler(svc, tracer, logger), logger) @@ -117,7 +117,7 @@ func main() { grpcServerConfig := server.Config{Port: defSvcGrpcPort} if err := env.Parse(&grpcServerConfig, env.Options{Prefix: envPrefixGrpc, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err)) } registerAuthServiceServer := func(srv *grpc.Server) { mainflux.RegisterAuthServiceServer(srv, grpcapi.NewServer(tracer, svc)) @@ -141,7 +141,7 @@ func main() { } } -func newService(db *sqlx.DB, tracer opentracing.Tracer, secret string, logger logger.Logger, readerConn, writerConn *grpc.ClientConn, duration time.Duration) auth.Service { +func newService(db *sqlx.DB, tracer opentracing.Tracer, secret string, logger mflog.Logger, readerConn, writerConn *grpc.ClientConn, duration time.Duration) auth.Service { database := authPg.NewDatabase(db) keysRepo := tracing.New(authPg.New(database), tracer) diff --git a/cmd/bootstrap/main.go b/cmd/bootstrap/main.go index be77db00be..c4a729425c 100644 --- a/cmd/bootstrap/main.go +++ b/cmd/bootstrap/main.go @@ -23,7 +23,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" mfsdk "github.com/mainflux/mainflux/pkg/sdk/go" "golang.org/x/sync/errgroup" ) @@ -51,12 +51,12 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatal(err.Error()) + log.Fatalf("failed to init logger: %s", err) } // Create new postgres client @@ -64,21 +64,21 @@ func main() { db, err := pgClient.SetupWithConfig(envPrefix, *bootstrapPg.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() // Create new redis client for bootstrap event store esClient, err := redisClient.Setup(envPrefixES) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup %s bootstrap event store redis client : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup %s bootstrap event store redis client : %s", svcName, err)) } defer esClient.Close() // Create new auth grpc client api auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) @@ -89,7 +89,7 @@ func main() { // Create an new HTTP server httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svc, bootstrap.NewConfigReader([]byte(cfg.EncKey)), logger), logger) @@ -104,7 +104,7 @@ func main() { // Subscribe to things event store thingsESClient, err := redisClient.Setup(envPrefixES) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer thingsESClient.Close() @@ -115,7 +115,7 @@ func main() { } } -func newService(auth mainflux.AuthServiceClient, db *sqlx.DB, logger logger.Logger, esClient *r.Client, cfg config) bootstrap.Service { +func newService(auth mainflux.AuthServiceClient, db *sqlx.DB, logger mflog.Logger, esClient *r.Client, cfg config) bootstrap.Service { repoConfig := bootstrapPg.NewConfigRepository(db, logger) config := mfsdk.Config{ @@ -133,7 +133,7 @@ func newService(auth mainflux.AuthServiceClient, db *sqlx.DB, logger logger.Logg return svc } -func subscribeToThingsES(svc bootstrap.Service, client *r.Client, consumer string, logger logger.Logger) { +func subscribeToThingsES(svc bootstrap.Service, client *r.Client, consumer string, logger mflog.Logger) { eventStore := rediscons.NewEventStore(svc, client, consumer, logger) logger.Info("Subscribed to Redis Event Store") if err := eventStore.Subscribe(context.Background(), "mainflux.things"); err != nil { diff --git a/cmd/cassandra-reader/main.go b/cmd/cassandra-reader/main.go index f0a3e53bd8..3efee2fae8 100644 --- a/cmd/cassandra-reader/main.go +++ b/cmd/cassandra-reader/main.go @@ -17,7 +17,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/readers" "github.com/mainflux/mainflux/readers/api" "github.com/mainflux/mainflux/readers/cassandra" @@ -44,18 +44,18 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s service configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s service configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } // Create new thing grpc client tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) @@ -63,7 +63,7 @@ func main() { // Create new auth grpc client auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) @@ -71,7 +71,7 @@ func main() { // Create new cassandra client csdSession, err := cassandraClient.Setup(envPrefix) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer csdSession.Close() @@ -82,7 +82,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(repo, tc, auth, svcName, logger), logger) @@ -101,7 +101,7 @@ func main() { } } -func newService(csdSession *gocql.Session, logger logger.Logger) readers.MessageRepository { +func newService(csdSession *gocql.Session, logger mflog.Logger) readers.MessageRepository { repo := cassandra.New(csdSession) repo = api.LoggingMiddleware(repo, logger) counter, latency := internal.MakeMetrics("cassandra", "message_reader") diff --git a/cmd/cassandra-writer/main.go b/cmd/cassandra-writer/main.go index 12e5da4a74..3073118ab3 100644 --- a/cmd/cassandra-writer/main.go +++ b/cmd/cassandra-writer/main.go @@ -18,7 +18,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "golang.org/x/sync/errgroup" ) @@ -42,20 +42,19 @@ func main() { // Create new cassandra writer service configurations cfg := config{} - if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s service configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } // Create new to cassandra client csdSession, err := cassandraClient.SetupDB(envPrefix, cassandra.Table) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer csdSession.Close() @@ -65,7 +64,7 @@ func main() { // Create new pub sub broker pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() @@ -78,7 +77,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefix, AltPrefix: envPrefixHttp}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svcName), logger) @@ -98,7 +97,7 @@ func main() { } -func newService(session *gocql.Session, logger logger.Logger) consumers.Consumer { +func newService(session *gocql.Session, logger mflog.Logger) consumers.Consumer { repo := cassandra.New(session) repo = api.LoggingMiddleware(repo, logger) counter, latency := internal.MakeMetrics("cassandra", "message_writer") diff --git a/cmd/certs/main.go b/cmd/certs/main.go index 567cdb70c0..fb7c3dc62d 100644 --- a/cmd/certs/main.go +++ b/cmd/certs/main.go @@ -20,7 +20,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "golang.org/x/sync/errgroup" "github.com/jmoiron/sqlx" @@ -71,12 +71,12 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } tlsCert, caCert, err := loadCertificates(cfg, logger) @@ -85,24 +85,24 @@ func main() { } if cfg.PkiHost == "" { - logger.Fatal("No host specified for PKI engine")() + logger.Fatal("No host specified for PKI engine") } pkiClient, err := vault.NewVaultClient(cfg.PkiToken, cfg.PkiHost, cfg.PkiPath, cfg.PkiRole) if err != nil { - logger.Fatal("failed to configure client for PKI engine")() + logger.Fatal("failed to configure client for PKI engine") } dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *certsPg.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) @@ -111,7 +111,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svc, logger), logger) @@ -128,7 +128,7 @@ func main() { } } -func newService(auth mainflux.AuthServiceClient, db *sqlx.DB, logger logger.Logger, esClient *redis.Client, tlsCert tls.Certificate, x509Cert *x509.Certificate, cfg config, pkiAgent vault.Agent) certs.Service { +func newService(auth mainflux.AuthServiceClient, db *sqlx.DB, logger mflog.Logger, esClient *redis.Client, tlsCert tls.Certificate, x509Cert *x509.Certificate, cfg config, pkiAgent vault.Agent) certs.Service { certsRepo := certsPg.NewRepository(db, logger) config := mfsdk.Config{ CertsURL: cfg.CertsURL, @@ -142,7 +142,7 @@ func newService(auth mainflux.AuthServiceClient, db *sqlx.DB, logger logger.Logg return svc } -func loadCertificates(conf config, logger logger.Logger) (tls.Certificate, *x509.Certificate, error) { +func loadCertificates(conf config, logger mflog.Logger) (tls.Certificate, *x509.Certificate, error) { var tlsCert tls.Certificate var caCert *x509.Certificate @@ -170,7 +170,7 @@ func loadCertificates(conf config, logger logger.Logger) (tls.Certificate, *x509 block, _ := pem.Decode(b) if block == nil { - logger.Fatal("No PEM data found, failed to decode CA")() + logger.Fatal("No PEM data found, failed to decode CA") } caCert, err = x509.ParseCertificate(block.Bytes) diff --git a/cmd/coap/main.go b/cmd/coap/main.go index a6678474b5..7b43df402d 100644 --- a/cmd/coap/main.go +++ b/cmd/coap/main.go @@ -17,7 +17,7 @@ import ( "github.com/mainflux/mainflux/internal/server" coapserver "github.com/mainflux/mainflux/internal/server/coap" httpserver "github.com/mainflux/mainflux/internal/server/http" - logger "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "golang.org/x/sync/errgroup" ) @@ -43,24 +43,24 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) nps, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer nps.Close() @@ -73,13 +73,13 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHTTPHandler(), logger) coapServerConfig := server.Config{Port: defSvcCoapPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixCoap, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s CoAP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s CoAP server configuration : %s", svcName, err)) } cs := coapserver.New(ctx, cancel, svcName, coapServerConfig, api.MakeCoAPHandler(svc, logger), logger) diff --git a/cmd/http/main.go b/cmd/http/main.go index 909e403421..4fedb4c46e 100644 --- a/cmd/http/main.go +++ b/cmd/http/main.go @@ -18,7 +18,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging" "github.com/mainflux/mainflux/pkg/messaging/brokers" "golang.org/x/sync/errgroup" @@ -43,24 +43,24 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s service configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) pub, err := brokers.NewPublisher(cfg.BrokerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pub.Close() @@ -68,13 +68,13 @@ func main() { tracer, closer, err := jaegerClient.NewTracer("http_adapter", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer closer.Close() httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svc, tracer, logger), logger) @@ -91,7 +91,7 @@ func main() { } } -func newService(pub messaging.Publisher, tc mainflux.ThingsServiceClient, logger logger.Logger) adapter.Service { +func newService(pub messaging.Publisher, tc mainflux.ThingsServiceClient, logger mflog.Logger) adapter.Service { svc := adapter.New(pub, tc) svc = api.LoggingMiddleware(svc, logger) counter, latency := internal.MakeMetrics(svcName, "api") diff --git a/cmd/influxdb-reader/main.go b/cmd/influxdb-reader/main.go index 3b546c246c..c30545e4cf 100644 --- a/cmd/influxdb-reader/main.go +++ b/cmd/influxdb-reader/main.go @@ -14,7 +14,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/readers" "github.com/mainflux/mainflux/readers/api" "github.com/mainflux/mainflux/readers/influxdb" @@ -40,35 +40,35 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) influxDBConfig := influxDBClient.Config{} if err := env.Parse(&influxDBConfig, env.Options{Prefix: envPrefixInfluxdb}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load InfluxDB client configuration from environment variable : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load InfluxDB client configuration from environment variable : %s", err)) } client, err := influxDBClient.Connect(influxDBConfig) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to InfluxDB : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to InfluxDB : %s", err)) } defer client.Close() @@ -76,7 +76,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(repo, tc, auth, svcName, logger), logger) @@ -93,7 +93,7 @@ func main() { } } -func newService(client influxdata.Client, dbName string, logger logger.Logger) readers.MessageRepository { +func newService(client influxdata.Client, dbName string, logger mflog.Logger) readers.MessageRepository { repo := influxdb.New(client, dbName) repo = api.LoggingMiddleware(repo, logger) counter, latency := internal.MakeMetrics("influxdb", "message_reader") diff --git a/cmd/influxdb-writer/main.go b/cmd/influxdb-writer/main.go index 05344f9180..9f5fde678c 100644 --- a/cmd/influxdb-writer/main.go +++ b/cmd/influxdb-writer/main.go @@ -18,7 +18,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "golang.org/x/sync/errgroup" ) @@ -43,39 +43,39 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() influxDBConfig := influxDBClient.Config{} if err := env.Parse(&influxDBConfig, env.Options{Prefix: envPrefixInfluxdb}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load InfluxDB client configuration from environment variable : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load InfluxDB client configuration from environment variable : %s", err)) } client, err := influxDBClient.Connect(influxDBConfig) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to InfluxDB : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to InfluxDB : %s", err)) } defer client.Close() repo := newService(client, influxDBConfig.DbName, logger) if err := consumers.Start(svcName, pubSub, repo, cfg.ConfigPath, logger); err != nil { - logger.Fatal(fmt.Sprintf("failed to start InfluxDB writer: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to start InfluxDB writer: %s", err)) } httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svcName), logger) @@ -92,7 +92,7 @@ func main() { } } -func newService(client influxdata.Client, dbName string, logger logger.Logger) consumers.Consumer { +func newService(client influxdata.Client, dbName string, logger mflog.Logger) consumers.Consumer { repo := influxdb.New(client, dbName) repo = api.LoggingMiddleware(repo, logger) counter, latency := internal.MakeMetrics("influxdb", "message_writer") diff --git a/cmd/lora/main.go b/cmd/lora/main.go index 00433fb829..f094750405 100644 --- a/cmd/lora/main.go +++ b/cmd/lora/main.go @@ -16,7 +16,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/lora" "github.com/mainflux/mainflux/lora/api" "github.com/mainflux/mainflux/lora/mqtt" @@ -58,23 +58,23 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } rmConn, err := redisClient.Setup(envPrefixRouteMap) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup route map redis client : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup route map redis client : %s", err)) } defer rmConn.Close() pub, err := brokers.NewPublisher(cfg.BrokerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pub.Close() @@ -82,7 +82,7 @@ func main() { esConn, err := redisClient.Setup(envPrefixThingsES) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup things event store redis client : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup things event store redis client : %s", err)) } defer esConn.Close() @@ -93,7 +93,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(), logger) @@ -110,7 +110,7 @@ func main() { } } -func connectToMQTTBroker(url, user, password string, timeout time.Duration, logger logger.Logger) mqttPaho.Client { +func connectToMQTTBroker(url, user, password string, timeout time.Duration, logger mflog.Logger) mqttPaho.Client { opts := mqttPaho.NewClientOptions() opts.AddBroker(url) opts.SetUsername(user) @@ -119,27 +119,27 @@ func connectToMQTTBroker(url, user, password string, timeout time.Duration, logg logger.Info("Connected to Lora MQTT broker") }) opts.SetConnectionLostHandler(func(c mqttPaho.Client, err error) { - logger.Fatal(fmt.Sprintf("MQTT connection lost: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("MQTT connection lost: %s", err)) }) client := mqttPaho.NewClient(opts) if token := client.Connect(); token.WaitTimeout(timeout) && token.Error() != nil { - logger.Fatal(fmt.Sprintf("failed to connect to Lora MQTT broker: %s", token.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to Lora MQTT broker: %s", token.Error())) } return client } -func subscribeToLoRaBroker(svc lora.Service, mc mqttPaho.Client, timeout time.Duration, topic string, logger logger.Logger) { +func subscribeToLoRaBroker(svc lora.Service, mc mqttPaho.Client, timeout time.Duration, topic string, logger mflog.Logger) { mqtt := mqtt.NewBroker(svc, mc, timeout, logger) logger.Info("Subscribed to Lora MQTT broker") if err := mqtt.Subscribe(topic); err != nil { - logger.Fatal(fmt.Sprintf("failed to subscribe to Lora MQTT broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to subscribe to Lora MQTT broker: %s", err)) } } -func subscribeToThingsES(svc lora.Service, client *r.Client, consumer string, logger logger.Logger) { +func subscribeToThingsES(svc lora.Service, client *r.Client, consumer string, logger mflog.Logger) { eventStore := redis.NewEventStore(svc, client, consumer, logger) logger.Info("Subscribed to Redis Event Store") if err := eventStore.Subscribe(context.Background(), "mainflux.things"); err != nil { @@ -147,12 +147,12 @@ func subscribeToThingsES(svc lora.Service, client *r.Client, consumer string, lo } } -func newRouteMapRepository(client *r.Client, prefix string, logger logger.Logger) lora.RouteMapRepository { +func newRouteMapRepository(client *r.Client, prefix string, logger mflog.Logger) lora.RouteMapRepository { logger.Info(fmt.Sprintf("Connected to %s Redis Route-map", prefix)) return redis.NewRouteMapRepository(client, prefix) } -func newService(pub messaging.Publisher, rmConn *r.Client, thingsRMPrefix, channelsRMPrefix, connsRMPrefix string, logger logger.Logger) lora.Service { +func newService(pub messaging.Publisher, rmConn *r.Client, thingsRMPrefix, channelsRMPrefix, connsRMPrefix string, logger mflog.Logger) lora.Service { thingsRM := newRouteMapRepository(rmConn, thingsRMPrefix, logger) chansRM := newRouteMapRepository(rmConn, channelsRMPrefix, logger) connsRM := newRouteMapRepository(rmConn, connsRMPrefix, logger) diff --git a/cmd/mongodb-reader/main.go b/cmd/mongodb-reader/main.go index aadff1efb8..247f104789 100644 --- a/cmd/mongodb-reader/main.go +++ b/cmd/mongodb-reader/main.go @@ -16,7 +16,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/readers" "github.com/mainflux/mainflux/readers/api" "github.com/mainflux/mainflux/readers/mongodb" @@ -43,38 +43,38 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } db, err := mongoClient.Setup(envPrefixDB) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup mongo database : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup mongo database : %s", err)) } repo := newService(db, logger) tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(repo, tc, auth, svcName, logger), logger) @@ -89,10 +89,9 @@ func main() { if err := g.Wait(); err != nil { logger.Error(fmt.Sprintf("MongoDB reader service terminated: %s", err)) } - } -func newService(db *mongo.Database, logger logger.Logger) readers.MessageRepository { +func newService(db *mongo.Database, logger mflog.Logger) readers.MessageRepository { repo := mongodb.New(db) repo = api.LoggingMiddleware(repo, logger) counter, latency := internal.MakeMetrics("mongodb", "message_reader") diff --git a/cmd/mongodb-writer/main.go b/cmd/mongodb-writer/main.go index aefdbd40bd..e49942569c 100644 --- a/cmd/mongodb-writer/main.go +++ b/cmd/mongodb-writer/main.go @@ -17,7 +17,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "go.mongodb.org/mongo-driver/mongo" "golang.org/x/sync/errgroup" @@ -43,34 +43,34 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatal(err) + log.Fatalf("failed to init logger: %s", err) } pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() db, err := mongoClient.Setup(envPrefixDB) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup mongo database : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup mongo database : %s", err)) } repo := newService(db, logger) if err := consumers.Start(svcName, pubSub, repo, cfg.ConfigPath, logger); err != nil { - logger.Fatal(fmt.Sprintf("failed to start MongoDB writer: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to start MongoDB writer: %s", err)) } httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svcName), logger) @@ -87,7 +87,7 @@ func main() { } } -func newService(db *mongo.Database, logger logger.Logger) consumers.Consumer { +func newService(db *mongo.Database, logger mflog.Logger) consumers.Consumer { repo := mongodb.New(db) repo = api.LoggingMiddleware(repo, logger) counter, latency := internal.MakeMetrics("mongodb", "message_writer") diff --git a/cmd/mqtt/main.go b/cmd/mqtt/main.go index ff25e5b41f..b756403794 100644 --- a/cmd/mqtt/main.go +++ b/cmd/mqtt/main.go @@ -56,12 +56,12 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } if cfg.MqttTargetHealthCheck != "" { @@ -71,35 +71,35 @@ func main() { err := backoff.RetryNotify(healthcheck(cfg), backoff.NewExponentialBackOff(), notify) if err != nil { - logger.Fatal(fmt.Sprintf("MQTT healthcheck limit exceeded, exiting. %s ", err.Error()))() + logger.Fatal(fmt.Sprintf("MQTT healthcheck limit exceeded, exiting. %s ", err)) } } nps, err := brokers.NewPubSub(cfg.BrokerURL, "mqtt", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer nps.Close() mpub, err := mqttpub.NewPublisher(fmt.Sprintf("%s:%s", cfg.MqttTargetHost, cfg.MqttTargetPort), cfg.MqttForwarderTimeout) if err != nil { - logger.Fatal(fmt.Sprintf("failed to create MQTT publisher: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to create MQTT publisher: %s", err)) } fwd := mqtt.NewForwarder(brokers.SubjectAllChannels, logger) if err := fwd.Forward(svcName, nps, mpub); err != nil { - logger.Fatal(fmt.Sprintf("failed to forward message broker messages: %s", err))() + logger.Fatal(fmt.Sprintf("failed to forward message broker messages: %s", err)) } np, err := brokers.NewPublisher(cfg.BrokerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer np.Close() ec, err := redisClient.Setup(envPrefixES) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup %s event store redis client : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup %s event store redis client : %s", svcName, err)) } defer ec.Close() @@ -107,13 +107,13 @@ func main() { ac, err := redisClient.Setup(envPrefixAuthCache) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup %s event store redis client : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup %s event store redis client : %s", svcName, err)) } defer ac.Close() tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) diff --git a/cmd/opcua/main.go b/cmd/opcua/main.go index 11d27f77f7..304ebf2f0c 100644 --- a/cmd/opcua/main.go +++ b/cmd/opcua/main.go @@ -15,7 +15,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/opcua" "github.com/mainflux/mainflux/opcua/api" "github.com/mainflux/mainflux/opcua/db" @@ -50,22 +50,22 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } opcConfig := opcua.Config{} if err := env.Parse(&opcConfig); err != nil { - log.Fatalf("failed to load %s opcua client configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s opcua client configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - logger.Fatal(err.Error())() + log.Fatalf("failed to init logger: %s", err) } rmConn, err := redisClient.Setup(envPrefixRouteMap) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup %s bootstrap event store redis client : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup %s bootstrap event store redis client : %s", svcName, err)) } defer rmConn.Close() @@ -75,13 +75,13 @@ func main() { esConn, err := redisClient.Setup(envPrefixES) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup %s bootstrap event store redis client : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup %s bootstrap event store redis client : %s", svcName, err)) } defer esConn.Close() pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() @@ -96,7 +96,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(httpCtx, httpCancel, svcName, httpServerConfig, api.MakeHandler(svc, logger), logger) @@ -113,7 +113,7 @@ func main() { } } -func subscribeToStoredSubs(sub opcua.Subscriber, cfg opcua.Config, logger logger.Logger) { +func subscribeToStoredSubs(sub opcua.Subscriber, cfg opcua.Config, logger mflog.Logger) { // Get all stored subscriptions nodes, err := db.ReadAll() if err != nil { @@ -131,19 +131,19 @@ func subscribeToStoredSubs(sub opcua.Subscriber, cfg opcua.Config, logger logger } } -func subscribeToThingsES(svc opcua.Service, client *r.Client, prefix string, logger logger.Logger) { +func subscribeToThingsES(svc opcua.Service, client *r.Client, prefix string, logger mflog.Logger) { eventStore := redis.NewEventStore(svc, client, prefix, logger) if err := eventStore.Subscribe(context.Background(), "mainflux.things"); err != nil { logger.Warn(fmt.Sprintf("Failed to subscribe to Redis event source: %s", err)) } } -func newRouteMapRepositoy(client *r.Client, prefix string, logger logger.Logger) opcua.RouteMapRepository { +func newRouteMapRepositoy(client *r.Client, prefix string, logger mflog.Logger) opcua.RouteMapRepository { logger.Info(fmt.Sprintf("Connected to %s Redis Route-map", prefix)) return redis.NewRouteMapRepository(client, prefix) } -func newService(sub opcua.Subscriber, browser opcua.Browser, thingRM, chanRM, connRM opcua.RouteMapRepository, opcuaConfig opcua.Config, logger logger.Logger) opcua.Service { +func newService(sub opcua.Subscriber, browser opcua.Browser, thingRM, chanRM, connRM opcua.RouteMapRepository, opcuaConfig opcua.Config, logger mflog.Logger) opcua.Service { svc := opcua.New(sub, browser, thingRM, chanRM, connRM, opcuaConfig, logger) svc = api.LoggingMiddleware(svc, logger) counter, latency := internal.MakeMetrics(svcName, "api") diff --git a/cmd/postgres-reader/main.go b/cmd/postgres-reader/main.go index 793ffebcbd..1fa3643e61 100644 --- a/cmd/postgres-reader/main.go +++ b/cmd/postgres-reader/main.go @@ -17,7 +17,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/readers" "github.com/mainflux/mainflux/readers/api" "github.com/mainflux/mainflux/readers/postgres" @@ -43,35 +43,35 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) dbConfig := pgClient.Config{Name: defDB} if err := dbConfig.LoadEnv(envPrefix); err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } db, err := pgClient.Connect(dbConfig) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup postgres database : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup postgres database : %s", err)) } defer db.Close() @@ -79,7 +79,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(repo, tc, auth, svcName, logger), logger) @@ -96,7 +96,7 @@ func main() { } } -func newService(db *sqlx.DB, logger logger.Logger) readers.MessageRepository { +func newService(db *sqlx.DB, logger mflog.Logger) readers.MessageRepository { svc := postgres.New(db) svc = api.LoggingMiddleware(svc, logger) counter, latency := internal.MakeMetrics("postgres", "message_reader") diff --git a/cmd/postgres-writer/main.go b/cmd/postgres-writer/main.go index 46e2634fec..66ce11ea7b 100644 --- a/cmd/postgres-writer/main.go +++ b/cmd/postgres-writer/main.go @@ -18,7 +18,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "golang.org/x/sync/errgroup" ) @@ -43,36 +43,36 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *writerPg.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() repo := newService(db, logger) if err = consumers.Start(svcName, pubSub, repo, cfg.ConfigPath, logger); err != nil { - logger.Fatal(fmt.Sprintf("failed to create Postgres writer: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to create Postgres writer: %s", err)) } httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svcName), logger) @@ -89,7 +89,7 @@ func main() { } } -func newService(db *sqlx.DB, logger logger.Logger) consumers.Consumer { +func newService(db *sqlx.DB, logger mflog.Logger) consumers.Consumer { svc := writerPg.New(db) svc = api.LoggingMiddleware(svc, logger) counter, latency := internal.MakeMetrics("postgres", "message_writer") diff --git a/cmd/provision/main.go b/cmd/provision/main.go index 4ecac8ff98..4a1ee8dae3 100644 --- a/cmd/provision/main.go +++ b/cmd/provision/main.go @@ -89,6 +89,7 @@ func main() { if err != nil { log.Fatalf(err.Error()) } + if cfgFromFile, err := loadConfigFromFile(cfg.File); err != nil { logger.Warn(fmt.Sprintf("Continue with settings from env, failed to load from: %s: %s", cfg.File, err)) } else { diff --git a/cmd/smpp-notifier/main.go b/cmd/smpp-notifier/main.go index 403c2cc24e..2575d84ec4 100644 --- a/cmd/smpp-notifier/main.go +++ b/cmd/smpp-notifier/main.go @@ -26,7 +26,7 @@ import ( authClient "github.com/mainflux/mainflux/internal/clients/grpc/auth" jaegerClient "github.com/mainflux/mainflux/internal/clients/jaeger" pgClient "github.com/mainflux/mainflux/internal/clients/postgres" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "github.com/mainflux/mainflux/pkg/ulid" opentracing "github.com/opentracing/opentracing-go" @@ -54,60 +54,60 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *notifierPg.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() smppConfig := mfsmpp.Config{} if err := env.Parse(&smppConfig); err != nil { - logger.Fatal(fmt.Sprintf("failed to load SMPP configuration from environment : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load SMPP configuration from environment : %s", err)) } pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) tracer, closer, err := jaegerClient.NewTracer("smpp-notifier", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer closer.Close() dbTracer, dbCloser, err := jaegerClient.NewTracer("smpp-notifier_db", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer dbCloser.Close() svc := newService(db, dbTracer, auth, cfg, smppConfig, logger) if err = consumers.Start(svcName, pubSub, svc, cfg.ConfigPath, logger); err != nil { - logger.Fatal(fmt.Sprintf("failed to create Postgres writer: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to create Postgres writer: %s", err)) } httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svc, tracer, logger), logger) @@ -125,7 +125,7 @@ func main() { } -func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServiceClient, c config, sc mfsmpp.Config, logger logger.Logger) notifiers.Service { +func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServiceClient, c config, sc mfsmpp.Config, logger mflog.Logger) notifiers.Service { database := notifierPg.NewDatabase(db) repo := tracing.New(notifierPg.New(database), tracer) idp := ulid.New() diff --git a/cmd/smtp-notifier/main.go b/cmd/smtp-notifier/main.go index 6e63ae2fe0..d4959afa03 100644 --- a/cmd/smtp-notifier/main.go +++ b/cmd/smtp-notifier/main.go @@ -25,7 +25,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "github.com/mainflux/mainflux/pkg/ulid" opentracing "github.com/opentracing/opentracing-go" @@ -54,60 +54,60 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *notifierPg.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() ec := email.Config{} if err := env.Parse(&cfg); err != nil { - logger.Fatal(fmt.Sprintf("failed to load email configuration : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load email configuration : %s", err)) } pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) tracer, closer, err := jagerClient.NewTracer("smtp-notifier", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer closer.Close() dbTracer, dbCloser, err := jagerClient.NewTracer("smtp-notifier_db", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer dbCloser.Close() svc := newService(db, dbTracer, auth, cfg, ec, logger) if err = consumers.Start(svcName, pubSub, svc, cfg.ConfigPath, logger); err != nil { - logger.Fatal(fmt.Sprintf("failed to create Postgres writer: %s", err))() + logger.Fatal(fmt.Sprintf("failed to create Postgres writer: %s", err)) } httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svc, tracer, logger), logger) @@ -125,14 +125,14 @@ func main() { } -func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServiceClient, c config, ec email.Config, logger logger.Logger) notifiers.Service { +func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServiceClient, c config, ec email.Config, logger mflog.Logger) notifiers.Service { database := notifierPg.NewDatabase(db) repo := tracing.New(notifierPg.New(database), tracer) idp := ulid.New() agent, err := email.New(&ec) if err != nil { - logger.Fatal(fmt.Sprintf("failed to create email agent: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to create email agent: %s", err)) } notifier := smtp.New(agent) diff --git a/cmd/things/main.go b/cmd/things/main.go index 46429e53d0..785064d8dc 100644 --- a/cmd/things/main.go +++ b/cmd/things/main.go @@ -21,7 +21,7 @@ import ( "github.com/mainflux/mainflux/internal/server" grpcserver "github.com/mainflux/mainflux/internal/server/grpc" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/uuid" "github.com/mainflux/mainflux/things" "github.com/mainflux/mainflux/things/api" @@ -64,40 +64,40 @@ func main() { // Create new things configuration cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s service configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } // Create new database for things dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *thingsPg.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() // Setup new redis cache client cacheClient, err := redisClient.Setup(envPrefixCache) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer cacheClient.Close() // Setup new redis event store client esClient, err := redisClient.Setup(envPrefixES) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer esClient.Close() // Setup new auth grpc client auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) @@ -105,14 +105,14 @@ func main() { // Create tracer for things database dbTracer, dbCloser, err := jaegerClient.NewTracer("things_db", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer dbCloser.Close() // Create tracer for things cache cacheTracer, cacheCloser, err := jaegerClient.NewTracer("things_cache", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer cacheCloser.Close() @@ -122,21 +122,21 @@ func main() { // Create tracer for HTTP handler things thingsTracer, thingsCloser, err := jaegerClient.NewTracer("things", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer thingsCloser.Close() // Create new HTTP server httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err)) } hs1 := httpserver.New(ctx, cancel, "thing-http", httpServerConfig, thhttpapi.MakeHandler(thingsTracer, svc, logger), logger) // Create new things auth http server authHttpServerConfig := server.Config{Port: defSvcAuthHttpPort} if err := env.Parse(&authHttpServerConfig, env.Options{Prefix: envPrefixAuthHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err)) } hs2 := httpserver.New(ctx, cancel, "auth-http", authHttpServerConfig, authhttpapi.MakeHandler(thingsTracer, svc, logger), logger) @@ -147,7 +147,7 @@ func main() { } grpcServerConfig := server.Config{Port: defSvcAuthGrpcPort} if err := env.Parse(&grpcServerConfig, env.Options{Prefix: envPrefixAuthGrpc, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err)) } gs := grpcserver.New(ctx, cancel, svcName, grpcServerConfig, registerThingsServiceServer, logger) @@ -171,7 +171,7 @@ func main() { } } -func newService(auth mainflux.AuthServiceClient, dbTracer opentracing.Tracer, cacheTracer opentracing.Tracer, db *sqlx.DB, cacheClient *redis.Client, esClient *redis.Client, logger logger.Logger) things.Service { +func newService(auth mainflux.AuthServiceClient, dbTracer opentracing.Tracer, cacheTracer opentracing.Tracer, db *sqlx.DB, cacheClient *redis.Client, esClient *redis.Client, logger mflog.Logger) things.Service { database := thingsPg.NewDatabase(db) thingsRepo := thingsPg.NewThingRepository(database) diff --git a/cmd/timescale-reader/main.go b/cmd/timescale-reader/main.go index 955e338b6b..a2c0b780a1 100644 --- a/cmd/timescale-reader/main.go +++ b/cmd/timescale-reader/main.go @@ -17,7 +17,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/readers" "github.com/mainflux/mainflux/readers/api" "github.com/mainflux/mainflux/readers/timescale" @@ -43,21 +43,21 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s service configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } dbConfig := pgClient.Config{Name: defDB} if err := dbConfig.LoadEnv(envPrefix); err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } db, err := pgClient.Connect(dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() @@ -65,21 +65,21 @@ func main() { auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer tcHandler.Close() logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(repo, tc, auth, svcName, logger), logger) @@ -96,7 +96,7 @@ func main() { } } -func newService(db *sqlx.DB, logger logger.Logger) readers.MessageRepository { +func newService(db *sqlx.DB, logger mflog.Logger) readers.MessageRepository { svc := timescale.New(db) svc = api.LoggingMiddleware(svc, logger) counter, latency := internal.MakeMetrics("timescale", "message_reader") diff --git a/cmd/timescale-writer/main.go b/cmd/timescale-writer/main.go index e9fc0f71fc..3919d35447 100644 --- a/cmd/timescale-writer/main.go +++ b/cmd/timescale-writer/main.go @@ -18,7 +18,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging/brokers" "golang.org/x/sync/errgroup" ) @@ -43,18 +43,18 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s service configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s service configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatal(err.Error()) + log.Fatal(err) } dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *timescale.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() @@ -62,17 +62,17 @@ func main() { pubSub, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() if err = consumers.Start(svcName, pubSub, repo, cfg.ConfigPath, logger); err != nil { - logger.Fatal(fmt.Sprintf("failed to create Timescale writer: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to create Timescale writer: %s", err)) } httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svcName), logger) @@ -89,7 +89,7 @@ func main() { } } -func newService(db *sqlx.DB, logger logger.Logger) consumers.Consumer { +func newService(db *sqlx.DB, logger mflog.Logger) consumers.Consumer { svc := timescale.New(db) svc = api.LoggingMiddleware(svc, logger) counter, latency := internal.MakeMetrics("timescale", "message_writer") diff --git a/cmd/twins/main.go b/cmd/twins/main.go index 4f28a32908..c815e6d0bc 100644 --- a/cmd/twins/main.go +++ b/cmd/twins/main.go @@ -19,7 +19,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging" "github.com/mainflux/mainflux/pkg/messaging/brokers" "github.com/mainflux/mainflux/pkg/uuid" @@ -58,34 +58,35 @@ func main() { g, ctx := errgroup.WithContext(ctx) cfg := config{} - if err := env.Parse(&cfg, env.Options{Prefix: envPrefix}); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + if err := env.Parse(&cfg); err != nil { + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } cacheClient, err := redisClient.Setup(envPrefixCache) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer cacheClient.Close() cacheTracer, cacheCloser, err := jaegerClient.NewTracer("twins_cache", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer cacheCloser.Close() db, err := mongoClient.Setup(envPrefix) if err != nil { - logger.Fatal(fmt.Sprintf("failed to setup postgres database : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to setup postgres database : %s", err)) } dbTracer, dbCloser, err := jaegerClient.NewTracer("twins_db", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer dbCloser.Close() @@ -96,7 +97,7 @@ func main() { default: authServiceClient, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() auth = authServiceClient @@ -105,7 +106,7 @@ func main() { pubSub, err := brokers.NewPubSub(cfg.BrokerURL, queue, logger) if err != nil { - logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to connect to message broker: %s", err)) } defer pubSub.Close() @@ -113,13 +114,13 @@ func main() { tracer, closer, err := jaegerClient.NewTracer("twins", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer closer.Close() httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, twapi.MakeHandler(tracer, svc, logger), logger) @@ -136,7 +137,7 @@ func main() { } } -func newService(id string, ps messaging.PubSub, chanID string, users mainflux.AuthServiceClient, dbTracer opentracing.Tracer, db *mongo.Database, cacheTracer opentracing.Tracer, cacheClient *redis.Client, logger logger.Logger) twins.Service { +func newService(id string, ps messaging.PubSub, chanID string, users mainflux.AuthServiceClient, dbTracer opentracing.Tracer, db *mongo.Database, cacheTracer opentracing.Tracer, cacheClient *redis.Client, logger mflog.Logger) twins.Service { twinRepo := twmongodb.NewTwinRepository(db) twinRepo = tracing.TwinRepositoryMiddleware(dbTracer, twinRepo) @@ -153,12 +154,12 @@ func newService(id string, ps messaging.PubSub, chanID string, users mainflux.Au svc = api.MetricsMiddleware(svc, counter, latency) err := ps.Subscribe(id, brokers.SubjectAllChannels, handle(logger, chanID, svc)) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } return svc } -func handle(logger logger.Logger, chanID string, svc twins.Service) handlerFunc { +func handle(logger mflog.Logger, chanID string, svc twins.Service) handlerFunc { return func(msg *messaging.Message) error { if msg.Channel == chanID { return nil diff --git a/cmd/users/main.go b/cmd/users/main.go index 061d527704..b47337a370 100644 --- a/cmd/users/main.go +++ b/cmd/users/main.go @@ -28,7 +28,7 @@ import ( "github.com/jmoiron/sqlx" "github.com/mainflux/mainflux" jaegerClient "github.com/mainflux/mainflux/internal/clients/jaeger" - "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/users/api" usersPg "github.com/mainflux/mainflux/users/postgres" opentracing "github.com/opentracing/opentracing-go" @@ -59,7 +59,12 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) + } + + logger, err := mflog.New(os.Stdout, cfg.LogLevel) + if err != nil { + log.Fatalf("failed to init logger: %s", err) } passRegex, err := regexp.Compile(cfg.PassRegexText) if err != nil { @@ -67,33 +72,28 @@ func main() { } cfg.PassRegex = passRegex - logger, err := logger.New(os.Stdout, cfg.LogLevel) - if err != nil { - logger.Fatal(err.Error())() - } - ec := email.Config{} if err := env.Parse(&ec); err != nil { - logger.Fatal(fmt.Sprintf("failed to load email configuration : %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load email configuration : %s", err)) } dbConfig := pgClient.Config{Name: defDB} db, err := pgClient.SetupWithConfig(envPrefix, *usersPg.Migration(), dbConfig) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer db.Close() auth, authHandler, err := authClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer authHandler.Close() logger.Info("Successfully connected to auth grpc server " + authHandler.Secure()) dbTracer, dbCloser, err := jaegerClient.NewTracer("auth_db", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer dbCloser.Close() @@ -101,13 +101,13 @@ func main() { tracer, closer, err := jaegerClient.NewTracer("users", cfg.JaegerURL) if err != nil { - logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("failed to init Jaeger: %s", err)) } defer closer.Close() httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svc, tracer, logger), logger) @@ -124,14 +124,14 @@ func main() { } } -func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServiceClient, c config, ec email.Config, logger logger.Logger) users.Service { +func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServiceClient, c config, ec email.Config, logger mflog.Logger) users.Service { database := usersPg.NewDatabase(db) hasher := bcrypt.New() userRepo := tracing.UserRepositoryMiddleware(usersPg.NewUserRepo(database), tracer) emailer, err := emailer.New(c.ResetURL, &ec) if err != nil { - logger.Error(fmt.Sprintf("Failed to configure e-mailing util: %s", err.Error())) + logger.Error(fmt.Sprintf("Failed to configure e-mailing util: %s", err)) } idProvider := uuid.New() @@ -142,7 +142,7 @@ func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServic svc = api.MetricsMiddleware(svc, counter, latency) if err := createAdmin(svc, userRepo, c, auth); err != nil { - logger.Fatal(fmt.Sprintf("failed to create admin user: " + err.Error()))() + logger.Fatal(fmt.Sprintf("failed to create admin user: %s", err)) } switch c.SelfRegister { @@ -156,10 +156,10 @@ func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServic // Add a policy that allows anybody to create a user apr, err := auth.AddPolicy(context.Background(), &mainflux.AddPolicyReq{Obj: "user", Act: "create", Sub: "*"}) if err != nil { - logger.Fatal(fmt.Sprintf("failed to add the policy related to MF_USERS_ALLOW_SELF_REGISTER: " + err.Error()))() + logger.Fatal(fmt.Sprintf("failed to add the policy related to MF_USERS_ALLOW_SELF_REGISTER: %s", err)) } if !apr.GetAuthorized() { - logger.Fatal(fmt.Sprintf("failed to authorized the policy result related to MF_USERS_ALLOW_SELF_REGISTER: " + errors.ErrAuthorization.Error()))() + logger.Fatal(fmt.Sprintf("failed to authorized the policy result related to MF_USERS_ALLOW_SELF_REGISTER: " + errors.ErrAuthorization.Error())) } } default: @@ -168,10 +168,10 @@ func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServic // allows everybody to create a new user. dpr, err := auth.DeletePolicy(context.Background(), &mainflux.DeletePolicyReq{Obj: "user", Act: "create", Sub: "*"}) if err != nil { - logger.Fatal(fmt.Sprintf("failed to delete a policy: " + err.Error()))() + logger.Fatal(fmt.Sprintf("failed to delete a policy: %s", err)) } if !dpr.GetDeleted() { - logger.Fatal("deleting a policy expected to succeed.")() + logger.Fatal("deleting a policy expected to succeed.") } } diff --git a/cmd/ws/main.go b/cmd/ws/main.go index b783e38961..e695a61b90 100644 --- a/cmd/ws/main.go +++ b/cmd/ws/main.go @@ -17,7 +17,7 @@ import ( "github.com/mainflux/mainflux/internal/env" "github.com/mainflux/mainflux/internal/server" httpserver "github.com/mainflux/mainflux/internal/server/http" - logger "github.com/mainflux/mainflux/logger" + mflog "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/messaging" "github.com/mainflux/mainflux/pkg/messaging/brokers" adapter "github.com/mainflux/mainflux/ws" @@ -43,24 +43,24 @@ func main() { cfg := config{} if err := env.Parse(&cfg); err != nil { - log.Fatalf("failed to load %s service configuration : %s", svcName, err.Error()) + log.Fatalf("failed to load %s configuration : %s", svcName, err) } - logger, err := logger.New(os.Stdout, cfg.LogLevel) + logger, err := mflog.New(os.Stdout, cfg.LogLevel) if err != nil { - log.Fatalf(err.Error()) + log.Fatalf("failed to init logger: %s", err) } tc, tcHandler, err := thingsClient.Setup(envPrefix, cfg.JaegerURL) if err != nil { - logger.Fatal(err.Error())() + logger.Fatal(err.Error()) } defer internal.Close(logger, tcHandler) logger.Info("Successfully connected to things grpc server " + tcHandler.Secure()) nps, err := brokers.NewPubSub(cfg.BrokerURL, "", logger) if err != nil { - logger.Fatal(fmt.Sprintf("Failed to connect to message broker: %s", err.Error()))() + logger.Fatal(fmt.Sprintf("Failed to connect to message broker: %s", err)) } defer nps.Close() @@ -69,7 +69,7 @@ func main() { httpServerConfig := server.Config{Port: defSvcHttpPort} if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHttp, AltPrefix: envPrefix}); err != nil { - logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err.Error()))() + logger.Fatal(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err)) } hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, api.MakeHandler(svc, logger), logger) @@ -86,7 +86,7 @@ func main() { } } -func newService(tc mainflux.ThingsServiceClient, nps messaging.PubSub, logger logger.Logger) adapter.Service { +func newService(tc mainflux.ThingsServiceClient, nps messaging.PubSub, logger mflog.Logger) adapter.Service { svc := adapter.New(tc, nps) svc = api.LoggingMiddleware(svc, logger) counter, latency := internal.MakeMetrics("ws_adapter", "api") diff --git a/consumers/writers/cassandra/setup_test.go b/consumers/writers/cassandra/setup_test.go index 54016441d6..f66ba8b3b7 100644 --- a/consumers/writers/cassandra/setup_test.go +++ b/consumers/writers/cassandra/setup_test.go @@ -46,7 +46,7 @@ func TestMain(m *testing.M) { return nil }); err != nil { - logger.Fatal(fmt.Sprintf("Could not connect to docker: %s", err))() + logger.Fatal(fmt.Sprintf("Could not connect to docker: %s", err)) } code := m.Run() diff --git a/go.mod b/go.mod index 2c96e101c3..7dc692d3b4 100644 --- a/go.mod +++ b/go.mod @@ -10,6 +10,7 @@ require ( github.com/fatih/color v1.13.0 github.com/fiorix/go-smpp v0.0.0-20210403173735-2894b96e70ba github.com/go-kit/kit v0.12.0 + github.com/go-kit/log v0.2.1 github.com/go-redis/redis/v8 v8.11.5 github.com/go-zoo/bone v1.3.0 github.com/gocql/gocql v1.2.1 @@ -72,7 +73,6 @@ require ( github.com/fsnotify/fsnotify v1.6.0 // indirect github.com/fxamacker/cbor/v2 v2.4.0 // indirect github.com/go-gorp/gorp/v3 v3.1.0 // indirect - github.com/go-kit/log v0.2.1 // indirect github.com/go-logfmt/logfmt v0.5.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/snappy v0.0.4 // indirect diff --git a/logger/level_test.go b/logger/level_test.go index caa869307c..6a7ba4f3b5 100644 --- a/logger/level_test.go +++ b/logger/level_test.go @@ -2,62 +2,178 @@ package logger import ( "fmt" - "github.com/stretchr/testify/assert" "testing" + + "github.com/stretchr/testify/assert" ) func TestUnmarshalText(t *testing.T) { - cases := map[string]struct { + cases := []struct { + desc string input string output Level err error }{ - "select log level Not_A_Level": {"Not_A_Level", 0, ErrInvalidLogLevel}, - "select log level Bad_Input": {"Bad_Input", 0, ErrInvalidLogLevel}, + { + desc: "select log level Not_A_Level", + input: "Not_A_Level", + output: 0, + err: ErrInvalidLogLevel, + }, + { + desc: "select log level Bad_Input", + input: "Bad_Input", + output: 0, + err: ErrInvalidLogLevel, + }, - "select log level debug": {"debug", Debug, nil}, - "select log level DEBUG": {"DEBUG", Debug, nil}, - "select log level info": {"info", Info, nil}, - "select log level INFO": {"INFO", Info, nil}, - "select log level warn": {"warn", Warn, nil}, - "select log level WARN": {"WARN", Warn, nil}, - "select log level Error": {"Error", Error, nil}, - "select log level ERROR": {"ERROR", Error, nil}, + { + desc: "select log level debug", + input: "debug", + output: Debug, + err: nil, + }, + { + desc: "select log level DEBUG", + input: "DEBUG", + output: Debug, + err: nil, + }, + { + desc: "select log level info", + input: "info", + output: Info, + err: nil, + }, + { + desc: "select log level INFO", + input: "INFO", + output: Info, + err: nil, + }, + { + desc: "select log level warn", + input: "warn", + output: Warn, + err: nil, + }, + { + desc: "select log level WARN", + input: "WARN", + output: Warn, + err: nil, + }, + { + desc: "select log level Error", + input: "Error", + output: Error, + err: nil, + }, + { + desc: "select log level ERROR", + input: "ERROR", + output: Error, + err: nil, + }, } - for desc, tc := range cases { + for _, tc := range cases { var logLevel Level err := logLevel.UnmarshalText(tc.input) - assert.Equal(t, tc.output, logLevel, fmt.Sprintf("%s: expected %s got %d", desc, tc.output, logLevel)) - assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %d", desc, tc.err, err)) - + assert.Equal(t, tc.output, logLevel, fmt.Sprintf("%s: expected %s got %d", tc.desc, tc.output, logLevel)) + assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %d", tc.desc, tc.err, err)) } - } func TestLevelIsAllowed(t *testing.T) { - cases := map[string]struct { + cases := []struct { + desc string requestedLevel Level allowedLevel Level output bool }{ - "log debug when level debug": {Debug, Debug, true}, - "log info when level debug": {Info, Debug, true}, - "log warn when level debug": {Warn, Debug, true}, - "log error when level debug": {Error, Debug, true}, - "log warn when level info": {Warn, Info, true}, - "log error when level warn": {Error, Warn, true}, - "log error when level error": {Error, Error, true}, + { + desc: "log debug when level debug", + requestedLevel: Debug, + allowedLevel: Debug, + output: true, + }, + { + desc: "log info when level debug", + requestedLevel: Info, + allowedLevel: Debug, + output: true, + }, + { + desc: "log warn when level debug", + requestedLevel: Warn, + allowedLevel: Debug, + output: true, + }, + { + desc: "log error when level debug", + requestedLevel: Error, + allowedLevel: Debug, + output: true, + }, + { + desc: "log warn when level info", + requestedLevel: Warn, + allowedLevel: Info, + output: true, + }, + { + desc: "log error when level warn", + requestedLevel: Error, + allowedLevel: Warn, + output: true, + }, + { + desc: "log error when level error", + requestedLevel: Error, + allowedLevel: Error, + output: true, + }, - "log debug when level error": {Debug, Error, false}, - "log info when level error": {Info, Error, false}, - "log warn when level error": {Warn, Error, false}, - "log debug when level warn": {Debug, Warn, false}, - "log info when level warn": {Info, Warn, false}, - "log debug when level info": {Debug, Info, false}, + { + desc: "log debug when level error", + requestedLevel: Debug, + allowedLevel: Error, + output: false, + }, + { + desc: "log info when level error", + requestedLevel: Info, + allowedLevel: Error, + output: false, + }, + { + desc: "log warn when level error", + requestedLevel: Warn, + allowedLevel: Error, + output: false, + }, + { + desc: "log debug when level warn", + requestedLevel: Debug, + allowedLevel: Warn, + output: false, + }, + { + desc: "log info when level warn", + requestedLevel: Info, + allowedLevel: Warn, + output: false, + }, + { + desc: "log debug when level info", + requestedLevel: Debug, + allowedLevel: Info, + output: false, + }, } - for desc, tc := range cases { + for _, tc := range cases { result := tc.requestedLevel.isAllowed(tc.allowedLevel) - assert.Equal(t, tc.output, result, fmt.Sprintf("%s: expected %t got %t", desc, tc.output, result)) + assert.Equal(t, tc.output, result, fmt.Sprintf("%s: expected %t got %t", tc.desc, tc.output, result)) } } diff --git a/logger/logger.go b/logger/logger.go index 0b310e8e97..c2b08b808d 100644 --- a/logger/logger.go +++ b/logger/logger.go @@ -22,8 +22,8 @@ type Logger interface { Warn(string) // Error logs any object in JSON format on error level. Error(string) - // Fatal logs any object in JSON format on error level and calls os.Exit(1). - Fatal(string) func() + // Fatal logs any object in JSON format on any level and calls os.Exit(1). + Fatal(string) } var _ Logger = (*logger)(nil) @@ -69,7 +69,7 @@ func (l logger) Error(msg string) { } } -func (l logger) Fatal(msg string) func() { - l.kitLogger.Log("level", l.level.String(), "message", msg) - return func() { os.Exit(1) } +func (l logger) Fatal(msg string) { + l.kitLogger.Log("fatal", msg) + os.Exit(1) } diff --git a/logger/logger_test.go b/logger/logger_test.go index 01568b1cbf..b82dbe1b1b 100644 --- a/logger/logger_test.go +++ b/logger/logger_test.go @@ -7,14 +7,23 @@ import ( "encoding/json" "fmt" "io" + "os" + "os/exec" "testing" log "github.com/mainflux/mainflux/logger" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// Env vars needed for testing Fatal in subprocess. +const ( + testMsg = "TEST_MSG" + testFlag = "TEST_FLAG" + testFlagVal = "assert_test" ) var _ io.Writer = (*mockWriter)(nil) -var writer mockWriter var logger log.Logger var err error var output logMsg @@ -37,90 +46,212 @@ func (writer *mockWriter) Read() (logMsg, error) { type logMsg struct { Level string `json:"level"` Message string `json:"message"` + Fatal string `json:"fatal,omitempty"` // needed for Fatal messages } func TestDebug(t *testing.T) { - cases := map[string]struct { - input string - logLevel string - output logMsg + cases := []struct { + desc string + input string + level string + output logMsg }{ - "debug log ordinary string": {"input_string", log.Debug.String(), logMsg{log.Debug.String(), "input_string"}}, - "debug log empty string": {"", log.Debug.String(), logMsg{log.Debug.String(), ""}}, - "debug ordinary string lvl not allowed": {"input_string", log.Info.String(), logMsg{"", ""}}, - "debug empty string lvl not allowed": {"", log.Info.String(), logMsg{"", ""}}, + { + desc: "debug log ordinary string", + input: "input_string", + level: log.Debug.String(), + output: logMsg{log.Debug.String(), "input_string", ""}, + }, + { + desc: "debug log empty string", + input: "", + level: log.Debug.String(), + output: logMsg{log.Debug.String(), "", ""}, + }, + { + desc: "debug ordinary string lvl not allowed", + input: "input_string", + level: log.Info.String(), + output: logMsg{"", "", ""}, + }, + { + desc: "debug empty string lvl not allowed", + input: "", + level: log.Info.String(), + output: logMsg{"", "", ""}, + }, } - for desc, tc := range cases { - writer = mockWriter{} - logger, err = log.New(&writer, tc.logLevel) - assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err)) + for _, tc := range cases { + writer := mockWriter{} + logger, err = log.New(&writer, tc.level) + assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err)) logger.Debug(tc.input) output, err = writer.Read() - assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output)) + assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", tc.desc, tc.output, output)) } } func TestInfo(t *testing.T) { - cases := map[string]struct { - input string - logLevel string - output logMsg + cases := []struct { + desc string + input string + level string + output logMsg }{ - "info log ordinary string": {"input_string", log.Info.String(), logMsg{log.Info.String(), "input_string"}}, - "info log empty string": {"", log.Info.String(), logMsg{log.Info.String(), ""}}, - "info ordinary string lvl not allowed": {"input_string", log.Warn.String(), logMsg{"", ""}}, - "info empty string lvl not allowed": {"", log.Warn.String(), logMsg{"", ""}}, + { + desc: "info log ordinary string", + input: "input_string", + level: log.Info.String(), + output: logMsg{log.Info.String(), "input_string", ""}, + }, + { + desc: "info log empty string", + input: "", + level: log.Info.String(), + output: logMsg{log.Info.String(), "", ""}, + }, + { + desc: "info ordinary string lvl not allowed", + input: "input_string", + level: log.Warn.String(), + output: logMsg{"", "", ""}, + }, + { + desc: "info empty string lvl not allowed", + input: "", + level: log.Warn.String(), + output: logMsg{"", "", ""}, + }, } - for desc, tc := range cases { - writer = mockWriter{} - logger, err = log.New(&writer, tc.logLevel) - assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err)) + for _, tc := range cases { + writer := mockWriter{} + logger, err = log.New(&writer, tc.level) + assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err)) logger.Info(tc.input) output, err = writer.Read() - assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output)) + assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", tc.desc, tc.output, output)) } } func TestWarn(t *testing.T) { - cases := map[string]struct { - input string - logLevel string - output logMsg + cases := []struct { + desc string + input string + level string + output logMsg }{ - "warn log ordinary string": {"input_string", log.Warn.String(), logMsg{log.Warn.String(), "input_string"}}, - "warn log empty string": {"", log.Warn.String(), logMsg{log.Warn.String(), ""}}, - "warn ordinary string lvl not allowed": {"input_string", log.Error.String(), logMsg{"", ""}}, - "warn empty string lvl not allowed": {"", log.Error.String(), logMsg{"", ""}}, + { + desc: "warn log ordinary string", + input: "input_string", + level: log.Warn.String(), + output: logMsg{log.Warn.String(), "input_string", ""}, + }, + { + desc: "warn log empty string", + input: "", + level: log.Warn.String(), + output: logMsg{log.Warn.String(), "", ""}, + }, + { + desc: "warn ordinary string lvl not allowed", + input: "input_string", + level: log.Error.String(), + output: logMsg{"", "", ""}, + }, + { + desc: "warn empty string lvl not allowed", + input: "", + level: log.Error.String(), + output: logMsg{"", "", ""}, + }, } - for desc, tc := range cases { - writer = mockWriter{} - logger, err = log.New(&writer, tc.logLevel) - assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err)) + for _, tc := range cases { + writer := mockWriter{} + logger, err = log.New(&writer, tc.level) + require.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err)) logger.Warn(tc.input) output, err = writer.Read() - assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output)) + assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", tc.desc, tc.output, output)) } } func TestError(t *testing.T) { - cases := map[string]struct { + cases := []struct { + desc string input string output logMsg }{ - "error log ordinary string": {"input_string", logMsg{log.Error.String(), "input_string"}}, - "error log empty string": {"", logMsg{log.Error.String(), ""}}, + { + desc: "error log ordinary string", + input: "input_string", + output: logMsg{log.Error.String(), "input_string", ""}, + }, + { + desc: "error log empty string", + input: "", + output: logMsg{log.Error.String(), "", ""}, + }, } writer := mockWriter{} - logger, _ := log.New(&writer, log.Error.String()) - - for desc, tc := range cases { + logger, err := log.New(&writer, log.Error.String()) + require.Nil(t, err) + for _, tc := range cases { logger.Error(tc.input) output, err := writer.Read() - assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err)) - assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output)) + assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err)) + assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", tc.desc, tc.output, output)) + } +} + +func TestFatal(t *testing.T) { + // This is the actually Fatal call we test that will + // be executed in the subprocess spawned by the test. + if os.Getenv(testFlag) == testFlagVal { + logger, err := log.New(os.Stderr, log.Error.String()) + require.Nil(t, err) + msg := os.Getenv(testMsg) + logger.Fatal(msg) + return + } + + cases := []struct { + desc string + input string + output logMsg + }{ + { + desc: "error log ordinary string", + input: "input_string", + output: logMsg{"", "", "input_string"}, + }, + { + desc: "error log empty string", + input: "", + output: logMsg{"", "", ""}, + }, + } + writer := mockWriter{} + for _, tc := range cases { + // This command will run this same test as a separate subprocess. + // It needs to be executed as a subprocess because we need to test os.Exit(1) call. + cmd := exec.Command(os.Args[0], "-test.run=TestFatal") + // This flag is used to prevent an infinite loop of spawning this test and never + // actually running the necessary Fatal call. + cmd.Env = append(os.Environ(), fmt.Sprintf("%s=%s", testFlag, testFlagVal)) + cmd.Stderr = &writer + cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", testMsg, tc.input)) + err := cmd.Run() + if e, ok := err.(*exec.ExitError); ok && !e.Success() { + res, err := writer.Read() + require.Nil(t, err, "required successful buffer read") + assert.Equal(t, 1, e.ExitCode(), fmt.Sprintf("%s: expected exit code %d, got %d", tc.desc, 1, e.ExitCode())) + assert.Equal(t, tc.output, res, fmt.Sprintf("%s: expected output %s got %s", tc.desc, tc.output, res)) + continue + } + t.Fatal("subprocess ran successfully, want non-zero exit status") } } diff --git a/logger/mock.go b/logger/mock.go index 513af6e976..544dd55daf 100644 --- a/logger/mock.go +++ b/logger/mock.go @@ -24,6 +24,5 @@ func (l loggerMock) Warn(msg string) { func (l loggerMock) Error(msg string) { } -func (l loggerMock) Fatal(msg string) func() { - return func() {} +func (l loggerMock) Fatal(msg string) { } diff --git a/pkg/errors/errors.go b/pkg/errors/errors.go index 07ef104d71..f7a364c9c7 100644 --- a/pkg/errors/errors.go +++ b/pkg/errors/errors.go @@ -13,7 +13,6 @@ import ( // Error specifies an API that must be fullfiled by error type type Error interface { - // Error implements the error interface. Error() string diff --git a/readers/cassandra/setup_test.go b/readers/cassandra/setup_test.go index 6cc3d971fb..77643a397b 100644 --- a/readers/cassandra/setup_test.go +++ b/readers/cassandra/setup_test.go @@ -46,7 +46,7 @@ func TestMain(m *testing.M) { return nil }); err != nil { - logger.Fatal(fmt.Sprintf("Could not connect to docker: %s", err))() + logger.Fatal(fmt.Sprintf("Could not connect to docker: %s", err)) } code := m.Run() diff --git a/things/service.go b/things/service.go index 07082620d5..ef98c2da3c 100644 --- a/things/service.go +++ b/things/service.go @@ -22,7 +22,7 @@ const ( deleteRelationKey = "delete" ) -// Service specifies an API that must be fullfiled by the domain service +// Service specifies an API that must be fulfilled by the domain service // implementation, and all of its decorators (e.g. logging & metrics). type Service interface { // CreateThings adds things to the user identified by the provided key. diff --git a/tools/mqtt-bench/cmd/main.go b/tools/mqtt-bench/cmd/main.go index c92e3c98a7..bca3371420 100644 --- a/tools/mqtt-bench/cmd/main.go +++ b/tools/mqtt-bench/cmd/main.go @@ -26,7 +26,7 @@ Complete documentation is available at https://docs.mainflux.io`, viper.SetConfigFile(confFile) if err := viper.ReadInConfig(); err != nil { - log.Printf("Failed to load config - %s", err.Error()) + log.Printf("Failed to load config - %s", err) } if err := viper.Unmarshal(&bconf); err != nil { diff --git a/vendor/github.com/go-kit/kit/log/README.md b/vendor/github.com/go-kit/kit/log/README.md deleted file mode 100644 index 5492dd9448..0000000000 --- a/vendor/github.com/go-kit/kit/log/README.md +++ /dev/null @@ -1,160 +0,0 @@ -# package log - -**Deprecation notice:** The core Go kit log packages (log, log/level, log/term, and -log/syslog) have been moved to their own repository at github.com/go-kit/log. -The corresponding packages in this directory remain for backwards compatibility. -Their types alias the types and their functions call the functions provided by -the new repository. Using either import path should be equivalent. Prefer the -new import path when practical. - -______ - -`package log` provides a minimal interface for structured logging in services. -It may be wrapped to encode conventions, enforce type-safety, provide leveled -logging, and so on. It can be used for both typical application log events, -and log-structured data streams. - -## Structured logging - -Structured logging is, basically, conceding to the reality that logs are -_data_, and warrant some level of schematic rigor. Using a stricter, -key/value-oriented message format for our logs, containing contextual and -semantic information, makes it much easier to get insight into the -operational activity of the systems we build. Consequently, `package log` is -of the strong belief that "[the benefits of structured logging outweigh the -minimal effort involved](https://www.thoughtworks.com/radar/techniques/structured-logging)". - -Migrating from unstructured to structured logging is probably a lot easier -than you'd expect. - -```go -// Unstructured -log.Printf("HTTP server listening on %s", addr) - -// Structured -logger.Log("transport", "HTTP", "addr", addr, "msg", "listening") -``` - -## Usage - -### Typical application logging - -```go -w := log.NewSyncWriter(os.Stderr) -logger := log.NewLogfmtLogger(w) -logger.Log("question", "what is the meaning of life?", "answer", 42) - -// Output: -// question="what is the meaning of life?" answer=42 -``` - -### Contextual Loggers - -```go -func main() { - var logger log.Logger - logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr)) - logger = log.With(logger, "instance_id", 123) - - logger.Log("msg", "starting") - NewWorker(log.With(logger, "component", "worker")).Run() - NewSlacker(log.With(logger, "component", "slacker")).Run() -} - -// Output: -// instance_id=123 msg=starting -// instance_id=123 component=worker msg=running -// instance_id=123 component=slacker msg=running -``` - -### Interact with stdlib logger - -Redirect stdlib logger to Go kit logger. - -```go -import ( - "os" - stdlog "log" - kitlog "github.com/go-kit/kit/log" -) - -func main() { - logger := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout)) - stdlog.SetOutput(kitlog.NewStdlibAdapter(logger)) - stdlog.Print("I sure like pie") -} - -// Output: -// {"msg":"I sure like pie","ts":"2016/01/01 12:34:56"} -``` - -Or, if, for legacy reasons, you need to pipe all of your logging through the -stdlib log package, you can redirect Go kit logger to the stdlib logger. - -```go -logger := kitlog.NewLogfmtLogger(kitlog.StdlibWriter{}) -logger.Log("legacy", true, "msg", "at least it's something") - -// Output: -// 2016/01/01 12:34:56 legacy=true msg="at least it's something" -``` - -### Timestamps and callers - -```go -var logger log.Logger -logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr)) -logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller) - -logger.Log("msg", "hello") - -// Output: -// ts=2016-01-01T12:34:56Z caller=main.go:15 msg=hello -``` - -## Levels - -Log levels are supported via the [level package](https://godoc.org/github.com/go-kit/kit/log/level). - -## Supported output formats - -- [Logfmt](https://brandur.org/logfmt) ([see also](https://blog.codeship.com/logfmt-a-log-format-thats-easy-to-read-and-write)) -- JSON - -## Enhancements - -`package log` is centered on the one-method Logger interface. - -```go -type Logger interface { - Log(keyvals ...interface{}) error -} -``` - -This interface, and its supporting code like is the product of much iteration -and evaluation. For more details on the evolution of the Logger interface, -see [The Hunt for a Logger Interface](http://go-talks.appspot.com/github.com/ChrisHines/talks/structured-logging/structured-logging.slide#1), -a talk by [Chris Hines](https://github.com/ChrisHines). -Also, please see -[#63](https://github.com/go-kit/kit/issues/63), -[#76](https://github.com/go-kit/kit/pull/76), -[#131](https://github.com/go-kit/kit/issues/131), -[#157](https://github.com/go-kit/kit/pull/157), -[#164](https://github.com/go-kit/kit/issues/164), and -[#252](https://github.com/go-kit/kit/pull/252) -to review historical conversations about package log and the Logger interface. - -Value-add packages and suggestions, -like improvements to [the leveled logger](https://godoc.org/github.com/go-kit/kit/log/level), -are of course welcome. Good proposals should - -- Be composable with [contextual loggers](https://godoc.org/github.com/go-kit/kit/log#With), -- Not break the behavior of [log.Caller](https://godoc.org/github.com/go-kit/kit/log#Caller) in any wrapped contextual loggers, and -- Be friendly to packages that accept only an unadorned log.Logger. - -## Benchmarks & comparisons - -There are a few Go logging benchmarks and comparisons that include Go kit's package log. - -- [imkira/go-loggers-bench](https://github.com/imkira/go-loggers-bench) includes kit/log -- [uber-common/zap](https://github.com/uber-common/zap), a zero-alloc logging library, includes a comparison with kit/log diff --git a/vendor/github.com/go-kit/kit/log/doc.go b/vendor/github.com/go-kit/kit/log/doc.go deleted file mode 100644 index c9873f4bce..0000000000 --- a/vendor/github.com/go-kit/kit/log/doc.go +++ /dev/null @@ -1,118 +0,0 @@ -// Package log provides a structured logger. -// -// Deprecated: Use github.com/go-kit/log instead. -// -// Structured logging produces logs easily consumed later by humans or -// machines. Humans might be interested in debugging errors, or tracing -// specific requests. Machines might be interested in counting interesting -// events, or aggregating information for off-line processing. In both cases, -// it is important that the log messages are structured and actionable. -// Package log is designed to encourage both of these best practices. -// -// Basic Usage -// -// The fundamental interface is Logger. Loggers create log events from -// key/value data. The Logger interface has a single method, Log, which -// accepts a sequence of alternating key/value pairs, which this package names -// keyvals. -// -// type Logger interface { -// Log(keyvals ...interface{}) error -// } -// -// Here is an example of a function using a Logger to create log events. -// -// func RunTask(task Task, logger log.Logger) string { -// logger.Log("taskID", task.ID, "event", "starting task") -// ... -// logger.Log("taskID", task.ID, "event", "task complete") -// } -// -// The keys in the above example are "taskID" and "event". The values are -// task.ID, "starting task", and "task complete". Every key is followed -// immediately by its value. -// -// Keys are usually plain strings. Values may be any type that has a sensible -// encoding in the chosen log format. With structured logging it is a good -// idea to log simple values without formatting them. This practice allows -// the chosen logger to encode values in the most appropriate way. -// -// Contextual Loggers -// -// A contextual logger stores keyvals that it includes in all log events. -// Building appropriate contextual loggers reduces repetition and aids -// consistency in the resulting log output. With, WithPrefix, and WithSuffix -// add context to a logger. We can use With to improve the RunTask example. -// -// func RunTask(task Task, logger log.Logger) string { -// logger = log.With(logger, "taskID", task.ID) -// logger.Log("event", "starting task") -// ... -// taskHelper(task.Cmd, logger) -// ... -// logger.Log("event", "task complete") -// } -// -// The improved version emits the same log events as the original for the -// first and last calls to Log. Passing the contextual logger to taskHelper -// enables each log event created by taskHelper to include the task.ID even -// though taskHelper does not have access to that value. Using contextual -// loggers this way simplifies producing log output that enables tracing the -// life cycle of individual tasks. (See the Contextual example for the full -// code of the above snippet.) -// -// Dynamic Contextual Values -// -// A Valuer function stored in a contextual logger generates a new value each -// time an event is logged. The Valuer example demonstrates how this feature -// works. -// -// Valuers provide the basis for consistently logging timestamps and source -// code location. The log package defines several valuers for that purpose. -// See Timestamp, DefaultTimestamp, DefaultTimestampUTC, Caller, and -// DefaultCaller. A common logger initialization sequence that ensures all log -// entries contain a timestamp and source location looks like this: -// -// logger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout)) -// logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller) -// -// Concurrent Safety -// -// Applications with multiple goroutines want each log event written to the -// same logger to remain separate from other log events. Package log provides -// two simple solutions for concurrent safe logging. -// -// NewSyncWriter wraps an io.Writer and serializes each call to its Write -// method. Using a SyncWriter has the benefit that the smallest practical -// portion of the logging logic is performed within a mutex, but it requires -// the formatting Logger to make only one call to Write per log event. -// -// NewSyncLogger wraps any Logger and serializes each call to its Log method. -// Using a SyncLogger has the benefit that it guarantees each log event is -// handled atomically within the wrapped logger, but it typically serializes -// both the formatting and output logic. Use a SyncLogger if the formatting -// logger may perform multiple writes per log event. -// -// Error Handling -// -// This package relies on the practice of wrapping or decorating loggers with -// other loggers to provide composable pieces of functionality. It also means -// that Logger.Log must return an error because some -// implementations—especially those that output log data to an io.Writer—may -// encounter errors that cannot be handled locally. This in turn means that -// Loggers that wrap other loggers should return errors from the wrapped -// logger up the stack. -// -// Fortunately, the decorator pattern also provides a way to avoid the -// necessity to check for errors every time an application calls Logger.Log. -// An application required to panic whenever its Logger encounters -// an error could initialize its logger as follows. -// -// fmtlogger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout)) -// logger := log.LoggerFunc(func(keyvals ...interface{}) error { -// if err := fmtlogger.Log(keyvals...); err != nil { -// panic(err) -// } -// return nil -// }) -package log diff --git a/vendor/github.com/go-kit/kit/log/json_logger.go b/vendor/github.com/go-kit/kit/log/json_logger.go deleted file mode 100644 index edfde2f463..0000000000 --- a/vendor/github.com/go-kit/kit/log/json_logger.go +++ /dev/null @@ -1,15 +0,0 @@ -package log - -import ( - "io" - - "github.com/go-kit/log" -) - -// NewJSONLogger returns a Logger that encodes keyvals to the Writer as a -// single JSON object. Each log event produces no more than one call to -// w.Write. The passed Writer must be safe for concurrent use by multiple -// goroutines if the returned Logger will be used concurrently. -func NewJSONLogger(w io.Writer) Logger { - return log.NewJSONLogger(w) -} diff --git a/vendor/github.com/go-kit/kit/log/log.go b/vendor/github.com/go-kit/kit/log/log.go deleted file mode 100644 index 164a4f94a8..0000000000 --- a/vendor/github.com/go-kit/kit/log/log.go +++ /dev/null @@ -1,51 +0,0 @@ -package log - -import ( - "github.com/go-kit/log" -) - -// Logger is the fundamental interface for all log operations. Log creates a -// log event from keyvals, a variadic sequence of alternating keys and values. -// Implementations must be safe for concurrent use by multiple goroutines. In -// particular, any implementation of Logger that appends to keyvals or -// modifies or retains any of its elements must make a copy first. -type Logger = log.Logger - -// ErrMissingValue is appended to keyvals slices with odd length to substitute -// the missing value. -var ErrMissingValue = log.ErrMissingValue - -// With returns a new contextual logger with keyvals prepended to those passed -// to calls to Log. If logger is also a contextual logger created by With, -// WithPrefix, or WithSuffix, keyvals is appended to the existing context. -// -// The returned Logger replaces all value elements (odd indexes) containing a -// Valuer with their generated value for each call to its Log method. -func With(logger Logger, keyvals ...interface{}) Logger { - return log.With(logger, keyvals...) -} - -// WithPrefix returns a new contextual logger with keyvals prepended to those -// passed to calls to Log. If logger is also a contextual logger created by -// With, WithPrefix, or WithSuffix, keyvals is prepended to the existing context. -// -// The returned Logger replaces all value elements (odd indexes) containing a -// Valuer with their generated value for each call to its Log method. -func WithPrefix(logger Logger, keyvals ...interface{}) Logger { - return log.WithPrefix(logger, keyvals...) -} - -// WithSuffix returns a new contextual logger with keyvals appended to those -// passed to calls to Log. If logger is also a contextual logger created by -// With, WithPrefix, or WithSuffix, keyvals is appended to the existing context. -// -// The returned Logger replaces all value elements (odd indexes) containing a -// Valuer with their generated value for each call to its Log method. -func WithSuffix(logger Logger, keyvals ...interface{}) Logger { - return log.WithSuffix(logger, keyvals...) -} - -// LoggerFunc is an adapter to allow use of ordinary functions as Loggers. If -// f is a function with the appropriate signature, LoggerFunc(f) is a Logger -// object that calls f. -type LoggerFunc = log.LoggerFunc diff --git a/vendor/github.com/go-kit/kit/log/logfmt_logger.go b/vendor/github.com/go-kit/kit/log/logfmt_logger.go deleted file mode 100644 index 51cde2c566..0000000000 --- a/vendor/github.com/go-kit/kit/log/logfmt_logger.go +++ /dev/null @@ -1,15 +0,0 @@ -package log - -import ( - "io" - - "github.com/go-kit/log" -) - -// NewLogfmtLogger returns a logger that encodes keyvals to the Writer in -// logfmt format. Each log event produces no more than one call to w.Write. -// The passed Writer must be safe for concurrent use by multiple goroutines if -// the returned Logger will be used concurrently. -func NewLogfmtLogger(w io.Writer) Logger { - return log.NewLogfmtLogger(w) -} diff --git a/vendor/github.com/go-kit/kit/log/nop_logger.go b/vendor/github.com/go-kit/kit/log/nop_logger.go deleted file mode 100644 index b02c686064..0000000000 --- a/vendor/github.com/go-kit/kit/log/nop_logger.go +++ /dev/null @@ -1,8 +0,0 @@ -package log - -import "github.com/go-kit/log" - -// NewNopLogger returns a logger that doesn't do anything. -func NewNopLogger() Logger { - return log.NewNopLogger() -} diff --git a/vendor/github.com/go-kit/kit/log/stdlib.go b/vendor/github.com/go-kit/kit/log/stdlib.go deleted file mode 100644 index cb604a7a85..0000000000 --- a/vendor/github.com/go-kit/kit/log/stdlib.go +++ /dev/null @@ -1,54 +0,0 @@ -package log - -import ( - "io" - - "github.com/go-kit/log" -) - -// StdlibWriter implements io.Writer by invoking the stdlib log.Print. It's -// designed to be passed to a Go kit logger as the writer, for cases where -// it's necessary to redirect all Go kit log output to the stdlib logger. -// -// If you have any choice in the matter, you shouldn't use this. Prefer to -// redirect the stdlib log to the Go kit logger via NewStdlibAdapter. -type StdlibWriter = log.StdlibWriter - -// StdlibAdapter wraps a Logger and allows it to be passed to the stdlib -// logger's SetOutput. It will extract date/timestamps, filenames, and -// messages, and place them under relevant keys. -type StdlibAdapter = log.StdlibAdapter - -// StdlibAdapterOption sets a parameter for the StdlibAdapter. -type StdlibAdapterOption = log.StdlibAdapterOption - -// TimestampKey sets the key for the timestamp field. By default, it's "ts". -func TimestampKey(key string) StdlibAdapterOption { - return log.TimestampKey(key) -} - -// FileKey sets the key for the file and line field. By default, it's "caller". -func FileKey(key string) StdlibAdapterOption { - return log.FileKey(key) -} - -// MessageKey sets the key for the actual log message. By default, it's "msg". -func MessageKey(key string) StdlibAdapterOption { - return log.MessageKey(key) -} - -// Prefix configures the adapter to parse a prefix from stdlib log events. If -// you provide a non-empty prefix to the stdlib logger, then your should provide -// that same prefix to the adapter via this option. -// -// By default, the prefix isn't included in the msg key. Set joinPrefixToMsg to -// true if you want to include the parsed prefix in the msg. -func Prefix(prefix string, joinPrefixToMsg bool) StdlibAdapterOption { - return log.Prefix(prefix, joinPrefixToMsg) -} - -// NewStdlibAdapter returns a new StdlibAdapter wrapper around the passed -// logger. It's designed to be passed to log.SetOutput. -func NewStdlibAdapter(logger Logger, options ...StdlibAdapterOption) io.Writer { - return log.NewStdlibAdapter(logger, options...) -} diff --git a/vendor/github.com/go-kit/kit/log/sync.go b/vendor/github.com/go-kit/kit/log/sync.go deleted file mode 100644 index bcfee2bfd2..0000000000 --- a/vendor/github.com/go-kit/kit/log/sync.go +++ /dev/null @@ -1,37 +0,0 @@ -package log - -import ( - "io" - - "github.com/go-kit/log" -) - -// SwapLogger wraps another logger that may be safely replaced while other -// goroutines use the SwapLogger concurrently. The zero value for a SwapLogger -// will discard all log events without error. -// -// SwapLogger serves well as a package global logger that can be changed by -// importers. -type SwapLogger = log.SwapLogger - -// NewSyncWriter returns a new writer that is safe for concurrent use by -// multiple goroutines. Writes to the returned writer are passed on to w. If -// another write is already in progress, the calling goroutine blocks until -// the writer is available. -// -// If w implements the following interface, so does the returned writer. -// -// interface { -// Fd() uintptr -// } -func NewSyncWriter(w io.Writer) io.Writer { - return log.NewSyncWriter(w) -} - -// NewSyncLogger returns a logger that synchronizes concurrent use of the -// wrapped logger. When multiple goroutines use the SyncLogger concurrently -// only one goroutine will be allowed to log to the wrapped logger at a time. -// The other goroutines will block until the logger is available. -func NewSyncLogger(logger Logger) Logger { - return log.NewSyncLogger(logger) -} diff --git a/vendor/github.com/go-kit/kit/log/value.go b/vendor/github.com/go-kit/kit/log/value.go deleted file mode 100644 index 96d783bd5d..0000000000 --- a/vendor/github.com/go-kit/kit/log/value.go +++ /dev/null @@ -1,52 +0,0 @@ -package log - -import ( - "time" - - "github.com/go-kit/log" -) - -// A Valuer generates a log value. When passed to With, WithPrefix, or -// WithSuffix in a value element (odd indexes), it represents a dynamic -// value which is re-evaluated with each log event. -type Valuer = log.Valuer - -// Timestamp returns a timestamp Valuer. It invokes the t function to get the -// time; unless you are doing something tricky, pass time.Now. -// -// Most users will want to use DefaultTimestamp or DefaultTimestampUTC, which -// are TimestampFormats that use the RFC3339Nano format. -func Timestamp(t func() time.Time) Valuer { - return log.Timestamp(t) -} - -// TimestampFormat returns a timestamp Valuer with a custom time format. It -// invokes the t function to get the time to format; unless you are doing -// something tricky, pass time.Now. The layout string is passed to -// Time.Format. -// -// Most users will want to use DefaultTimestamp or DefaultTimestampUTC, which -// are TimestampFormats that use the RFC3339Nano format. -func TimestampFormat(t func() time.Time, layout string) Valuer { - return log.TimestampFormat(t, layout) -} - -// Caller returns a Valuer that returns a file and line from a specified depth -// in the callstack. Users will probably want to use DefaultCaller. -func Caller(depth int) Valuer { - return log.Caller(depth) -} - -var ( - // DefaultTimestamp is a Valuer that returns the current wallclock time, - // respecting time zones, when bound. - DefaultTimestamp = log.DefaultTimestamp - - // DefaultTimestampUTC is a Valuer that returns the current time in UTC - // when bound. - DefaultTimestampUTC = log.DefaultTimestampUTC - - // DefaultCaller is a Valuer that returns the file and line where the Log - // method was invoked. It can only be used with log.With. - DefaultCaller = log.DefaultCaller -) diff --git a/vendor/modules.txt b/vendor/modules.txt index 3cc2e153bf..d1bbc54718 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -98,7 +98,6 @@ github.com/go-gorp/gorp/v3 # github.com/go-kit/kit v0.12.0 ## explicit; go 1.17 github.com/go-kit/kit/endpoint -github.com/go-kit/kit/log github.com/go-kit/kit/metrics github.com/go-kit/kit/metrics/internal/lv github.com/go-kit/kit/metrics/prometheus