Added Command/Query decorators

Author: roblaszczak

internal/common/decorator/command.go

@@ -0,0 +1,27 @@
+package decorator
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+)
+
+func ApplyCommandDecorators[H any](handler CommandHandler[H], logger *logrus.Entry, metricsClient MetricsClient) CommandHandler[H] {
+	return commandLoggingDecorator[H]{
+		base: commandMetricsDecorator[H]{
+			base:   handler,
+			client: metricsClient,
+		},
+		logger: logger,
+	}
+}
+
+type CommandHandler[C any] interface {
+	Handle(ctx context.Context, cmd C) error
+}
+
+func generateActionName(handler any) string {
+	return strings.Split(fmt.Sprintf("%T", handler), ".")[1]
+}

internal/common/decorator/logging.go

@@ -0,0 +1,56 @@
+package decorator
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/sirupsen/logrus"
+)
+
+type commandLoggingDecorator[C any] struct {
+	base   CommandHandler[C]
+	logger *logrus.Entry
+}
+
+func (d commandLoggingDecorator[C]) Handle(ctx context.Context, cmd C) (err error) {
+	handlerType := generateActionName(cmd)
+
+	logger := d.logger.WithFields(logrus.Fields{
+		"command":      handlerType,
+		"command_body": fmt.Sprintf("%#v", cmd),
+	})
+
+	logger.Debug("Executing command")
+	defer func() {
+		if err == nil {
+			logger.Info("Command executed successfully")
+		} else {
+			logger.WithError(err).Error("Failed to execute command")
+		}
+	}()
+
+	return d.base.Handle(ctx, cmd)
+}
+
+type queryLoggingDecorator[C any, R any] struct {
+	base   QueryHandler[C, R]
+	logger *logrus.Entry
+}
+
+func (d queryLoggingDecorator[C, R]) Handle(ctx context.Context, cmd C) (result R, err error) {
+	logger := d.logger.WithFields(logrus.Fields{
+		"query":      generateActionName(cmd),
+		"query_body": fmt.Sprintf("%#v", cmd),
+	})
+
+	logger.Debug("Executing query")
+	defer func() {
+		if err == nil {
+			logger.Info("Query executed successfully")
+		} else {
+			logger.WithError(err).Error("Failed to execute query")
+		}
+	}()
+
+	return d.base.Handle(ctx, cmd)
+}

internal/common/decorator/metrics.go

@@ -0,0 +1,62 @@
+package decorator
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+)
+
+type MetricsClient interface {
+	Inc(key string, value int)
+}
+
+type commandMetricsDecorator[C any] struct {
+	base   CommandHandler[C]
+	client MetricsClient
+}
+
+func (d commandMetricsDecorator[C]) Handle(ctx context.Context, cmd C) (err error) {
+	start := time.Now()
+
+	actionName := strings.ToLower(generateActionName(cmd))
+
+	defer func() {
+		end := time.Since(start)
+
+		d.client.Inc(fmt.Sprintf("commands.%s.duration", actionName), int(end.Seconds()))
+
+		if err == nil {
+			d.client.Inc(fmt.Sprintf("commands.%s.success", actionName), 1)
+		} else {
+			d.client.Inc(fmt.Sprintf("commands.%s.failure", actionName), 1)
+		}
+	}()
+
+	return d.base.Handle(ctx, cmd)
+}
+
+type queryMetricsDecorator[C any, R any] struct {
+	base   QueryHandler[C, R]
+	client MetricsClient
+}
+
+func (d queryMetricsDecorator[C, R]) Handle(ctx context.Context, query C) (result R, err error) {
+	start := time.Now()
+
+	actionName := strings.ToLower(generateActionName(query))
+
+	defer func() {
+		end := time.Since(start)
+
+		d.client.Inc(fmt.Sprintf("querys.%s.duration", actionName), int(end.Seconds()))
+
+		if err == nil {
+			d.client.Inc(fmt.Sprintf("querys.%s.success", actionName), 1)
+		} else {
+			d.client.Inc(fmt.Sprintf("querys.%s.failure", actionName), 1)
+		}
+	}()
+
+	return d.base.Handle(ctx, query)
+}

