refactor: move tracing to middleware folder

felixgateru · felixgateru · commit 655b91318007 · 2025-07-28T15:38:10.000+03:00
Signed-off-by: Felix Gateru &lt;felix.gateru@gmail.com&gt;
diff --git a/channels/middleware/authorization.go b/channels/middleware/authorization.go
@@ -54,8 +54,8 @@ type authorizationMiddleware struct {
 	rmMW.RoleManagerAuthorizationMiddleware
 }
 
-// AuthorizationMiddleware adds authorization to the channels service.
-func AuthorizationMiddleware(
+// Authorization adds authorization to the channels service.
+func Authorization(
 	svc channels.Service,
 	repo channels.Repository,
 	authz smqauthz.Authorization,
diff --git a/channels/middleware/doc.go b/channels/middleware/doc.go
@@ -0,0 +1,9 @@
+// Copyright (c) Abstract Machines
+// SPDX-License-Identifier: Apache-2.0
+
+// Package middleware provides authorization, logging, metrics and tracing middleware
+// for Magistrala Channels Service.
+//
+// For more details about tracing instrumentation for Magistrala messaging refer
+// to the documentation at https://docs.magistrala.abstractmachines.fr/tracing/.
+package middleware
diff --git a/channels/middleware/logging.go b/channels/middleware/logging.go
@@ -25,7 +25,7 @@ type loggingMiddleware struct {
 	rmMW.RoleManagerLoggingMiddleware
 }
 
-func LoggingMiddleware(svc channels.Service, logger *slog.Logger) channels.Service {
+func Logging(svc channels.Service, logger *slog.Logger) channels.Service {
 	return &loggingMiddleware{logger, svc, rmMW.NewRoleManagerLoggingMiddleware("channels", svc, logger)}
 }
 
diff --git a/channels/middleware/metrics.go b/channels/middleware/metrics.go
@@ -24,8 +24,8 @@ type metricsMiddleware struct {
 	rmMW.RoleManagerMetricsMiddleware
 }
 
-// MetricsMiddleware returns a new metrics middleware wrapper.
-func MetricsMiddleware(svc channels.Service, counter metrics.Counter, latency metrics.Histogram) channels.Service {
+// Metrics returns a new metrics middleware wrapper.
+func Metrics(svc channels.Service, counter metrics.Counter, latency metrics.Histogram) channels.Service {
 	return &metricsMiddleware{
 		counter:                      counter,
 		latency:                      latency,
diff --git a/channels/middleware/tracing.go b/channels/middleware/tracing.go
@@ -1,7 +1,7 @@
 // Copyright (c) Abstract Machines
 // SPDX-License-Identifier: Apache-2.0
 
-package tracing
+package middleware
 
 import (
 	"context"
@@ -25,7 +25,7 @@ type tracingMiddleware struct {
 }
 
 // New returns a new group service with tracing capabilities.
-func New(svc channels.Service, tracer trace.Tracer) channels.Service {
+func Tracing(svc channels.Service, tracer trace.Tracer) channels.Service {
 	return &tracingMiddleware{tracer, svc, rmTrace.NewRoleManagerTracing("channels", svc, tracer)}
 }
 
diff --git a/channels/tracing/doc.go b/channels/tracing/doc.go
diff --git a/clients/middleware/authorization.go b/clients/middleware/authorization.go
@@ -48,8 +48,8 @@ type authorizationMiddleware struct {
 	rmMW.RoleManagerAuthorizationMiddleware
 }
 
-// AuthorizationMiddleware adds authorization to the clients service.
-func AuthorizationMiddleware(
+// Authorization adds authorization to the clients service.
+func Authorization(
 	entityType string,
 	svc clients.Service,
 	authz smqauthz.Authorization,
diff --git a/clients/middleware/doc.go b/clients/middleware/doc.go
@@ -1,5 +1,9 @@
 // Copyright (c) Abstract Machines
 // SPDX-License-Identifier: Apache-2.0
 
-// Package middleware provides middleware for SuperMQ Clients service.
+// Package middleware provides authorization, logging, metrics and tracing middleware
+// for Magistrala Clients Service.
+//
+// For more details about tracing instrumentation for Magistrala messaging refer
+// to the documentation at https://docs.magistrala.abstractmachines.fr/tracing/.
 package middleware
diff --git a/clients/middleware/logging.go b/clients/middleware/logging.go
@@ -24,7 +24,8 @@ type loggingMiddleware struct {
 	rmMW.RoleManagerLoggingMiddleware
 }
 
-func LoggingMiddleware(svc clients.Service, logger *slog.Logger) clients.Service {
+// Logging adds logging facilities to the core service.
+func Logging(svc clients.Service, logger *slog.Logger) clients.Service {
 	return &loggingMiddleware{
 		logger:                       logger,
 		svc:                          svc,
diff --git a/clients/middleware/metrics.go b/clients/middleware/metrics.go
@@ -23,8 +23,8 @@ type metricsMiddleware struct {
 	rmMW.RoleManagerMetricsMiddleware
 }
 
-// MetricsMiddleware returns a new metrics middleware wrapper.
-func MetricsMiddleware(svc clients.Service, counter metrics.Counter, latency metrics.Histogram) clients.Service {
+// Metrics returns a new metrics middleware wrapper.
+func Metrics(svc clients.Service, counter metrics.Counter, latency metrics.Histogram) clients.Service {
 	return &metricsMiddleware{
 		counter:                      counter,
 		latency:                      latency,
diff --git a/clients/middleware/tracing.go b/clients/middleware/tracing.go
@@ -1,7 +1,7 @@
 // Copyright (c) Abstract Machines
 // SPDX-License-Identifier: Apache-2.0
 
-package tracing
+package middleware
 
 import (
 	"context"
@@ -23,8 +23,8 @@ type tracingMiddleware struct {
 	rmTrace.RoleManagerTracing
 }
 
-// New returns a new group service with tracing capabilities.
-func New(svc clients.Service, tracer trace.Tracer) clients.Service {
+// Tracing returns a new clients service with tracing capabilities.
+func Tracing(svc clients.Service, tracer trace.Tracer) clients.Service {
 	return &tracingMiddleware{
 		tracer:             tracer,
 		svc:                svc,
diff --git a/clients/tracing/doc.go b/clients/tracing/doc.go
diff --git a/cmd/auth/main.go b/cmd/auth/main.go
@@ -25,7 +25,6 @@ import (
 	"github.com/absmach/supermq/auth/jwt"
 	"github.com/absmach/supermq/auth/middleware"
 	apostgres "github.com/absmach/supermq/auth/postgres"
-	"github.com/absmach/supermq/auth/tracing"
 	redisclient "github.com/absmach/supermq/internal/clients/redis"
 	smqlog "github.com/absmach/supermq/logger"
 	"github.com/absmach/supermq/pkg/jaeger"
@@ -245,7 +244,7 @@ func newService(db *sqlx.DB, tracer trace.Tracer, cfg config, dbConfig pgclient.
 	t := jwt.New([]byte(cfg.SecretKey))
 
 	svc := auth.New(keysRepo, patsRepo, nil, hasher, idProvider, t, pEvaluator, pService, cfg.AccessDuration, cfg.RefreshDuration, cfg.InvitationDuration)
-	svc = api.LoggingMiddleware(svc, logger)
+	svc = middleware.Logging(svc, logger)
 	counter, latency := prometheus.MakeMetrics("auth", "api")
 	svc = middleware.Metrics(svc, counter, latency)
 	svc = middleware.Tracing(svc, tracer)
diff --git a/cmd/certs/main.go b/cmd/certs/main.go
@@ -16,9 +16,9 @@ import (
 	"github.com/absmach/supermq"
 	"github.com/absmach/supermq/certs"
 	httpapi "github.com/absmach/supermq/certs/api"
+	"github.com/absmach/supermq/certs/middleware"
 	pki "github.com/absmach/supermq/certs/pki/openbao"
 	"github.com/absmach/supermq/certs/postgres"
-	"github.com/absmach/supermq/certs/tracing"
 	smqlog "github.com/absmach/supermq/logger"
 	authsvcAuthn "github.com/absmach/supermq/pkg/authn/authsvc"
 	"github.com/absmach/supermq/pkg/grpcclient"
@@ -191,7 +191,7 @@ func newService(db *sqlx.DB, dbConfig pgclient.Config, tracer trace.Tracer, logg
 	sdk := mgsdk.NewSDK(config)
 	repo := postgres.NewRepository(database)
 	svc := certs.New(sdk, repo, pkiAgent)
-	svc = httpapi.LoggingMiddleware(svc, logger)
+	svc = middleware.Logging(svc, logger)
 	counter, latency := prometheus.MakeMetrics(svcName, "api")
 	svc = middleware.Metrics(svc, counter, latency)
 	svc = middleware.Tracing(svc, tracer)
diff --git a/cmd/channels/main.go b/cmd/channels/main.go
@@ -26,7 +26,6 @@ import (
 	"github.com/absmach/supermq/channels/middleware"
 	"github.com/absmach/supermq/channels/postgres"
 	pChannels "github.com/absmach/supermq/channels/private"
-	"github.com/absmach/supermq/channels/tracing"
 	dpostgres "github.com/absmach/supermq/domains/postgres"
 	gpostgres "github.com/absmach/supermq/groups/postgres"
 	redisclient "github.com/absmach/supermq/internal/clients/redis"
@@ -357,16 +356,16 @@ func newService(ctx context.Context, db *sqlx.DB, dbConfig pgclient.Config, cach
 		return nil, nil, err
 	}
 
-	svc = tracing.New(svc, tracer)
+	svc = middleware.Tracing(svc, tracer)
 
 	counter, latency := prometheus.MakeMetrics("channels", "api")
-	svc = middleware.MetricsMiddleware(svc, counter, latency)
+	svc = middleware.Metrics(svc, counter, latency)
 
-	svc, err = middleware.AuthorizationMiddleware(svc, repo, authz, channels.NewOperationPermissionMap(), channels.NewRolesOperationPermissionMap(), channels.NewExternalOperationPermissionMap(), callout)
+	svc, err = middleware.Authorization(svc, repo, authz, channels.NewOperationPermissionMap(), channels.NewRolesOperationPermissionMap(), channels.NewExternalOperationPermissionMap(), callout)
 	if err != nil {
 		return nil, nil, err
 	}
-	svc = middleware.LoggingMiddleware(svc, logger)
+	svc = middleware.Logging(svc, logger)
 
 	psvc := pChannels.New(repo, cache, pe, ps, da)
 	return svc, psvc, err
diff --git a/cmd/clients/main.go b/cmd/clients/main.go
@@ -26,7 +26,6 @@ import (
 	"github.com/absmach/supermq/clients/middleware"
 	"github.com/absmach/supermq/clients/postgres"
 	pClients "github.com/absmach/supermq/clients/private"
-	"github.com/absmach/supermq/clients/tracing"
 	dpostgres "github.com/absmach/supermq/domains/postgres"
 	gpostgres "github.com/absmach/supermq/groups/postgres"
 	redisclient "github.com/absmach/supermq/internal/clients/redis"
@@ -358,17 +357,16 @@ func newService(ctx context.Context, db *sqlx.DB, dbConfig pgclient.Config, auth
 		return nil, nil, err
 	}
 
-	csvc = tracing.New(csvc, tracer)
+	csvc = middleware.Tracing(csvc, tracer)
 
 	counter, latency := prometheus.MakeMetrics(svcName, "api")
-	csvc = middleware.MetricsMiddleware(csvc, counter, latency)
-	csvc = middleware.MetricsMiddleware(csvc, counter, latency)
+	csvc = middleware.Metrics(csvc, counter, latency)
 
-	csvc, err = middleware.AuthorizationMiddleware(policies.ClientType, csvc, authz, repo, clients.NewOperationPermissionMap(), clients.NewRolesOperationPermissionMap(), clients.NewExternalOperationPermissionMap(), callout)
+	csvc, err = middleware.Authorization(policies.ClientType, csvc, authz, repo, clients.NewOperationPermissionMap(), clients.NewRolesOperationPermissionMap(), clients.NewExternalOperationPermissionMap(), callout)
 	if err != nil {
 		return nil, nil, err
 	}
-	csvc = middleware.LoggingMiddleware(csvc, logger)
+	csvc = middleware.Logging(csvc, logger)
 
 	isvc := pClients.New(repo, cache, pe, ps)
 
diff --git a/cmd/domains/main.go b/cmd/domains/main.go
@@ -24,7 +24,6 @@ import (
 	dmw "github.com/absmach/supermq/domains/middleware"
 	dpostgres "github.com/absmach/supermq/domains/postgres"
 	"github.com/absmach/supermq/domains/private"
-	dtracing "github.com/absmach/supermq/domains/tracing"
 	redisclient "github.com/absmach/supermq/internal/clients/redis"
 	smqlog "github.com/absmach/supermq/logger"
 	authsvcAuthn "github.com/absmach/supermq/pkg/authn/authsvc"
@@ -280,17 +279,17 @@ func newDomainService(ctx context.Context, domainsRepo domainsSvc.Repository, ca
 		return nil, fmt.Errorf("failed to init domain event store middleware: %w", err)
 	}
 
-	svc, err = dmw.AuthorizationMiddleware(policies.DomainType, svc, authz, domains.NewOperationPermissionMap(), domains.NewRolesOperationPermissionMap(), callout)
+	svc, err = dmw.Authorization(policies.DomainType, svc, authz, domains.NewOperationPermissionMap(), domains.NewRolesOperationPermissionMap(), callout)
 	if err != nil {
 		return nil, err
 	}
 
 	counter, latency := prometheus.MakeMetrics("domains", "api")
-	svc = dmw.MetricsMiddleware(svc, counter, latency)
+	svc = dmw.Metrics(svc, counter, latency)
 
-	svc = dmw.LoggingMiddleware(svc, logger)
+	svc = dmw.Logging(svc, logger)
 
-	svc = dtracing.New(svc, tracer)
+	svc = dmw.Tracing(svc, tracer)
 	return svc, nil
 }
 
diff --git a/cmd/groups/main.go b/cmd/groups/main.go
@@ -26,7 +26,6 @@ import (
 	"github.com/absmach/supermq/groups/middleware"
 	"github.com/absmach/supermq/groups/postgres"
 	pgroups "github.com/absmach/supermq/groups/private"
-	"github.com/absmach/supermq/groups/tracing"
 	smqlog "github.com/absmach/supermq/logger"
 	authsvcAuthn "github.com/absmach/supermq/pkg/authn/authsvc"
 	smqauthz "github.com/absmach/supermq/pkg/authz"
@@ -327,16 +326,16 @@ func newService(ctx context.Context, authz smqauthz.Authorization, policy polici
 		return nil, nil, err
 	}
 
-	svc, err = middleware.AuthorizationMiddleware(policies.GroupType, svc, repo, authz, groups.NewOperationPermissionMap(), groups.NewRolesOperationPermissionMap(),
+	svc, err = middleware.Authorization(policies.GroupType, svc, repo, authz, groups.NewOperationPermissionMap(), groups.NewRolesOperationPermissionMap(),
 		groups.NewExternalOperationPermissionMap(), callout)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	svc = tracing.New(svc, tracer)
-	svc = middleware.LoggingMiddleware(svc, logger)
+	svc = middleware.Tracing(svc, tracer)
+	svc = middleware.Logging(svc, logger)
 	counter, latency := prometheus.MakeMetrics("groups", "api")
-	svc = middleware.MetricsMiddleware(svc, counter, latency)
+	svc = middleware.Metrics(svc, counter, latency)
 
 	psvc := pgroups.New(repo)
 	return svc, psvc, err
diff --git a/cmd/journal/main.go b/cmd/journal/main.go
@@ -199,7 +199,7 @@ func newService(db *sqlx.DB, dbConfig pgclient.Config, authz smqauthz.Authorizat
 	idp := uuid.New()
 
 	svc := journal.NewService(idp, repo)
-	svc = middleware.AuthorizationMiddleware(svc, authz)
+	svc = middleware.Authorization(svc, authz)
 	svc = middleware.Logging(svc, logger)
 	counter, latency := prometheus.MakeMetrics("journal", "journal_writer")
 	svc = middleware.Metrics(svc, counter, latency)
diff --git a/cmd/users/main.go b/cmd/users/main.go
@@ -274,7 +274,7 @@ func newService(ctx context.Context, authz smqauthz.Authorization, token grpcTok
 	if err != nil {
 		return nil, err
 	}
-	svc = middleware.AuthorizationMiddleware(svc, authz, c.SelfRegister)
+	svc = middleware.Authorization(svc, authz, c.SelfRegister)
 
 	svc = middleware.Tracing(svc, tracer)
 	svc = middleware.Logging(svc, logger)
diff --git a/domains/middleware/authorization.go b/domains/middleware/authorization.go
@@ -35,8 +35,8 @@ type authorizationMiddleware struct {
 	rmMW.RoleManagerAuthorizationMiddleware
 }
 
-// AuthorizationMiddleware adds authorization to the clients service.
-func AuthorizationMiddleware(entityType string, svc domains.Service, authz smqauthz.Authorization, domainsOpPerm, rolesOpPerm map[svcutil.Operation]svcutil.Permission, callout callout.Callout) (domains.Service, error) {
+// Authorization adds authorization to the clients service.
+func Authorization(entityType string, svc domains.Service, authz smqauthz.Authorization, domainsOpPerm, rolesOpPerm map[svcutil.Operation]svcutil.Permission, callout callout.Callout) (domains.Service, error) {
 	opp := domains.NewOperationPerm()
 	if err := opp.AddOperationPermissionMap(domainsOpPerm); err != nil {
 		return nil, err
diff --git a/domains/middleware/doc.go b/domains/middleware/doc.go
@@ -0,0 +1,9 @@
+// Copyright (c) Abstract Machines
+// SPDX-License-Identifier: Apache-2.0
+
+// Package middleware provides authorization, logging, metrics and tracing middleware
+// for Magistrala Domains service.
+//
+// For more details about tracing instrumentation for Magistrala messaging refer
+// to the documentation at https://docs.magistrala.abstractmachines.fr/tracing/.
+package middleware
diff --git a/domains/middleware/logging.go b/domains/middleware/logging.go
@@ -25,8 +25,8 @@ type loggingMiddleware struct {
 	rmMW.RoleManagerLoggingMiddleware
 }
 
-// LoggingMiddleware adds logging facilities to the core service.
-func LoggingMiddleware(svc domains.Service, logger *slog.Logger) domains.Service {
+// Logging adds logging facilities to the core service.
+func Logging(svc domains.Service, logger *slog.Logger) domains.Service {
 	rmlm := rmMW.NewRoleManagerLoggingMiddleware("domains", svc, logger)
 	return &loggingMiddleware{
 		logger:                       logger,
diff --git a/domains/middleware/metrics.go b/domains/middleware/metrics.go
@@ -25,8 +25,8 @@ type metricsMiddleware struct {
 	rmMW.RoleManagerMetricsMiddleware
 }
 
-// MetricsMiddleware instruments core service by tracking request count and latency.
-func MetricsMiddleware(svc domains.Service, counter metrics.Counter, latency metrics.Histogram) domains.Service {
+// Metrics instruments core service by tracking request count and latency.
+func Metrics(svc domains.Service, counter metrics.Counter, latency metrics.Histogram) domains.Service {
 	rmmw := rmMW.NewRoleManagerMetricsMiddleware("domains", svc, counter, latency)
 
 	return &metricsMiddleware{
diff --git a/domains/middleware/tracing.go b/domains/middleware/tracing.go
@@ -1,7 +1,7 @@
 // Copyright (c) Abstract Machines
 // SPDX-License-Identifier: Apache-2.0
 
-package tracing
+package middleware
 
 import (
 	"context"
@@ -23,8 +23,8 @@ type tracingMiddleware struct {
 	rmTrace.RoleManagerTracing
 }
 
-// New returns a new group service with tracing capabilities.
-func New(svc domains.Service, tracer trace.Tracer) domains.Service {
+// Tracing returns a new domains service with tracing capabilities.
+func Tracing(svc domains.Service, tracer trace.Tracer) domains.Service {
 	return &tracingMiddleware{tracer, svc, rmTrace.NewRoleManagerTracing("domain", svc, tracer)}
 }
 
diff --git a/groups/middleware/authorization.go b/groups/middleware/authorization.go
@@ -54,8 +54,8 @@ type authorizationMiddleware struct {
 	rmMW.RoleManagerAuthorizationMiddleware
 }
 
-// AuthorizationMiddleware adds authorization to the clients service.
-func AuthorizationMiddleware(entityType string,
+// Authorization adds authorization to the clients service.
+func Authorization(entityType string,
 	svc groups.Service,
 	repo groups.Repository,
 	authz smqauthz.Authorization,
diff --git a/groups/middleware/doc.go b/groups/middleware/doc.go
diff --git a/groups/middleware/logging.go b/groups/middleware/logging.go
diff --git a/groups/middleware/metrics.go b/groups/middleware/metrics.go
diff --git a/groups/middleware/tracing.go b/groups/middleware/tracing.go
diff --git a/groups/tracing/doc.go b/groups/tracing/doc.go
diff --git a/journal/middleware/authorization.go b/journal/middleware/authorization.go
diff --git a/users/middleware/authorization.go b/users/middleware/authorization.go

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ type loggingMiddleware struct {`
`25`	`25`	`rmMW.RoleManagerLoggingMiddleware`
`26`	`26`	`}`
`27`	`27`
`28`		`-func LoggingMiddleware(svc channels.Service, logger *slog.Logger) channels.Service {`
	`28`	`+func Logging(svc channels.Service, logger *slog.Logger) channels.Service {`
`29`	`29`	`return &loggingMiddleware{logger, svc, rmMW.NewRoleManagerLoggingMiddleware("channels", svc, logger)}`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`// Copyright (c) Abstract Machines`
`2`	`2`	`// SPDX-License-Identifier: Apache-2.0`
`3`	`3`
`4`		`-package tracing`
	`4`	`+package middleware`
`5`	`5`
`6`	`6`	`import (`
`7`	`7`	`"context"`
`@@ -25,7 +25,7 @@ type tracingMiddleware struct {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`// New returns a new group service with tracing capabilities.`
`28`		`-func New(svc channels.Service, tracer trace.Tracer) channels.Service {`
	`28`	`+func Tracing(svc channels.Service, tracer trace.Tracer) channels.Service {`
`29`	`29`	`return &tracingMiddleware{tracer, svc, rmTrace.NewRoleManagerTracing("channels", svc, tracer)}`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,8 @@ type loggingMiddleware struct {`
`24`	`24`	`rmMW.RoleManagerLoggingMiddleware`
`25`	`25`	`}`
`26`	`26`
`27`		`-func LoggingMiddleware(svc clients.Service, logger *slog.Logger) clients.Service {`
	`27`	`+// Logging adds logging facilities to the core service.`
	`28`	`+func Logging(svc clients.Service, logger *slog.Logger) clients.Service {`
`28`	`29`	`return &loggingMiddleware{`
`29`	`30`	`logger: logger,`
`30`	`31`	`svc: svc,`