logging_middleware.go

package middleware

import (
	"context"

	"git.perx.ru/perxis/perxis-go/id"
	"git.perx.ru/perxis/perxis-go/pkg/items"
	"git.perx.ru/perxis/perxis-go/pkg/schema"
	logzap "git.perx.ru/perxis/perxis-go/zap"
	"go.uber.org/zap"
)

type loggingMiddleware struct {
	logger *zap.Logger
	next   items.Items
}

func LoggingMiddleware(logger *zap.Logger) Middleware {
	return func(next items.Items) items.Items {
		return &loggingMiddleware{
			next:   next,
			logger: logger.With(logzap.Component("items")),
		}
	}
}

func (m *loggingMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregateOptions) (result map[string]interface{}, err error) {
	logger := m.logger.With(
		logzap.CallerFromContext(ctx),
	)

	result, err = m.next.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
	if err != nil {
		logger.Error("Failed to aggregate", zap.Error(err))
		return
	}

	return result, err
}

func (m *loggingMiddleware) AggregatePublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
	logger := m.logger.With(
		logzap.CallerFromContext(ctx),
	)

	result, err = m.next.AggregatePublished(ctx, spaceId, envId, collectionId, filter, options...)
	if err != nil {
		logger.Error("Failed to aggregate_published", zap.Error(err))
		return
	}

	return result, err
}

func (m *loggingMiddleware) Archive(ctx context.Context, item *items.Item, options ...*items.ArchiveOptions) (err error) {
	logger := m.logger.With(
		logzap.CallerFromContext(ctx),
		logzap.Event(items.EventItemArchive),
		logzap.Object(item),
	)

	err = m.next.Archive(ctx, item, options...)
	if err != nil {
		logger.Error("Failed to archive", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
		return
	}

	logger.Info("Successfully archived", logzap.Channels(logzap.Userlog))
	return err
}