diff --git a/assets/templates/middleware/access_log b/assets/templates/middleware/access_log
new file mode 100755
index 0000000000000000000000000000000000000000..86b4fe25ef6247f78dd491578f5b6bf05fa8e992
--- /dev/null
+++ b/assets/templates/middleware/access_log
@@ -0,0 +1,65 @@
+import (
+  "fmt"
+  "time"
+  "context"
+
+  "go.uber.org/zap"
+)
+
+{{ $funcName := (or .Vars.FuncName ("LoggingMiddleware")) }}
+{{ $decorator := (or .Vars.DecoratorName ("loggingMiddleware")) }}
+
+// {{$decorator}} implements {{.Interface.Type}} that is instrumented with logging
+type {{$decorator}} struct {
+  logger *zap.Logger
+  next {{.Interface.Type}}
+}
+
+// {{$funcName}} instruments an implementation of the {{.Interface.Type}} with simple logging
+func {{$funcName}}(logger *zap.Logger) Middleware {
+  return func(next {{.Interface.Type}}) {{.Interface.Type}} {
+    return &{{$decorator}}{
+      next: next,
+      logger: logger,
+    }
+  }
+}
+
+{{range $method := .Interface.Methods}}
+    func (m *{{$decorator}}) {{$method.Declaration}} {
+        begin := time.Now()
+        var fields []zapcore.Field
+        {{- if $method.HasParams}}
+        for k, v := range {{$method.ParamsMap}} {
+            if k == "ctx" {
+			    fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
+                continue
+            }
+            fields = append(fields, zap.Reflect(k,v))
+        }
+        {{end}}
+
+		m.logger.Debug("{{$method.Name}}.Request",fields...)
+
+        {{ $method.ResultsNames }} = m.next.{{ $method.Call }}
+
+        fields = []zapcore.Field{
+			zap.Duration("time", time.Since(begin)),
+        }
+
+        {{ if $method.HasResults}}
+        for k, v := range {{$method.ResultsMap}} {
+            if k == "err" {
+                err, _ := v.(error)
+                fields = append(fields, zap.Error(err))
+                continue
+            }
+            fields = append(fields, zap.Reflect(k,v))
+        }
+        {{end}}
+
+		m.logger.Debug("{{$method.Name}}.Response", fields...)
+
+        return {{ $method.ResultsNames }}
+    }
+{{end}}
diff --git a/assets/templates/middleware/access_log.tmpl b/assets/templates/middleware/access_log.tmpl
deleted file mode 100755
index 9f9899b835a1ec46652da008035f3a8931dc472d..0000000000000000000000000000000000000000
--- a/assets/templates/middleware/access_log.tmpl
+++ /dev/null
@@ -1,58 +0,0 @@
-import (
-  "fmt"
-  "time"
-  "context"
-
-  "go.uber.org/zap"
-)
-
-{{ $funcName := (or .Vars.FuncName ("AccessLoggingMiddleware")) }}
-{{ $decorator := (or .Vars.DecoratorName ("accessLoggingMiddleware")) }}
-{{ $objectName := (trimSuffix "s" (split "." .Interface.Type)._1) }}
-
-// {{$decorator}} implements {{.Interface.Type}} that is instrumented with logging
-type {{$decorator}} struct {
-  logger *zap.Logger
-  next {{.Interface.Type}}
-}
-
-// {{$funcName}} instruments an implementation of the {{.Interface.Type}} with simple logging
-func {{$funcName}}(logger *zap.Logger) Middleware {
-  return func(next {{.Interface.Type}}) {{.Interface.Type}} {
-    return &{{$decorator}}{
-      next: next,
-      logger: logger,
-    }
-  }
-}
-
-{{range $method := .Interface.Methods}}
-    func (m *{{$decorator}}) {{$method.Declaration}} {
-        begin := time.Now()
-
-        m.logger.Debug("{{$method.Name}}.Request",
-        {{- range $param := $method.Params -}}
-            {{- if (eq $param.Name "ctx") }}
-                zap.Reflect("principal", auth.GetPrincipal(ctx)),
-            {{- else }}
-                zap.Reflect("{{$param.Name}}", {{$param.Name}}),
-            {{- end -}}
-        {{ end }}
-        )
-
-        {{ $method.ResultsNames }} = m.next.{{ $method.Call }}
-
-        m.logger.Debug("{{$method.Name}}.Response",
-            zap.Duration("time", time.Since(begin)),
-            {{- range $param := $method.Results -}}
-                {{- if (eq $param.Name "err") }}
-                zap.Error(err),
-                {{- else }}
-                zap.Reflect("{{$param.Name}}", {{$param.Name}}),
-                {{- end -}}
-            {{ end }}
-        )
-
-        return {{ $method.ResultsNames }}
-    }
-{{end}}
diff --git a/assets/templates/middleware/log.tmpl b/assets/templates/middleware/log.tmpl
deleted file mode 100644
index ab91909fb61f1044fe74810390a64d469a6cb614..0000000000000000000000000000000000000000
--- a/assets/templates/middleware/log.tmpl
+++ /dev/null
@@ -1,73 +0,0 @@
-{{/*
-Этот шаблон предназначен только для первичной генерации LoggingMiddleware,
-поскольку он не может учесть все сигнатуры логгируемых методов. После генерации
-необходимо внести правки в код в местах, помеченных 'TODO'
-
-Сгенерировать middleware:
-```shell
-gowrap gen -p git.perx.ru/perxis/perxis-go/<package_name> -i <interface> -t ../../../assets/templates/middleware/logging.tmpl -o info_logging_middleware.go -g
-```
- */}}
-
-import (
-    "fmt"
-    "time"
-    "context"
-
-    logzap "git.perx.ru/perxis/perxis-go/zap"
-    "go.uber.org/zap"
-    "go.uber.org/zap/zapcore"
-)
-
-{{ $funcName := (or .Vars.FuncName ("LoggingMiddleware")) }}
-{{ $decorator := (or .Vars.DecoratorName ("loggingMiddleware")) }}
-{{ $packageName := (split "." .Interface.Type)._0 }}
-{{ $serviceName := (split "." .Interface.Type)._1 }}
-{{ $objectName := (trimSuffix "s" (split "." .Interface.Type)._1) }}
-{{ $writeMethods :=  list "Archive" "Create" "Delete" "Publish" "Unarchive" "Undelete" "Unpublish" "Update" "SetSchema" "Migrate" }}
-
-type {{ $decorator }} struct {
-    logger *zap.Logger
-    next {{ .Interface.Type }}
-}
-
-func {{ $funcName }} (logger *zap.Logger) Middleware {
-    return func(next {{ .Interface.Type }}) {{ .Interface.Type }} {
-        return &{{ $decorator }}{
-            next: next,
-            logger: logger.With(logzap.Component("{{ (lower $serviceName ) }}")),
-        }
-    }
-}
-
-{{ range $method := .Interface.Methods }}
-func (m *{{ $decorator }}) {{ $method.Declaration }} {
-    logger := m.logger.With(
-        {{- if $method.AcceptsContext }}
-        logzap.CallerFromContext(ctx),
-        {{ end -}}
-        {{- if has $method.Name $writeMethods -}}
-        logzap.Event({{ $packageName }}.Event{{ $objectName }}{{ $method.Name }}),
-        logzap.Object(TODO),
-        {{ end -}}
-    )
-
-    {{ $method.ResultsNames }} = m.next.{{ $method.Call }}
-
-    {{- if $method.ReturnsError }}
-    if err != nil {
-        logger.Error("Failed to {{ (lower $method.Name) }}", zap.Error(err)
-            {{- if has $method.Name $writeMethods -}}
-            , logzap.Channels(logzap.Userlog, logzap.Syslog)
-            {{- end -}})
-        return
-    }
-    {{ end }}
-
-    {{ if has $method.Name $writeMethods }}
-    logger.Info("Successfully {{ (lower (trimSuffix "e" $method.Name)) }}ed",  logzap.Channels(logzap.Userlog))
-    {{ end -}}
-
-    return {{ $method.ResultsNames }}
-}
-{{ end }}
diff --git a/assets/templates/middleware/middleware.tmpl b/assets/templates/middleware/middleware
similarity index 57%
rename from assets/templates/middleware/middleware.tmpl
rename to assets/templates/middleware/middleware
index c717d577e89331ed386cf21a1b8ba5486cd54714..89877774c933840c2bdd569f2beed8105588aae2 100755
--- a/assets/templates/middleware/middleware.tmpl
+++ b/assets/templates/middleware/middleware
@@ -2,26 +2,20 @@ import (
 	"go.uber.org/zap"
 )
 
