diff --git a/assets/templates/middleware/middleware.tmpl b/assets/templates/middleware/middleware.tmpl
index c717d577e89331ed386cf21a1b8ba5486cd54714..7a34d393cbe71648913dd708d49118da36da1105 100755
--- a/assets/templates/middleware/middleware.tmpl
+++ b/assets/templates/middleware/middleware.tmpl
@@ -11,17 +11,14 @@ func WithLog(s {{.Interface.Type}}, logger *zap.Logger, log_access bool) {{.Inte
 		logger = zap.NewNop()
 	}
     logger = logger.Named("{{ .Interface.Name }}")
-    {{- if (has $serviceName (list "Items" "Collections") ) }}
 	if log_access {
 		s = AccessLoggingMiddleware(logger)(s)
 	}
-	s = LoggingMiddleware(logger)(s)
-	{{ else }}
-	s = ErrorLoggingMiddleware(logger)(s)
-	if log_access {
+	{{- if (has $serviceName (list "Items" "Collections") ) }}
 		s = LoggingMiddleware(logger)(s)
-	}
-	{{ end -}}
+	{{ else }}
+		s = ErrorLoggingMiddleware(logger)(s)
+	{{ end }}
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/images/middleware/access_logging_middleware.go b/images/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..0a5f5ec2374db349e5eea81ec147d8258649412f
--- /dev/null
+++ b/images/middleware/access_logging_middleware.go
@@ -0,0 +1,53 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/images -i Images -t ../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/images"
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/files"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements images.Images that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   images.Images
+}
+
+// AccessLoggingMiddleware instruments an implementation of the images.Images with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next images.Images) images.Images {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, source *files.File, opts *images.GetOptions) (result *files.File, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("source", source),
+		zap.Reflect("opts", opts),
+	)
+
+	result, err = m.next.Get(ctx, source, opts)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("result", result),
+		zap.Error(err),
+	)
+
+	return result, err
+}
diff --git a/images/middleware/logging_middleware.go b/images/middleware/logging_middleware.go
deleted file mode 100644
index a69a56ee6a236aab96b1d22340691a63e36fdc01..0000000000000000000000000000000000000000
--- a/images/middleware/logging_middleware.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-package middleware
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/images -i Images -t ../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/images"
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/files"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements images.Images that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   images.Images
-}
-
-// LoggingMiddleware instruments an implementation of the images.Images with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next images.Images) images.Images {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, source *files.File, opts *images.GetOptions) (result *files.File, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"source": source,
-		"opts":   opts} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	result, err = m.next.Get(ctx, source, opts)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"result": result,
-		"err":    err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return result, err
-}
diff --git a/images/middleware/middleware.go b/images/middleware/middleware.go
index e29bdeb8c6e7a5e2d6b298d01069f4566481e80a..bf07dd54eb80280edf4ea7edc2ac43d66085ae2d 100644
--- a/images/middleware/middleware.go
+++ b/images/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/images -i Images -t ../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/images -i Images -t ../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/images"
@@ -17,12 +17,12 @@ func WithLog(s images.Images, logger *zap.Logger, log_access bool) images.Images
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Images")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/images/middleware/recovering_middleware.go b/images/middleware/recovering_middleware.go
index 9ad61603a2584b58f4635c9ee8296f67f047b7a5..9c0a447e802a95d3002f6e45060a2a359024ff5a 100644
--- a/images/middleware/recovering_middleware.go
+++ b/images/middleware/recovering_middleware.go
@@ -1,5 +1,5 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/recovery
+// template: ../../assets/templates/middleware/recovery
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
diff --git a/logs/middleware/middleware.go b/logs/middleware/middleware.go
index 4ca25f1940e8847afe4fb1230d76e1ded86e2b37..120d2b41cc8d392ed7ca2eff73f1f8b47c3dcc14 100644
--- a/logs/middleware/middleware.go
+++ b/logs/middleware/middleware.go
@@ -18,10 +18,11 @@ func WithLog(s logs.Service, logger *zap.Logger, log_access bool) logs.Service {
 		logger = zap.NewNop()
 	}
 	logger = logger.Named("Service")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
 		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/clients/middleware/access_logging_middleware.go b/pkg/clients/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..66379ef014588aa0b6bcdb92863e00ba9f428fc5
