diff --git a/pkg/environments/events.go b/pkg/environments/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..21b79f7f76ee0ca354265ff3ff82cb36138cb0ee
--- /dev/null
+++ b/pkg/environments/events.go
@@ -0,0 +1,8 @@
+package environments
+
+const (
+	EventCreate  = "environment.create"
+	EventUpdate  = "environment.update"
+	EventDelete  = "environment.delete"
+	EventMigrate = "environment.migrate"
+)
diff --git a/pkg/environments/middleware/logging_middleware.go b/pkg/environments/middleware/logging_middleware.go
new file mode 100644
index 0000000000000000000000000000000000000000..df753096bbf2764f9dfaa837b1ccf98edc8ca3bf
--- /dev/null
+++ b/pkg/environments/middleware/logging_middleware.go
@@ -0,0 +1,166 @@
+package middleware
+
+import (
+	"context"
+	"git.perx.ru/perxis/perxis-go/id"
+	"git.perx.ru/perxis/perxis-go/pkg/environments"
+
+	logzap "git.perx.ru/perxis/perxis-go/zap"
+	"go.uber.org/zap"
+)
+
+type loggingMiddleware struct {
+	logger *zap.Logger
+	next   environments.Environments
+}
+
+func LoggingMiddleware(logger *zap.Logger) Middleware {
+	return func(next environments.Environments) environments.Environments {
+		return &loggingMiddleware{
+			next:   next,
+			logger: logger.With(logzap.Component("Environments")),
+		}
+	}
+}
+
+func (m *loggingMiddleware) Create(ctx context.Context, env *environments.Environment) (created *environments.Environment, err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(environments.EventCreate),
+		logzap.Object(env),
+	)
+
+	created, err = m.next.Create(ctx, env)
+	if err != nil {
+		logger.Error("Failed to create", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Environment created", logzap.Channels(logzap.Userlog))
+
+	return created, err
+}
+
+func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string, envId string) (err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(environments.EventDelete),
+		logzap.Object(id.NewEnvironmentId(spaceId, envId)),
+	)
+
+	err = m.next.Delete(ctx, spaceId, envId)
+	if err != nil {
+		logger.Error("Failed to delete", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Environment deleted", logzap.Channels(logzap.Userlog))
+
+	return err
+}
+
+func (m *loggingMiddleware) Get(ctx context.Context, spaceId string, envId string) (env *environments.Environment, err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Object(id.NewEnvironmentId(spaceId, envId)),
+	)
+
+	env, err = m.next.Get(ctx, spaceId, envId)
+	if err != nil {
+		logger.Error("Failed to get", zap.Error(err))
+		return
+	}
+
+	return env, err
+}
+
+func (m *loggingMiddleware) List(ctx context.Context, spaceId string) (envs []*environments.Environment, err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+	)
+
+	envs, err = m.next.List(ctx, spaceId)
+	if err != nil {
+		logger.Error("Failed to list", zap.Error(err))
+		return
+	}
+
+	return envs, err
+}
+
+func (m *loggingMiddleware) Migrate(ctx context.Context, spaceId string, envId string, options ...*environments.MigrateOptions) (err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(environments.EventMigrate),
+		logzap.Object(id.NewEnvironmentId(spaceId, envId)),
+	)
+
+	err = m.next.Migrate(ctx, spaceId, envId, options...)
+	if err != nil {
+		logger.Error("Failed to migrate", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	opt := environments.MergeMigrateOptions(options...)
+
+	// В случае асинхронной миграции, информация о ней будет отправлена в сервис логирования внутри самого сервиса.
+	if !opt.Async {
+		logger.Info("Environment migrated", logzap.Channels(logzap.Userlog))
+	}
+
+	return err
+}
+
+func (m *loggingMiddleware) RemoveAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(environments.EventUpdate),
+		logzap.Object(id.NewEnvironmentId(spaceId, envId)),
+	)
+
+	err = m.next.RemoveAlias(ctx, spaceId, envId, alias)
+	if err != nil {
+		logger.Error("Failed to remove alias", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Environment alias removed", logzap.Channels(logzap.Userlog))
+
+	return err
+}
+
+func (m *loggingMiddleware) SetAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(environments.EventUpdate),
+		logzap.Object(id.NewEnvironmentId(spaceId, envId)),
+	)
+
+	err = m.next.SetAlias(ctx, spaceId, envId, alias)
+	if err != nil {
+		logger.Error("Failed to set alias", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Environment alias was set", logzap.Channels(logzap.Userlog))
+
+	return err
+}
+
+func (m *loggingMiddleware) Update(ctx context.Context, env *environments.Environment) (err error) {
+	logger := m.logger.With(
+		logzap.CallerFromContext(ctx, ""),
+		logzap.Event(environments.EventUpdate),
+		logzap.Object(env),
+	)
+
+	err = m.next.Update(ctx, env)
+	if err != nil {
+		logger.Error("Failed to update", zap.Error(err), logzap.Channels(logzap.Userlog, logzap.Syslog))
+		return
+	}
+
+	logger.Info("Environment updated", logzap.Channels(logzap.Userlog))
+
+	return err
+}
diff --git a/pkg/environments/middleware/middleware.go b/pkg/environments/middleware/middleware.go
index 7c887417848d7cdea79681b73d7c1954318ad009..d8e2816928241555275aa14a87f03d35ae99bcf7 100644
--- a/pkg/environments/middleware/middleware.go
+++ b/pkg/environments/middleware/middleware.go
@@ -21,7 +21,7 @@ func WithLog(s environments.Environments, logger *zap.Logger, log_access bool) e
 	if log_access {
 		s = AccessLoggingMiddleware(logger)(s)
 	}
-	s = ErrorLoggingMiddleware(logger)(s)
+	s = LoggingMiddleware(logger)(s)
 
 	s = RecoveringMiddleware(logger)(s)
 	return s