use slog for logging as mglogger was deprecated

Signed-off-by: Rodney Osodo <[email protected]>

.github/workflows/tests.yml

@@ -116,6 +116,13 @@ jobs:
  - "pkg/uuid/**"
  - "pkg/messaging/**"
 
+ eventlogs:
+ - "eventlogs/**"
+ - "cmd/eventlogs/**"
+ - "auth.pb.go"
+ - "auth_grpc.pb.go"
+ - "auth/**"
+
  http:
  - "http/**"
  - "cmd/http/**"
@@ -288,6 +295,11 @@ jobs:
  run: |
  go test --race -v -count=1 -coverprofile=coverage/consumers.out ./consumers/...
 
+ - name: Run pkg eventlogs tests
+ if: steps.changes.outputs.eventlogs == 'true' || steps.changes.outputs.workflow == 'true'
+ run: |
+ go test --race -v -count=1 -coverprofile=coverage/eventlogs.out ./pkg/events/...
+
  - name: Run HTTP tests
  if: steps.changes.outputs.http == 'true' || steps.changes.outputs.workflow == 'true'
  run: |

cmd/event-logs/main.go

@@ -6,11 +6,12 @@ package main
 
 import (
  "context"
- "fmt"
  "log"
+ "log/slog"
  "net/url"
  "os"
 
+ chclient "github.com/absmach/callhome/pkg/client"
  "github.com/absmach/magistrala"
  "github.com/absmach/magistrala/eventlogs"
  "github.com/absmach/magistrala/eventlogs/api"
@@ -26,7 +27,6 @@ import (
  "github.com/absmach/magistrala/pkg/events/store"
  "github.com/absmach/magistrala/pkg/uuid"
  "github.com/caarlos0/env/v10"
- chclient "github.com/mainflux/callhome/pkg/client"
  "go.opentelemetry.io/otel/trace"
  "golang.org/x/sync/errgroup"
 )
@@ -68,28 +68,30 @@ func main() {
 
  if cfg.InstanceID == "" {
  if cfg.InstanceID, err = uuid.New().ID(); err != nil {
- logger.Error(fmt.Sprintf("failed to generate instanceID: %s", err))
+ logger.Error("failed to generate instanceID: %s", err)
  exitCode = 1
  return
  }
  }
 
  dbConfig := pgclient.Config{Name: defDB}
  if err := env.ParseWithOptions(&dbConfig, env.Options{Prefix: envPrefixDB}); err != nil {
- logger.Error(fmt.Sprintf("failed to load %s Postgres configuration : %s", svcName, err))
+ logger.Error("failed to load %s Postgres configuration : %s", svcName, err)
  exitCode = 1
  return
  }
  db, err := pgclient.Setup(dbConfig, *eventlogspg.Migration())
  if err != nil {
- logger.Fatal(err.Error())
+ logger.Error(err.Error())
+ exitCode = 1
+ return
  }
  defer db.Close()
  repo := eventlogspg.NewRepository(db)
 
  authConfig := auth.Config{}
  if err := env.ParseWithOptions(&authConfig, env.Options{Prefix: envPrefixAuth}); err != nil {
- logger.Error(fmt.Sprintf("failed to load %s auth configuration : %s", svcName, err))
+ logger.Error("failed to load %s auth configuration : %s", svcName, err)
  exitCode = 1
  return
  }
@@ -106,13 +108,13 @@ func main() {
 
  tp, err := jaegerclient.NewProvider(ctx, svcName, cfg.JaegerURL, cfg.InstanceID, cfg.TraceRatio)
  if err != nil {
- logger.Error(fmt.Sprintf("Failed to init Jaeger: %s", err))
+ logger.Error("Failed to init Jaeger: %s", err)
  exitCode = 1
  return
  }
  defer func() {
  if err := tp.Shutdown(ctx); err != nil {
- logger.Error(fmt.Sprintf("Error shutting down tracer provider: %v", err))
+ logger.Error("Error shutting down tracer provider: %v", err)
  }
  }()
  tracer := tp.Tracer(svcName)
@@ -121,22 +123,22 @@ func main() {
 
  subscriber, err := store.NewSubscriber(ctx, cfg.ESURL, logger)
  if err != nil {
- logger.Error(fmt.Sprintf("failed to create subscriber: %s", err))
+ logger.Error("failed to create subscriber: %s", err)
  exitCode = 1
  return
  }
 
  logger.Info("Subscribed to Event Store")
 
  if err := eventlogs.Start(ctx, svcName, subscriber, repo); err != nil {
- logger.Error(fmt.Sprintf("failed to start %s service: %s", svcName, err))
+ logger.Error("failed to start %s service: %s", svcName, err)
  exitCode = 1
  return
  }
 
  httpServerConfig := server.Config{Port: defSvcHTTPPort}
  if err := env.ParseWithOptions(&httpServerConfig, env.Options{Prefix: envPrefixHTTP}); err != nil {
- logger.Error(fmt.Sprintf("failed to load %s HTTP server configuration : %s", svcName, err))
+ logger.Error("failed to load %s HTTP server configuration : %s", svcName, err)
  exitCode = 1
  return
  }
@@ -157,11 +159,11 @@ func main() {
  })
 
  if err := g.Wait(); err != nil {
- logger.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
+ logger.Error("%s service terminated: %s", svcName, err)
  }
 }
 
-func newService(repo eventlogs.Repository, authClient magistrala.AuthServiceClient, logger mglog.Logger, tracer trace.Tracer) eventlogs.Service {
+func newService(repo eventlogs.Repository, authClient magistrala.AuthServiceClient, logger *slog.Logger, tracer trace.Tracer) eventlogs.Service {
  svc := eventlogs.NewService(repo, authClient)
  svc = middleware.LoggingMiddleware(svc, logger)
  counter, latency := internal.MakeMetrics("eventlogs", "event_writer")

eventlogs/api/transport.go

@@ -5,14 +5,14 @@ package api
 
 import (
  "context"
+ "log/slog"
  "net/http"
  "time"
 
  "github.com/absmach/magistrala"
  "github.com/absmach/magistrala/eventlogs"
  "github.com/absmach/magistrala/internal/api"
  "github.com/absmach/magistrala/internal/apiutil"
- mglog "github.com/absmach/magistrala/logger"
  "github.com/absmach/magistrala/pkg/errors"
  "github.com/go-chi/chi/v5"
  kithttp "github.com/go-kit/kit/transport/http"
@@ -28,7 +28,7 @@ const (
 )
 
 // MakeHandler returns a HTTP API handler with health check and metrics.
-func MakeHandler(svc eventlogs.Service, logger mglog.Logger, svcName, instanceID string) http.Handler {
+func MakeHandler(svc eventlogs.Service, logger *slog.Logger, svcName, instanceID string) http.Handler {
  opts := []kithttp.ServerOption{
  kithttp.ServerErrorEncoder(apiutil.LoggingErrorEncoder(logger, api.EncodeError)),
  }

eventlogs/middleware/logging.go

@@ -5,22 +5,21 @@ package middleware
 
 import (
  "context"
- "fmt"
+ "log/slog"
  "time"
 
  "github.com/absmach/magistrala/eventlogs"
- mglog "github.com/absmach/magistrala/logger"
 )
 
 var _ eventlogs.Service = (*loggingMiddleware)(nil)
 
 type loggingMiddleware struct {
- logger mglog.Logger
+ logger *slog.Logger
  service eventlogs.Service
 }
 
 // LoggingMiddleware adds logging facilities to the adapter.
-func LoggingMiddleware(service eventlogs.Service, logger mglog.Logger) eventlogs.Service {
+func LoggingMiddleware(service eventlogs.Service, logger *slog.Logger) eventlogs.Service {
  return &loggingMiddleware{
  logger: logger,
  service: service,
@@ -29,12 +28,21 @@ func LoggingMiddleware(service eventlogs.Service, logger mglog.Logger) eventlogs
 
 func (lm *loggingMiddleware) ReadAll(ctx context.Context, token string, page eventlogs.Page) (eventsPage eventlogs.EventsPage, err error) {
  defer func(begin time.Time) {
- message := fmt.Sprintf("Method read_all for operation %s with query %v took %s to complete", page.Operation, page, time.Since(begin))
+ args := []any{
+ slog.String("duration", time.Since(begin).String()),
+ slog.Group("page",
+ slog.String("operation", page.Operation),
+ slog.Uint64("offset", page.Offset),
+ slog.Uint64("limit", page.Limit),
+ slog.Uint64("total", eventsPage.Total),
+ ),
+ }
  if err != nil {
- lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
+ args = append(args, slog.Any("error", err))
+ lm.logger.Warn("Read all events failed to complete successfully", args...)
  return
  }
- lm.logger.Info(fmt.Sprintf("%s without errors.", message))
+ lm.logger.Info("Read all events completed successfully", args...)
  }(time.Now())
 
  return lm.service.ReadAll(ctx, token, page)

eventlogs/service_test.go

@@ -24,7 +24,7 @@ import (
 
 func TestReadAll(t *testing.T) {
  repo := new(mocks.Repository)
- authsvc := new(authmocks.Service)
+ authsvc := new(authmocks.AuthClient)
  svc := eventlogs.NewService(repo, authsvc)
 
  validToken := "token"

users/api/endpoint_test.go

@@ -666,7 +666,7 @@ func TestListClients(t *testing.T) {
  desc: "list users with invalid order direction",
  token: validToken,
  query: "dir=invalid",
- status: http.StatusInternalServerError,
+ status: http.StatusBadRequest,
  err: apiutil.ErrValidation,
  },
  {