--- /dev/null
+++ b/pkg/clients/middleware/access_logging_middleware.go
@@ -0,0 +1,167 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/clients -i Clients -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/clients"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements clients.Clients that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   clients.Clients
+}
+
+// AccessLoggingMiddleware instruments an implementation of the clients.Clients with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next clients.Clients) clients.Clients {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, client *clients.Client) (created *clients.Client, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("client", client),
+	)
+
+	created, err = m.next.Create(ctx, client)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("created", created),
+		zap.Error(err),
+	)
+
+	return created, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, spaceId string, id string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("id", id),
+	)
+
+	err = m.next.Delete(ctx, spaceId, id)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Enable(ctx context.Context, spaceId string, id string, enable bool) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Enable.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("id", id),
+		zap.Reflect("enable", enable),
+	)
+
+	err = m.next.Enable(ctx, spaceId, id, enable)
+
+	m.logger.Debug("Enable.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, spaceId string, id string) (client *clients.Client, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("id", id),
+	)
+
+	client, err = m.next.Get(ctx, spaceId, id)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("client", client),
+		zap.Error(err),
+	)
+
+	return client, err
+}
+
+func (m *accessLoggingMiddleware) GetBy(ctx context.Context, spaceId string, params *clients.GetByParams) (client *clients.Client, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("GetBy.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("params", params),
+	)
+
+	client, err = m.next.GetBy(ctx, spaceId, params)
+
+	m.logger.Debug("GetBy.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("client", client),
+		zap.Error(err),
+	)
+
+	return client, err
+}
+
+func (m *accessLoggingMiddleware) List(ctx context.Context, spaceId string) (clients []*clients.Client, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("List.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+	)
+
+	clients, err = m.next.List(ctx, spaceId)
+
+	m.logger.Debug("List.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("clients", clients),
+		zap.Error(err),
+	)
+
+	return clients, err
+}
+
+func (m *accessLoggingMiddleware) Update(ctx context.Context, client *clients.Client) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Update.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("client", client),
+	)
+
+	err = m.next.Update(ctx, client)
+
+	m.logger.Debug("Update.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/clients/middleware/error_logging_middleware.go b/pkg/clients/middleware/error_logging_middleware.go
index 0b96827a0c620ad1ca1aa5aaf6b93a821af6279d..3e60cc1d8e49f0712362a7e3e8f072571333a97a 100644
--- a/pkg/clients/middleware/error_logging_middleware.go
+++ b/pkg/clients/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/clients -i Clients -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/clients/middleware/logging_middleware.go b/pkg/clients/middleware/logging_middleware.go
deleted file mode 100644
index 6fa0e811c5511748b55d756742a2c81789c0cced..0000000000000000000000000000000000000000
--- a/pkg/clients/middleware/logging_middleware.go
+++ /dev/null
@@ -1,295 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/clients -i Clients -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/clients"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements clients.Clients that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   clients.Clients
-}
-
-// LoggingMiddleware instruments an implementation of the clients.Clients with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next clients.Clients) clients.Clients {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, client *clients.Client) (created *clients.Client, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"client": client} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	created, err = m.next.Create(ctx, client)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"created": created,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return created, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string, id string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"id":      id} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, spaceId, id)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Enable(ctx context.Context, spaceId string, id string, enable bool) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"id":      id,
-		"enable":  enable} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Enable.Request", fields...)
-
-	err = m.next.Enable(ctx, spaceId, id, enable)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Enable.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, id string) (client *clients.Client, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"id":      id} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	client, err = m.next.Get(ctx, spaceId, id)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"client": client,
-		"err":    err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return client, err
-}
-
-func (m *loggingMiddleware) GetBy(ctx context.Context, spaceId string, params *clients.GetByParams) (client *clients.Client, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"params":  params} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("GetBy.Request", fields...)
-
-	client, err = m.next.GetBy(ctx, spaceId, params)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"client": client,
-		"err":    err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("GetBy.Response", fields...)
-
-	return client, err
-}
-
-func (m *loggingMiddleware) List(ctx context.Context, spaceId string) (clients []*clients.Client, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Request", fields...)
-
-	clients, err = m.next.List(ctx, spaceId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"clients": clients,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Response", fields...)
-
-	return clients, err
-}
-
-func (m *loggingMiddleware) Update(ctx context.Context, client *clients.Client) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"client": client} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Request", fields...)
-
-	err = m.next.Update(ctx, client)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Response", fields...)
-
-	return err
-}
diff --git a/pkg/clients/middleware/middleware.go b/pkg/clients/middleware/middleware.go
index a49c9b3ebb0c041c23178d457ea5ddf2d2357d91..0c72c1660e15f147a773e2da5e2f31b469b90260 100644
--- a/pkg/clients/middleware/middleware.go
+++ b/pkg/clients/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/clients -i Clients -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/clients -i Clients -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/clients"
@@ -17,12 +17,12 @@ func WithLog(s clients.Clients, logger *zap.Logger, log_access bool) clients.Cli
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Clients")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/collaborators/middleware/access_logging_middleware.go b/pkg/collaborators/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..505624ba33f2f91280d3b1dce338262f4a7405d3
--- /dev/null
+++ b/pkg/collaborators/middleware/access_logging_middleware.go
@@ -0,0 +1,129 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collaborators -i Collaborators -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/collaborators"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements collaborators.Collaborators that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   collaborators.Collaborators
+}
+
+// AccessLoggingMiddleware instruments an implementation of the collaborators.Collaborators with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next collaborators.Collaborators) collaborators.Collaborators {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, spaceId string, subject string) (role string, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("subject", subject),
+	)
+
+	role, err = m.next.Get(ctx, spaceId, subject)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("role", role),
+		zap.Error(err),
+	)
+
+	return role, err
+}
+
+func (m *accessLoggingMiddleware) ListCollaborators(ctx context.Context, spaceId string) (collaborators []*collaborators.Collaborator, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("ListCollaborators.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+	)
+
+	collaborators, err = m.next.ListCollaborators(ctx, spaceId)
+
+	m.logger.Debug("ListCollaborators.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("collaborators", collaborators),
+		zap.Error(err),
+	)
+
+	return collaborators, err
+}
+
+func (m *accessLoggingMiddleware) ListSpaces(ctx context.Context, subject string) (spaces []*collaborators.Collaborator, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("ListSpaces.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("subject", subject),
+	)
+
+	spaces, err = m.next.ListSpaces(ctx, subject)
+
+	m.logger.Debug("ListSpaces.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("spaces", spaces),
+		zap.Error(err),
+	)
+
+	return spaces, err
+}
+
+func (m *accessLoggingMiddleware) Remove(ctx context.Context, spaceId string, subject string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Remove.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("subject", subject),
+	)
+
+	err = m.next.Remove(ctx, spaceId, subject)
+
+	m.logger.Debug("Remove.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Set(ctx context.Context, spaceId string, subject string, role string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Set.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("subject", subject),
+		zap.Reflect("role", role),
+	)
+
+	err = m.next.Set(ctx, spaceId, subject, role)
+
+	m.logger.Debug("Set.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/collaborators/middleware/error_logging_middleware.go b/pkg/collaborators/middleware/error_logging_middleware.go
index b0bc4518dad30925e41562f334e1891e2c4fb633..6f67ce3ff960815793c8c59d588b012980559334 100644
--- a/pkg/collaborators/middleware/error_logging_middleware.go
+++ b/pkg/collaborators/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collaborators -i Collaborators -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/collaborators/middleware/logging_middleware.go b/pkg/collaborators/middleware/logging_middleware.go
deleted file mode 100644
index 4b4569a48b0900027cf1453779913996b5146525..0000000000000000000000000000000000000000
--- a/pkg/collaborators/middleware/logging_middleware.go
+++ /dev/null
@@ -1,221 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collaborators -i Collaborators -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/collaborators"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements collaborators.Collaborators that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   collaborators.Collaborators
-}
-
-// LoggingMiddleware instruments an implementation of the collaborators.Collaborators with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next collaborators.Collaborators) collaborators.Collaborators {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, subject string) (role string, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"subject": subject} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	role, err = m.next.Get(ctx, spaceId, subject)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"role": role,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return role, err
-}
-
-func (m *loggingMiddleware) ListCollaborators(ctx context.Context, spaceId string) (collaborators []*collaborators.Collaborator, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListCollaborators.Request", fields...)
-
-	collaborators, err = m.next.ListCollaborators(ctx, spaceId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"collaborators": collaborators,
-		"err":           err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListCollaborators.Response", fields...)
-
-	return collaborators, err
-}
-
-func (m *loggingMiddleware) ListSpaces(ctx context.Context, subject string) (spaces []*collaborators.Collaborator, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"subject": subject} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListSpaces.Request", fields...)
-
-	spaces, err = m.next.ListSpaces(ctx, subject)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"spaces": spaces,
-		"err":    err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListSpaces.Response", fields...)
-
-	return spaces, err
-}
-
-func (m *loggingMiddleware) Remove(ctx context.Context, spaceId string, subject string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"subject": subject} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Remove.Request", fields...)
-
-	err = m.next.Remove(ctx, spaceId, subject)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Remove.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Set(ctx context.Context, spaceId string, subject string, role string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"subject": subject,
-		"role":    role} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Set.Request", fields...)
-
-	err = m.next.Set(ctx, spaceId, subject, role)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Set.Response", fields...)
-
-	return err
-}
diff --git a/pkg/collaborators/middleware/middleware.go b/pkg/collaborators/middleware/middleware.go
index 60931c8494b76be2fe0657ec0d204377e58e0c11..28f0bc687c5ee66f2395303efa502149f8394644 100644
--- a/pkg/collaborators/middleware/middleware.go
+++ b/pkg/collaborators/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collaborators -i Collaborators -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collaborators -i Collaborators -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/collaborators"
@@ -17,12 +17,12 @@ func WithLog(s collaborators.Collaborators, logger *zap.Logger, log_access bool)
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Collaborators")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/collaborators/middleware/recovering_middleware.go b/pkg/collaborators/middleware/recovering_middleware.go
index 0521cce7a30c9b86cb0fe0a04d058c70a9c48cf4..2217ca1f5827cf228c537223c3181701948b50a5 100644
--- a/pkg/collaborators/middleware/recovering_middleware.go
+++ b/pkg/collaborators/middleware/recovering_middleware.go
@@ -1,5 +1,5 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../../assets/templates/middleware/recovery
+// template: ../../../assets/templates/middleware/recovery
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
diff --git a/pkg/collections/middleware/logging_middleware.go b/pkg/collections/middleware/logging_middleware.go
index c5e2e2fb3e5bf604fdb57c8484f4a20289029da6..bf04a4aac6e1f5304e982dac0b6c77662715a1cc 100644
--- a/pkg/collections/middleware/logging_middleware.go
+++ b/pkg/collections/middleware/logging_middleware.go
@@ -1,11 +1,5 @@
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/log.tmpl
-// gowrap: http://github.com/hexdigest/gowrap
-
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collections -i Collections -t ../../../assets/templates/middleware/log.tmpl -o logging_middleware.go -l ""
-
 import (
 	"context"
 
@@ -100,11 +94,11 @@ func (m *loggingMiddleware) SetSchema(ctx context.Context, spaceId string, envId
 
 	err = m.next.SetSchema(ctx, spaceId, envId, collectionId, schema)
 	if err != nil {
-		logger.Error("Failed to setschema", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		logger.Error("Failed to set schema", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
 		return
 	}
 
-	logger.Info("Successfully setschemaed", logzap.Channels(logzap.Userlog))
+	logger.Info("Successfully set schema", logzap.Channels(logzap.Userlog))
 	return err
 }
 
@@ -115,10 +109,11 @@ func (m *loggingMiddleware) SetState(ctx context.Context, spaceId string, envId
 
 	err = m.next.SetState(ctx, spaceId, envId, collectionId, state)
 	if err != nil {
-		logger.Error("Failed to setstate", zap.Error(err))
+		logger.Error("Failed to set state", zap.Error(err))
 		return
 	}
 
+	logger.Info("Successfully set state", logzap.Channels(logzap.Userlog))
 	return err
 }
 
diff --git a/pkg/environments/middleware/access_logging_middleware.go b/pkg/environments/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..e357e2ec9786edb9f67a7b14445558f86938e924
--- /dev/null
+++ b/pkg/environments/middleware/access_logging_middleware.go
@@ -0,0 +1,187 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/environments -i Environments -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/environments"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements environments.Environments that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   environments.Environments
+}
+
+// AccessLoggingMiddleware instruments an implementation of the environments.Environments with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next environments.Environments) environments.Environments {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, env *environments.Environment) (created *environments.Environment, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("env", env),
+	)
+
+	created, err = m.next.Create(ctx, env)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("created", created),
+		zap.Error(err),
+	)
+
+	return created, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, spaceId string, envId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("envId", envId),
+	)
+
+	err = m.next.Delete(ctx, spaceId, envId)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, spaceId string, envId string) (env *environments.Environment, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("envId", envId),
+	)
+
+	env, err = m.next.Get(ctx, spaceId, envId)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("env", env),
+		zap.Error(err),
+	)
+
+	return env, err
+}
+
+func (m *accessLoggingMiddleware) List(ctx context.Context, spaceId string) (envs []*environments.Environment, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("List.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+	)
+
+	envs, err = m.next.List(ctx, spaceId)
+
+	m.logger.Debug("List.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("envs", envs),
+		zap.Error(err),
+	)
+
+	return envs, err
+}
+
+func (m *accessLoggingMiddleware) Migrate(ctx context.Context, spaceId string, envId string, options ...*environments.MigrateOptions) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Migrate.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("envId", envId),
+		zap.Reflect("options", options),
+	)
+
+	err = m.next.Migrate(ctx, spaceId, envId, options...)
+
+	m.logger.Debug("Migrate.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) RemoveAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("RemoveAlias.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("envId", envId),
+		zap.Reflect("alias", alias),
+	)
+
+	err = m.next.RemoveAlias(ctx, spaceId, envId, alias)
+
+	m.logger.Debug("RemoveAlias.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) SetAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("SetAlias.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("envId", envId),
+		zap.Reflect("alias", alias),
+	)
+
+	err = m.next.SetAlias(ctx, spaceId, envId, alias)
+
+	m.logger.Debug("SetAlias.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Update(ctx context.Context, env *environments.Environment) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Update.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("env", env),
+	)
+
+	err = m.next.Update(ctx, env)
+
+	m.logger.Debug("Update.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/environments/middleware/error_logging_middleware.go b/pkg/environments/middleware/error_logging_middleware.go
index 91ff984763f696cde9f8c152f96842ae995a411e..812de4033878fe1c6d774730c68d2e6e00489751 100644
--- a/pkg/environments/middleware/error_logging_middleware.go
+++ b/pkg/environments/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/environments -i Environments -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/environments/middleware/logging_middleware.go b/pkg/environments/middleware/logging_middleware.go
deleted file mode 100644
index 74692e333c12a3230a03b0cf584010745fb52329..0000000000000000000000000000000000000000
--- a/pkg/environments/middleware/logging_middleware.go
+++ /dev/null
@@ -1,333 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/environments -i Environments -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/environments"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements environments.Environments that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   environments.Environments
-}
-
-// LoggingMiddleware instruments an implementation of the environments.Environments with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next environments.Environments) environments.Environments {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, env *environments.Environment) (created *environments.Environment, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"env": env} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	created, err = m.next.Create(ctx, env)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"created": created,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return created, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string, envId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"envId":   envId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, spaceId, envId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, envId string) (env *environments.Environment, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"envId":   envId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	env, err = m.next.Get(ctx, spaceId, envId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"env": env,
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return env, err
-}
-
-func (m *loggingMiddleware) List(ctx context.Context, spaceId string) (envs []*environments.Environment, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Request", fields...)
-
-	envs, err = m.next.List(ctx, spaceId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"envs": envs,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Response", fields...)
-
-	return envs, err
-}
-
-func (m *loggingMiddleware) Migrate(ctx context.Context, spaceId string, envId string, options ...*environments.MigrateOptions) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"envId":   envId,
-		"options": options} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Migrate.Request", fields...)
-
-	err = m.next.Migrate(ctx, spaceId, envId, options...)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Migrate.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) RemoveAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"envId":   envId,
-		"alias":   alias} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("RemoveAlias.Request", fields...)
-
-	err = m.next.RemoveAlias(ctx, spaceId, envId, alias)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("RemoveAlias.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) SetAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"envId":   envId,
-		"alias":   alias} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("SetAlias.Request", fields...)
-
-	err = m.next.SetAlias(ctx, spaceId, envId, alias)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("SetAlias.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Update(ctx context.Context, env *environments.Environment) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"env": env} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Request", fields...)
-
-	err = m.next.Update(ctx, env)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Response", fields...)
-
-	return err
-}
diff --git a/pkg/environments/middleware/middleware.go b/pkg/environments/middleware/middleware.go
index cfc89b98b7b17b5335afb81ea3dc5d686a9c892b..7c887417848d7cdea79681b73d7c1954318ad009 100644
--- a/pkg/environments/middleware/middleware.go
+++ b/pkg/environments/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/environments -i Environments -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/environments -i Environments -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/environments"
@@ -17,12 +17,12 @@ func WithLog(s environments.Environments, logger *zap.Logger, log_access bool) e
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Environments")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/extension/middleware/access_logging_middleware.go b/pkg/extension/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..0fbd63de8991c449fc96ad49527f5e079bd88773
--- /dev/null
+++ b/pkg/extension/middleware/access_logging_middleware.go
@@ -0,0 +1,196 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/extension -i Manager -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/extension"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements extension.Manager that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   extension.Manager
+}
+
+// AccessLoggingMiddleware instruments an implementation of the extension.Manager with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next extension.Manager) extension.Manager {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Action(ctx context.Context, in *extension.ActionRequest) (ap1 *extension.ActionResponse, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Action.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("in", in),
+	)
+
+	ap1, err = m.next.Action(ctx, in)
+
+	m.logger.Debug("Action.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("ap1", ap1),
+		zap.Error(err),
+	)
+
+	return ap1, err
+}
+
+func (m *accessLoggingMiddleware) Check(ctx context.Context, in *extension.CheckRequest) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Check.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("in", in),
+	)
+
+	err = m.next.Check(ctx, in)
+
+	m.logger.Debug("Check.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) GetDescriptor() (ep1 *extension.ExtensionDescriptor) {
+	begin := time.Now()
+
+	m.logger.Debug("GetDescriptor.Request")
+
+	ep1 = m.next.GetDescriptor()
+
+	m.logger.Debug("GetDescriptor.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("ep1", ep1),
+	)
+
+	return ep1
+}
+
+func (m *accessLoggingMiddleware) Install(ctx context.Context, in *extension.InstallRequest) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Install.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("in", in),
+	)
+
+	err = m.next.Install(ctx, in)
+
+	m.logger.Debug("Install.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) ListExtensions(ctx context.Context, space string, env string, filter *extension.ListExtensionsFilter) (ipa1 []*extension.Info, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("ListExtensions.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("space", space),
+		zap.Reflect("env", env),
+		zap.Reflect("filter", filter),
+	)
+
+	ipa1, err = m.next.ListExtensions(ctx, space, env, filter)
+
+	m.logger.Debug("ListExtensions.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("ipa1", ipa1),
+		zap.Error(err),
+	)
+
+	return ipa1, err
+}
+
+func (m *accessLoggingMiddleware) ListRegisteredExtensions(ctx context.Context, extensions ...string) (epa1 []*extension.ExtensionConnector, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("ListRegisteredExtensions.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("extensions", extensions),
+	)
+
+	epa1, err = m.next.ListRegisteredExtensions(ctx, extensions...)
+
+	m.logger.Debug("ListRegisteredExtensions.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("epa1", epa1),
+		zap.Error(err),
+	)
+
+	return epa1, err
+}
+
+func (m *accessLoggingMiddleware) RegisterExtensions(ctx context.Context, ext ...*extension.ExtensionConnector) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("RegisterExtensions.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("ext", ext),
+	)
+
+	err = m.next.RegisterExtensions(ctx, ext...)
+
+	m.logger.Debug("RegisterExtensions.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Uninstall(ctx context.Context, in *extension.UninstallRequest) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Uninstall.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("in", in),
+	)
+
+	err = m.next.Uninstall(ctx, in)
+
+	m.logger.Debug("Uninstall.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) UnregisterExtensions(ctx context.Context, ext ...*extension.ExtensionConnector) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("UnregisterExtensions.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("ext", ext),
+	)
+
+	err = m.next.UnregisterExtensions(ctx, ext...)
+
+	m.logger.Debug("UnregisterExtensions.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/extension/middleware/error_logging_middleware.go b/pkg/extension/middleware/error_logging_middleware.go
index e7dec72ba015ffe7e75a7bf0736f3a20cd7f4204..474003790010e858eed9fb9ac2af71f17fb35094 100644
--- a/pkg/extension/middleware/error_logging_middleware.go
+++ b/pkg/extension/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/extension -i Manager -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/extension/middleware/logging_middleware.go b/pkg/extension/middleware/logging_middleware.go
deleted file mode 100644
index 8ae37929d26a9dbccf40ab1030d73b708d3d96ba..0000000000000000000000000000000000000000
--- a/pkg/extension/middleware/logging_middleware.go
+++ /dev/null
@@ -1,354 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/extension -i Manager -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/extension"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements extension.Manager that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   extension.Manager
-}
-
-// LoggingMiddleware instruments an implementation of the extension.Manager with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next extension.Manager) extension.Manager {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Action(ctx context.Context, in *extension.ActionRequest) (ap1 *extension.ActionResponse, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"in":  in} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Action.Request", fields...)
-
-	ap1, err = m.next.Action(ctx, in)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"ap1": ap1,
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Action.Response", fields...)
-
-	return ap1, err
-}
-
-func (m *loggingMiddleware) Check(ctx context.Context, in *extension.CheckRequest) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"in":  in} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Check.Request", fields...)
-
-	err = m.next.Check(ctx, in)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Check.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) GetDescriptor() (ep1 *extension.ExtensionDescriptor) {
-	begin := time.Now()
-	var fields []zapcore.Field
-
-	m.logger.Debug("GetDescriptor.Request", fields...)
-
-	ep1 = m.next.GetDescriptor()
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"ep1": ep1} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("GetDescriptor.Response", fields...)
-
-	return ep1
-}
-
-func (m *loggingMiddleware) Install(ctx context.Context, in *extension.InstallRequest) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"in":  in} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Install.Request", fields...)
-
-	err = m.next.Install(ctx, in)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Install.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) ListExtensions(ctx context.Context, space string, env string, filter *extension.ListExtensionsFilter) (ipa1 []*extension.Info, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"space":  space,
-		"env":    env,
-		"filter": filter} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListExtensions.Request", fields...)
-
-	ipa1, err = m.next.ListExtensions(ctx, space, env, filter)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"ipa1": ipa1,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListExtensions.Response", fields...)
-
-	return ipa1, err
-}
-
-func (m *loggingMiddleware) ListRegisteredExtensions(ctx context.Context, extensions ...string) (epa1 []*extension.ExtensionConnector, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":        ctx,
-		"extensions": extensions} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListRegisteredExtensions.Request", fields...)
-
-	epa1, err = m.next.ListRegisteredExtensions(ctx, extensions...)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"epa1": epa1,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListRegisteredExtensions.Response", fields...)
-
-	return epa1, err
-}
-
-func (m *loggingMiddleware) RegisterExtensions(ctx context.Context, ext ...*extension.ExtensionConnector) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"ext": ext} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("RegisterExtensions.Request", fields...)
-
-	err = m.next.RegisterExtensions(ctx, ext...)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("RegisterExtensions.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Uninstall(ctx context.Context, in *extension.UninstallRequest) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"in":  in} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Uninstall.Request", fields...)
-
-	err = m.next.Uninstall(ctx, in)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Uninstall.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) UnregisterExtensions(ctx context.Context, ext ...*extension.ExtensionConnector) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"ext": ext} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("UnregisterExtensions.Request", fields...)
-
-	err = m.next.UnregisterExtensions(ctx, ext...)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("UnregisterExtensions.Response", fields...)
-
-	return err
-}
diff --git a/pkg/extension/middleware/middleware.go b/pkg/extension/middleware/middleware.go
index 52b8bff724419d007ece694ade348182a738ce82..f308b6a1d0af97853b6105788cd28977f6c637ac 100644
--- a/pkg/extension/middleware/middleware.go
+++ b/pkg/extension/middleware/middleware.go
@@ -1,10 +1,10 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/extension -i Manager -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/extension -i Manager -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/extension"
@@ -17,12 +17,12 @@ func WithLog(s extension.Manager, logger *zap.Logger, log_access bool) extension
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Manager")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/extension/middleware/recovering_middleware.go b/pkg/extension/middleware/recovering_middleware.go
index d75af3364a31dd2e0961166a3a7dca573079f4e1..54b78da481917fda0d5614f6d9158c455d4d03e6 100644
--- a/pkg/extension/middleware/recovering_middleware.go
+++ b/pkg/extension/middleware/recovering_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/recovery
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/extension -i Manager -t ../../../assets/templates/middleware/recovery -o recovering_middleware.go -l ""
 
 import (
diff --git a/pkg/files/middleware/access_logging_middleware.go b/pkg/files/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..df932a8282989e17936438b66b714dd9b4b14df6
--- /dev/null
+++ b/pkg/files/middleware/access_logging_middleware.go
@@ -0,0 +1,163 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/files -i Files -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/files"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements files.Files that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   files.Files
+}
+
+// AccessLoggingMiddleware instruments an implementation of the files.Files with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next files.Files) files.Files {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) AbortUpload(ctx context.Context, upload *files.MultipartUpload) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("AbortUpload.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("upload", upload),
+	)
+
+	err = m.next.AbortUpload(ctx, upload)
+
+	m.logger.Debug("AbortUpload.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) CompleteUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("CompleteUpload.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("upload", upload),
+	)
+
+	u, err = m.next.CompleteUpload(ctx, upload)
+
+	m.logger.Debug("CompleteUpload.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("u", u),
+		zap.Error(err),
+	)
+
+	return u, err
+}
+
+func (m *accessLoggingMiddleware) DeleteFile(ctx context.Context, file *files.File) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("DeleteFile.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("file", file),
+	)
+
+	err = m.next.DeleteFile(ctx, file)
+
+	m.logger.Debug("DeleteFile.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) GetFile(ctx context.Context, file *files.File) (f *files.File, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("GetFile.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("file", file),
+	)
+
+	f, err = m.next.GetFile(ctx, file)
+
+	m.logger.Debug("GetFile.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("f", f),
+		zap.Error(err),
+	)
+
+	return f, err
+}
+
+func (m *accessLoggingMiddleware) MoveUpload(ctx context.Context, upload *files.MultipartUpload) (file *files.File, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("MoveUpload.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("upload", upload),
+	)
+
+	file, err = m.next.MoveUpload(ctx, upload)
+
+	m.logger.Debug("MoveUpload.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("file", file),
+		zap.Error(err),
+	)
+
+	return file, err
+}
+
+func (m *accessLoggingMiddleware) StartUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("StartUpload.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("upload", upload),
+	)
+
+	u, err = m.next.StartUpload(ctx, upload)
+
+	m.logger.Debug("StartUpload.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("u", u),
+		zap.Error(err),
+	)
+
+	return u, err
+}
+
+func (m *accessLoggingMiddleware) Upload(ctx context.Context, file *files.File) (u *files.Upload, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Upload.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("file", file),
+	)
+
+	u, err = m.next.Upload(ctx, file)
+
+	m.logger.Debug("Upload.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("u", u),
+		zap.Error(err),
+	)
+
+	return u, err
+}
diff --git a/pkg/files/middleware/logging_middleware.go b/pkg/files/middleware/logging_middleware.go
deleted file mode 100644
index b295fa68cc8367021d5fa5e00a0c850cc27c7cee..0000000000000000000000000000000000000000
--- a/pkg/files/middleware/logging_middleware.go
+++ /dev/null
@@ -1,291 +0,0 @@
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-package middleware
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/files -i Files -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/files"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements files.Files that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   files.Files
-}
-
-// LoggingMiddleware instruments an implementation of the files.Files with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next files.Files) files.Files {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) AbortUpload(ctx context.Context, upload *files.MultipartUpload) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"upload": upload} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("AbortUpload.Request", fields...)
-
-	err = m.next.AbortUpload(ctx, upload)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("AbortUpload.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) CompleteUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"upload": upload} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("CompleteUpload.Request", fields...)
-
-	u, err = m.next.CompleteUpload(ctx, upload)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"u":   u,
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("CompleteUpload.Response", fields...)
-
-	return u, err
-}
-
-func (m *loggingMiddleware) DeleteFile(ctx context.Context, file *files.File) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":  ctx,
-		"file": file} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("DeleteFile.Request", fields...)
-
-	err = m.next.DeleteFile(ctx, file)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("DeleteFile.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) GetFile(ctx context.Context, file *files.File) (f *files.File, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":  ctx,
-		"file": file} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("GetFile.Request", fields...)
-
-	f, err = m.next.GetFile(ctx, file)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"f":   f,
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("GetFile.Response", fields...)
-
-	return f, err
-}
-
-func (m *loggingMiddleware) MoveUpload(ctx context.Context, upload *files.MultipartUpload) (file *files.File, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"upload": upload} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("MoveUpload.Request", fields...)
-
-	file, err = m.next.MoveUpload(ctx, upload)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"file": file,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("MoveUpload.Response", fields...)
-
-	return file, err
-}
-
-func (m *loggingMiddleware) StartUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"upload": upload} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("StartUpload.Request", fields...)
-
-	u, err = m.next.StartUpload(ctx, upload)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"u":   u,
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("StartUpload.Response", fields...)
-
-	return u, err
-}
-
-func (m *loggingMiddleware) Upload(ctx context.Context, file *files.File) (u *files.Upload, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":  ctx,
-		"file": file} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Upload.Request", fields...)
-
-	u, err = m.next.Upload(ctx, file)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"u":   u,
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Upload.Response", fields...)
-
-	return u, err
-}
diff --git a/pkg/files/middleware/middleware.go b/pkg/files/middleware/middleware.go
index 39c64f8764e904b53fcce18bf8b990424ad03149..68d4c21f67b202f8639963930c71dcd6ab1cc3f9 100644
--- a/pkg/files/middleware/middleware.go
+++ b/pkg/files/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/files -i Files -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/files -i Files -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/files"
@@ -17,12 +17,12 @@ func WithLog(s files.Files, logger *zap.Logger, log_access bool) files.Files {
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Files")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/invitations/middleware/access_logging_middleware.go b/pkg/invitations/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..24a854995bed29e849ccf873f41ccd1af073cb69
--- /dev/null
+++ b/pkg/invitations/middleware/access_logging_middleware.go
@@ -0,0 +1,129 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/invitations -i Invitations -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/invitations"
+	"git.perx.ru/perxis/perxis-go/pkg/options"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements invitations.Invitations that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   invitations.Invitations
+}
+
+// AccessLoggingMiddleware instruments an implementation of the invitations.Invitations with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next invitations.Invitations) invitations.Invitations {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Accept(ctx context.Context, invitationId string, userId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Accept.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("invitationId", invitationId),
+		zap.Reflect("userId", userId),
+	)
+
+	err = m.next.Accept(ctx, invitationId, userId)
+
+	m.logger.Debug("Accept.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, invitation *invitations.Invitation) (created *invitations.Invitation, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("invitation", invitation),
+	)
+
+	created, err = m.next.Create(ctx, invitation)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("created", created),
+		zap.Error(err),
+	)
+
+	return created, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, invitationId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("invitationId", invitationId),
+	)
+
+	err = m.next.Delete(ctx, invitationId)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Find(ctx context.Context, filter *invitations.Filter, opts *options.FindOptions) (invitations []*invitations.Invitation, total int, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Find.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("filter", filter),
+		zap.Reflect("opts", opts),
+	)
+
+	invitations, total, err = m.next.Find(ctx, filter, opts)
+
+	m.logger.Debug("Find.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("invitations", invitations),
+		zap.Reflect("total", total),
+		zap.Error(err),
+	)
+
+	return invitations, total, err
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, invitationId string) (invitation *invitations.Invitation, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("invitationId", invitationId),
+	)
+
+	invitation, err = m.next.Get(ctx, invitationId)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("invitation", invitation),
+		zap.Error(err),
+	)
+
+	return invitation, err
+}
diff --git a/pkg/invitations/middleware/error_logging_middleware.go b/pkg/invitations/middleware/error_logging_middleware.go
index ab0a2122f23c660281716d5dbc697cc6e13de3fe..da6603acdda802808abac634896ceb7d3b92cd1b 100644
--- a/pkg/invitations/middleware/error_logging_middleware.go
+++ b/pkg/invitations/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/invitations -i Invitations -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/invitations/middleware/logging_middleware.go b/pkg/invitations/middleware/logging_middleware.go
deleted file mode 100644
index ac358b3e1e635bc7f410d5b6a318b4eddc231d38..0000000000000000000000000000000000000000
--- a/pkg/invitations/middleware/logging_middleware.go
+++ /dev/null
@@ -1,221 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/invitations -i Invitations -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/invitations"
-	"git.perx.ru/perxis/perxis-go/pkg/options"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements invitations.Invitations that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   invitations.Invitations
-}
-
-// LoggingMiddleware instruments an implementation of the invitations.Invitations with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next invitations.Invitations) invitations.Invitations {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Accept(ctx context.Context, invitationId string, userId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":          ctx,
-		"invitationId": invitationId,
-		"userId":       userId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Accept.Request", fields...)
-
-	err = m.next.Accept(ctx, invitationId, userId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Accept.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, invitation *invitations.Invitation) (created *invitations.Invitation, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":        ctx,
-		"invitation": invitation} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	created, err = m.next.Create(ctx, invitation)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"created": created,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return created, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, invitationId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":          ctx,
-		"invitationId": invitationId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, invitationId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Find(ctx context.Context, filter *invitations.Filter, opts *options.FindOptions) (invitations []*invitations.Invitation, total int, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"filter": filter,
-		"opts":   opts} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Find.Request", fields...)
-
-	invitations, total, err = m.next.Find(ctx, filter, opts)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"invitations": invitations,
-		"total":       total,
-		"err":         err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Find.Response", fields...)
-
-	return invitations, total, err
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, invitationId string) (invitation *invitations.Invitation, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":          ctx,
-		"invitationId": invitationId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	invitation, err = m.next.Get(ctx, invitationId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"invitation": invitation,
-		"err":        err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return invitation, err
-}
diff --git a/pkg/invitations/middleware/middleware.go b/pkg/invitations/middleware/middleware.go
index d4a336ba62cdbef2da5a06e4d71ecdf20491fe49..f59604ba948ade1b4fe03bc3e3cadd8de6f7cfcd 100644
--- a/pkg/invitations/middleware/middleware.go
+++ b/pkg/invitations/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/invitations -i Invitations -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/invitations -i Invitations -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/invitations"
@@ -17,12 +17,12 @@ func WithLog(s invitations.Invitations, logger *zap.Logger, log_access bool) inv
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Invitations")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/items/middleware/middleware.go b/pkg/items/middleware/middleware.go
index 2ce07ef94ff532af1ed3353ef5bdba6e5f6871aa..4ef6a1fd2a0e2aec25d759d75d2e40d699ad7e06 100644
--- a/pkg/items/middleware/middleware.go
+++ b/pkg/items/middleware/middleware.go
@@ -22,6 +22,7 @@ func WithLog(s items.Items, logger *zap.Logger, log_access bool) items.Items {
 		s = AccessLoggingMiddleware(logger)(s)
 	}
 	s = LoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/locales/middleware/access_logging_middleware.go b/pkg/locales/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..eabb71c37756d0a7d39d6abe217f394036a69922
--- /dev/null
+++ b/pkg/locales/middleware/access_logging_middleware.go
@@ -0,0 +1,89 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/locales -i Locales -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/locales"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements locales.Locales that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   locales.Locales
+}
+
+// AccessLoggingMiddleware instruments an implementation of the locales.Locales with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next locales.Locales) locales.Locales {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, locale *locales.Locale) (created *locales.Locale, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("locale", locale),
+	)
+
+	created, err = m.next.Create(ctx, locale)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("created", created),
+		zap.Error(err),
+	)
+
+	return created, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, spaceId string, localeId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("localeId", localeId),
+	)
+
+	err = m.next.Delete(ctx, spaceId, localeId)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) List(ctx context.Context, spaceId string) (locales []*locales.Locale, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("List.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+	)
+
+	locales, err = m.next.List(ctx, spaceId)
+
+	m.logger.Debug("List.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("locales", locales),
+		zap.Error(err),
+	)
+
+	return locales, err
+}
diff --git a/pkg/locales/middleware/error_logging_middleware.go b/pkg/locales/middleware/error_logging_middleware.go
index 3251fc7c972217ca4480ecbc26cb65cc055504ea..a00f23a29aa8b5330e1097c670e6cc0edf5b9983 100644
--- a/pkg/locales/middleware/error_logging_middleware.go
+++ b/pkg/locales/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/locales -i Locales -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/locales/middleware/logging_middleware.go b/pkg/locales/middleware/logging_middleware.go
deleted file mode 100644
index 2db3ef39beb37cabf73adbfb9a3e1122f9e85387..0000000000000000000000000000000000000000
--- a/pkg/locales/middleware/logging_middleware.go
+++ /dev/null
@@ -1,145 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/locales -i Locales -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/locales"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements locales.Locales that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   locales.Locales
-}
-
-// LoggingMiddleware instruments an implementation of the locales.Locales with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next locales.Locales) locales.Locales {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, locale *locales.Locale) (created *locales.Locale, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"locale": locale} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	created, err = m.next.Create(ctx, locale)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"created": created,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return created, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string, localeId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":      ctx,
-		"spaceId":  spaceId,
-		"localeId": localeId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, spaceId, localeId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) List(ctx context.Context, spaceId string) (locales []*locales.Locale, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Request", fields...)
-
-	locales, err = m.next.List(ctx, spaceId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"locales": locales,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Response", fields...)
-
-	return locales, err
-}
diff --git a/pkg/locales/middleware/middleware.go b/pkg/locales/middleware/middleware.go
index 721829405e98efc0c47e75f8670f4e74b784998d..2598e397afafb552c16be249cfcf1ed62149339b 100644
--- a/pkg/locales/middleware/middleware.go
+++ b/pkg/locales/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/locales -i Locales -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/locales -i Locales -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/locales"
@@ -17,12 +17,12 @@ func WithLog(s locales.Locales, logger *zap.Logger, log_access bool) locales.Loc
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Locales")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/members/middleware/access_logging_middleware.go b/pkg/members/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..0a062331a51f9f93d0d7c877637636d3640ef8a7
--- /dev/null
+++ b/pkg/members/middleware/access_logging_middleware.go
@@ -0,0 +1,147 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members -i Members -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/members"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements members.Members that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   members.Members
+}
+
+// AccessLoggingMiddleware instruments an implementation of the members.Members with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next members.Members) members.Members {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, orgId string, userId string) (role members.Role, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+		zap.Reflect("userId", userId),
+	)
+
+	role, err = m.next.Get(ctx, orgId, userId)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("role", role),
+		zap.Error(err),
+	)
+
+	return role, err
+}
+
+func (m *accessLoggingMiddleware) ListMembers(ctx context.Context, orgId string) (members []*members.Member, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("ListMembers.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+	)
+
+	members, err = m.next.ListMembers(ctx, orgId)
+
+	m.logger.Debug("ListMembers.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("members", members),
+		zap.Error(err),
+	)
+
+	return members, err
+}
+
+func (m *accessLoggingMiddleware) ListOrganizations(ctx context.Context, userId string) (organizations []*members.Member, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("ListOrganizations.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("userId", userId),
+	)
+
+	organizations, err = m.next.ListOrganizations(ctx, userId)
+
+	m.logger.Debug("ListOrganizations.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("organizations", organizations),
+		zap.Error(err),
+	)
+
+	return organizations, err
+}
+
+func (m *accessLoggingMiddleware) Remove(ctx context.Context, orgId string, userId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Remove.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+		zap.Reflect("userId", userId),
+	)
+
+	err = m.next.Remove(ctx, orgId, userId)
+
+	m.logger.Debug("Remove.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) RemoveAll(ctx context.Context, orgId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("RemoveAll.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+	)
+
+	err = m.next.RemoveAll(ctx, orgId)
+
+	m.logger.Debug("RemoveAll.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Set(ctx context.Context, orgId string, userId string, role members.Role) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Set.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+		zap.Reflect("userId", userId),
+		zap.Reflect("role", role),
+	)
+
+	err = m.next.Set(ctx, orgId, userId, role)
+
+	m.logger.Debug("Set.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/members/middleware/error_logging_middleware.go b/pkg/members/middleware/error_logging_middleware.go
index 79a92a1f2ac6f3d5854fcdf6c1f709e21ee160a7..d3c1a594983ac1bf25a8a397c12580d445b063b6 100644
--- a/pkg/members/middleware/error_logging_middleware.go
+++ b/pkg/members/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members -i Members -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/members/middleware/logging_middleware.go b/pkg/members/middleware/logging_middleware.go
deleted file mode 100644
index 3136597a451cc8938c4dc326b01b9e022658293e..0000000000000000000000000000000000000000
--- a/pkg/members/middleware/logging_middleware.go
+++ /dev/null
@@ -1,257 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members -i Members -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/members"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements members.Members that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   members.Members
-}
-
-// LoggingMiddleware instruments an implementation of the members.Members with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next members.Members) members.Members {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, orgId string, userId string) (role members.Role, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"orgId":  orgId,
-		"userId": userId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	role, err = m.next.Get(ctx, orgId, userId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"role": role,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return role, err
-}
-
-func (m *loggingMiddleware) ListMembers(ctx context.Context, orgId string) (members []*members.Member, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"orgId": orgId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListMembers.Request", fields...)
-
-	members, err = m.next.ListMembers(ctx, orgId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"members": members,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListMembers.Response", fields...)
-
-	return members, err
-}
-
-func (m *loggingMiddleware) ListOrganizations(ctx context.Context, userId string) (organizations []*members.Member, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"userId": userId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListOrganizations.Request", fields...)
-
-	organizations, err = m.next.ListOrganizations(ctx, userId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"organizations": organizations,
-		"err":           err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListOrganizations.Response", fields...)
-
-	return organizations, err
-}
-
-func (m *loggingMiddleware) Remove(ctx context.Context, orgId string, userId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"orgId":  orgId,
-		"userId": userId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Remove.Request", fields...)
-
-	err = m.next.Remove(ctx, orgId, userId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Remove.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) RemoveAll(ctx context.Context, orgId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"orgId": orgId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("RemoveAll.Request", fields...)
-
-	err = m.next.RemoveAll(ctx, orgId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("RemoveAll.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Set(ctx context.Context, orgId string, userId string, role members.Role) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"orgId":  orgId,
-		"userId": userId,
-		"role":   role} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Set.Request", fields...)
-
-	err = m.next.Set(ctx, orgId, userId, role)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Set.Response", fields...)
-
-	return err
-}
diff --git a/pkg/members/middleware/middleware.go b/pkg/members/middleware/middleware.go
index 517bfa624a35e247d1e93f44db75a5eccaf0c721..bb491623865e21496adedb1e91987bc2205a3ce4 100644
--- a/pkg/members/middleware/middleware.go
+++ b/pkg/members/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members -i Members -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members -i Members -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/members"
@@ -17,12 +17,12 @@ func WithLog(s members.Members, logger *zap.Logger, log_access bool) members.Mem
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Members")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/members/observer/middleware/access_logging_middleware.go b/pkg/members/observer/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..48e9da969978baf7abdad1ae3c9a92582f56d299
--- /dev/null
+++ b/pkg/members/observer/middleware/access_logging_middleware.go
@@ -0,0 +1,52 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members/observer -i Observer -t ../../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/collaborators"
+	"git.perx.ru/perxis/perxis-go/pkg/members/observer"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements observer.Observer that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   observer.Observer
+}
+
+// AccessLoggingMiddleware instruments an implementation of the observer.Observer with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next observer.Observer) observer.Observer {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) OnCollaboratorSet(ctx context.Context, collaborator *collaborators.Collaborator) (delayedTaskID string, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("OnCollaboratorSet.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("collaborator", collaborator),
+	)
+
+	delayedTaskID, err = m.next.OnCollaboratorSet(ctx, collaborator)
+
+	m.logger.Debug("OnCollaboratorSet.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("delayedTaskID", delayedTaskID),
+		zap.Error(err),
+	)
+
+	return delayedTaskID, err
+}
diff --git a/pkg/members/observer/middleware/error_logging_middleware.go b/pkg/members/observer/middleware/error_logging_middleware.go
index b7184b475d626a0f4a2a53cd427a672841b38249..462eff251d5aec0648d4ef7e8d60e200896cbe6e 100644
--- a/pkg/members/observer/middleware/error_logging_middleware.go
+++ b/pkg/members/observer/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members/observer -i Observer -t ../../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/members/observer/middleware/logging_middleware.go b/pkg/members/observer/middleware/logging_middleware.go
deleted file mode 100644
index 09f203fd21f3a3d2ecabd3279c3d1ca2a323194d..0000000000000000000000000000000000000000
--- a/pkg/members/observer/middleware/logging_middleware.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members/observer -i Observer -t ../../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/collaborators"
-	"git.perx.ru/perxis/perxis-go/pkg/members/observer"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements observer.Observer that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   observer.Observer
-}
-
-// LoggingMiddleware instruments an implementation of the observer.Observer with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next observer.Observer) observer.Observer {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) OnCollaboratorSet(ctx context.Context, collaborator *collaborators.Collaborator) (delayedTaskID string, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":          ctx,
-		"collaborator": collaborator} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("OnCollaboratorSet.Request", fields...)
-
-	delayedTaskID, err = m.next.OnCollaboratorSet(ctx, collaborator)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"delayedTaskID": delayedTaskID,
-		"err":           err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("OnCollaboratorSet.Response", fields...)
-
-	return delayedTaskID, err
-}
diff --git a/pkg/members/observer/middleware/middleware.go b/pkg/members/observer/middleware/middleware.go
index f68b58c7398b341f8f3850ddb96538027a58d354..ba2dff4fee8f9ad426d951d518c18e07dc05134e 100644
--- a/pkg/members/observer/middleware/middleware.go
+++ b/pkg/members/observer/middleware/middleware.go
@@ -1,10 +1,10 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../../assets/templates/middleware/middleware
+// template: ../../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members/observer -i Observer -t ../../../../assets/templates/middleware/middleware -o middleware.go -l ""
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members/observer -i Observer -t ../../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/members/observer"
@@ -17,12 +17,12 @@ func WithLog(s observer.Observer, logger *zap.Logger, log_access bool) observer.
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Observer")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/members/observer/middleware/recovering_middleware.go b/pkg/members/observer/middleware/recovering_middleware.go
index bd576ecd2699dea927925b935bc024630420f997..f4d96995ded61101fde4a8faabf21da84000f1fb 100644
--- a/pkg/members/observer/middleware/recovering_middleware.go
+++ b/pkg/members/observer/middleware/recovering_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../../assets/templates/middleware/recovery
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/members/observer -i Observer -t ../../../../assets/templates/middleware/recovery -o recovering_middleware.go -l ""
 
 import (
diff --git a/pkg/organizations/middleware/access_logging_middleware.go b/pkg/organizations/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..be6e937d1dc76ba9a6d4d80acd5c6343e35eacd7
--- /dev/null
+++ b/pkg/organizations/middleware/access_logging_middleware.go
@@ -0,0 +1,128 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/organizations -i Organizations -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/options"
+	"git.perx.ru/perxis/perxis-go/pkg/organizations"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements organizations.Organizations that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   organizations.Organizations
+}
+
+// AccessLoggingMiddleware instruments an implementation of the organizations.Organizations with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next organizations.Organizations) organizations.Organizations {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, org *organizations.Organization) (created *organizations.Organization, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("org", org),
+	)
+
+	created, err = m.next.Create(ctx, org)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("created", created),
+		zap.Error(err),
+	)
+
+	return created, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, orgId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+	)
+
+	err = m.next.Delete(ctx, orgId)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Find(ctx context.Context, filter *organizations.Filter, opts *options.FindOptions) (orgs []*organizations.Organization, total int, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Find.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("filter", filter),
+		zap.Reflect("opts", opts),
+	)
+
+	orgs, total, err = m.next.Find(ctx, filter, opts)
+
+	m.logger.Debug("Find.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("orgs", orgs),
+		zap.Reflect("total", total),
+		zap.Error(err),
+	)
+
+	return orgs, total, err
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, orgId string) (org *organizations.Organization, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+	)
+
+	org, err = m.next.Get(ctx, orgId)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("org", org),
+		zap.Error(err),
+	)
+
+	return org, err
+}
+
+func (m *accessLoggingMiddleware) Update(ctx context.Context, org *organizations.Organization) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Update.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("org", org),
+	)
+
+	err = m.next.Update(ctx, org)
+
+	m.logger.Debug("Update.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/organizations/middleware/error_logging_middleware.go b/pkg/organizations/middleware/error_logging_middleware.go
index 1ededdd2a8f391c56909cc33ec799175380a939a..2d6db8198b885e157ba8ebcc855bb6d9dadb519c 100644
--- a/pkg/organizations/middleware/error_logging_middleware.go
+++ b/pkg/organizations/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/organizations -i Organizations -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/organizations/middleware/logging_middleware.go b/pkg/organizations/middleware/logging_middleware.go
deleted file mode 100644
index b1e6bc3b914ea49d0781d7ae39ddcc5c795fff45..0000000000000000000000000000000000000000
--- a/pkg/organizations/middleware/logging_middleware.go
+++ /dev/null
@@ -1,220 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/organizations -i Organizations -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/options"
-	"git.perx.ru/perxis/perxis-go/pkg/organizations"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements organizations.Organizations that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   organizations.Organizations
-}
-
-// LoggingMiddleware instruments an implementation of the organizations.Organizations with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next organizations.Organizations) organizations.Organizations {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, org *organizations.Organization) (created *organizations.Organization, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"org": org} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	created, err = m.next.Create(ctx, org)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"created": created,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return created, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, orgId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"orgId": orgId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, orgId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Find(ctx context.Context, filter *organizations.Filter, opts *options.FindOptions) (orgs []*organizations.Organization, total int, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"filter": filter,
-		"opts":   opts} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Find.Request", fields...)
-
-	orgs, total, err = m.next.Find(ctx, filter, opts)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"orgs":  orgs,
-		"total": total,
-		"err":   err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Find.Response", fields...)
-
-	return orgs, total, err
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, orgId string) (org *organizations.Organization, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"orgId": orgId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	org, err = m.next.Get(ctx, orgId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"org": org,
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return org, err
-}
-
-func (m *loggingMiddleware) Update(ctx context.Context, org *organizations.Organization) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx": ctx,
-		"org": org} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Request", fields...)
-
-	err = m.next.Update(ctx, org)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Response", fields...)
-
-	return err
-}
diff --git a/pkg/organizations/middleware/middleware.go b/pkg/organizations/middleware/middleware.go
index f6cf5c5527ede8c7d285cc280642ca6aa420970c..906a4c356b434fa2926a3e970bf0f32d0c0fa936 100644
--- a/pkg/organizations/middleware/middleware.go
+++ b/pkg/organizations/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/organizations -i Organizations -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/organizations -i Organizations -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/organizations"
@@ -17,12 +17,12 @@ func WithLog(s organizations.Organizations, logger *zap.Logger, log_access bool)
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Organizations")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/references/middleware/access_logging_middleware.go b/pkg/references/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..c628dc11fccc175b91f0ed7fdc7f180e3a91bfb4
--- /dev/null
+++ b/pkg/references/middleware/access_logging_middleware.go
@@ -0,0 +1,80 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/items"
+	"git.perx.ru/perxis/perxis-go/pkg/references"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements references.References that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   references.References
+}
+
+// AccessLoggingMiddleware instruments an implementation of the references.References with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next references.References) references.References {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, spaceId string, envId string, references []*references.Reference) (items []*items.Item, notfound []*references.Reference, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("envId", envId),
+		zap.Reflect("references", references),
+	)
+
+	items, notfound, err = m.next.Get(ctx, spaceId, envId, references)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("items", items),
+		zap.Reflect("notfound", notfound),
+		zap.Error(err),
+	)
+
+	return items, notfound, err
+}
+
+func (m *accessLoggingMiddleware) Publish(ctx context.Context, spaceId string, envId string, references []*references.Reference, recursive bool, force bool) (published []*references.Reference, notfound []*references.Reference, unpublished []*references.Reference, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Publish.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("envId", envId),
+		zap.Reflect("references", references),
+		zap.Reflect("recursive", recursive),
+		zap.Reflect("force", force),
+	)
+
+	published, notfound, unpublished, err = m.next.Publish(ctx, spaceId, envId, references, recursive, force)
+
+	m.logger.Debug("Publish.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("published", published),
+		zap.Reflect("notfound", notfound),
+		zap.Reflect("unpublished", unpublished),
+		zap.Error(err),
+	)
+
+	return published, notfound, unpublished, err
+}
diff --git a/pkg/references/middleware/error_logging_middleware.go b/pkg/references/middleware/error_logging_middleware.go
index 0cfbf919e5acd70dc453494d15e9e8778afcca85..b55b11679d819e42f30234d27f6f140b2d024aa8 100644
--- a/pkg/references/middleware/error_logging_middleware.go
+++ b/pkg/references/middleware/error_logging_middleware.go
@@ -1,10 +1,10 @@
-package middleware
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/error_log
+// gowrap: http://github.com/hexdigest/gowrap
 
