diff --git a/pkg/clients/events.go b/pkg/clients/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..5bba0b6f8d9dcb35f3dd6446a209735dcc57bf60
--- /dev/null
+++ b/pkg/clients/events.go
@@ -0,0 +1,9 @@
+package clients
+
+const (
+	EventCreate  = "client.create"
+	EventUpdate  = "client.update"
+	EventDelete  = "client.delete"
+	EventEnable  = "client.enable"
+	EventDisable = "client.disable"
+)
diff --git a/pkg/clients/middleware/logging_middleware.go b/pkg/clients/middleware/logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..c8ce011a5e991a18ca8a28f54d21ff3d5034f54c
--- /dev/null
+++ b/pkg/clients/middleware/logging_middleware.go
@@ -0,0 +1,146 @@
+package middleware
+
+import (
+	"context"
+
+	"git.perx.ru/perxis/perxis-go/id"
+	"git.perx.ru/perxis/perxis-go/pkg/clients"
+	logzap "git.perx.ru/perxis/perxis-go/zap"
+	"go.uber.org/zap"
+)
+
+type loggingMiddleware struct {
+	logger *zap.Logger
+	next   clients.Clients
+}
+
+func LoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next clients.Clients) clients.Clients {
+		return &loggingMiddleware{
+			next:   next,
+			logger: logger.With(logzap.Component("Clients")),
+		}
+	}
+}
+
+func (m *loggingMiddleware) Create(ctx context.Context, client *clients.Client) (created *clients.Client, err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(clients.EventCreate),
+		logzap.Object(client),
+	)
+
+	created, err = m.next.Create(ctx, client)
+	if err != nil {
+		logger.Error("Failed to create", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Client created", logzap.Channels(logzap.Userlog))
+
+	return created, err
+}
+
+func (m *loggingMiddleware) Get(ctx context.Context, spaceId, clientId string) (client *clients.Client, err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Object(id.NewClientId(spaceId, clientId)),
+	)
+
+	client, err = m.next.Get(ctx, spaceId, clientId)
+	if err != nil {
+		logger.Error("Failed to get", zap.Error(err))
+		return
+	}
+
+	return client, err
+}
+
+func (m *loggingMiddleware) GetBy(ctx context.Context, spaceId string, params *clients.GetByParams) (client *clients.Client, err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+	)
+
+	client, err = m.next.GetBy(ctx, spaceId, params)
+	if err != nil {
+		logger.Error("Failed to get by", zap.Error(err))
+		return
+	}
+
+	return client, err
+}
+
+func (m *loggingMiddleware) List(ctx context.Context, spaceId string) (clients []*clients.Client, err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+	)
+
+	clients, err = m.next.List(ctx, spaceId)
+	if err != nil {
+		logger.Error("Failed to list", zap.Error(err))
+		return
+	}
+
+	return clients, err
+}
+
+func (m *loggingMiddleware) Update(ctx context.Context, client *clients.Client) (err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(clients.EventUpdate),
+		logzap.Object(client),
+	)
+
+	err = m.next.Update(ctx, client)
+	if err != nil {
+		logger.Error("Failed to update", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Client updated", logzap.Channels(logzap.Userlog))
+
+	return err
+}
+
+func (m *loggingMiddleware) Delete(ctx context.Context, spaceId, clientId string) (err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(clients.EventDelete),
+		logzap.Object(id.NewClientId(spaceId, clientId)),
+	)
+
+	err = m.next.Delete(ctx, spaceId, clientId)
+	if err != nil {
+		logger.Error("Failed to delete", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Client deleted", logzap.Channels(logzap.Userlog))
+
+	return err
+}
+
+func (m *loggingMiddleware) Enable(ctx context.Context, spaceId, clientId string, enable bool) (err error) {
+	event := clients.EventDisable
+	logMsg := "disable"
+
+	if enable {
+		event = clients.EventEnable
+		logMsg = "enable"
+	}
+
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(event),
+		logzap.Object(id.NewClientId(spaceId, clientId)),
+	)
+
+	err = m.next.Enable(ctx, spaceId, clientId, enable)
+	if err != nil {
+		logger.Error("Failed to "+logMsg, zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Client "+logMsg+"d", logzap.Channels(logzap.Userlog))
+	return err
+}
diff --git a/pkg/clients/middleware/middleware.go b/pkg/clients/middleware/middleware.go
index 0c72c1660e15f147a773e2da5e2f31b469b90260..945ae1f2afde7274140b6cbd3c84fff260d0b1cb 100644
--- a/pkg/clients/middleware/middleware.go
+++ b/pkg/clients/middleware/middleware.go
@@ -21,7 +21,7 @@ func WithLog(s clients.Clients, logger *zap.Logger, log_access bool) clients.Cli
 	if log_access {
 		s = AccessLoggingMiddleware(logger)(s)
 	}
-	s = ErrorLoggingMiddleware(logger)(s)
+	s = LoggingMiddleware(logger)(s)
 
 	s = RecoveringMiddleware(logger)(s)
 	return s