-{{ $serviceName := (split "." .Interface.Type)._1 }}
-
 type Middleware func({{.Interface.Type}}) {{.Interface.Type}}
 
+
 func WithLog(s {{.Interface.Type}}, logger *zap.Logger, log_access bool) {{.Interface.Type}} {
 	if logger == nil {
 		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 }}
+
+	logger = logger.Named("{{ .Interface.Name }}")
 	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
 		s = LoggingMiddleware(logger)(s)
 	}
-	{{ end -}}
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
+
diff --git a/log/service.go b/log/service.go
index 46e306077d8ee3476dc1e83aa30a7501494325d5..8a39ca53e0573ac4ed0bed8bba619837d1fdf030 100644
--- a/log/service.go
+++ b/log/service.go
@@ -8,8 +8,6 @@ import (
 	pb "git.perx.ru/perxis/perxis-go/proto/log"
 )
 
-const ServiceName = "logs"
-
 type Service interface {
 
 	// Log метод записи логов
diff --git a/log/zap/core.go b/log/zap/core.go
index 070e6fb84eb3ca74cd59262eb5244054967e9307..f2b220eab78a6cd2416408385b521c743bcefb94 100644
--- a/log/zap/core.go
+++ b/log/zap/core.go
@@ -1,8 +1,6 @@
 package zap
 
 import (
-	"fmt"
-
 	oid "git.perx.ru/perxis/perxis-go/id"
 	"git.perx.ru/perxis/perxis-go/log"
 	"git.perx.ru/perxis/perxis-go/pkg/id"
@@ -78,10 +76,6 @@ func (core *Core) getEntry(entry zapcore.Entry, fields []zapcore.Field) *log.Ent
 	ent.CallerID, _ = enc.Fields["caller"].(*oid.ObjectId)
 	ent.Attr = enc.Fields["attr"]
 
-	if err, _ := enc.Fields["error"].(error); err != nil {
-		ent.Message = fmt.Sprintf("%s. Error: %s", ent.Message, err.Error())
-	}
-
 	if tags, ok := enc.Fields["tags"].([]any); ok {
 		for _, item := range tags {
 			if tag, ok := item.(string); ok {
diff --git a/pkg/collections/events.go b/pkg/collections/events.go
deleted file mode 100644
index bdc92e7769a7cd7ffc880825caaf3098fb5495fb..0000000000000000000000000000000000000000
--- a/pkg/collections/events.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package collections
-
-const (
-	EventCollectionCreate    = "collection_create"
-	EventCollectionUpdate    = "collection_update"
-	EventCollectionDelete    = "collection_delete"
-	EventCollectionSetSchema = "collection_set_schema"
-)
diff --git a/pkg/collections/middleware/access_logging_middleware.go b/pkg/collections/middleware/access_logging_middleware.go
deleted file mode 100644
index 3624955b5d3ef6201704932e623b4e8e00cc6192..0000000000000000000000000000000000000000
--- a/pkg/collections/middleware/access_logging_middleware.go
+++ /dev/null
@@ -1,175 +0,0 @@
-// 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/collections -i Collections -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/collections"
-	"git.perx.ru/perxis/perxis-go/pkg/schema"
-	"go.uber.org/zap"
-)
-
-// accessLoggingMiddleware implements collections.Collections that is instrumented with logging
-type accessLoggingMiddleware struct {
-	logger *zap.Logger
-	next   collections.Collections
-}
-
-// AccessLoggingMiddleware instruments an implementation of the collections.Collections with simple logging
-func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next collections.Collections) collections.Collections {
-		return &accessLoggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *accessLoggingMiddleware) Create(ctx context.Context, collection *collections.Collection) (created *collections.Collection, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Create.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("collection", collection),
-	)
-
-	created, err = m.next.Create(ctx, collection)
-
-	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, collectionId 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),
-		zap.Reflect("collectionId", collectionId),
-	)
-
-	err = m.next.Delete(ctx, spaceId, envId, collectionId)
-
-	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, collectionId string, options ...*collections.GetOptions) (collection *collections.Collection, 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("collectionId", collectionId),
-		zap.Reflect("options", options),
-	)
-
-	collection, err = m.next.Get(ctx, spaceId, envId, collectionId, options...)
-
-	m.logger.Debug("Get.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("collection", collection),
-		zap.Error(err),
-	)
-
-	return collection, err
-}
-
-func (m *accessLoggingMiddleware) List(ctx context.Context, spaceId string, envId string, filter *collections.Filter) (collections []*collections.Collection, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("List.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("filter", filter),
-	)
-
-	collections, err = m.next.List(ctx, spaceId, envId, filter)
-
-	m.logger.Debug("List.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("collections", collections),
-		zap.Error(err),
-	)
-
-	return collections, err
-}
-
-func (m *accessLoggingMiddleware) SetSchema(ctx context.Context, spaceId string, envId string, collectionId string, schema *schema.Schema) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("SetSchema.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("schema", schema),
-	)
-
-	err = m.next.SetSchema(ctx, spaceId, envId, collectionId, schema)
-
-	m.logger.Debug("SetSchema.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) SetState(ctx context.Context, spaceId string, envId string, collectionId string, state *collections.StateInfo) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("SetState.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("state", state),
-	)
-
-	err = m.next.SetState(ctx, spaceId, envId, collectionId, state)
-
-	m.logger.Debug("SetState.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) Update(ctx context.Context, coll *collections.Collection) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Update.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("coll", coll),
-	)
-
-	err = m.next.Update(ctx, coll)
-
-	m.logger.Debug("Update.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
diff --git a/pkg/collections/middleware/error_logging_middleware.go b/pkg/collections/middleware/error_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..0491250639063a0e4d229c711c19b36223b9b2e4
--- /dev/null
+++ b/pkg/collections/middleware/error_logging_middleware.go
@@ -0,0 +1,101 @@
+package middleware
+
+// Code generated by gowrap. DO NOT EDIT.
+// template: ../../../assets/templates/middleware/error_log
+// gowrap: http://github.com/hexdigest/gowrap
+
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collections -i Collections -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
+
+import (
+	"context"
+
+	"git.perx.ru/perxis/perxis-go/pkg/collections"
+	"git.perx.ru/perxis/perxis-go/pkg/schema"
+	"go.uber.org/zap"
+)
+
+// errorLoggingMiddleware implements collections.Collections that is instrumented with logging
+type errorLoggingMiddleware struct {
+	logger *zap.Logger
+	next   collections.Collections
+}
+
+// ErrorLoggingMiddleware instruments an implementation of the collections.Collections with simple logging
+func ErrorLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next collections.Collections) collections.Collections {
+		return &errorLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *errorLoggingMiddleware) Create(ctx context.Context, collection *collections.Collection) (created *collections.Collection, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Create(ctx, collection)
+}
+
+func (m *errorLoggingMiddleware) Delete(ctx context.Context, spaceId string, envId string, collectionId string) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Delete(ctx, spaceId, envId, collectionId)
+}
+
+func (m *errorLoggingMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, options ...*collections.GetOptions) (collection *collections.Collection, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Get(ctx, spaceId, envId, collectionId, options...)
+}
+
+func (m *errorLoggingMiddleware) List(ctx context.Context, spaceId string, envId string, filter *collections.Filter) (collections []*collections.Collection, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.List(ctx, spaceId, envId, filter)
+}
+
+func (m *errorLoggingMiddleware) SetSchema(ctx context.Context, spaceId string, envId string, collectionId string, schema *schema.Schema) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.SetSchema(ctx, spaceId, envId, collectionId, schema)
+}
+
+func (m *errorLoggingMiddleware) SetState(ctx context.Context, spaceId string, envId string, collectionId string, state *collections.StateInfo) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.SetState(ctx, spaceId, envId, collectionId, state)
+}
+
+func (m *errorLoggingMiddleware) Update(ctx context.Context, coll *collections.Collection) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Update(ctx, coll)
+}
diff --git a/pkg/collections/middleware/logging_middleware.go b/pkg/collections/middleware/logging_middleware.go
index c5e2e2fb3e5bf604fdb57c8484f4a20289029da6..bc3e41070fc56e0a4ec2a75f073f9696a88560fb 100644
--- a/pkg/collections/middleware/logging_middleware.go
+++ b/pkg/collections/middleware/logging_middleware.go
@@ -1,140 +1,303 @@
+package middleware
+
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/log.tmpl
+// 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/collections -i Collections -t ../../../assets/templates/middleware/log.tmpl -o logging_middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collections -i Collections -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
 
 import (
 	"context"
+	"fmt"
+	"time"
 
-	"git.perx.ru/perxis/perxis-go/id"
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
 	"git.perx.ru/perxis/perxis-go/pkg/collections"
 	"git.perx.ru/perxis/perxis-go/pkg/schema"
-	logzap "git.perx.ru/perxis/perxis-go/zap"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 )
 