-// DO NOT EDIT!
-// This code is generated with http://github.com/hexdigest/gowrap tool
-// using ../../../assets/templates/middleware/error_log template
+package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
 	"context"
diff --git a/pkg/references/middleware/logging_middleware.go b/pkg/references/middleware/logging_middleware.go
deleted file mode 100644
index a0f010ae99c2f9ce1eb726e5caba316379328a42..0000000000000000000000000000000000000000
--- a/pkg/references/middleware/logging_middleware.go
+++ /dev/null
@@ -1,118 +0,0 @@
-package middleware
-
-// DO NOT EDIT!
-// This code is generated with http://github.com/hexdigest/gowrap tool
-// using ../../../assets/templates/middleware/access_log template
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/access_log -o logging_middleware.go
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/items"
-	"git.perx.ru/perxis/perxis-go/pkg/references"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements references.References that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   references.References
-}
-
-// LoggingMiddleware instruments an implementation of the references.References with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next references.References) references.References {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, envId string, references []*references.Reference) (items []*items.Item, notfound []*references.Reference, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":        ctx,
-		"spaceId":    spaceId,
-		"envId":      envId,
-		"references": references} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	items, notfound, err = m.next.Get(ctx, spaceId, envId, references)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"items":    items,
-		"notfound": notfound,
-		"err":      err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return items, notfound, err
-}
-
-func (m *loggingMiddleware) Publish(ctx context.Context, spaceId string, envId string, references []*references.Reference, recursive bool, force bool) (published []*references.Reference, notfound []*references.Reference, unpublished []*references.Reference, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":        ctx,
-		"spaceId":    spaceId,
-		"envId":      envId,
-		"references": references,
-		"recursive":  recursive,
-		"force":      force} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Publish.Request", fields...)
-
-	published, notfound, unpublished, err = m.next.Publish(ctx, spaceId, envId, references, recursive, force)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"published":   published,
-		"notfound":    notfound,
-		"unpublished": unpublished,
-		"err":         err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Publish.Response", fields...)
-
-	return published, notfound, unpublished, err
-}
diff --git a/pkg/references/middleware/middleware.go b/pkg/references/middleware/middleware.go
index 6bd830146952e16ccabf780230d03dc6b9473a74..529a61b60265f0f77bc0a4a3be38151f7ba5334e 100644
--- a/pkg/references/middleware/middleware.go
+++ b/pkg/references/middleware/middleware.go
@@ -1,10 +1,10 @@
-package middleware
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/middleware.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
 
