OrgGo/Mainflux.mainflux
1
0
Fork 0
mirror of https://github.com/mainflux/mainflux.git synced 2025-04-24 13:48:49 +08:00
Code Issues Projects Releases Wiki Activity

NOISSUE - Logger Fatal method returns no value (#1728)

Browse Source 
* Make Fatal return no value

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>

* Add Fatal test

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>

* Rename logger imports

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>

* Replace Fatal with Fatalf

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>

* Refactor Logger tests

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>

* Fix expected and actual order inversion

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>

* Update dependencies

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>

---------

Signed-off-by: dusanb94 <dusan.borovcanin@mainflux.com>
This commit is contained in:
Dušan Borovčanin 2023-02-22 20:50:51 +01:00 committed by GitHub
parent 108077a356
commit c0c72491ff
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
45 changed files with 611 additions and 877 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
cmd/auth/main.go
View File

@ -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)

22
cmd/bootstrap/main.go
View File

@ -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 {

18
cmd/cassandra-reader/main.go
View File

@ -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")

17
cmd/cassandra-writer/main.go
View File

@ -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")

24
cmd/certs/main.go
View File

@ -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)

16
cmd/coap/main.go
View File

@ -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)

18
cmd/http/main.go
View File

@ -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")

20
cmd/influxdb-reader/main.go
View File

@ -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")

20
cmd/influxdb-writer/main.go
View File

@ -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")

32
cmd/lora/main.go
View File

@ -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)

19
cmd/mongodb-reader/main.go
View File

@ -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")

18
cmd/mongodb-writer/main.go
View File

@ -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")

20
cmd/mqtt/main.go
View File

@ -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())

26
cmd/opcua/main.go
View File

@ -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")

20
cmd/postgres-reader/main.go
View File

@ -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")

18
cmd/postgres-writer/main.go
View File

@ -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")

1
cmd/provision/main.go
View File

@ -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 {

26
cmd/smpp-notifier/main.go
View File

@ -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()

28
cmd/smtp-notifier/main.go
View File

@ -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)

30
cmd/things/main.go
View File

@ -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)

20
cmd/timescale-reader/main.go
View File

@ -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")

18
cmd/timescale-writer/main.go
View File

@ -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")

33
cmd/twins/main.go
View File

@ -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

40
cmd/users/main.go
View File

@ -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.")
}
}

16
cmd/ws/main.go
View File

@ -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")

2
consumers/writers/cassandra/setup_test.go
View File

@ -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()

2
go.mod
View File

@ -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

182
logger/level_test.go
View File

@ -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))
}
}

10
logger/logger.go
View File

@ -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)
}

227
logger/logger_test.go
View File

@ -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")
}
}

3
logger/mock.go
View File

@ -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) {
}

1
pkg/errors/errors.go
View File

@ -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

2
readers/cassandra/setup_test.go
View File

@ -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()

2
things/service.go
View File

@ -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.

2
tools/mqtt-bench/cmd/main.go
View File

@ -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 {

160
vendor/github.com/go-kit/kit/log/README.md generated vendored
View File

@ -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

118
vendor/github.com/go-kit/kit/log/doc.go generated vendored
View File

@ -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

15
vendor/github.com/go-kit/kit/log/json_logger.go generated vendored
View File

@ -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)
}

51
vendor/github.com/go-kit/kit/log/log.go generated vendored
View File

@ -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

15
vendor/github.com/go-kit/kit/log/logfmt_logger.go generated vendored
View File

@ -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)
}

8
vendor/github.com/go-kit/kit/log/nop_logger.go generated vendored
View File

@ -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()
}

54
vendor/github.com/go-kit/kit/log/stdlib.go generated vendored
View File

@ -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...)
}

37
vendor/github.com/go-kit/kit/log/sync.go generated vendored
View File

@ -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)
}

52
vendor/github.com/go-kit/kit/log/value.go generated vendored
View File

@ -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
)

1
vendor/modules.txt vendored
View File

@ -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