+// loggingMiddleware implements collections.Collections that is instrumented with logging
 type loggingMiddleware struct {
 	logger *zap.Logger
 	next   collections.Collections
 }
 
+// LoggingMiddleware instruments an implementation of the collections.Collections with simple logging
 func LoggingMiddleware(logger *zap.Logger) Middleware {
 	return func(next collections.Collections) collections.Collections {
 		return &loggingMiddleware{
 			next:   next,
-			logger: logger.With(logzap.Component("collections")),
+			logger: logger,
 		}
 	}
 }
 
 func (m *loggingMiddleware) Create(ctx context.Context, collection *collections.Collection) (created *collections.Collection, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(collections.EventCollectionCreate),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":        ctx,
+		"collection": collection} {
+		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, collection)
-	if err != nil {
-		logger.Error("Failed to create", zap.Error(err), logzap.Object(collection), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
-	logger.Info("Successfully created", logzap.Object(created), logzap.Channels(logzap.Userlog))
+	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, collectionId string) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(collections.EventCollectionDelete),
-		logzap.Object(id.NewCollectionId(spaceId, envId, collectionId)),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId} {
+		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, collectionId)
-	if err != nil {
-		logger.Error("Failed to delete", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	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))
 	}
 
-	logger.Info("Successfully deleted", logzap.Channels(logzap.Userlog))
+	m.logger.Debug("Delete.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, options ...*collections.GetOptions) (collection *collections.Collection, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"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("Get.Request", fields...)
 
 	collection, err = m.next.Get(ctx, spaceId, envId, collectionId, options...)
-	if err != nil {
-		logger.Error("Failed to get", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
+	}
+
+	for k, v := range map[string]interface{}{
+		"collection": collection,
+		"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 collection, err
 }
 
 func (m *loggingMiddleware) List(ctx context.Context, spaceId string, envId string, filter *collections.Filter) (collections []*collections.Collection, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"spaceId": spaceId,
+		"envId":   envId,
+		"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("List.Request", fields...)
 
 	collections, err = m.next.List(ctx, spaceId, envId, filter)
-	if err != nil {
-		logger.Error("Failed to list", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
+	}
+
+	for k, v := range map[string]interface{}{
+		"collections": collections,
+		"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 collections, err
 }
 
 func (m *loggingMiddleware) SetSchema(ctx context.Context, spaceId string, envId string, collectionId string, schema *schema.Schema) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(collections.EventCollectionSetSchema),
-		logzap.Object(id.NewCollectionId(spaceId, envId, collectionId)),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"schema":       schema} {
+		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("SetSchema.Request", fields...)
 
 	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))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
-	logger.Info("Successfully setschemaed", logzap.Channels(logzap.Userlog))
+	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("SetSchema.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) SetState(ctx context.Context, spaceId string, envId string, collectionId string, state *collections.StateInfo) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"state":        state} {
+		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("SetState.Request", fields...)
 
 	err = m.next.SetState(ctx, spaceId, envId, collectionId, state)
-	if err != nil {
-		logger.Error("Failed to setstate", zap.Error(err))
-		return
+
+	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("SetState.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) Update(ctx context.Context, coll *collections.Collection) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(collections.EventCollectionUpdate),
-		logzap.Object(coll),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":  ctx,
+		"coll": coll} {
+		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, coll)
-	if err != nil {
-		logger.Error("Failed to update", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
-	logger.Info("Successfully updated", logzap.Channels(logzap.Userlog))
+	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/collections/middleware/middleware.go b/pkg/collections/middleware/middleware.go
index 22514e7c93ec032847590821bfb2ba7467462f63..b581ce74b6071c707cc96fe9f11656bece37eb99 100644
--- a/pkg/collections/middleware/middleware.go
+++ b/pkg/collections/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware.tmpl
+// template: ../../../assets/templates/middleware/middleware
 // 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/middleware.tmpl -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/collections -i Collections -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/collections"
@@ -17,11 +17,12 @@ func WithLog(s collections.Collections, logger *zap.Logger, log_access bool) col
 	if logger == nil {
 		logger = zap.NewNop()
 	}
+
 	logger = logger.Named("Collections")
+	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = AccessLoggingMiddleware(logger)(s)
+		s = LoggingMiddleware(logger)(s)
 	}
-	s = LoggingMiddleware(logger)(s)
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/pkg/items/events.go b/pkg/items/events.go
index 9a1eb9249ff9224eaa217fdfd8bf1cb12c9d68fc..b697d60733031bc259ce0d5b2efc24f2bb63bc94 100644
--- a/pkg/items/events.go
+++ b/pkg/items/events.go
@@ -7,14 +7,11 @@ import (
 )
 
 const (
-	EventItemCreate    = "create_item"
-	EventItemUpdate    = "update_item"
-	EventItemPublish   = "publish_item"
-	EventItemUnpublish = "unpublish_item"
-	EventItemDelete    = "delete_item"
-	EventItemUndelete  = "item_undelete"
-	EventItemArchive   = "item_archive"
-	EventItemUnarchive = "item_unarchive"
+	EventCreateItem    = "create_item"
+	EventUpdateItem    = "update_item"
+	EventPublishItem   = "publish_item"
+	EventUnpublishItem = "unpublish_item"
+	EventDeleteItem    = "delete_item"
 
 	DefaultEventSubject = "content.{{.EventType}}.{{.SpaceID}}.{{.EnvID}}.{{.CollectionID}}.{{.ItemID}}"
 )
diff --git a/pkg/items/middleware/access_logging_middleware.go b/pkg/items/middleware/access_logging_middleware.go
deleted file mode 100644
index 2342a6d99249f427aa0f4ad6b4220a43ba872a4f..0000000000000000000000000000000000000000
--- a/pkg/items/middleware/access_logging_middleware.go
+++ /dev/null
@@ -1,418 +0,0 @@
-// 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/items -i Items -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/schema"
-	"go.uber.org/zap"
-)
-
-// accessLoggingMiddleware implements items.Items that is instrumented with logging
-type accessLoggingMiddleware struct {
-	logger *zap.Logger
-	next   items.Items
-}
-
-// AccessLoggingMiddleware instruments an implementation of the items.Items with simple logging
-func AccessLoggingMiddleware(logger *zap.Logger) Middleware {
-	return func(next items.Items) items.Items {
-		return &accessLoggingMiddleware{
-			next:   next,
-			logger: logger,
-		}
-	}
-}
-
-func (m *accessLoggingMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregateOptions) (result map[string]interface{}, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Aggregate.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("filter", filter),
-		zap.Reflect("options", options),
-	)
-
-	result, err = m.next.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
-
-	m.logger.Debug("Aggregate.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("result", result),
-		zap.Error(err),
-	)
-
-	return result, err
-}
-
-func (m *accessLoggingMiddleware) AggregatePublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("AggregatePublished.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("filter", filter),
-		zap.Reflect("options", options),
-	)
-
-	result, err = m.next.AggregatePublished(ctx, spaceId, envId, collectionId, filter, options...)
-
-	m.logger.Debug("AggregatePublished.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("result", result),
-		zap.Error(err),
-	)
-
-	return result, err
-}
-
-func (m *accessLoggingMiddleware) Archive(ctx context.Context, item *items.Item, options ...*items.ArchiveOptions) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Archive.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("options", options),
-	)
-
-	err = m.next.Archive(ctx, item, options...)
-
-	m.logger.Debug("Archive.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) Create(ctx context.Context, item *items.Item, opts ...*items.CreateOptions) (created *items.Item, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Create.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("opts", opts),
-	)
-
-	created, err = m.next.Create(ctx, item, opts...)
-
-	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, item *items.Item, options ...*items.DeleteOptions) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Delete.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("options", options),
-	)
-
-	err = m.next.Delete(ctx, item, options...)
-
-	m.logger.Debug("Delete.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) Find(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindOptions) (items []*items.Item, total int, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Find.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("filter", filter),
-		zap.Reflect("options", options),
-	)
-
-	items, total, err = m.next.Find(ctx, spaceId, envId, collectionId, filter, options...)
-
-	m.logger.Debug("Find.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("items", items),
-		zap.Reflect("total", total),
-		zap.Error(err),
-	)
-
-	return items, total, err
-}
-
-func (m *accessLoggingMiddleware) FindArchived(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindArchivedOptions) (items []*items.Item, total int, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("FindArchived.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("filter", filter),
-		zap.Reflect("options", options),
-	)
-
-	items, total, err = m.next.FindArchived(ctx, spaceId, envId, collectionId, filter, options...)
-
-	m.logger.Debug("FindArchived.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("items", items),
-		zap.Reflect("total", total),
-		zap.Error(err),
-	)
-
-	return items, total, err
-}
-
-func (m *accessLoggingMiddleware) FindPublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindPublishedOptions) (items []*items.Item, total int, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("FindPublished.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("filter", filter),
-		zap.Reflect("options", options),
-	)
-
-	items, total, err = m.next.FindPublished(ctx, spaceId, envId, collectionId, filter, options...)
-
-	m.logger.Debug("FindPublished.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("items", items),
-		zap.Reflect("total", total),
-		zap.Error(err),
-	)
-
-	return items, total, err
-}
-
-func (m *accessLoggingMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetOptions) (item *items.Item, 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("collectionId", collectionId),
-		zap.Reflect("itemId", itemId),
-		zap.Reflect("options", options),
-	)
-
-	item, err = m.next.Get(ctx, spaceId, envId, collectionId, itemId, options...)
-
-	m.logger.Debug("Get.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("item", item),
-		zap.Error(err),
-	)
-
-	return item, err
-}
-
-func (m *accessLoggingMiddleware) GetPublished(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetPublishedOptions) (item *items.Item, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("GetPublished.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("itemId", itemId),
-		zap.Reflect("options", options),
-	)
-
-	item, err = m.next.GetPublished(ctx, spaceId, envId, collectionId, itemId, options...)
-
-	m.logger.Debug("GetPublished.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("item", item),
-		zap.Error(err),
-	)
-
-	return item, err
-}
-
-func (m *accessLoggingMiddleware) GetRevision(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, revisionId string, options ...*items.GetRevisionOptions) (item *items.Item, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("GetRevision.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("itemId", itemId),
-		zap.Reflect("revisionId", revisionId),
-		zap.Reflect("options", options),
-	)
-
-	item, err = m.next.GetRevision(ctx, spaceId, envId, collectionId, itemId, revisionId, options...)
-
-	m.logger.Debug("GetRevision.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("item", item),
-		zap.Error(err),
-	)
-
-	return item, err
-}
-
-func (m *accessLoggingMiddleware) Introspect(ctx context.Context, item *items.Item, opts ...*items.IntrospectOptions) (itm *items.Item, sch *schema.Schema, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Introspect.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("opts", opts),
-	)
-
-	itm, sch, err = m.next.Introspect(ctx, item, opts...)
-
-	m.logger.Debug("Introspect.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("itm", itm),
-		zap.Reflect("sch", sch),
-		zap.Error(err),
-	)
-
-	return itm, sch, err
-}
-
-func (m *accessLoggingMiddleware) ListRevisions(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.ListRevisionsOptions) (items []*items.Item, err error) {
-	begin := time.Now()
-
-	m.logger.Debug("ListRevisions.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("spaceId", spaceId),
-		zap.Reflect("envId", envId),
-		zap.Reflect("collectionId", collectionId),
-		zap.Reflect("itemId", itemId),
-		zap.Reflect("options", options),
-	)
-
-	items, err = m.next.ListRevisions(ctx, spaceId, envId, collectionId, itemId, options...)
-
-	m.logger.Debug("ListRevisions.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Reflect("items", items),
-		zap.Error(err),
-	)
-
-	return items, err
-}
-
-func (m *accessLoggingMiddleware) Publish(ctx context.Context, item *items.Item, options ...*items.PublishOptions) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Publish.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("options", options),
-	)
-
-	err = m.next.Publish(ctx, item, options...)
-
-	m.logger.Debug("Publish.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) Unarchive(ctx context.Context, item *items.Item, options ...*items.UnarchiveOptions) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Unarchive.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("options", options),
-	)
-
-	err = m.next.Unarchive(ctx, item, options...)
-
-	m.logger.Debug("Unarchive.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) Undelete(ctx context.Context, item *items.Item, options ...*items.UndeleteOptions) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Undelete.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("options", options),
-	)
-
-	err = m.next.Undelete(ctx, item, options...)
-
-	m.logger.Debug("Undelete.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) Unpublish(ctx context.Context, item *items.Item, options ...*items.UnpublishOptions) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Unpublish.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("options", options),
-	)
-
-	err = m.next.Unpublish(ctx, item, options...)
-
-	m.logger.Debug("Unpublish.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
-
-func (m *accessLoggingMiddleware) Update(ctx context.Context, item *items.Item, options ...*items.UpdateOptions) (err error) {
-	begin := time.Now()
-
-	m.logger.Debug("Update.Request",
-		zap.Reflect("principal", auth.GetPrincipal(ctx)),
-		zap.Reflect("item", item),
-		zap.Reflect("options", options),
-	)
-
-	err = m.next.Update(ctx, item, options...)
-
-	m.logger.Debug("Update.Response",
-		zap.Duration("time", time.Since(begin)),
-		zap.Error(err),
-	)
-
-	return err
-}
diff --git a/pkg/items/middleware/error_logging_middleware.go b/pkg/items/middleware/error_logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..345d22ca2727d1516e4a7176e885195ab38f1d20
--- /dev/null
+++ b/pkg/items/middleware/error_logging_middleware.go
@@ -0,0 +1,211 @@
+// 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/items -i Items -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
+
+import (
+	"context"
+
+	"git.perx.ru/perxis/perxis-go/pkg/items"
+	"git.perx.ru/perxis/perxis-go/pkg/schema"
+	"go.uber.org/zap"
+)
+
+// errorLoggingMiddleware implements items.Items that is instrumented with logging
+type errorLoggingMiddleware struct {
+	logger *zap.Logger
+	next   items.Items
+}
+
+// ErrorLoggingMiddleware instruments an implementation of the items.Items with simple logging
+func ErrorLoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next items.Items) items.Items {
+		return &errorLoggingMiddleware{
+			next:   next,
+			logger: logger,
+		}
+	}
+}
+
+func (m *errorLoggingMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregateOptions) (result map[string]interface{}, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
+}
+
+func (m *errorLoggingMiddleware) AggregatePublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.AggregatePublished(ctx, spaceId, envId, collectionId, filter, options...)
+}
+
+func (m *errorLoggingMiddleware) Archive(ctx context.Context, item *items.Item, options ...*items.ArchiveOptions) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Archive(ctx, item, options...)
+}
+
+func (m *errorLoggingMiddleware) Create(ctx context.Context, item *items.Item, opts ...*items.CreateOptions) (created *items.Item, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Create(ctx, item, opts...)
+}
+
+func (m *errorLoggingMiddleware) Delete(ctx context.Context, item *items.Item, options ...*items.DeleteOptions) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Delete(ctx, item, options...)
+}
+
+func (m *errorLoggingMiddleware) Find(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindOptions) (items []*items.Item, total int, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Find(ctx, spaceId, envId, collectionId, filter, options...)
+}
+
+func (m *errorLoggingMiddleware) FindArchived(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindArchivedOptions) (items []*items.Item, total int, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.FindArchived(ctx, spaceId, envId, collectionId, filter, options...)
+}
+
+func (m *errorLoggingMiddleware) FindPublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindPublishedOptions) (items []*items.Item, total int, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.FindPublished(ctx, spaceId, envId, collectionId, filter, options...)
+}
+
+func (m *errorLoggingMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetOptions) (item *items.Item, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Get(ctx, spaceId, envId, collectionId, itemId, options...)
+}
+
+func (m *errorLoggingMiddleware) GetPublished(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetPublishedOptions) (item *items.Item, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.GetPublished(ctx, spaceId, envId, collectionId, itemId, options...)
+}
+
+func (m *errorLoggingMiddleware) GetRevision(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, revisionId string, options ...*items.GetRevisionOptions) (item *items.Item, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.GetRevision(ctx, spaceId, envId, collectionId, itemId, revisionId, options...)
+}
+
+func (m *errorLoggingMiddleware) Introspect(ctx context.Context, item *items.Item, opts ...*items.IntrospectOptions) (itm *items.Item, sch *schema.Schema, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Introspect(ctx, item, opts...)
+}
+
+func (m *errorLoggingMiddleware) ListRevisions(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.ListRevisionsOptions) (items []*items.Item, err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.ListRevisions(ctx, spaceId, envId, collectionId, itemId, options...)
+}
+
+func (m *errorLoggingMiddleware) Publish(ctx context.Context, item *items.Item, options ...*items.PublishOptions) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Publish(ctx, item, options...)
+}
+
+func (m *errorLoggingMiddleware) Unarchive(ctx context.Context, item *items.Item, options ...*items.UnarchiveOptions) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Unarchive(ctx, item, options...)
+}
+
+func (m *errorLoggingMiddleware) Undelete(ctx context.Context, item *items.Item, options ...*items.UndeleteOptions) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Undelete(ctx, item, options...)
+}
+
+func (m *errorLoggingMiddleware) Unpublish(ctx context.Context, item *items.Item, options ...*items.UnpublishOptions) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Unpublish(ctx, item, options...)
+}
+
+func (m *errorLoggingMiddleware) Update(ctx context.Context, item *items.Item, options ...*items.UpdateOptions) (err error) {
+	logger := m.logger
+	defer func() {
+		if err != nil {
+			logger.Warn("response error", zap.Error(err))
+		}
+	}()
+	return m.next.Update(ctx, item, options...)
+}
diff --git a/pkg/items/middleware/logging_middleware.go b/pkg/items/middleware/logging_middleware.go
index 8870912f5ee01671c026431c80fe1e091b36bbdd..6ed28f90053eab68a44b1e5ac79d5228d7bfe9be 100644
--- a/pkg/items/middleware/logging_middleware.go
+++ b/pkg/items/middleware/logging_middleware.go
@@ -1,306 +1,744 @@
+// 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/items -i Items -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
+
 import (
 	"context"
+	"fmt"
+	"time"
 
-	"git.perx.ru/perxis/perxis-go/id"
+	"git.perx.ru/perxis/perxis-go/pkg/auth"
 	"git.perx.ru/perxis/perxis-go/pkg/items"
 	"git.perx.ru/perxis/perxis-go/pkg/schema"
-	logzap "git.perx.ru/perxis/perxis-go/zap"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 )
 
