diff --git a/pkg/spaces/events.go b/pkg/spaces/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..418e4ea8a27237c39250433f3ff0cfa7c819e457
--- /dev/null
+++ b/pkg/spaces/events.go
@@ -0,0 +1,12 @@
+package spaces
+
+const (
+	EventAbortTransfer = "spaces.abort_transfer"
+	EventCreate        = "spaces.create"
+	EventDelete        = "spaces.delete"
+	EventMove          = "spaces.move"
+	EventTransfer      = "spaces.transfer"
+	EventUpdate        = "spaces.update"
+	EventUpdateConfig  = "spaces.update_config"
+	EventMigrate       = "spaces.migrate"
+)
diff --git a/pkg/spaces/middleware/logging_middleware.go b/pkg/spaces/middleware/logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a7ef7c183dcdb60f64af49ec626c6ef5c7a9987
--- /dev/null
+++ b/pkg/spaces/middleware/logging_middleware.go
@@ -0,0 +1,193 @@
+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),
+		logzap.Object(space),
+	)
+
+	created, err = m.next.Create(ctx, space)
+	if err != nil {
+		logger.Error("Failed to create", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Space created", logzap.Channels(logzap.Userlog))
+
+	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
+}
diff --git a/pkg/spaces/middleware/middleware.go b/pkg/spaces/middleware/middleware.go
index 73c3b8c3538e6bf9a6457617afc35f68f429aaf3..15f2bc259beacd5ea312632ba042a33b59022f32 100644
--- a/pkg/spaces/middleware/middleware.go
+++ b/pkg/spaces/middleware/middleware.go
@@ -21,7 +21,7 @@ func WithLog(s spaces.Spaces, logger *zap.Logger, log_access bool) spaces.Spaces
 	if log_access {
 		s = AccessLoggingMiddleware(logger)(s)
 	}
-	s = ErrorLoggingMiddleware(logger)(s)
+	s = LoggingMiddleware(logger)(s)
 
 	s = RecoveringMiddleware(logger)(s)
 	return s