internal/common/decorator/query.go

@@ -0,0 +1,21 @@
+package decorator
+
+import (
+	"context"
+
+	"github.com/sirupsen/logrus"
+)
+
+func ApplyQueryDecorators[H any, R any](handler QueryHandler[H, R], logger *logrus.Entry, metricsClient MetricsClient) QueryHandler[H, R] {
+	return queryLoggingDecorator[H, R]{
+		base: queryMetricsDecorator[H, R]{
+			base:   handler,
+			client: metricsClient,
+		},
+		logger: logger,
+	}
+}
+
+type QueryHandler[Q any, R any] interface {
+	Handle(ctx context.Context, q Q) (R, error)
+}

internal/common/metrics/dummy.go

@@ -0,0 +1,7 @@
+package metrics
+
+type NoOp struct{}
+
+func (d NoOp) Inc(_ string, _ int) {
+	// todo - add some implementation!
+}

internal/trainer/app/command/cancel_training.go

@@ -4,24 +4,40 @@ import (
 	"context"
 	"time"
 
+	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/decorator"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/errors"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/trainer/domain/hour"
+	"github.com/sirupsen/logrus"
 )
 
-type CancelTrainingHandler struct {
+type CancelTraining struct {
+	Hour time.Time
+}
+
+type CancelTrainingHandler decorator.CommandHandler[CancelTraining]
+
+type cancelTrainingHandler struct {
 	hourRepo hour.Repository
 }
 
-func NewCancelTrainingHandler(hourRepo hour.Repository) CancelTrainingHandler {
+func NewCancelTrainingHandler(
+	hourRepo hour.Repository,
+	logger *logrus.Entry,
+	metricsClient decorator.MetricsClient,
+) CancelTrainingHandler {
 	if hourRepo == nil {
 		panic("nil hourRepo")
 	}
 
-	return CancelTrainingHandler{hourRepo: hourRepo}
+	return decorator.ApplyCommandDecorators[CancelTraining](
+		cancelTrainingHandler{hourRepo: hourRepo},
+		logger,
+		metricsClient,
+	)
 }
 
-func (h CancelTrainingHandler) Handle(ctx context.Context, hourToCancel time.Time) error {
-	if err := h.hourRepo.UpdateHour(ctx, hourToCancel, func(h *hour.Hour) (*hour.Hour, error) {
+func (h cancelTrainingHandler) Handle(ctx context.Context, cmd CancelTraining) error {
+	if err := h.hourRepo.UpdateHour(ctx, cmd.Hour, func(h *hour.Hour) (*hour.Hour, error) {
 		if err := h.CancelTraining(); err != nil {
 			return nil, err
 		}

internal/trainer/app/command/make_hours_available.go

@@ -4,24 +4,40 @@ import (
 	"context"
 	"time"
 
+	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/decorator"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/errors"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/trainer/domain/hour"
+	"github.com/sirupsen/logrus"
 )
 
-type MakeHoursAvailableHandler struct {
+type MakeHoursAvailable struct {
+	Hours []time.Time
+}
+
+type MakeHoursAvailableHandler decorator.CommandHandler[MakeHoursAvailable]
+
+type makeHoursAvailableHandler struct {
 	hourRepo hour.Repository
 }
 
-func NewMakeHoursAvailableHandler(hourRepo hour.Repository) MakeHoursAvailableHandler {
+func NewMakeHoursAvailableHandler(
+	hourRepo hour.Repository,
+	logger *logrus.Entry,
+	metricsClient decorator.MetricsClient,
+) MakeHoursAvailableHandler {
 	if hourRepo == nil {
 		panic("hourRepo is nil")
 	}
 
-	return MakeHoursAvailableHandler{hourRepo: hourRepo}
+	return decorator.ApplyCommandDecorators[MakeHoursAvailable](
+		makeHoursAvailableHandler{hourRepo: hourRepo},
+		logger,
+		metricsClient,
+	)
 }
 
-func (c MakeHoursAvailableHandler) Handle(ctx context.Context, hours []time.Time) error {
-	for _, hourToUpdate := range hours {
+func (c makeHoursAvailableHandler) Handle(ctx context.Context, cmd MakeHoursAvailable) error {
+	for _, hourToUpdate := range cmd.Hours {
 		if err := c.hourRepo.UpdateHour(ctx, hourToUpdate, func(h *hour.Hour) (*hour.Hour, error) {
 			if err := h.MakeAvailable(); err != nil {
 				return nil, err

internal/trainer/app/command/make_hours_unavailable.go

@@ -4,24 +4,40 @@ import (
 	"context"
 	"time"
 
+	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/decorator"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/errors"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/trainer/domain/hour"
+	"github.com/sirupsen/logrus"
 )
 
-type MakeHoursUnavailableHandler struct {
+type MakeHoursUnavailable struct {
+	Hours []time.Time
+}
+
+type MakeHoursUnavailableHandler decorator.CommandHandler[MakeHoursUnavailable]
+
+type makeHoursUnavailableHandler struct {
 	hourRepo hour.Repository
 }
 
-func NewMakeHoursUnavailableHandler(hourRepo hour.Repository) MakeHoursUnavailableHandler {
+func NewMakeHoursUnavailableHandler(
+	hourRepo hour.Repository,
+	logger *logrus.Entry,
+	metricsClient decorator.MetricsClient,
+) MakeHoursUnavailableHandler {
 	if hourRepo == nil {
 		panic("hourRepo is nil")
 	}
 
-	return MakeHoursUnavailableHandler{hourRepo: hourRepo}
+	return decorator.ApplyCommandDecorators[MakeHoursUnavailable](
+		makeHoursUnavailableHandler{hourRepo: hourRepo},
+		logger,
+		metricsClient,
+	)
 }
 
-func (c MakeHoursUnavailableHandler) Handle(ctx context.Context, hours []time.Time) error {
-	for _, hourToUpdate := range hours {
+func (c makeHoursUnavailableHandler) Handle(ctx context.Context, cmd MakeHoursUnavailable) error {
+	for _, hourToUpdate := range cmd.Hours {
 		if err := c.hourRepo.UpdateHour(ctx, hourToUpdate, func(h *hour.Hour) (*hour.Hour, error) {
 			if err := h.MakeNotAvailable(); err != nil {
 				return nil, err

internal/trainer/app/command/schedule_training.go

@@ -4,24 +4,40 @@ import (
 	"context"
 	"time"
 
+	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/decorator"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/common/errors"
 	"github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/internal/trainer/domain/hour"
+	"github.com/sirupsen/logrus"
 )
 
-type ScheduleTrainingHandler struct {
+type ScheduleTraining struct {
+	Hour time.Time
+}
+
+type ScheduleTrainingHandler decorator.CommandHandler[ScheduleTraining]
+
+type scheduleTrainingHandler struct {
 	hourRepo hour.Repository
 }
 
-func NewScheduleTrainingHandler(hourRepo hour.Repository) ScheduleTrainingHandler {
+func NewScheduleTrainingHandler(
+	hourRepo hour.Repository,
+	logger *logrus.Entry,
+	metricsClient decorator.MetricsClient,
+) ScheduleTrainingHandler {
 	if hourRepo == nil {
 		panic("nil hourRepo")
 	}
 
-	return ScheduleTrainingHandler{hourRepo: hourRepo}
+	return decorator.ApplyCommandDecorators[ScheduleTraining](
+		scheduleTrainingHandler{hourRepo: hourRepo},
+		logger,
+		metricsClient,
+	)
 }
 
-func (h ScheduleTrainingHandler) Handle(ctx context.Context, hourToCancel time.Time) error {
-	if err := h.hourRepo.UpdateHour(ctx, hourToCancel, func(h *hour.Hour) (*hour.Hour, error) {
+func (h scheduleTrainingHandler) Handle(ctx context.Context, cmd ScheduleTraining) error {
+	if err := h.hourRepo.UpdateHour(ctx, cmd.Hour, func(h *hour.Hour) (*hour.Hour, error) {
 		if err := h.ScheduleTraining(); err != nil {
 			return nil, err
 		}