+// loggingMiddleware implements items.Items that is instrumented with logging
 type loggingMiddleware struct {
 	logger *zap.Logger
 	next   items.Items
 }
 
+// LoggingMiddleware instruments an implementation of the items.Items with simple logging
 func LoggingMiddleware(logger *zap.Logger) Middleware {
 	return func(next items.Items) items.Items {
 		return &loggingMiddleware{
 			next:   next,
-			logger: logger.With(logzap.Component("items")),
+			logger: logger,
 		}
 	}
 }
 
 func (m *loggingMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregateOptions) (result map[string]interface{}, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"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("Aggregate.Request", fields...)
 
 	result, err = m.next.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
-	if err != nil {
-		logger.Error("Failed to aggregate", zap.Error(err))
-		return
+
+	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("Aggregate.Response", fields...)
+
 	return result, err
 }
 
 func (m *loggingMiddleware) AggregatePublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"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("AggregatePublished.Request", fields...)
 
 	result, err = m.next.AggregatePublished(ctx, spaceId, envId, collectionId, filter, options...)
-	if err != nil {
-		logger.Error("Failed to aggregate_published", zap.Error(err))
-		return
+
+	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("AggregatePublished.Response", fields...)
+
 	return result, err
 }
 
 func (m *loggingMiddleware) Archive(ctx context.Context, item *items.Item, options ...*items.ArchiveOptions) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemArchive),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"item":    item,