-// DO NOT EDIT!
-// This code is generated with http://github.com/hexdigest/gowrap tool
-// using ../../../assets/templates/middleware/middleware template
+package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/middleware -o middleware.go
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/references"
@@ -17,12 +17,12 @@ func WithLog(s references.References, logger *zap.Logger, log_access bool) refer
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("References")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/references/middleware/recovering_middleware.go b/pkg/references/middleware/recovering_middleware.go
index 070d9d22fca08a8394362b8eea6a31628d56902c..1331a96787b8ba98322ab2e4ee5764d296504066 100644
--- a/pkg/references/middleware/recovering_middleware.go
+++ b/pkg/references/middleware/recovering_middleware.go
@@ -1,10 +1,10 @@
-package middleware
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/recovery
+// gowrap: http://github.com/hexdigest/gowrap
 
-// DO NOT EDIT!
-// This code is generated with http://github.com/hexdigest/gowrap tool
-// using ../../../assets/templates/middleware/recovery template
+package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/recovery -o recovering_middleware.go
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/references -i References -t ../../../assets/templates/middleware/recovery -o recovering_middleware.go -l ""
 
 import (
 	"context"
diff --git a/pkg/roles/middleware/access_logging_middleware.go b/pkg/roles/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..310cdeda7c585c571263bebb6c42739a8d3074de
--- /dev/null
+++ b/pkg/roles/middleware/access_logging_middleware.go
@@ -0,0 +1,127 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/roles -i Roles -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/roles"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements roles.Roles that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   roles.Roles
+}
+
+// AccessLoggingMiddleware instruments an implementation of the roles.Roles with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next roles.Roles) roles.Roles {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, role *roles.Role) (created *roles.Role, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("role", role),
+	)
+
+	created, err = m.next.Create(ctx, role)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("created", created),
+		zap.Error(err),
+	)
+
+	return created, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, spaceId string, roleId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("roleId", roleId),
+	)
+
+	err = m.next.Delete(ctx, spaceId, roleId)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, spaceId string, roleId string) (role *roles.Role, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("roleId", roleId),
+	)
+
+	role, err = m.next.Get(ctx, spaceId, roleId)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("role", role),
+		zap.Error(err),
+	)
+
+	return role, err
+}
+
+func (m *accessLoggingMiddleware) List(ctx context.Context, spaceId string) (roles []*roles.Role, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("List.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+	)
+
+	roles, err = m.next.List(ctx, spaceId)
+
+	m.logger.Debug("List.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("roles", roles),
+		zap.Error(err),
+	)
+
+	return roles, err
+}
+
+func (m *accessLoggingMiddleware) Update(ctx context.Context, role *roles.Role) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Update.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("role", role),
+	)
+
+	err = m.next.Update(ctx, role)
+
+	m.logger.Debug("Update.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/roles/middleware/error_logging_middleware.go b/pkg/roles/middleware/error_logging_middleware.go
index 48f12c3d6416ade72e1567c976e78b6237a3d323..bb6073d11fef1d2763ca85855274edf4a8c71839 100644
--- a/pkg/roles/middleware/error_logging_middleware.go
+++ b/pkg/roles/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/roles -i Roles -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/roles/middleware/logging_middleware.go b/pkg/roles/middleware/logging_middleware.go
deleted file mode 100644
index 31d9d49245bd64eb0e2ba542e54e32f01805d007..0000000000000000000000000000000000000000
--- a/pkg/roles/middleware/logging_middleware.go
+++ /dev/null
@@ -1,219 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/roles -i Roles -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/roles"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements roles.Roles that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   roles.Roles
-}
-
-// LoggingMiddleware instruments an implementation of the roles.Roles with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next roles.Roles) roles.Roles {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, role *roles.Role) (created *roles.Role, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":  ctx,
-		"role": role} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	created, err = m.next.Create(ctx, role)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"created": created,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return created, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string, roleId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"roleId":  roleId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, spaceId, roleId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, roleId string) (role *roles.Role, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"roleId":  roleId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	role, err = m.next.Get(ctx, spaceId, roleId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"role": role,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return role, err
-}
-
-func (m *loggingMiddleware) List(ctx context.Context, spaceId string) (roles []*roles.Role, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Request", fields...)
-
-	roles, err = m.next.List(ctx, spaceId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"roles": roles,
-		"err":   err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Response", fields...)
-
-	return roles, err
-}
-
-func (m *loggingMiddleware) Update(ctx context.Context, role *roles.Role) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":  ctx,
-		"role": role} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Request", fields...)
-
-	err = m.next.Update(ctx, role)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Response", fields...)
-
-	return err
-}
diff --git a/pkg/roles/middleware/middleware.go b/pkg/roles/middleware/middleware.go
index 6b1a8b16e0178a22a57a6f44226aa32c6dacf4eb..aaeb2da895d5aa71768e577315e549daa6a247c4 100644
--- a/pkg/roles/middleware/middleware.go
+++ b/pkg/roles/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/roles -i Roles -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/roles -i Roles -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/roles"
@@ -17,12 +17,12 @@ func WithLog(s roles.Roles, logger *zap.Logger, log_access bool) roles.Roles {
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Roles")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/spaces/middleware/access_logging_middleware.go b/pkg/spaces/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..7fca51ede8a87ba31ceb7293537e32c2db4c08d7
--- /dev/null
+++ b/pkg/spaces/middleware/access_logging_middleware.go
@@ -0,0 +1,219 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/spaces"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements spaces.Spaces that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   spaces.Spaces
+}
+
+// AccessLoggingMiddleware instruments an implementation of the spaces.Spaces with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next spaces.Spaces) spaces.Spaces {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) AbortTransfer(ctx context.Context, spaceID string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("AbortTransfer.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceID", spaceID),
+	)
+
+	err = m.next.AbortTransfer(ctx, spaceID)
+
+	m.logger.Debug("AbortTransfer.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("space", space),
+	)
+
+	created, err = m.next.Create(ctx, space)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("created", created),
+		zap.Error(err),
+	)
+
+	return created, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+	)
+
+	err = m.next.Delete(ctx, spaceId)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+	)
+
+	space, err = m.next.Get(ctx, spaceId)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("space", space),
+		zap.Error(err),
+	)
+
+	return space, err
+}
+
+func (m *accessLoggingMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("List.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgId", orgId),
+	)
+
+	spaces, err = m.next.List(ctx, orgId)
+
+	m.logger.Debug("List.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("spaces", spaces),
+		zap.Error(err),
+	)
+
+	return spaces, err
+}
+
+func (m *accessLoggingMiddleware) ListTransfers(ctx context.Context, orgID string) (spaces []*spaces.Space, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("ListTransfers.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("orgID", orgID),
+	)
+
+	spaces, err = m.next.ListTransfers(ctx, orgID)
+
+	m.logger.Debug("ListTransfers.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("spaces", spaces),
+		zap.Error(err),
+	)
+
+	return spaces, err
+}
+
+func (m *accessLoggingMiddleware) Move(ctx context.Context, spaceID string, orgID string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Move.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceID", spaceID),
+		zap.Reflect("orgID", orgID),
+	)
+
+	err = m.next.Move(ctx, spaceID, orgID)
+
+	m.logger.Debug("Move.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Transfer(ctx context.Context, spaceID string, transferToOrg string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Transfer.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceID", spaceID),
+		zap.Reflect("transferToOrg", transferToOrg),
+	)
+
+	err = m.next.Transfer(ctx, spaceID, transferToOrg)
+
+	m.logger.Debug("Transfer.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Update.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("space", space),
+	)
+
+	err = m.next.Update(ctx, space)
+
+	m.logger.Debug("Update.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("UpdateConfig.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("spaceId", spaceId),
+		zap.Reflect("config", config),
+	)
+
+	err = m.next.UpdateConfig(ctx, spaceId, config)
+
+	m.logger.Debug("UpdateConfig.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/spaces/middleware/error_logging_middleware.go b/pkg/spaces/middleware/error_logging_middleware.go
index b82cc16f7b7652dcec33bb262346d727c719d390..2b11838b51f1a033e9963a729c6378401e193d0c 100644
--- a/pkg/spaces/middleware/error_logging_middleware.go
+++ b/pkg/spaces/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/spaces/middleware/logging_middleware.go b/pkg/spaces/middleware/logging_middleware.go
deleted file mode 100644
index 499ed2d23d12737be2af49ec02835956d4b6eb83..0000000000000000000000000000000000000000
--- a/pkg/spaces/middleware/logging_middleware.go
+++ /dev/null
@@ -1,401 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/spaces"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements spaces.Spaces that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   spaces.Spaces
-}
-
-// LoggingMiddleware instruments an implementation of the spaces.Spaces with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next spaces.Spaces) spaces.Spaces {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) AbortTransfer(ctx context.Context, spaceID string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceID": spaceID} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("AbortTransfer.Request", fields...)
-
-	err = m.next.AbortTransfer(ctx, spaceID)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("AbortTransfer.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"space": space} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	created, err = m.next.Create(ctx, space)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"created": created,
-		"err":     err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return created, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, spaceId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	space, err = m.next.Get(ctx, spaceId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"space": space,
-		"err":   err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return space, err
-}
-
-func (m *loggingMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"orgId": orgId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Request", fields...)
-
-	spaces, err = m.next.List(ctx, orgId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"spaces": spaces,
-		"err":    err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("List.Response", fields...)
-
-	return spaces, err
-}
-
-func (m *loggingMiddleware) ListTransfers(ctx context.Context, orgID string) (spaces []*spaces.Space, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"orgID": orgID} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListTransfers.Request", fields...)
-
-	spaces, err = m.next.ListTransfers(ctx, orgID)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"spaces": spaces,
-		"err":    err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("ListTransfers.Response", fields...)
-
-	return spaces, err
-}
-
-func (m *loggingMiddleware) Move(ctx context.Context, spaceID string, orgID string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceID": spaceID,
-		"orgID":   orgID} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Move.Request", fields...)
-
-	err = m.next.Move(ctx, spaceID, orgID)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Move.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Transfer(ctx context.Context, spaceID string, transferToOrg string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":           ctx,
-		"spaceID":       spaceID,
-		"transferToOrg": transferToOrg} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Transfer.Request", fields...)
-
-	err = m.next.Transfer(ctx, spaceID, transferToOrg)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Transfer.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":   ctx,
-		"space": space} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Request", fields...)
-
-	err = m.next.Update(ctx, space)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"spaceId": spaceId,
-		"config":  config} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("UpdateConfig.Request", fields...)
-
-	err = m.next.UpdateConfig(ctx, spaceId, config)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("UpdateConfig.Response", fields...)
-
-	return err
-}
diff --git a/pkg/spaces/middleware/middleware.go b/pkg/spaces/middleware/middleware.go
index 7379b4ae182293f7750504663e59005551e3a63d..73c3b8c3538e6bf9a6457617afc35f68f429aaf3 100644
--- a/pkg/spaces/middleware/middleware.go
+++ b/pkg/spaces/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/spaces"
@@ -17,12 +17,12 @@ func WithLog(s spaces.Spaces, logger *zap.Logger, log_access bool) spaces.Spaces
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Spaces")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/spaces/middleware/recovering_middleware.go b/pkg/spaces/middleware/recovering_middleware.go
index ad13a929c8c1ebd9a6132043a00617352af7e6d8..7b9b64ed276aa9a91dd9e07ee1b463ff8bb06003 100644
--- a/pkg/spaces/middleware/recovering_middleware.go
+++ b/pkg/spaces/middleware/recovering_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/recovery
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/recovery -o recovering_middleware.go -l ""
 
 import (
diff --git a/pkg/users/middleware/access_logging_middleware.go b/pkg/users/middleware/access_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..dd8d4a14c73915d553381b239770fcf05c02aca5
--- /dev/null
+++ b/pkg/users/middleware/access_logging_middleware.go
@@ -0,0 +1,147 @@
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/access_log.tmpl
+// gowrap: http://github.com/hexdigest/gowrap
+
+package middleware
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/users -i Users -t ../../../assets/templates/middleware/access_log.tmpl -o access_logging_middleware.go -l ""
+
+import (
+	"context"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
+	"git.perx.ru/perxis/perxis-go/pkg/options"
+	"git.perx.ru/perxis/perxis-go/pkg/users"
+	"go.uber.org/zap"
+)
+
+// accessLoggingMiddleware implements users.Users that is instrumented with logging
+type accessLoggingMiddleware struct {
+	logger *zap.Logger
+	next   users.Users
+}
+
+// AccessLoggingMiddleware instruments an implementation of the users.Users with simple logging
+func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next users.Users) users.Users {
+		return &accessLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *accessLoggingMiddleware) Create(ctx context.Context, create *users.User) (user *users.User, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Create.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("create", create),
+	)
+
+	user, err = m.next.Create(ctx, create)
+
+	m.logger.Debug("Create.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("user", user),
+		zap.Error(err),
+	)
+
+	return user, err
+}
+
+func (m *accessLoggingMiddleware) Delete(ctx context.Context, userId string) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Delete.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("userId", userId),
+	)
+
+	err = m.next.Delete(ctx, userId)
+
+	m.logger.Debug("Delete.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
+
+func (m *accessLoggingMiddleware) Find(ctx context.Context, filter *users.Filter, options *options.FindOptions) (users []*users.User, total int, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Find.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("filter", filter),
+		zap.Reflect("options", options),
+	)
+
+	users, total, err = m.next.Find(ctx, filter, options)
+
+	m.logger.Debug("Find.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("users", users),
+		zap.Reflect("total", total),
+		zap.Error(err),
+	)
+
+	return users, total, err
+}
+
+func (m *accessLoggingMiddleware) Get(ctx context.Context, userId string) (user *users.User, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Get.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("userId", userId),
+	)
+
+	user, err = m.next.Get(ctx, userId)
+
+	m.logger.Debug("Get.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("user", user),
+		zap.Error(err),
+	)
+
+	return user, err
+}
+
+func (m *accessLoggingMiddleware) GetByIdentity(ctx context.Context, identity string) (user *users.User, err error) {
+	begin := time.Now()
+
+	m.logger.Debug("GetByIdentity.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("identity", identity),
+	)
+
+	user, err = m.next.GetByIdentity(ctx, identity)
+
+	m.logger.Debug("GetByIdentity.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Reflect("user", user),
+		zap.Error(err),
+	)
+
+	return user, err
+}
+
+func (m *accessLoggingMiddleware) Update(ctx context.Context, update *users.User) (err error) {
+	begin := time.Now()
+
+	m.logger.Debug("Update.Request",
+		zap.Reflect("principal", auth.GetPrincipal(ctx)),
+		zap.Reflect("update", update),
+	)
+
+	err = m.next.Update(ctx, update)
+
+	m.logger.Debug("Update.Response",
+		zap.Duration("time", time.Since(begin)),
+		zap.Error(err),
+	)
+
+	return err
+}
diff --git a/pkg/users/middleware/error_logging_middleware.go b/pkg/users/middleware/error_logging_middleware.go
index 688083dac93de779db6cdabd02002836901a0883..c499b9f3bf60726a10d30ced82e24bced6702236 100644
--- a/pkg/users/middleware/error_logging_middleware.go
+++ b/pkg/users/middleware/error_logging_middleware.go
@@ -1,9 +1,9 @@
-package middleware
-
 // Code generated by gowrap. DO NOT EDIT.
 // template: ../../../assets/templates/middleware/error_log
 // gowrap: http://github.com/hexdigest/gowrap
 
