Skip to content
Snippets Groups Projects
Select Git revision
  • c4c2cc2e954701f58dc3e0dc8c13f973865ff3a0
  • master default protected
  • feature/PRXS-3383-CollectionsRankSortAPI
  • feature/PRXS-3383-CollectionsSort
  • feature/3109-SerializeFeature
  • release/0.33
  • feature/3109-RecoverySchema
  • feature/3109-feature
  • fix/PRXS-3369-ValidateFields
  • refactor/PRXS-3306-MovePkgGroup1
  • refactor/6-pkg-refactor-expr
  • fix/PRXS-3360-TemplateBuilderPatch
  • feature/3293-MongoV2
  • feature/3272-GoVersionUp
  • feature/PRXS-3218-HideTemplateActions
  • feature/PRXS-3234-PruneIdents
  • feature/3146-UpdateItemStorageInterface
  • feature/3274-ObjectIndexesFixes
  • feature/PRXS-3143-3235-ReferenceOptions
  • feature/PRXS-3143-3237-ExecuteOptions
  • feature/3149-LocaleCodeAsID-Implementation
  • v0.33.1
  • v0.32.0
  • v0.31.1
  • v0.31.0
  • v0.30.0
  • v0.29.0
  • v0.28.0
  • v0.27.0-alpha.1+16
  • v0.27.0-alpha.1+15
  • v0.27.0-alpha.1+14
  • v0.27.0-alpha.1+13
  • v0.27.0-alpha.1+12
  • v0.27.0-alpha.1+11
  • v0.27.0-alpha.1+10
  • v0.27.0-alpha.1+9
  • v0.27.0-alpha.1+8
  • v0.27.0-alpha.1+7
  • v0.27.0-alpha.1+6
  • v0.27.0-alpha.1+5
  • v0.27.0-alpha.1+4
41 results

logging_middleware.go

Blame
  • logging_middleware.go 4.72 KiB
    package middleware
    
    import (
    	"context"
    
    	"git.perx.ru/perxis/perxis-go/id"
    	"git.perx.ru/perxis/perxis-go/pkg/spaces"
    
    	logzap "git.perx.ru/perxis/perxis-go/zap"
    	"go.uber.org/zap"
    )
    
    type loggingMiddleware struct {
    	logger *zap.Logger
    	next   spaces.Spaces
    }
    
    func LoggingMiddleware(logger *zap.Logger) Middleware {
    	return func(next spaces.Spaces) spaces.Spaces {
    		return &loggingMiddleware{
    			next:   next,
    			logger: logger.With(logzap.Component("Spaces")),
    		}
    	}
    }
    
    func (m *loggingMiddleware) AbortTransfer(ctx context.Context, spaceID string) (err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Event(spaces.EventAbortTransfer),
    		logzap.Object(id.NewSpaceId(spaceID)),
    	)
    
    	err = m.next.AbortTransfer(ctx, spaceID)
    	if err != nil {
    		logger.Error("Failed to abort transfer", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
    		return
    	}
    
    	logger.Info("Aborted space transfer", logzap.Channels(logzap.Userlog))
    
    	return err
    }
    
    func (m *loggingMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Event(spaces.EventCreate),
    	)
    
    	created, err = m.next.Create(ctx, space)
    	if err != nil {
    		logger.Error("Failed to create", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog), logzap.Object(space))
    		return
    	}
    
    	logger.Info("Space created", logzap.Channels(logzap.Userlog), logzap.Object(created))
    
    	return created, err
    }
    
    func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Event(spaces.EventDelete),
    		logzap.Object(id.NewSpaceId(spaceId)),
    	)
    
    	err = m.next.Delete(ctx, spaceId)
    	if err != nil {
    		logger.Error("Failed to delete", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
    		return
    	}
    
    	logger.Info("Space deleted", logzap.Channels(logzap.Userlog))
    
    	return err
    }
    
    func (m *loggingMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Object(id.NewSpaceId(spaceId)),
    	)
    
    	space, err = m.next.Get(ctx, spaceId)
    	if err != nil {
    		logger.Error("Failed to get", zap.Error(err))
    		return
    	}
    
    	return space, err
    }
    
    func (m *loggingMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    	)
    
    	spaces, err = m.next.List(ctx, orgId)
    	if err != nil {
    		logger.Error("Failed to list", zap.Error(err))
    		return
    	}
    
    	return spaces, err
    }
    
    func (m *loggingMiddleware) ListTransfers(ctx context.Context, orgID string) (spaces []*spaces.Space, err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    	)
    
    	spaces, err = m.next.ListTransfers(ctx, orgID)
    	if err != nil {
    		logger.Error("Failed to list transfers", zap.Error(err))
    		return
    	}
    
    	return spaces, err
    }
    
    func (m *loggingMiddleware) Move(ctx context.Context, spaceID string, orgID string) (err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Event(spaces.EventMove),
    		logzap.Object(id.NewSpaceId(spaceID)),
    	)
    
    	err = m.next.Move(ctx, spaceID, orgID)
    	if err != nil {
    		logger.Error("Failed to move", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
    		return
    	}
    
    	logger.Info("Space moved", logzap.Channels(logzap.Userlog))
    
    	return err
    }
    
    func (m *loggingMiddleware) Transfer(ctx context.Context, spaceID string, transferToOrg string) (err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Event(spaces.EventTransfer),
    		logzap.Object(id.NewSpaceId(spaceID)),
    	)
    
    	err = m.next.Transfer(ctx, spaceID, transferToOrg)
    	if err != nil {
    		logger.Error("Failed to transfer", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
    		return
    	}
    
    	logger.Info("Space transferred", logzap.Channels(logzap.Userlog))
    
    	return err
    }
    
    func (m *loggingMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Event(spaces.EventUpdate),
    		logzap.Object(space),
    	)
    
    	err = m.next.Update(ctx, space)
    	if err != nil {
    		logger.Error("Failed to update", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
    		return
    	}
    
    	logger.Info("Space updated", logzap.Channels(logzap.Userlog))
    
    	return err
    }
    
    func (m *loggingMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
    	logger := m.logger.With(
    		logzap.Caller(ctx),
    		logzap.Event(spaces.EventUpdateConfig),
    		logzap.Object(id.NewSpaceId(spaceId)),
    	)
    
    	err = m.next.UpdateConfig(ctx, spaceId, config)
    	if err != nil {
    		logger.Error("Failed to update config", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
    		return
    	}
    
    	logger.Info("Updated space config", logzap.Channels(logzap.Userlog))
    
    	return err
    }