+		"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("Archive.Request", fields...)
 
 	err = m.next.Archive(ctx, item, options...)
-	if err != nil {
-		logger.Error("Failed to archive", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
-	logger.Info("Successfully archived", logzap.Channels(logzap.Userlog))
+	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("Archive.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) Create(ctx context.Context, item *items.Item, opts ...*items.CreateOptions) (created *items.Item, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemCreate),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":  ctx,
+		"item": item,
+		"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("Create.Request", fields...)
 
 	created, err = m.next.Create(ctx, item, opts...)
-	if err != nil {
-		logger.Error("Failed to create", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog), logzap.Object(item))
-		return
+
+	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))
 	}
 
-	logger.Info("Successfully created", logzap.Channels(logzap.Userlog), logzap.Object(created))
+	m.logger.Debug("Create.Response", fields...)
+
 	return created, err
 }
 
 func (m *loggingMiddleware) Delete(ctx context.Context, item *items.Item, options ...*items.DeleteOptions) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemDelete),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"item":    item,
+		"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("Delete.Request", fields...)
 
 	err = m.next.Delete(ctx, item, options...)
-	if err != nil {
-		logger.Error("Failed to delete", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
-	logger.Info("Successfully deleted", logzap.Channels(logzap.Userlog))
+	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, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindOptions) (items []*items.Item, total int, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"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...)
 
 	items, total, err = m.next.Find(ctx, spaceId, envId, collectionId, filter, options...)
 
-	if err != nil {
-		logger.Error("Failed to find", zap.Error(err))
-		return
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
+	}
+
+	for k, v := range map[string]interface{}{
+		"items": items,
+		"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 items, total, err
 }
 
 func (m *loggingMiddleware) FindArchived(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindArchivedOptions) (items []*items.Item, total int, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"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("FindArchived.Request", fields...)
 
 	items, total, err = m.next.FindArchived(ctx, spaceId, envId, collectionId, filter, options...)
-	if err != nil {
-		logger.Error("Failed to find_archived", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
+	}
+
+	for k, v := range map[string]interface{}{
+		"items": items,
+		"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("FindArchived.Response", fields...)
+
 	return items, total, err
 }
 
 func (m *loggingMiddleware) FindPublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindPublishedOptions) (items []*items.Item, total int, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"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("FindPublished.Request", fields...)
 
 	items, total, err = m.next.FindPublished(ctx, spaceId, envId, collectionId, filter, options...)
-	if err != nil {
-		logger.Error("Failed to findpublished", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
+	}
+
+	for k, v := range map[string]interface{}{
+		"items": items,
+		"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("FindPublished.Response", fields...)
+
 	return items, total, err
 }
 
 func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetOptions) (item *items.Item, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Object(id.NewItemId(spaceId, envId, collectionId, itemId)),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"itemId":       itemId,
+		"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("Get.Request", fields...)
 
 	item, err = m.next.Get(ctx, spaceId, envId, collectionId, itemId, options...)
-	if err != nil {
-		logger.Error("Failed to get", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
+	for k, v := range map[string]interface{}{
+		"item": item,
+		"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 item, err
 }
 
 func (m *loggingMiddleware) GetPublished(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetPublishedOptions) (item *items.Item, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Object(id.NewItemId(spaceId, envId, collectionId, itemId)),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"itemId":       itemId,
+		"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("GetPublished.Request", fields...)
 
 	item, err = m.next.GetPublished(ctx, spaceId, envId, collectionId, itemId, options...)
-	if err != nil {
-		logger.Error("Failed to get published", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
+	for k, v := range map[string]interface{}{
+		"item": item,
+		"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("GetPublished.Response", fields...)
+
 	return item, err
 }
 
 func (m *loggingMiddleware) GetRevision(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, revisionId string, options ...*items.GetRevisionOptions) (item *items.Item, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Object(id.NewItemId(spaceId, envId, collectionId, itemId)),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"itemId":       itemId,
+		"revisionId":   revisionId,
+		"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("GetRevision.Request", fields...)
 
 	item, err = m.next.GetRevision(ctx, spaceId, envId, collectionId, itemId, revisionId, options...)
-	if err != nil {
-		logger.Error("Failed to get revision", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
+	for k, v := range map[string]interface{}{
+		"item": item,
+		"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("GetRevision.Response", fields...)
+
 	return item, err
 }
 
 func (m *loggingMiddleware) Introspect(ctx context.Context, item *items.Item, opts ...*items.IntrospectOptions) (itm *items.Item, sch *schema.Schema, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":  ctx,
+		"item": item,
+		"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("Introspect.Request", fields...)
 
 	itm, sch, err = m.next.Introspect(ctx, item, opts...)
-	if err != nil {
-		logger.Error("Failed to introspect", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
+	}
+
+	for k, v := range map[string]interface{}{
+		"itm": itm,
+		"sch": sch,
+		"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("Introspect.Response", fields...)
+
 	return itm, sch, err
 }
 
 func (m *loggingMiddleware) ListRevisions(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.ListRevisionsOptions) (items []*items.Item, err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Object(id.NewItemId(spaceId, envId, collectionId, itemId)),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":          ctx,
+		"spaceId":      spaceId,
+		"envId":        envId,
+		"collectionId": collectionId,
+		"itemId":       itemId,
+		"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("ListRevisions.Request", fields...)
 
 	items, err = m.next.ListRevisions(ctx, spaceId, envId, collectionId, itemId, options...)
-	if err != nil {
-		logger.Error("Failed to list revisions", zap.Error(err))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
+	for k, v := range map[string]interface{}{
+		"items": items,
+		"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("ListRevisions.Response", fields...)
+
 	return items, err
 }
 
 func (m *loggingMiddleware) Publish(ctx context.Context, item *items.Item, options ...*items.PublishOptions) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemPublish),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"item":    item,
+		"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("Publish.Request", fields...)
 
 	err = m.next.Publish(ctx, item, options...)
-	if err != nil {
-		logger.Error("Failed to publish", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
-	logger.Info("Successfully published", logzap.Channels(logzap.Userlog))
+	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("Publish.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) Unarchive(ctx context.Context, item *items.Item, options ...*items.UnarchiveOptions) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemUnarchive),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"item":    item,
+		"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("Unarchive.Request", fields...)
 
 	err = m.next.Unarchive(ctx, item, options...)
-	if err != nil {
-		logger.Error("Failed to unarchive", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	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))
 	}
 
-	logger.Info("Successfully unarchived", logzap.Channels(logzap.Userlog))
+	m.logger.Debug("Unarchive.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) Undelete(ctx context.Context, item *items.Item, options ...*items.UndeleteOptions) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemUndelete),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"item":    item,
+		"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("Undelete.Request", fields...)
 
 	err = m.next.Undelete(ctx, item, options...)
-	if err != nil {
-		logger.Error("Failed to undelete", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	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))
 	}
 
-	logger.Info("Successfully undeleted", logzap.Channels(logzap.Userlog))
+	m.logger.Debug("Undelete.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) Unpublish(ctx context.Context, item *items.Item, options ...*items.UnpublishOptions) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemUnpublish),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"item":    item,
+		"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("Unpublish.Request", fields...)
 
 	err = m.next.Unpublish(ctx, item, options...)
-	if err != nil {
-		logger.Error("Failed to unpublish", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	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))
 	}
 
-	logger.Info("Successfully unpublished", logzap.Channels(logzap.Userlog))
+	m.logger.Debug("Unpublish.Response", fields...)
+
 	return err
 }
 
 func (m *loggingMiddleware) Update(ctx context.Context, item *items.Item, options ...*items.UpdateOptions) (err error) {
-	logger := m.logger.With(
-		logzap.CallerFromContext(ctx),
-		logzap.Event(items.EventItemUpdate),
-		logzap.Object(item),
-	)
+	begin := time.Now()
+	var fields []zapcore.Field
+	for k, v := range map[string]interface{}{
+		"ctx":     ctx,
+		"item":    item,
+		"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("Update.Request", fields...)
 
 	err = m.next.Update(ctx, item, options...)
-	if err != nil {
-		logger.Error("Failed to update", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
-		return
+
+	fields = []zapcore.Field{
+		zap.Duration("time", time.Since(begin)),
 	}
 
-	logger.Info("Successfully updated", logzap.Channels(logzap.Userlog))
+	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/items/middleware/middleware.go b/pkg/items/middleware/middleware.go
index 2ce07ef94ff532af1ed3353ef5bdba6e5f6871aa..52a1c1218d1605dc52ae80342684bb0339e63103 100644
--- a/pkg/items/middleware/middleware.go
+++ b/pkg/items/middleware/middleware.go
@@ -1,10 +1,10 @@
 // Code generated by gowrap. DO NOT EDIT.
-// template: ../../../assets/templates/middleware/middleware.tmpl
+// template: ../../../assets/templates/middleware/middleware
 // gowrap: http://github.com/hexdigest/gowrap
 
 package middleware
 
-//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/items -i Items -t ../../../assets/templates/middleware/middleware.tmpl -o middleware.go -l ""
+//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/items -i Items -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
 
 import (
 	"git.perx.ru/perxis/perxis-go/pkg/items"
@@ -17,11 +17,12 @@ func WithLog(s items.Items, logger *zap.Logger, log_access bool) items.Items {
 	if logger == nil {
 		logger = zap.NewNop()
 	}
+
 	logger = logger.Named("Items")
+	s = ErrorLoggingMiddleware(logger)(s)
 	if log_access {
-		s = AccessLoggingMiddleware(logger)(s)
+		s = LoggingMiddleware(logger)(s)
 	}
-	s = LoggingMiddleware(logger)(s)
 	s = RecoveringMiddleware(logger)(s)
 	return s
 }
diff --git a/zap/channels.go b/zap/channels.go
index 92b3d823e3aef22c30736942c0aa8931c7e19b31..6d323aa881f31e5c8db6d03c06d2c6ee7d91ef65 100644
--- a/zap/channels.go
+++ b/zap/channels.go
@@ -7,10 +7,6 @@ import (
 
 const (
 	channelKey = "channel"
-
-	Syslog  = "syslog"
-	Userlog = "userlog"
-	// ChannelsAll   = "*"
 )
 
 func ContainsChannels(channels ...string) FilterFunc {