+package middleware
+
 //go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/users -i Users -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
 
 import (
diff --git a/pkg/users/middleware/logging_middleware.go b/pkg/users/middleware/logging_middleware.go
deleted file mode 100644
index 0b9438ed939131c97679c5a3364a1e715be63b75..0000000000000000000000000000000000000000
--- a/pkg/users/middleware/logging_middleware.go
+++ /dev/null
@@ -1,257 +0,0 @@
-package middleware
-
-// Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/access_log
-// gowrap: http://github.com/hexdigest/gowrap
-
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/users -i Users -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"git.perx.ru/perxis/perxis-go/pkg/auth"
-	"git.perx.ru/perxis/perxis-go/pkg/options"
-	"git.perx.ru/perxis/perxis-go/pkg/users"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-// loggingMiddleware implements users.Users that is instrumented with logging
-type loggingMiddleware struct {
-	logger *zap.Logger
-	next   users.Users
-}
-
-// LoggingMiddleware instruments an implementation of the users.Users with simple logging
-func LoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next users.Users) users.Users {
-		return &loggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *loggingMiddleware) Create(ctx context.Context, create *users.User) (user *users.User, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"create": create} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Request", fields...)
-
-	user, err = m.next.Create(ctx, create)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"user": user,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Create.Response", fields...)
-
-	return user, err
-}
-
-func (m *loggingMiddleware) Delete(ctx context.Context, userId string) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"userId": userId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Request", fields...)
-
-	err = m.next.Delete(ctx, userId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Delete.Response", fields...)
-
-	return err
-}
-
-func (m *loggingMiddleware) Find(ctx context.Context, filter *users.Filter, options *options.FindOptions) (users []*users.User, total int, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":     ctx,
-		"filter":  filter,
-		"options": options} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Find.Request", fields...)
-
-	users, total, err = m.next.Find(ctx, filter, options)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"users": users,
-		"total": total,
-		"err":   err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Find.Response", fields...)
-
-	return users, total, err
-}
-
-func (m *loggingMiddleware) Get(ctx context.Context, userId string) (user *users.User, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"userId": userId} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Request", fields...)
-
-	user, err = m.next.Get(ctx, userId)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"user": user,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Get.Response", fields...)
-
-	return user, err
-}
-
-func (m *loggingMiddleware) GetByIdentity(ctx context.Context, identity string) (user *users.User, err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":      ctx,
-		"identity": identity} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("GetByIdentity.Request", fields...)
-
-	user, err = m.next.GetByIdentity(ctx, identity)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"user": user,
-		"err":  err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("GetByIdentity.Response", fields...)
-
-	return user, err
-}
-
-func (m *loggingMiddleware) Update(ctx context.Context, update *users.User) (err error) {
-	begin := time.Now()
-	var fields []zapcore.Field
-	for k, v := range map[string]interface{}{
-		"ctx":    ctx,
-		"update": update} {
-		if k == "ctx" {
-			fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Request", fields...)
-
-	err = m.next.Update(ctx, update)
-
-	fields = []zapcore.Field{
-		zap.Duration("time", time.Since(begin)),
-	}
-
-	for k, v := range map[string]interface{}{
-		"err": err} {
-		if k == "err" {
-			err, _ := v.(error)
-			fields = append(fields, zap.Error(err))
-			continue
-		}
-		fields = append(fields, zap.Reflect(k, v))
-	}
-
-	m.logger.Debug("Update.Response", fields...)
-
-	return err
-}
diff --git a/pkg/users/middleware/middleware.go b/pkg/users/middleware/middleware.go
index 63bc862271dc6d7002ea2db479aa359885ad5ebd..d94190827de3028c96000df15bf06c719e30cf92 100644
--- a/pkg/users/middleware/middleware.go
+++ b/pkg/users/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware
+// template: ../../../assets/templates/middleware/middleware.tmpl
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/users -i Users -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/users -i Users -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/users"
@@ -17,12 +17,12 @@ func WithLog(s users.Users, logger *zap.Logger, log_access bool) users.Users {
 	if logger == nil {
 		logger = zap.NewNop()
 	}
-
 	logger = logger.Named("Users")
-	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = LoggingMiddleware(logger)(s)
+		s = AccessLoggingMiddleware(logger)(s)
 	}
+	s = ErrorLoggingMiddleware(logger)(s)
+
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }