diff --git a/ydb/library/actors/queues/bench/bench_cases.h b/ydb/library/actors/queues/bench/bench_cases.h
index 981ca9ff201b..a62b610498a1 100644
--- a/ydb/library/actors/queues/bench/bench_cases.h
+++ b/ydb/library/actors/queues/bench/bench_cases.h
@@ -1,109 +1,394 @@
 #pragma once
 
+#include "defs.h"
 #include "queue.h"
 #include "worker.h"
 
+#include <util/string/builder.h>
+#include <util/random/fast.h>
+
 
 namespace NActors::NQueueBench {
-    
-    template <typename TRealQueue, typename TQueueAdaptor>
-    struct TBenchCases {
 
-        template <typename TStatsCollector>
-        static TStatsCollector BasicPushPopSingleThread() {
-            TRealQueue realQueue;
-            TQueueAdaptor adapter(&realQueue);
-            TStatsCollector collector;
-            TSimpleWorker<decltype(adapter)> worker(
-                &adapter,
-                {
-                    TWorkerAction{.Action=EWorkerAction::Push, .Expected=EExpectedStatus::Success, .Value=1},
-                    TWorkerAction{.Action=EWorkerAction::Push, .Expected=EExpectedStatus::Success, .Value=2},
-                    TWorkerAction{.Action=EWorkerAction::Pop, .Expected=EExpectedStatus::Success, .Value=1},
-                    TWorkerAction{.Action=EWorkerAction::Pop, .Expected=EExpectedStatus::Success, .Value=2},
-                }
-            );
-            RunThreads(std::make_unique<TTestThread<decltype(worker), TStatsCollector>>(worker, &collector));
-            return std::move(collector);
+    struct TThreadCounts {
+        ui64 ProducerThreads = 0;
+        ui64 ConsumerThreads = 0;
+    };
+
+    template <typename TStatsCollector>
+    class IBenchCase {
+    public:
+        virtual ~IBenchCase () {}
+
+        virtual TStatsCollector Run() = 0;
+
+        virtual TThreadCounts GetThreads(ui64 globalThreads) = 0;
+    };
+
+    template <typename TStatsCollector>
+    class IBenchCaseWithDurationAndThreads {
+    public:
+        virtual ~IBenchCaseWithDurationAndThreads() {}
+
+        virtual TStatsCollector Run(TDuration duration, ui64 threads) = 0;
+
+        virtual TString Validate(ui64 /*threads*/) {
+            return "";
         }
 
-        template <typename TStatsCollector, ui32 ThreadCount, ui32 RepeatCount>
-        static TStatsCollector BasicPushPopMultiThreads() {
-            TRealQueue realQueue;
-            TVector<std::unique_ptr<IQueue>> adapters;
-            TVector<std::unique_ptr<ISimpleThread>> threads;
-            TStatsCollector collector;
-            for (ui32 threadIdx = 0; threadIdx < ThreadCount; ++threadIdx) {
-                TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
-                adapters.emplace_back(adapter);
-                TSimpleWorker<std::decay_t<decltype(*adapter)>> worker(
-                    adapter,
+        virtual std::variant<TThreadCounts, ui64> GetThreads(ui64 globalThreads) = 0;
+    };
+    
+    template <typename TRealQueue, typename TQueueAdaptor>
+    struct TTestCases {
+        
+        template <typename TStatsCollector>
+        class TBasicPushPopSingleThread : public IBenchCase<TStatsCollector> {
+        public:
+            TStatsCollector Run() override {
+                TRealQueue realQueue;
+                TQueueAdaptor adapter(&realQueue);
+                TStatsCollector collector;
+                TSimpleWorker<decltype(adapter)> worker(
+                    &adapter,
                     {
                         TWorkerAction{.Action=EWorkerAction::Push, .Expected=EExpectedStatus::Success, .Value=1},
+                        TWorkerAction{.Action=EWorkerAction::Push, .Expected=EExpectedStatus::Success, .Value=2},
                         TWorkerAction{.Action=EWorkerAction::Pop, .Expected=EExpectedStatus::Success, .Value=1},
-                    },
-                    RepeatCount
+                        TWorkerAction{.Action=EWorkerAction::Pop, .Expected=EExpectedStatus::Success, .Value=2},
+                    }
                 );
-                threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                RunThreads(std::make_unique<TTestThread<decltype(worker), TStatsCollector>>(worker, &collector));
+                return std::move(collector);
             }
-            RunThreads(threads);
-            return std::move(collector);
-        }
 
+            TThreadCounts GetThreads(ui64) override {
+                return {1, 1};
+            }
+        };
+
+        template <typename TStatsCollector, ui32 ThreadCount, ui32 RepeatCount>
+        class TBasicPushPopMultiThreads : public IBenchCase<TStatsCollector> {
+        public:
+            TStatsCollector Run() override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                for (ui32 threadIdx = 0; threadIdx < ThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    TSimpleWorker<std::decay_t<decltype(*adapter)>> worker(
+                        adapter,
+                        {
+                            TWorkerAction{.Action=EWorkerAction::Push, .Expected=EExpectedStatus::Success, .Value=1},
+                            TWorkerAction{.Action=EWorkerAction::Pop, .Expected=EExpectedStatus::Success, .Value=1},
+                        },
+                        RepeatCount
+                    );
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
+
+            TThreadCounts GetThreads(ui64) override {
+                return {ThreadCount, ThreadCount};
+            }
+        };
+        
         template <typename TStatsCollector, ui32 ThreadCount>
-        static TStatsCollector BasicProducing() {
-            TRealQueue realQueue;
-            TVector<std::unique_ptr<IQueue>> adapters;
-            TVector<std::unique_ptr<ISimpleThread>> threads;
-            TStatsCollector collector;
-            for (ui32 threadIdx = 0; threadIdx < ThreadCount; ++threadIdx) {
-                TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
-                adapters.emplace_back(adapter);
-                TProducerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, {});
-                threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
-            }
-            RunThreads(threads);
-            return std::move(collector);
-        }
+        class TBasicProducing : public IBenchCase<TStatsCollector> {
+        public:
+            TStatsCollector Run() override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                for (ui32 threadIdx = 0; threadIdx < ThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    TProducerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, {});
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
 
+            TThreadCounts GetThreads(ui64) override {
+                return {ThreadCount, 0};
+            }
+        };
+        
         template <typename TStatsCollector, ui32 ThreadCount, ui32 Reads>
-        static TStatsCollector ConsumingEmptyQueue() {
-            TRealQueue realQueue;
-            TVector<std::unique_ptr<IQueue>> adapters;
-            TVector<std::unique_ptr<ISimpleThread>> threads;
-            TStatsCollector collector;
-            for (ui32 threadIdx = 0; threadIdx < ThreadCount; ++threadIdx) {
-                TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
-                adapters.emplace_back(adapter);
-                TConsumerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, Reads, true);
-                threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
-            }
-            RunThreads(threads);
-            return std::move(collector);
-        }
+        class TConsumingEmptyQueue : public IBenchCase<TStatsCollector> {
+        public:
+            TStatsCollector Run() override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                for (ui32 threadIdx = 0; threadIdx < ThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    TConsumerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, Reads, true);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
+
+            TThreadCounts GetThreads(ui64) override {
+                return {0, ThreadCount};
+            }
+        };
 
         template <typename TStatsCollector, ui32 ProducingThreadCount, ui32 ConsumingThreadCount, ui32 PushedItems, ui32 PoppedItems>
-        static TStatsCollector BasicProducingConsuming() {
-            TRealQueue realQueue;
-            TVector<std::unique_ptr<IQueue>> adapters;
-            TVector<std::unique_ptr<ISimpleThread>> threads;
-            TStatsCollector collector;
-            for (ui32 threadIdx = 0; threadIdx < ProducingThreadCount; ++threadIdx) {
-                TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
-                adapters.emplace_back(adapter);
-                TProducerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, PushedItems);
-                threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
-            }
-            collector.ConsumerInfo.resize(ConsumingThreadCount);
-            for (ui32 threadIdx = 0; threadIdx < ConsumingThreadCount; ++threadIdx) {
-                TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
-                adapters.emplace_back(adapter);
-                TConsumerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, PoppedItems, false, &collector.ConsumerInfo[threadIdx]);
-                threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
-            }
-            RunThreads(threads);
-            return std::move(collector);
-        }
+        class TBasicProducingConsuming : public IBenchCase<TStatsCollector> {
+        public:
+            TStatsCollector Run() override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                for (ui32 threadIdx = 0; threadIdx < ProducingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    TProducerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, PushedItems);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                collector.ConsumerInfo.resize(ConsumingThreadCount);
+                for (ui32 threadIdx = 0; threadIdx < ConsumingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    TConsumerWorker<std::decay_t<decltype(*adapter)>> worker(adapter, PoppedItems, false, &collector.ConsumerInfo[threadIdx]);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
+
+            TThreadCounts GetThreads(ui64) override {
+                return {ProducingThreadCount, ConsumingThreadCount};
+            }
+        };
+    };
+
+        
+    template <typename TRealQueue, typename TQueueAdaptor>
+    struct TBenchCasesWithDurationAndThreads {
+
+        template <typename TStatsCollector, bool Sleep>
+        class TBasicPushPop : public IBenchCaseWithDurationAndThreads<TStatsCollector> {
+            TStatsCollector Run(TDuration duration, ui64 threadCount) override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                for (ui32 threadIdx = 0; threadIdx < threadCount; ++threadIdx) {
+                    TQueueAdaptor* adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    auto action = [queue = adapter] () -> bool {
+                        while (!queue->TryPush(727)) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        while (!queue->TryPop()) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        return true;
+                    };
+                    TWorkerWithDuration<std::decay_t<decltype(action)>> worker(action, duration);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
+
+            std::variant<TThreadCounts, ui64> GetThreads(ui64 globalThreads) override {
+                return globalThreads;
+            }
+        };
+
+        template <typename TStatsCollector, ui64 Producers, ui64 Consumers, bool Sleep>
+        class TBasicProducingConsuming : public IBenchCaseWithDurationAndThreads<TStatsCollector> {
+            TStatsCollector Run(TDuration duration, ui64 threadCount) override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                ui64 producingThreadCount = Producers * (threadCount / (Producers + Consumers));
+                ui64 consumingThreadCount = Consumers * (threadCount / (Producers + Consumers));
+                for (ui32 threadIdx = 0; threadIdx < producingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    auto action = [queue = adapter] () -> bool {
+                        if (!queue->TryPush(727)) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        return true;
+                    };
+                    TWorkerWithDuration<std::decay_t<decltype(action)>> worker(action, duration);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                for (ui32 threadIdx = 0; threadIdx < consumingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    auto action = [queue = adapter] () -> bool {
+                        if (!queue->TryPop()) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        return true;
+                    };
+                    TWorkerWithDuration<std::decay_t<decltype(action)>> worker(action, duration);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
+
+            TString Validate(ui64 globalThreads) override {
+                if (globalThreads % (Producers + Consumers)) {
+                    return TStringBuilder() << "A number divisible by " << Producers + Consumers << " was expected instead of " << globalThreads;
+                }
+                return "";
+            }
+
+            std::variant<TThreadCounts, ui64> GetThreads(ui64 globalThreads) override {
+                ui64 producingThreadCount = Producers * (globalThreads / (Producers + Consumers));
+                ui64 consumingThreadCount = Consumers * (globalThreads / (Producers + Consumers));
+                return TThreadCounts{producingThreadCount, consumingThreadCount};
+            }
+        };
+
+        template <typename TStatsCollector, bool Sleep>
+        class TSingleProducer: public IBenchCaseWithDurationAndThreads<TStatsCollector> {
+            TStatsCollector Run(TDuration duration, ui64 threadCount) override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                ui64 producingThreadCount = 1;
+                ui64 consumingThreadCount = threadCount - 1;
+                for (ui32 threadIdx = 0; threadIdx < producingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    auto action = [queue = adapter] () -> bool {
+                        if (!queue->TryPush(727)) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        return true;
+                    };
+                    TWorkerWithDuration<std::decay_t<decltype(action)>> worker(action, duration);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                for (ui32 threadIdx = 0; threadIdx < consumingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    auto action = [queue = adapter] () -> bool {
+                        if (!queue->TryPop()) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        return true;
+                    };
+                    TWorkerWithDuration<std::decay_t<decltype(action)>> worker(action, duration);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
+
+            TString Validate(ui64 globalThreads) override {
+                if (globalThreads < 2) {
+                    return TStringBuilder() << "A number greater than 1 was expected instead of " << globalThreads;
+                }
+                return "";
+            }
+
+            std::variant<TThreadCounts, ui64> GetThreads(ui64 globalThreads) override {
+                return TThreadCounts{1, globalThreads - 1};
+            }
+        };
+
+        template <typename TStatsCollector, bool Sleep>
+        class TSingleConsumer: public IBenchCaseWithDurationAndThreads<TStatsCollector> {
+            TStatsCollector Run(TDuration duration, ui64 threadCount) override {
+                TRealQueue realQueue;
+                TVector<std::unique_ptr<IQueue>> adapters;
+                TVector<std::unique_ptr<ISimpleThread>> threads;
+                TStatsCollector collector;
+                ui64 producingThreadCount = threadCount - 1;
+                ui64 consumingThreadCount = 1;
+                for (ui32 threadIdx = 0; threadIdx < producingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    auto action = [queue = adapter] () -> bool {
+                        if (!queue->TryPush(727)) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        return true;
+                    };
+                    TWorkerWithDuration<std::decay_t<decltype(action)>> worker(action, duration);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                for (ui32 threadIdx = 0; threadIdx < consumingThreadCount; ++threadIdx) {
+                    TQueueAdaptor *adapter = new TQueueAdaptor(&realQueue);
+                    adapters.emplace_back(adapter);
+                    auto action = [queue = adapter] () -> bool {
+                        if (!queue->TryPop()) {
+                            if constexpr (Sleep) {
+                                NanoSleep(1'000);
+                            } else {
+                                SpinLockPause();
+                            }
+                        }
+                        return true;
+                    };
+                    TWorkerWithDuration<std::decay_t<decltype(action)>> worker(action, duration);
+                    threads.emplace_back(new TTestThread<decltype(worker), TStatsCollector>(worker, &collector));
+                }
+                RunThreads(threads);
+                return std::move(collector);
+            }
+
+            TString Validate(ui64 globalThreads) override {
+                if (globalThreads < 2) {
+                    return TStringBuilder() << "A number greater than 1 was expected instead of " << globalThreads;
+                }
+                return "";
+            }
+
+            std::variant<TThreadCounts, ui64> GetThreads(ui64 globalThreads) override {
+                return TThreadCounts{globalThreads - 1, 1};
+            }
+        };
 
     };
 
diff --git a/ydb/library/actors/queues/bench/main.cpp b/ydb/library/actors/queues/bench/main.cpp
index 11e543dbd15f..d05e5c4dfa24 100644
--- a/ydb/library/actors/queues/bench/main.cpp
+++ b/ydb/library/actors/queues/bench/main.cpp
@@ -1,5 +1,8 @@
 #include "queue.h"
 #include "worker.h"
+#include "bench_cases.h"
+#include "queue_tracer.h"
+#include "probes.h"
 
 #include <library/cpp/lwtrace/mon/mon_lwtrace.h>
 #include <library/cpp/getopt/last_getopt.h>
@@ -13,28 +16,167 @@
 #include <util/system/datetime.h>
 
 
+using TMonSrvc = NMonitoring::TMonService2;
+using namespace NActors;
+using namespace NActors::NQueueBench;
+
+void InitMonService(THolder<TMonSrvc>& monSrvc, int monPort)
+{
+    monSrvc.Reset(new TMonSrvc(monPort));
+    NLwTraceMonPage::RegisterPages(monSrvc->GetRoot());
+    NLwTraceMonPage::ProbeRegistry().AddProbesList(LWTRACE_GET_PROBES(BENCH_TRACING_PROVIDER));
+}
+
+using TTracer = NTracing::TMPMCRingQueueBadPathTracer;
+template <ui32 SIZE_BITS>
+using TCasesWithTracer = TBenchCasesWithDurationAndThreads<TMPMCRingQueue<SIZE_BITS, TTracer>, TAdaptiveQueue<SIZE_BITS, TTracer>>;
+using ICaseWithCollector = IBenchCaseWithDurationAndThreads<NTracing::TStatsCollector>;
+
+
+
+using TDegradator = NTracing::TMPMCRingQueueDegradatorAndTracer<1024, 1, 60'000'000>;
+
+template <>
+thread_local ui64 TDegradator::TDegradator::SkipSteps = 0;
+template <>
+std::atomic_uint64_t TDegradator::TDegradator::InFlight = 0;
+    
+template <ui32 SIZE_BITS>
+using TCasesWithDegradator = TBenchCasesWithDurationAndThreads<TMPMCRingQueue<SIZE_BITS, TTracer>, TAdaptiveQueue<SIZE_BITS, TTracer>>;
+
+
+THashMap<TString,ICaseWithCollector*> Tests {
+    {"Basic", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicPushPop<NTracing::TStatsCollector, false>)},
+    {"Producer1Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 1, false>)},
+    {"Producer1Consumer2", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 2, false>)},
+    {"Producer2Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 2, 1, false>)},
+    {"SingleProducer", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TSingleProducer<NTracing::TStatsCollector, false>)},
+    {"SingleConsumer", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TSingleConsumer<NTracing::TStatsCollector, false>)},
+};
+
+THashMap<TString,ICaseWithCollector*> TestsWithSleep1Us {
+    {"Basic", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicPushPop<NTracing::TStatsCollector, true>)},
+    {"Producer1Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 1, true>)},
+    {"Producer1Consumer2", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 2, true>)},
+    {"Producer2Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 2, 1, true>)},
+    {"SingleProducer", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TSingleProducer<NTracing::TStatsCollector, true>)},
+    {"SingleConsumer", static_cast<ICaseWithCollector*>(new TCasesWithTracer<20>::TSingleConsumer<NTracing::TStatsCollector, true>)},
+};
+
+THashMap<TString,ICaseWithCollector*> TestsWithBlockedThread {
+    {"Basic", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicPushPop<NTracing::TStatsCollector, false>)},
+    {"Producer1Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 1, false>)},
+    {"Producer1Consumer2", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 2, false>)},
+    {"Producer2Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 2, 1, false>)},
+    {"SingleProducer", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TSingleProducer<NTracing::TStatsCollector, false>)},
+    {"SingleConsumer", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TSingleConsumer<NTracing::TStatsCollector, false>)},
+};
+
+THashMap<TString,ICaseWithCollector*> TestsWithSleep1UsAndBlockedThread {
+    {"Basic", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicPushPop<NTracing::TStatsCollector, true>)},
+    {"Producer1Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 1, true>)},
+    {"Producer1Consumer2", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 1, 2, true>)},
+    {"Producer2Consumer1", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TBasicProducingConsuming<NTracing::TStatsCollector, 2, 1, true>)},
+    {"SingleProducer", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TSingleProducer<NTracing::TStatsCollector, true>)},
+    {"SingleConsumer", static_cast<ICaseWithCollector*>(new TCasesWithDegradator<20>::TSingleConsumer<NTracing::TStatsCollector, true>)},
+};
+
+
 int main(int argc, char* argv[]) {
     //NLWTrace::StartLwtraceFromEnv();
     //signal(SIGPIPE, SIG_IGN);
-    TString configPath;
+    TString testName;
+    int testDurationS = 600;
     int monPort = 7777;
-    int lwtraceThreadLogSize = 60000;
-    bool disableLWTrace = false;
+    int lwtraceThreadLogSize = 1'000'000;
+    int threadCount = 2;
+    bool shortOutput = false;
+    bool sleep1us = false;
+    bool blockThread = false;
 
     NLastGetopt::TOpts opts = NLastGetopt::TOpts::Default();
     opts.AddLongOption(0, "mon-port", "port of monitoring service")
         .RequiredArgument("port")
         .StoreResult(&monPort, monPort);
-    opts.AddLongOption('f', "file", "filepath to config")
+    opts.AddLongOption('n', "name", "test name")
         .Required()
-        .RequiredArgument("file")
-        .StoreResult(&configPath, configPath);
+        .RequiredArgument("testname")
+        .StoreResult(&testName, testName);
+    opts.AddLongOption('d', "duration", "test duration")
+        .RequiredArgument("seconds")
+        .StoreResult(&testDurationS, testDurationS);
+    opts.AddLongOption('t', "threads", "threads in the test")
+        .RequiredArgument("thread-count")
+        .StoreResult(&threadCount, threadCount);
     opts.AddLongOption("lwtrace-thread-log-size", "thread log size")
         .RequiredArgument("size")
         .StoreResult(&lwtraceThreadLogSize, lwtraceThreadLogSize);
-    opts.AddLongOption('L', "disable-lwtrace", "disable lwtrace")
+    opts.AddLongOption("short-output", "reduce output")
+        .NoArgument()
+        .SetFlag(&shortOutput);
+    opts.AddLongOption("sleep1us", "sleep 1us instead of spin-lock-pause")
+        .NoArgument()
+        .SetFlag(&sleep1us);
+    opts.AddLongOption("block-thread", "every time one thread will sleep 1 minute")
         .NoArgument()
-        .SetFlag(&disableLWTrace);
+        .SetFlag(&blockThread);
     NLastGetopt::TOptsParseResult res(&opts, argc, argv);
 
+    THolder<TMonSrvc> monSrvc;
+    InitMonService(monSrvc, monPort);
+    monSrvc->Start();
+    NLWTrace::TManager* traceMngr = &NLwTraceMonPage::TraceManager();
+
+    // init query lwtrace
+    auto query = NLWTrace::TQuery();
+    query.SetPerThreadLogSize(lwtraceThreadLogSize); // s -> ms
+    auto& block = *query.AddBlocks();
+    auto& probeDesc = *block.MutableProbeDesc();
+    probeDesc.SetGroup("BenchTracing");
+    auto action = block.AddAction();
+    action->MutableLogAction();
+
+    // init query threadpools stats
+    auto queueStats = NLWTrace::TQuery();
+    {
+        queueStats.SetPerThreadLogSize(lwtraceThreadLogSize);
+        auto& block = *queueStats.AddBlocks();
+        auto& probeDesc = *block.MutableProbeDesc();
+        probeDesc.SetGroup("ThreadPoolStats");
+        auto action = block.AddAction();
+        action->MutableLogAction();
+    }
+
+    auto *tests = &Tests;
+    if (blockThread && sleep1us) {
+        tests = &TestsWithSleep1UsAndBlockedThread;
+    } else if (blockThread) {
+        tests = &TestsWithBlockedThread;
+    } else if (sleep1us) {
+        tests = &TestsWithSleep1Us;
+    }
+
+    auto it = tests->find(testName);
+    if (it == tests->end()) {
+        Cerr << "Unknown test\n";
+        return 1;
+    }
+    TString error = it->second->Validate(threadCount);
+    if (error) {
+        Cerr << "Error: " << error << Endl;
+        return 1;
+    }
+
+    traceMngr->New(testName, query);
+    auto stats = it->second->Run(TDuration::Seconds(testDurationS), threadCount);
+    traceMngr->Stop(testName);
+    auto threads = it->second->GetThreads(threadCount);
+    std::visit([&](auto threads) {
+        if constexpr (std::is_same_v<ui64, std::decay_t<decltype(threads)>>) {
+            stats.Print(testDurationS, threads, shortOutput);
+        } else {
+            stats.Print(testDurationS, threads.ProducerThreads, threads.ConsumerThreads, shortOutput);
+        }
+    }, threads);
+    return 0;
 }
\ No newline at end of file
diff --git a/ydb/library/actors/queues/bench/probes.cpp b/ydb/library/actors/queues/bench/probes.cpp
new file mode 100644
index 000000000000..13e24ca8fd16
--- /dev/null
+++ b/ydb/library/actors/queues/bench/probes.cpp
@@ -0,0 +1,6 @@
+#include "probes.h"
+
+
+#include <util/string/builder.h>
+
+LWTRACE_DEFINE_PROVIDER(BENCH_TRACING_PROVIDER);
diff --git a/ydb/library/actors/queues/bench/probes.h b/ydb/library/actors/queues/bench/probes.h
new file mode 100644
index 000000000000..895c299fca7d
--- /dev/null
+++ b/ydb/library/actors/queues/bench/probes.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <library/cpp/lwtrace/all.h>
+#include <util/generic/vector.h>
+
+
+#define BENCH_TRACING_PROVIDER(PROBE, EVENT, GROUPS, TYPES, NAMES) \
+    PROBE(FoundOldSlot, GROUPS("BenchTracing"),                    \
+          TYPES(TString),                                          \
+          NAMES("method"))                                         \
+    PROBE(FailedOperation, GROUPS("BenchTracing"),                 \
+          TYPES(TString),                                          \
+          NAMES("method"))                                         \
+    PROBE(LongOperation, GROUPS("BenchTracing"),                   \
+          TYPES(TString),                                          \
+          NAMES("method"))                                         \
+// BENCH_TRACING_PROVIDER
+
+LWTRACE_DECLARE_PROVIDER(BENCH_TRACING_PROVIDER)
diff --git a/ydb/library/actors/queues/bench/queue.h b/ydb/library/actors/queues/bench/queue.h
index afc6ead6af98..d8fb2f34d93f 100644
--- a/ydb/library/actors/queues/bench/queue.h
+++ b/ydb/library/actors/queues/bench/queue.h
@@ -3,6 +3,7 @@
 #include "defs.h"
 
 #include <ydb/library/actors/queues/mpmc_ring_queue.h>
+#include <ydb/library/actors/queues/observer/observer.h>
 
 
 namespace NActors::NQueueBench {
@@ -13,16 +14,16 @@ namespace NActors::NQueueBench {
         virtual std::optional<ui32> TryPop() = 0;
     };
 
-    template <ui32 SizeBits>
-    using TTryPush = bool (TMPMCRingQueue<SizeBits>::*)(ui32 value);
-    template <ui32 SizeBits>
-    using TTryPop = std::optional<ui32> (TMPMCRingQueue<SizeBits>::*)();
+    template <ui32 SizeBits, typename TObserver>
+    using TTryPush = bool (TMPMCRingQueue<SizeBits, TObserver>::*)(ui32 value);
+    template <ui32 SizeBits, typename TObserver>
+    using TTryPop = std::optional<ui32> (TMPMCRingQueue<SizeBits, TObserver>::*)();
 
-    template <ui32 SizeBits, TTryPush<SizeBits> TryPushMethod, TTryPop<SizeBits> TryPopMethod>
+    template <ui32 SizeBits, typename TObserver, TTryPush<SizeBits, TObserver> TryPushMethod, TTryPop<SizeBits, TObserver> TryPopMethod>
     struct TMPMCQueueBase : IQueue {
-        TMPMCRingQueue<SizeBits> *Queue;
+        TMPMCRingQueue<SizeBits, TObserver> *Queue;
 
-        TMPMCQueueBase(TMPMCRingQueue<SizeBits> *queue)
+        TMPMCQueueBase(TMPMCRingQueue<SizeBits, TObserver> *queue)
             : Queue(queue)
         {}
 
@@ -34,27 +35,27 @@ namespace NActors::NQueueBench {
         }
     };
 
-    template <ui32 SizeBits>
-    using TVerySlowQueue = TMPMCQueueBase<SizeBits, &TMPMCRingQueue<SizeBits>::TryPushSlow, &TMPMCRingQueue<SizeBits>::TryPopReallySlow>;
+    template <ui32 SizeBits, typename TObserver=void>
+    using TVerySlowQueue = TMPMCQueueBase<SizeBits, TObserver, &TMPMCRingQueue<SizeBits, TObserver>::TryPushSlow, &TMPMCRingQueue<SizeBits, TObserver>::TryPopReallySlow>;
 
-    template <ui32 SizeBits>
-    using TSlowQueue = TMPMCQueueBase<SizeBits, &TMPMCRingQueue<SizeBits>::TryPushSlow, &TMPMCRingQueue<SizeBits>::TryPopSlow>;
+    template <ui32 SizeBits, typename TObserver=void>
+    using TSlowQueue = TMPMCQueueBase<SizeBits, TObserver, &TMPMCRingQueue<SizeBits, TObserver>::TryPushSlow, &TMPMCRingQueue<SizeBits, TObserver>::TryPopSlow>;
 
-    template <ui32 SizeBits>
-    using TFastQueue = TMPMCQueueBase<SizeBits, &TMPMCRingQueue<SizeBits>::TryPush, &TMPMCRingQueue<SizeBits>::TryPopFast>;
+    template <ui32 SizeBits, typename TObserver=void>
+    using TFastQueue = TMPMCQueueBase<SizeBits, TObserver, &TMPMCRingQueue<SizeBits, TObserver>::TryPush, &TMPMCRingQueue<SizeBits, TObserver>::TryPopFast>;
 
-    template <ui32 SizeBits>
-    using TVeryFastQueue = TMPMCQueueBase<SizeBits, &TMPMCRingQueue<SizeBits>::TryPush, &TMPMCRingQueue<SizeBits>::TryPopReallyFast>;
+    template <ui32 SizeBits, typename TObserver=void>
+    using TVeryFastQueue = TMPMCQueueBase<SizeBits, TObserver, &TMPMCRingQueue<SizeBits, TObserver>::TryPush, &TMPMCRingQueue<SizeBits, TObserver>::TryPopReallyFast>;
 
-    template <ui32 SizeBits>
-    using TSingleQueue = TMPMCQueueBase<SizeBits, &TMPMCRingQueue<SizeBits>::TryPush, &TMPMCRingQueue<SizeBits>::TryPopSingleConsumer>;
+    template <ui32 SizeBits, typename TObserver=void>
+    using TSingleQueue = TMPMCQueueBase<SizeBits, TObserver, &TMPMCRingQueue<SizeBits, TObserver>::TryPush, &TMPMCRingQueue<SizeBits, TObserver>::TryPopSingleConsumer>;
 
-    template <ui32 SizeBits>
+    template <ui32 SizeBits, typename TObserver=void>
     struct TAdaptiveQueue : IQueue {
-        TMPMCRingQueue<SizeBits> *Queue;
-        typename TMPMCRingQueue<SizeBits>::EPopMode State = TMPMCRingQueue<SizeBits>::EPopMode::ReallySlow;
+        TMPMCRingQueue<SizeBits, TObserver> *Queue;
+        typename TMPMCRingQueue<SizeBits, TObserver>::EPopMode State = TMPMCRingQueue<SizeBits, TObserver>::EPopMode::ReallySlow;
 
-        TAdaptiveQueue(TMPMCRingQueue<SizeBits> *queue)
+        TAdaptiveQueue(TMPMCRingQueue<SizeBits, TObserver> *queue)
             : Queue(queue)
         {}
 
@@ -67,4 +68,14 @@ namespace NActors::NQueueBench {
     };
 
 
+    template <ui32 SizeBits>
+    using TMPMCRingQueueWithStats = TMPMCRingQueue<SizeBits, TStatsObserver>;
+
+    template <template <ui32, typename> typename TAdaptor>
+    struct TAdaptorWithStats {
+        template <ui32 SizeBits>
+        using Type = TAdaptor<SizeBits, TStatsObserver>;
+    };
+
+
 }
\ No newline at end of file
diff --git a/ydb/library/actors/queues/bench/queue_tracer.cpp b/ydb/library/actors/queues/bench/queue_tracer.cpp
new file mode 100644
index 000000000000..756830764f82
--- /dev/null
+++ b/ydb/library/actors/queues/bench/queue_tracer.cpp
@@ -0,0 +1,112 @@
+#include "queue_tracer.h"
+
+
+namespace NActors::NQueueBench::NTracing {
+
+
+    void TStatsCollector::AddStats(const NActors::TStatsObserver::TStats &stats) {
+        TGuard<TMutex> guard(Mutex);
+        Stats += stats;
+    }
+
+    TString TStatsCollector::PrettyInt(ui64 value) {
+        std::initializer_list<std::pair<char, ui64>> measures = {
+            {'E', 1'000'000'000'000'000'000},
+            {'P', 1'000'000'000'000'000},
+            {'T', 1'000'000'000'000},
+            {'G', 1'000'000'000},
+            {'M', 1'000'000},
+            {'k', 1'000},
+        };
+        for (auto &[prefix, val] : measures) {
+            if (value >= val) {
+                ui64 f = value / val;
+                ui64 s = value % val / (val / 100);
+                if (s) {
+                    return TStringBuilder() << f << '.' << s << prefix;
+                } else {
+                    return TStringBuilder() << f << prefix;
+                }
+            }
+        }
+        return ToString(value);
+    }
+
+    TString TStatsCollector::PrettyDivision(ui64 value, ui64 divider) {
+        if (!value) {
+            return "0";
+        }
+        if (!divider) {
+            return "inf";
+        }
+        if (100 * divider > value) {
+            return ToString(double(value) / divider);
+        }
+        return PrettyInt(value / divider);
+    }
+
+    TString TStatsCollector::Pretty(ui64 stat, ui64 seconds, ui64  threads) {
+        TStringBuilder pretty;
+        pretty << PrettyInt(stat);
+        if (seconds) {
+            pretty << " (" << PrettyDivision(stat, seconds) << " per second)";
+        }
+        if (threads) {
+            pretty << " (" << PrettyDivision(stat, threads) << " per thread)";
+        }
+        if (seconds && threads) {
+            pretty << " (" << PrettyDivision(stat, seconds * threads) << " per thread per second)";
+        }
+        return pretty;
+    }
+
+    void TStatsCollector::GeneralPrint(ui64 seconds, ui64 producerThreads, ui64 consumerThreads, bool shortOutput) const {
+
+#define IF_ALLOWED(value) \
+    if (!shortOutput || value) \
+// IF_ALLOWED
+#define PRINT_STAT(STAT_NAME, TAB, THREAD_COUNT) \
+    IF_ALLOWED(Stats. STAT_NAME) Cerr << TAB << #STAT_NAME ": " << Pretty(Stats. STAT_NAME, seconds, THREAD_COUNT) << Endl; \
+// PRINT_STAT
+        PRINT_STAT(FoundOldSlotInFastPush, "", producerThreads);
+        PRINT_STAT(FoundOldSlotInSlowPush, "", producerThreads);
+        PRINT_STAT(FoundOldSlotInSlowPop, "", consumerThreads);
+        PRINT_STAT(FoundOldSlotInFastPop, "", consumerThreads);
+        PRINT_STAT(FoundOldSlotInReallyFastPop, "", consumerThreads);
+        PRINT_STAT(FailedPush, "", producerThreads);
+
+        PRINT_STAT(SuccessPush, "", producerThreads);
+        PRINT_STAT(SuccessFastPush, "  ", producerThreads);
+        PRINT_STAT(SuccessSlowPush, "  ", producerThreads);
+        PRINT_STAT(SuccessPop, "", consumerThreads);
+        PRINT_STAT(SuccessReallyFastPop, "  ", consumerThreads);
+        PRINT_STAT(SuccessFastPop, "  ", consumerThreads);
+        PRINT_STAT(SuccessSlowPop, "  ", consumerThreads);
+#undef PRINT_STAT
+
+#define PRINT_LONG(STAT_PREFIX, THREAD_COUNT) \
+    IF_ALLOWED(Stats. STAT_PREFIX ## 10It + Stats. STAT_PREFIX ## 100It + Stats. STAT_PREFIX ## 100It)  Cerr << #STAT_PREFIX << ": " << Endl; \
+    IF_ALLOWED(Stats. STAT_PREFIX ## 10It) Cerr << "  10It: " << Pretty(Stats. STAT_PREFIX ## 10It - Stats. STAT_PREFIX ## 100It - Stats. STAT_PREFIX ## 1000It, seconds, THREAD_COUNT) << Endl; \
+    IF_ALLOWED(Stats. STAT_PREFIX ## 100It) Cerr << "  100It: " << Pretty(Stats. STAT_PREFIX ## 100It - Stats. STAT_PREFIX ## 1000It, seconds, THREAD_COUNT) << Endl; \
+    IF_ALLOWED(Stats. STAT_PREFIX ## 1000It) Cerr << "  1000It: " << Pretty(Stats. STAT_PREFIX ## 1000It, seconds, THREAD_COUNT) << Endl; \
+// PRINT_LONG
+        PRINT_LONG(LongPush, producerThreads);
+        PRINT_LONG(LongSlowPop, consumerThreads);
+        PRINT_LONG(LongFastPop, consumerThreads);
+        PRINT_LONG(LongReallyFastPop, consumerThreads);
+#undef PRINT_LONG
+    }
+
+    void TStatsCollector::Print(ui64 seconds, ui64 producerThreads, ui64 consumerThreads, bool shortOutput) const {
+        Cerr << "DurationInSeconds: " << seconds << Endl;
+        Cerr << "ProducerThreads: " << producerThreads << Endl;
+        Cerr << "ConsumerThreads: " << consumerThreads << Endl;
+        GeneralPrint(seconds, producerThreads, consumerThreads, shortOutput);
+    }
+
+    void TStatsCollector::Print(ui64 seconds, ui64 threads, bool shortOutput) const {
+        Cerr << "DurationInSeconds: " << seconds << Endl;
+        Cerr << "Threads: " << threads << Endl;
+        GeneralPrint(seconds, threads, threads, shortOutput);
+    }
+}
diff --git a/ydb/library/actors/queues/bench/queue_tracer.h b/ydb/library/actors/queues/bench/queue_tracer.h
new file mode 100644
index 000000000000..a5c4b6534e30
--- /dev/null
+++ b/ydb/library/actors/queues/bench/queue_tracer.h
@@ -0,0 +1,119 @@
+#pragma once
+
+#include "defs.h"
+#include "probes.h"
+
+#include <ydb/library/actors/queues/observer/observer.h>
+
+
+namespace NActors::NQueueBench::NTracing {
+
+    LWTRACE_USING(BENCH_TRACING_PROVIDER);
+
+    struct TMPMCRingQueueBadPathTracer {
+
+        using TStats = TStatsObserver::TStats;
+
+#define LWPROBE_PROXY_STATIC_METHOD(STAT_NAME, PROBE, ...)    \
+    static void Observe ## STAT_NAME () {                     \
+        LWPROBE(PROBE, __VA_ARGS__);                          \
+        TStatsObserver::Observe ## STAT_NAME (); \
+    }                                                         \
+// LWPROBE_PROXY_STATIC_METHOD
+        LWPROBE_PROXY_STATIC_METHOD(FoundOldSlotInFastPush, FoundOldSlot, "FastPush");
+        LWPROBE_PROXY_STATIC_METHOD(FoundOldSlotInSlowPush, FoundOldSlot, "SlowPush");
+        LWPROBE_PROXY_STATIC_METHOD(FoundOldSlotInSlowPop, FoundOldSlot, "SlowPop");
+        LWPROBE_PROXY_STATIC_METHOD(FoundOldSlotInFastPop, FoundOldSlot, "FastPop");
+        LWPROBE_PROXY_STATIC_METHOD(FoundOldSlotInReallyFastPop, FoundOldSlot, "ReallyFastPop");
+
+        LWPROBE_PROXY_STATIC_METHOD(FailedPush, FailedOperation, "SlowPush");
+
+        LWPROBE_PROXY_STATIC_METHOD(LongPush10It, LongOperation, "Push10It");
+        LWPROBE_PROXY_STATIC_METHOD(LongSlowPop10It, LongOperation, "SlowPop10It");
+        LWPROBE_PROXY_STATIC_METHOD(LongFastPop10It, LongOperation, "FastPop10It");
+        LWPROBE_PROXY_STATIC_METHOD(LongReallyFastPop10It, LongOperation, "ReallyFastPop10It");
+
+        LWPROBE_PROXY_STATIC_METHOD(LongPush100It, LongOperation, "LongPush100It");
+        LWPROBE_PROXY_STATIC_METHOD(LongSlowPop100It, LongOperation, "LongSlowPop100It");
+        LWPROBE_PROXY_STATIC_METHOD(LongFastPop100It, LongOperation, "LongFastPop100It");
+        LWPROBE_PROXY_STATIC_METHOD(LongReallyFastPop100It, LongOperation, "LongReallyFastPop100It");
+
+        LWPROBE_PROXY_STATIC_METHOD(LongPush1000It, LongOperation, "LongPush1000It");
+        LWPROBE_PROXY_STATIC_METHOD(LongSlowPop1000It, LongOperation, "LongSlowPop1000It");
+        LWPROBE_PROXY_STATIC_METHOD(LongFastPop1000It, LongOperation, "LongFastPop1000It");
+        LWPROBE_PROXY_STATIC_METHOD(LongReallyFastPop1000It, LongOperation, "LongReallyFastPop1000It");
+#undef LWPROBE_PROXY_STATIC_METHOD
+
+#define DEFAULT_OBSERVER_PROXY_STATIC_METHOD(STAT_NAME)       \
+    static void Observe ## STAT_NAME () {                     \
+        TStatsObserver::Observe ## STAT_NAME (); \
+    }                                                         \
+// DEFAULT_OBSERVER_PROXY_STATIC_METHOD
+        DEFAULT_OBSERVER_PROXY_STATIC_METHOD(SuccessSlowPush);
+        DEFAULT_OBSERVER_PROXY_STATIC_METHOD(SuccessFastPush);
+
+        DEFAULT_OBSERVER_PROXY_STATIC_METHOD(SuccessSlowPop);
+        DEFAULT_OBSERVER_PROXY_STATIC_METHOD(SuccessFastPop);
+        DEFAULT_OBSERVER_PROXY_STATIC_METHOD(SuccessReallyFastPop);
+#undef DEFAULT_OBSERVER_PROXY_STATIC_METHOD
+
+        static TStats GetLocalStats() {
+            return TStatsObserver::GetLocalStats();
+        }
+
+    };
+
+    template <ui64 StepsBeforeAskingToSleep, ui64 MaxInFlight, ui64 SleepUs>
+    struct TMPMCRingQueueDegradator {
+        using TThis = TMPMCRingQueueDegradator<StepsBeforeAskingToSleep, MaxInFlight, SleepUs>;
+
+#define OBSERVER_SLEEPING_STATIC_METHOD(STAT_NAME)                                                                \
+    static void Observe ## STAT_NAME () {                                                                         \
+        if (TThis::InFlight++ == StepsBeforeAskingToSleep) {                                                      \
+            TThis::InFlight = 0;                                                                                  \
+            ui64 inFlight = TThis::InFlight.load(std::memory_order_acquire);                                      \
+            while (inFlight < MaxInFlight) {                                                                      \
+                if (TThis::InFlight.compare_exchange_strong(inFlight, inFlight + 1, std::memory_order_acq_rel)) { \
+                    NanoSleep(SleepUs * 1000);                                                                    \
+                    TThis::InFlight.fetch_sub(1, std::memory_order_relaxed);                                      \
+                    break;                                                                                        \
+                }                                                                                                 \
+            }                                                                                                     \
+        }                                                                                                         \
+    }                                                                                                             \
+// OBSERVER_SLEEPING_STATIC_METHOD
+        OBSERVER_SLEEPING_STATIC_METHOD(AfterReserveSlotInFastPush)
+        OBSERVER_SLEEPING_STATIC_METHOD(AfterReserveSlotInFastPop)
+        OBSERVER_SLEEPING_STATIC_METHOD(AfterReserveSlotInReallyFastPop)
+        OBSERVER_SLEEPING_STATIC_METHOD(AfterIncorectlyChangeSlotGenerationInReallyFastPop)
+#undef OBSERVER_SLEEPING_STATIC_METHOD
+
+        static thread_local ui64 SkipSteps;
+        alignas(64) static std::atomic_uint64_t InFlight;
+    };
+
+    template <ui64 StepsBeforeAskingToSleep, ui64 MaxInFlight, ui64 SleepUs>
+    struct TMPMCRingQueueDegradatorAndTracer
+        : TMPMCRingQueueBadPathTracer
+        , TMPMCRingQueueDegradator<StepsBeforeAskingToSleep, MaxInFlight, SleepUs>
+    {
+        using TDegradator = TMPMCRingQueueDegradator<StepsBeforeAskingToSleep, MaxInFlight, SleepUs>;
+    };
+
+
+    struct TStatsCollector {
+        using TStatsSource = TMPMCRingQueueBadPathTracer;
+
+        TMutex Mutex;
+        NActors::TStatsObserver::TStats Stats;
+
+        void AddStats(const NActors::TStatsObserver::TStats &stats);
+        static TString PrettyInt(ui64 value);
+        static TString PrettyDivision(ui64 value, ui64 divider);
+        static TString Pretty(ui64 stat, ui64 seconds, ui64  threads);
+        void GeneralPrint(ui64 seconds, ui64 producerThreads, ui64 consumerThreads, bool shortOutput) const;
+        void Print(ui64 seconds, ui64 producerThreads, ui64 consumerThreads, bool shortOutput) const;
+        void Print(ui64 seconds, ui64 threads, bool shortOutput) const;
+    };
+
+}
\ No newline at end of file
diff --git a/ydb/library/actors/queues/bench/worker.h b/ydb/library/actors/queues/bench/worker.h
index 13e3a1c7f036..12c09c46f57b 100644
--- a/ydb/library/actors/queues/bench/worker.h
+++ b/ydb/library/actors/queues/bench/worker.h
@@ -190,6 +190,34 @@ namespace NActors::NQueueBench {
         TConsumerInfo *Info;
     };
 
+
+    template <typename TAction>
+    class TWorkerWithDuration {
+    public:
+        TWorkerWithDuration(TAction action, TDuration duration)
+            : Action(action)
+            , Duration(duration)
+            , StartTime()
+        {}
+
+        TThreadAction Do() {
+            if (!StartTime) {
+                StartTime = TInstant::Now();
+            } else if (++Iteration % 1024 == 0 && TInstant::Now() - StartTime > Duration) {
+                return {.Action=EThreadAction::Kill};
+            }
+            if (Action()) {
+                return {.Action=EThreadAction::Continue};
+            }
+            return {.Action=EThreadAction::Kill};
+        }
+
+        TAction Action;
+        TDuration Duration;
+        TInstant StartTime;
+        ui32 Iteration = 0;
+    };
+
     template <typename TWorker, typename TStatsCollector=void>
     class TTestThread : public ISimpleThread {
     public:
@@ -211,7 +239,7 @@ namespace NActors::NQueueBench {
             case EThreadAction::Kill:
                 if constexpr (!std::is_same_v<std::decay_t<TStatsCollector>, void>) {
                     if (StatsCollector) {
-                        auto stats = NActors::TMPMCRingQueueStats::GetLocalStats();
+                        auto stats = TStatsCollector::TStatsSource::GetLocalStats();
                         // Cerr << (TStringBuilder() << "thread: " << (ui64)this << " pushes: " << stats.SuccessPushes.load() << Endl);
                         StatsCollector->AddStats(stats);
                     }
diff --git a/ydb/library/actors/queues/bench/ya.make b/ydb/library/actors/queues/bench/ya.make
index 9f91b6024057..2640475fdede 100644
--- a/ydb/library/actors/queues/bench/ya.make
+++ b/ydb/library/actors/queues/bench/ya.make
@@ -6,12 +6,16 @@ ENDIF()
 
 SRCS(
     main.cpp
+
+    probes.cpp
+    queue_tracer.cpp
 )
 
 PEERDIR(
-    ydb/library/actors/queues
+    ydb/library/actors/queues/observer
     library/cpp/getopt
     library/cpp/lwtrace
+    library/cpp/lwtrace/mon
 )
 
 END()
diff --git a/ydb/library/actors/queues/mpmc_ring_queue.cpp b/ydb/library/actors/queues/mpmc_ring_queue.cpp
deleted file mode 100644
index df186ee66e72..000000000000
--- a/ydb/library/actors/queues/mpmc_ring_queue.cpp
+++ /dev/null
@@ -1,3 +0,0 @@
-#include "mpmc_ring_queue.h"
-
-thread_local NActors::TMPMCRingQueueStats::TStats NActors::TMPMCRingQueueStats::Stats;
diff --git a/ydb/library/actors/queues/mpmc_ring_queue.h b/ydb/library/actors/queues/mpmc_ring_queue.h
index 4ca2241e5eff..9972b2931585 100644
--- a/ydb/library/actors/queues/mpmc_ring_queue.h
+++ b/ydb/library/actors/queues/mpmc_ring_queue.h
@@ -9,142 +9,82 @@
 
 namespace NActors {
 
-struct TMPMCRingQueueStats {
-
-    struct TStats {
-        ui64 SuccessPushes = 0;
-        ui64 SuccessSlowPushes = 0;
-        ui64 SuccessFastPushes = 0;
-
-        ui64 FailedPushes = 0;
-        ui64 FailedSlowPushAttempts = 0;
-
-        ui64 ChangesFastPushToSlowPush = 0;
-        ui64 ChangesReallySlowPopToSlowPop = 0;
-
-        ui64 SuccessPops = 0;
-        ui64 SuccessSingleConsumerPops = 0;
-        ui64 SuccessSlowPops = 0;
-        ui64 SuccessFastPops = 0;
-        ui64 SuccessReallyFastPops = 0;
-
-        ui64 FailedPops = 0;
-        ui64 FailedSingleConsumerPops = 0;
-        ui64 FailedSingleConsumerPopAttempts = 0;
-        ui64 FailedReallySlowPops = 0;
-        ui64 FailedSlowPops = 0;
-        ui64 FailedSlowPopAttempts = 0;
-        ui64 FailedFastPops = 0;
-        ui64 FailedFastPopAttempts = 0;
-        ui64 FailedReallyFastPops = 0;
-        ui64 FailedReallyFastPopAttempts = 0;
-
-
-        ui64 InvalidatedSlots = 0;
-        ui64 InvalidatedSlotsInSlowPop = 0;
-        ui64 InvalidatedSlotsInFastPop = 0;
-        ui64 InvalidatedSlotsInReallyFastPop = 0;
-
-        ui64 MoveTailBecauseHeadOvertakesInReallySlowPop = 0;
-        ui64 MoveTailBecauseHeadOvertakesInFastPop = 0;
-
-        TStats& operator += (const TStats &other) {
-            SuccessPushes += other.SuccessPushes;
-            SuccessSlowPushes += other.SuccessSlowPushes;
-            SuccessFastPushes += other.SuccessFastPushes;
-            ChangesFastPushToSlowPush += other.ChangesFastPushToSlowPush;
-            ChangesReallySlowPopToSlowPop += other.ChangesReallySlowPopToSlowPop;
-            FailedPushes += other.FailedPushes;
-            FailedSlowPushAttempts += other.FailedSlowPushAttempts;
-
-            SuccessPops += other.SuccessPops;
-            SuccessSingleConsumerPops += other.SuccessSingleConsumerPops;
-            SuccessSlowPops += other.SuccessSlowPops;
-            SuccessFastPops += other.SuccessFastPops;
-            SuccessReallyFastPops += other.SuccessReallyFastPops;
-
-            FailedPops += other.FailedPops;
-            FailedSingleConsumerPops += other.FailedSingleConsumerPops;
-            FailedSingleConsumerPopAttempts += other.FailedSingleConsumerPopAttempts;
-            FailedReallySlowPops += other.FailedReallySlowPops;
-            FailedSlowPops += other.FailedSlowPops;
-            FailedSlowPopAttempts += other.FailedSlowPopAttempts;
-            FailedFastPops += other.FailedFastPops;
-            FailedFastPopAttempts += other.FailedFastPopAttempts;
-            FailedReallyFastPops += other.FailedReallyFastPops;
-            FailedReallyFastPopAttempts += other.FailedReallyFastPopAttempts;
-
-            MoveTailBecauseHeadOvertakesInReallySlowPop += other.MoveTailBecauseHeadOvertakesInReallySlowPop;
-            MoveTailBecauseHeadOvertakesInFastPop += other.MoveTailBecauseHeadOvertakesInFastPop;
-
-            InvalidatedSlots += other.InvalidatedSlots;
-            InvalidatedSlotsInSlowPop += other.InvalidatedSlotsInSlowPop;
-            InvalidatedSlotsInFastPop += other.InvalidatedSlotsInFastPop;
-            InvalidatedSlotsInReallyFastPop += other.InvalidatedSlotsInReallyFastPop;
-
-            return *this;
-        }
-    };
-    static thread_local TStats Stats;
-
-#ifdef MPMC_RING_QUEUE_COLLECT_STATISTICS
-    static constexpr bool CollectStatistics = true;
-#else
-    static constexpr bool CollectStatistics = false;
-#endif
-
-    template <typename  ...TArgs>
-    static void IncrementMetrics(TArgs& ...args) {
-        if constexpr (CollectStatistics) {
-            auto dummy = [](...) {};
-            dummy(++args...);
-        }
-    }
 
-#define DEFINE_INCREMENT_STATS_1(M1)                \
-    static void Increment ## M1() {                 \
-        IncrementMetrics(Stats.M1);                 \
-    }                                               \
-// end DEFINE_INCREMENT_STATS_1
-
-#define DEFINE_INCREMENT_STATS_2(M1, M2)            \
-    static void Increment ## M1() {                 \
-        IncrementMetrics(Stats.M1, Stats.M2);       \
-    }                                               \
-// end DEFINE_INCREMENT_STATS_2
-
-    DEFINE_INCREMENT_STATS_2(SuccessSlowPushes, SuccessPushes)
-    DEFINE_INCREMENT_STATS_2(SuccessFastPushes, SuccessPushes)
-    DEFINE_INCREMENT_STATS_1(ChangesFastPushToSlowPush)
-    DEFINE_INCREMENT_STATS_1(FailedPushes)
-    DEFINE_INCREMENT_STATS_1(FailedSlowPushAttempts)
-    DEFINE_INCREMENT_STATS_2(SuccessSingleConsumerPops, SuccessPops)
-    DEFINE_INCREMENT_STATS_2(FailedSingleConsumerPops, FailedPops)
-    DEFINE_INCREMENT_STATS_1(FailedSingleConsumerPopAttempts)
-    DEFINE_INCREMENT_STATS_1(MoveTailBecauseHeadOvertakesInReallySlowPop)
-    DEFINE_INCREMENT_STATS_2(FailedReallySlowPops, FailedPops)
-    DEFINE_INCREMENT_STATS_2(SuccessSlowPops, SuccessPops)
-    DEFINE_INCREMENT_STATS_2(FailedSlowPops, FailedPops)
-    DEFINE_INCREMENT_STATS_1(FailedSlowPopAttempts)
-    DEFINE_INCREMENT_STATS_1(ChangesReallySlowPopToSlowPop)
-    DEFINE_INCREMENT_STATS_2(SuccessFastPops, SuccessPops)
-    DEFINE_INCREMENT_STATS_2(FailedFastPops, FailedPops)
-    DEFINE_INCREMENT_STATS_1(MoveTailBecauseHeadOvertakesInFastPop)
-    DEFINE_INCREMENT_STATS_1(FailedFastPopAttempts)
-    DEFINE_INCREMENT_STATS_2(SuccessReallyFastPops, SuccessPops)
-    DEFINE_INCREMENT_STATS_2(FailedReallyFastPops, FailedPops)
-    DEFINE_INCREMENT_STATS_1(FailedReallyFastPopAttempts)
-    DEFINE_INCREMENT_STATS_2(InvalidatedSlotsInSlowPop, InvalidatedSlots)
-    DEFINE_INCREMENT_STATS_2(InvalidatedSlotsInFastPop, InvalidatedSlots)
-    DEFINE_INCREMENT_STATS_2(InvalidatedSlotsInReallyFastPop, InvalidatedSlots)
-
-    static TStats GetLocalStats() {
-        return Stats;
-    }
-};
-
-template <ui32 MaxSizeBits>
+#define DEFINE_HAS_STATIC_METHOD_CONCEPT(STATIC_METHOD)   \
+    template <typename T>                                 \
+    concept HasStaticMethod ## STATIC_METHOD = requires { \
+        { T:: STATIC_METHOD } -> std::same_as<void(&)()>; \
+    };                                                    \
+// DEFINE_HAS_STATIC_METHOD_CONCEPT
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveSuccessSlowPush)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveSuccessFastPush)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveChangeFastPushToSlowPush)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedPush)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedSlowPushAttempt)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveSuccessSingleConsumerPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedSingleConsumerPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedSingleConsumerPopAttempt)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveMoveTailBecauseHeadOvertakesInReallySlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedReallySlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveSuccessSlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedSlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedSlowPopAttempt)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveMoveTailBecauseHeadOvertakesInSlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveChangeReallySlowPopToSlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveSuccessFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveMoveTailBecauseHeadOvertakesInFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedFastPopAttempt)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveSuccessReallyFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedReallyFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFailedReallyFastPopAttempt)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveInvalidatedSlotInSlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveInvalidatedSlotInFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveInvalidatedSlotInReallyFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFoundOldSlotInSlowPush)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFoundOldSlotInFastPush)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFoundOldSlotInSlowPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFoundOldSlotInFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveFoundOldSlotInReallyFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongPush10It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongSlowPop10It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongFastPop10It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongReallyFastPop10It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongPush100It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongSlowPop100It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongFastPop100It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongReallyFastPop100It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongPush1000It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongSlowPop1000It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongFastPop1000It)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveLongReallyFastPop1000It)
+
+    // FOR DEBUG PURPOSES
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveAfterReserveSlotInFastPush)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveAfterReserveSlotInFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveAfterReserveSlotInReallyFastPop)
+    DEFINE_HAS_STATIC_METHOD_CONCEPT(ObserveAfterIncorectlyChangeSlotGenerationInReallyFastPop)
+#undef DEFINE_HAS_STATIC_METHOD_CONCEPT
+
+template <ui32 MaxSizeBits, typename TObserver=void>
 struct TMPMCRingQueue {
+
+#define HAS_OBSERVE_METHOD(ENTRY_POINT) \
+    HasStaticMethodObserve ## ENTRY_POINT <TObserver>
+// HAS_OBSERVE_METHOD
+
+#define OBSERVE_WITH_CONDITION(ENTRY_POINT, CONDITION) \
+    if constexpr (HAS_OBSERVE_METHOD(ENTRY_POINT)) {               \
+        if ((CONDITION)) {                             \
+            TObserver::Observe ## ENTRY_POINT ();              \
+        }                                              \
+    } do {} while (false)                              \
+// OBSERVE_WITH_CONDITION
+
+#define OBSERVE(ENTRY_POINT) \
+    OBSERVE_WITH_CONDITION(ENTRY_POINT, true)
+// OBSERVE
+ 
     static constexpr ui32 MaxSize = 1 << MaxSizeBits;
 
     enum class EPopMode {
@@ -200,7 +140,10 @@ struct TMPMCRingQueue {
 
     bool TryPushSlow(ui32 val) {
         ui64 currentTail = Tail.load(std::memory_order_relaxed);
-        for (;;) {
+        for (ui32 it = 0;; ++it) {
+            OBSERVE_WITH_CONDITION(LongPush10It, it == 10);
+            OBSERVE_WITH_CONDITION(LongPush100It, it == 100);
+            OBSERVE_WITH_CONDITION(LongPush1000It, it == 1000);
             ui32 generation = currentTail / MaxSize;
 
             std::atomic<ui64> &currentSlot = Buffer[ConvertIdx(currentTail)];
@@ -209,7 +152,8 @@ struct TMPMCRingQueue {
             do {
                 if (currentSlot.compare_exchange_weak(expected, val)) {
                     Tail.compare_exchange_strong(currentTail, currentTail + 1);
-                    TMPMCRingQueueStats::IncrementSuccessSlowPushes();
+                    OBSERVE(SuccessSlowPush);
+                    OBSERVE_WITH_CONDITION(FoundOldSlotInSlowPush, (slot = TSlot::Recognise(expected), slot.Generation < generation));
                     return true;
                 }
                 slot = TSlot::Recognise(expected);
@@ -218,19 +162,20 @@ struct TMPMCRingQueue {
             if (!slot.IsEmpty) {
                 ui64 currentHead = Head.load(std::memory_order_acquire);
                 if (currentHead + MaxSize <= currentTail + std::min<ui64>(64, MaxSize - 1)) {
-                    TMPMCRingQueueStats::IncrementFailedPushes();
+                    OBSERVE(FailedPush);
                     return false;
                 }
             }
 
             SpinLockPause();
-            TMPMCRingQueueStats::IncrementFailedSlowPushAttempts();
+            OBSERVE(FailedSlowPushAttempt);
             Tail.compare_exchange_strong(currentTail, currentTail + 1, std::memory_order_acq_rel);
         }
     }
 
     bool TryPush(ui32 val) {
         ui64 currentTail = Tail.fetch_add(1, std::memory_order_relaxed);
+        OBSERVE(AfterReserveSlotInFastPush);
         ui32 generation = currentTail / MaxSize;
 
         std::atomic<ui64> &currentSlot = Buffer[ConvertIdx(currentTail)];
@@ -238,13 +183,14 @@ struct TMPMCRingQueue {
         ui64 expected = TSlot::MakeEmpty(generation);
         do {
             if (currentSlot.compare_exchange_weak(expected, val)) {
-                TMPMCRingQueueStats::IncrementSuccessFastPushes();
+                OBSERVE(SuccessFastPush);
+                OBSERVE_WITH_CONDITION(FoundOldSlotInFastPush, (slot = TSlot::Recognise(expected), slot.Generation < generation));
                 return true;
             }
             slot = TSlot::Recognise(expected);
         } while (slot.Generation <= generation && slot.IsEmpty);
 
-        TMPMCRingQueueStats::IncrementChangesFastPushToSlowPush();
+        OBSERVE(ChangeFastPushToSlowPush);
         return TryPushSlow(val);
     }
 
@@ -265,19 +211,19 @@ struct TMPMCRingQueue {
                 ui64 globalHead = LocalGeneration * MaxSize + LocalHead;
                 if (currentTail <= globalHead) {
                     Tail.compare_exchange_strong(currentTail, globalHead);
-                    TMPMCRingQueueStats::IncrementFailedSingleConsumerPops();
+                    OBSERVE(FailedSingleConsumerPop);
                     return std::nullopt;
                 }
                 if (currentSlot.compare_exchange_strong(expected, TSlot::MakeEmpty(LocalGeneration + 1))) {
                     ShiftLocalHead();
                 }
-                TMPMCRingQueueStats::IncrementFailedSingleConsumerPopAttempts();
+                OBSERVE(FailedSingleConsumerPopAttempt);
                 SpinLockPause();
                 continue;
             }
             currentSlot.store(TSlot::MakeEmpty(LocalGeneration + 1), std::memory_order_release);
             ShiftLocalHead();
-            TMPMCRingQueueStats::IncrementSuccessSingleConsumerPops();
+            OBSERVE(SuccessSingleConsumerPop);
             return slot.Value;
         }
     }
@@ -330,15 +276,15 @@ struct TMPMCRingQueue {
         while (currentHead > currentTail) {
             if (Tail.compare_exchange_weak(currentTail, currentHead)) {
                 currentTail = currentHead;
-                TMPMCRingQueueStats::IncrementMoveTailBecauseHeadOvertakesInReallySlowPop();
+                OBSERVE(MoveTailBecauseHeadOvertakesInReallySlowPop);
             }
         }
         if (currentHead == currentTail) {
-            TMPMCRingQueueStats::IncrementFailedReallySlowPops();
+            OBSERVE(FailedReallySlowPop);
             return std::nullopt;
         }
 
-        TMPMCRingQueueStats::IncrementChangesReallySlowPopToSlowPop();
+        OBSERVE(ChangeReallySlowPopToSlowPop);
         return TryPopSlow(currentHead);
     }
 
@@ -346,7 +292,10 @@ struct TMPMCRingQueue {
         if (!currentHead) {
             currentHead = Head.load(std::memory_order_acquire);
         }
-        for (;;) {
+        for (ui32 it = 0;; ++it) {
+            OBSERVE_WITH_CONDITION(LongSlowPop10It, it == 10);
+            OBSERVE_WITH_CONDITION(LongSlowPop100It, it == 100);
+            OBSERVE_WITH_CONDITION(LongSlowPop1000It, it == 1000);
             ui32 generation = currentHead / MaxSize;
 
             std::atomic<ui64> &currentSlot = Buffer[ConvertIdx(currentHead)];
@@ -356,7 +305,7 @@ struct TMPMCRingQueue {
 
             if (slot.Generation > generation) {
                 Head.compare_exchange_strong(currentHead, currentHead + 1);
-                TMPMCRingQueueStats::IncrementFailedSlowPopAttempts();
+                OBSERVE(FailedSlowPopAttempt);
                 SpinLockPause();
                 continue;
             }
@@ -365,7 +314,7 @@ struct TMPMCRingQueue {
                 if (currentSlot.compare_exchange_weak(expected, TSlot::MakeEmpty(generation + 1))) {
                     if (!slot.IsEmpty) {
                         Head.compare_exchange_strong(currentHead, currentHead + 1);
-                        TMPMCRingQueueStats::IncrementSuccessSlowPops();
+                        OBSERVE(SuccessSlowPop);
                         return slot.Value;
                     }
                     break;
@@ -376,7 +325,7 @@ struct TMPMCRingQueue {
             while (!slot.IsEmpty) {
                 if (currentSlot.compare_exchange_weak(expected, TSlot::MakeEmpty(generation + 1))) {
                     Head.compare_exchange_strong(currentHead, currentHead + 1);
-                    TMPMCRingQueueStats::IncrementSuccessSlowPops();
+                    OBSERVE(SuccessSlowPop);
                     return slot.Value;
                 }
                 slot = TSlot::Recognise(expected);
@@ -384,32 +333,33 @@ struct TMPMCRingQueue {
 
             if (slot.Generation > generation) {
                 Head.compare_exchange_strong(currentHead, currentHead + 1);
-                TMPMCRingQueueStats::IncrementFailedSlowPopAttempts();
+                OBSERVE(FailedSlowPopAttempt);
                 SpinLockPause();
                 continue;
             }
 
             ui64 currentTail = Tail.load(std::memory_order_acquire);
             if (currentTail <= currentHead) {
-                TMPMCRingQueueStats::IncrementFailedSlowPops();
+                OBSERVE(FailedSlowPop);
                 return std::nullopt;
             }
 
-            while (slot.Generation == generation && slot.IsEmpty) {
+            OBSERVE_WITH_CONDITION(FoundOldSlotInSlowPop, slot.Generation < generation); 
+            while (slot.Generation <= generation && slot.IsEmpty) {
                 if (currentSlot.compare_exchange_weak(expected, TSlot::MakeEmpty(generation + 1))) {
                     Head.compare_exchange_strong(currentHead, currentHead + 1);
-                    TMPMCRingQueueStats::IncrementInvalidatedSlotsInSlowPop();
-                    TMPMCRingQueueStats::IncrementMoveTailBecauseHeadOvertakesInFastPop();
+                    OBSERVE(InvalidatedSlotInSlowPop);
+                    OBSERVE(MoveTailBecauseHeadOvertakesInSlowPop);
                     break;
                 }
                 slot = TSlot::Recognise(expected);
             }
 
-            TMPMCRingQueueStats::IncrementFailedSlowPopAttempts();
+            OBSERVE(FailedSlowPopAttempt);
             SpinLockPause();
             currentHead = Head.load(std::memory_order_acquire);
         }
-        TMPMCRingQueueStats::IncrementFailedSlowPops();
+        OBSERVE(FailedSlowPop);
         return std::nullopt;
     }
 
@@ -418,8 +368,12 @@ struct TMPMCRingQueue {
     }
 
     std::optional<ui32> TryPopFast() {
-        for (;;) {
+        for (ui32 it = 0;; ++it) {
+            OBSERVE_WITH_CONDITION(LongFastPop10It, it == 10);
+            OBSERVE_WITH_CONDITION(LongFastPop100It, it == 100);
+            OBSERVE_WITH_CONDITION(LongFastPop1000It, it == 1000);
             ui64 currentHead = Head.fetch_add(1, std::memory_order_relaxed);
+            OBSERVE(AfterReserveSlotInFastPop);
             ui32 generation = currentHead / MaxSize;
 
             std::atomic<ui64> &currentSlot = Buffer[ConvertIdx(currentHead)];
@@ -428,7 +382,7 @@ struct TMPMCRingQueue {
             TSlot slot = TSlot::Recognise(expected);
 
             if (slot.Generation > generation) {
-                TMPMCRingQueueStats::IncrementFailedFastPopAttempts();
+                OBSERVE(FailedFastPopAttempt);
                 SpinLockPause();
                 continue;
             }
@@ -436,7 +390,7 @@ struct TMPMCRingQueue {
             while (generation >= slot.Generation) {
                 if (currentSlot.compare_exchange_weak(expected, TSlot::MakeEmpty(generation + 1))) {
                     if (!slot.IsEmpty) {
-                        TMPMCRingQueueStats::IncrementSuccessFastPops();
+                        OBSERVE(SuccessFastPop);
                         return slot.Value;
                     }
                     break;
@@ -445,27 +399,24 @@ struct TMPMCRingQueue {
             }
 
             if (slot.Generation > generation) {
-                TMPMCRingQueueStats::IncrementFailedFastPopAttempts();
+                OBSERVE(FailedFastPopAttempt);
                 SpinLockPause();
                 continue;
             }
 
-            if constexpr (TMPMCRingQueueStats::CollectStatistics) {
-                if (slot.Generation <= generation) {
-                    TMPMCRingQueueStats::IncrementInvalidatedSlotsInFastPop();
-                }
-            }
+            OBSERVE_WITH_CONDITION(FoundOldSlotInFastPop, slot.Generation < generation); 
+            OBSERVE_WITH_CONDITION(InvalidatedSlotInFastPop, slot.Generation <= generation); 
 
             ui64 currentTail = Tail.load(std::memory_order_acquire);
             if (currentTail > currentHead) {
-                TMPMCRingQueueStats::IncrementFailedFastPopAttempts();
+                OBSERVE(FailedFastPopAttempt);
                 SpinLockPause();
                 continue;
             }
 
             while (currentTail <= currentHead) {
                 if (Tail.compare_exchange_weak(currentTail, currentHead + 1)) {
-                    TMPMCRingQueueStats::IncrementFailedFastPops();
+                    OBSERVE(FailedFastPop);
                     return std::nullopt;
                 }
             }
@@ -475,8 +426,12 @@ struct TMPMCRingQueue {
     }
 
     std::optional<ui32> TryPopReallyFast() {
-        for (;;) {
+        for (ui32 it = 0;; ++it) {
+            OBSERVE_WITH_CONDITION(LongReallyFastPop10It, it == 10);
+            OBSERVE_WITH_CONDITION(LongReallyFastPop100It, it == 100);
+            OBSERVE_WITH_CONDITION(LongReallyFastPop1000It, it == 1000);
             ui64 currentHead = Head.fetch_add(1, std::memory_order_relaxed);
+            OBSERVE(AfterReserveSlotInReallyFastPop);
             ui32 generation = currentHead / MaxSize;
 
             std::atomic<ui64> &currentSlot = Buffer[ConvertIdx(currentHead)];
@@ -484,37 +439,36 @@ struct TMPMCRingQueue {
             ui64 expected = currentSlot.exchange(TSlot::MakeEmpty(generation + 1), std::memory_order_acq_rel);
             TSlot slot = TSlot::Recognise(expected);
             if (!slot.IsEmpty) {
-                TMPMCRingQueueStats::IncrementSuccessReallyFastPops();
+                OBSERVE(SuccessReallyFastPop);
                 return slot.Value;
             }
 
             if (slot.Generation > generation) {
+                OBSERVE(AfterIncorectlyChangeSlotGenerationInReallyFastPop);
                 expected = TSlot::MakeEmpty(generation + 1);
                 TSlot slot2 = TSlot::Recognise(expected);
                 while (slot.Generation > slot2.Generation) {
                     if (currentSlot.compare_exchange_weak(expected, TSlot::MakeEmpty(slot.Generation))) {
                         if (!slot2.IsEmpty) {
-                            TMPMCRingQueueStats::IncrementSuccessReallyFastPops();
+                            OBSERVE(SuccessReallyFastPop);
                             return slot2.Value;
                         }
                         break;
                     }
                     slot2 = TSlot::Recognise(expected);
+                    SpinLockPause();
                 }
 
-                TMPMCRingQueueStats::IncrementFailedReallyFastPopAttempts();
+                OBSERVE(FailedReallyFastPopAttempt);
                 SpinLockPause();
                 continue;
             }
 
-            if constexpr (TMPMCRingQueueStats::CollectStatistics) {
-                if (slot.Generation <= generation) {
-                    TMPMCRingQueueStats::IncrementInvalidatedSlotsInReallyFastPop();
-                }
-            }
+            OBSERVE_WITH_CONDITION(FoundOldSlotInReallyFastPop, slot.Generation < generation); 
+            OBSERVE_WITH_CONDITION(InvalidatedSlotInReallyFastPop, slot.Generation <= generation); 
 
             if (slot.Generation > generation) {
-                TMPMCRingQueueStats::IncrementFailedReallyFastPopAttempts();
+                OBSERVE(FailedReallyFastPopAttempt);
                 SpinLockPause();
                 continue;
             }
@@ -522,7 +476,7 @@ struct TMPMCRingQueue {
             ui64 currentTail = Tail.load(std::memory_order_acquire);
             while (currentTail <= currentHead) {
                 if (Tail.compare_exchange_weak(currentTail, currentHead + 1)) {
-                    TMPMCRingQueueStats::IncrementFailedReallyFastPops();
+                    OBSERVE(FailedReallyFastPop);
                     return std::nullopt;
                 }
             }
@@ -530,6 +484,9 @@ struct TMPMCRingQueue {
             SpinLockPause();
         }
     }
+#undef OBSERVE_WITH_CONDITION
+#undef OBSERVE
+#undef HAS_OBSERVE_METHOD
 };
 
 }  // NActors
\ No newline at end of file
diff --git a/ydb/library/actors/queues/mpmc_ring_queue_ut_multi_threads.cpp b/ydb/library/actors/queues/mpmc_ring_queue_ut_multi_threads.cpp
index 7d6800102e2d..f10d73e8d49f 100644
--- a/ydb/library/actors/queues/mpmc_ring_queue_ut_multi_threads.cpp
+++ b/ydb/library/actors/queues/mpmc_ring_queue_ut_multi_threads.cpp
@@ -21,11 +21,13 @@ namespace { // Tests
 
 
     struct TStatsCollector {
+        using TStatsSource = NActors::TStatsObserver;
+
         TMutex Mutex;
-        NActors::TMPMCRingQueueStats::TStats Stats;
+        NActors::TStatsObserver::TStats Stats;
         std::vector<TConsumerInfo> ConsumerInfo;
 
-        void AddStats(const NActors::TMPMCRingQueueStats::TStats &stats) {
+        void AddStats(const NActors::TStatsObserver::TStats &stats) {
             TGuard<TMutex> guard(Mutex);
             Stats += stats;
         }
@@ -37,28 +39,28 @@ namespace { // Tests
 
 #define BASIC_PUSH_POP_SINGLE_THREAD_FAST(QUEUE)                                       \
     Y_UNIT_TEST(BasicPushPopSingleThread_ ## QUEUE) {                                  \
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<10>, QUEUE<10>>::BasicPushPopSingleThread<TStatsCollector>(); \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, 2);                    \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes, 2);                \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, 0);        \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes, 0);                \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPushes, 0);                     \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPushAttempts, 0);           \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, 2);                      \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPops, 0);                       \
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<10>, TAdaptorWithStats<QUEUE>::Type<10>>::TBasicPushPopSingleThread<TStatsCollector>().Run(); \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, 2);                    \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush, 2);                \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, 0);        \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush, 0);                \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPush, 0);                     \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPushAttempt, 0);           \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, 2);                      \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPop, 0);                       \
     }                                                                                  \
 // end BASIC_PUSH_POP_SINGLE_THREAD
 
 
 #define BASIC_PUSH_POP_SINGLE_THREAD_SLOW(QUEUE)                                       \
     Y_UNIT_TEST(BasicPushPopSingleThread_ ## QUEUE) {                                  \
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<10>, QUEUE<10>>::BasicPushPopSingleThread<TStatsCollector>(); \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, 2);                    \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes, 0);                \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, 0);        \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes, 2);                \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPushes, 0);                     \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPushAttempts, 0);           \
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<10>, TAdaptorWithStats<QUEUE>::Type<10>>::TBasicPushPopSingleThread<TStatsCollector>().Run(); \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, 2);                    \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush, 0);                \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, 0);        \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush, 2);                \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPush, 0);                     \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPushAttempt, 0);           \
     }                                                                                  \
 // end BASIC_PUSH_POP_SINGLE_THREAD
 
@@ -67,14 +69,14 @@ namespace { // Tests
     Y_UNIT_TEST(BasicPushPopMultiThreads_ ## QUEUE) {                                                           \
         constexpr ui32 ThreadCount = 10;                                                                        \
         constexpr ui32 RepeatCount = 1000;                                                                      \
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<10>, QUEUE<10>>::BasicPushPopMultiThreads<TStatsCollector, ThreadCount, RepeatCount>();\
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, RepeatCount * ThreadCount);                     \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, collector.Stats.SuccessSlowPushes); \
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<10>, TAdaptorWithStats<QUEUE>::Type<10>>::TBasicPushPopMultiThreads<TStatsCollector, ThreadCount, RepeatCount>().Run();\
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, RepeatCount * ThreadCount);                     \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, collector.Stats.SuccessSlowPush); \
         UNIT_ASSERT_VALUES_EQUAL(                                                                               \
-                collector.Stats.SuccessFastPushes + collector.Stats.SuccessSlowPushes,                          \
-                collector.Stats.SuccessPushes                                                                   \
+                collector.Stats.SuccessFastPush + collector.Stats.SuccessSlowPush,                          \
+                collector.Stats.SuccessPush                                                                   \
         );                                                                                                      \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPushes, 0);                                              \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPush, 0);                                              \
     }                                                                                                           \
 // end BASIC_PUSH_POP_MUTLI_THREADS_FAST
 
@@ -83,12 +85,12 @@ namespace { // Tests
     Y_UNIT_TEST(BasicPushPopMultiThreads_ ## QUEUE) {                                                           \
         constexpr ui32 ThreadCount = 10;                                                                        \
         constexpr ui32 RepeatCount = 1000;                                                                      \
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<10>, QUEUE<10>>::BasicPushPopMultiThreads<TStatsCollector, ThreadCount, RepeatCount>();\
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, RepeatCount * ThreadCount);                     \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, 0);                                 \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes, 0);                                         \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes, collector.Stats.SuccessPushes);             \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPushes, 0);                                              \
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<10>, TAdaptorWithStats<QUEUE>::Type<10>>::TBasicPushPopMultiThreads<TStatsCollector, ThreadCount, RepeatCount>().Run();\
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, RepeatCount * ThreadCount);                     \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, 0);                                 \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush, 0);                                         \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush, collector.Stats.SuccessPush);             \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPush, 0);                                              \
     }                                                                                                           \
 // end BASIC_PUSH_POP_MUTLI_THREADS_SLOW
 
@@ -98,13 +100,13 @@ namespace { // Tests
         constexpr ui32 SizeBits = 10;                                                                           \
         constexpr ui32 MaxSize = 1 << SizeBits;                                                                 \
         constexpr ui32 ThreadCount = 10;                                                                        \
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, QUEUE<SizeBits>>::BasicProducing<TStatsCollector, ThreadCount>();                 \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, MaxSize);                                       \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes, MaxSize);                                   \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, ThreadCount);                       \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes, 0);                                         \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPushes, ThreadCount);                                    \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPushAttempts, 0);                                    \
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<10>, TAdaptorWithStats<QUEUE>::Type<10>>::TBasicProducing<TStatsCollector, ThreadCount>().Run();                 \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, MaxSize);                                       \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush, MaxSize);                                   \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, ThreadCount);                       \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush, 0);                                         \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPush, ThreadCount);                                    \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPushAttempt, 0);                                    \
     }                                                                                                           \
 // end BASIC_PUSH_POP_MUTLI_THREADS_FAST
 
@@ -114,12 +116,12 @@ namespace { // Tests
         constexpr ui32 SizeBits = 10;                                                                           \
         constexpr ui32 MaxSize = 1 << SizeBits;                                                                 \
         constexpr ui32 ThreadCount = 10;                                                                        \
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, QUEUE<SizeBits>>::BasicProducing<TStatsCollector, ThreadCount>();                 \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, MaxSize);                                       \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, 0);                                 \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes, 0);                                         \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes, collector.Stats.SuccessPushes);             \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPushes, ThreadCount);                                    \
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<QUEUE>::Type<SizeBits>>::TBasicProducing<TStatsCollector, ThreadCount>().Run();                 \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, MaxSize);                                       \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, 0);                                 \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush, 0);                                         \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush, collector.Stats.SuccessPush);             \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPush, ThreadCount);                                    \
     }                                                                                                           \
 // end BASIC_PUSH_POP_MUTLI_THREADS_SLOW
 
@@ -129,9 +131,9 @@ namespace { // Tests
         constexpr ui32 SizeBits = 10;                                                                           \
         constexpr ui32 MaxSize = 1 << SizeBits;                                                                 \
         constexpr ui32 ThreadCount = 10;                                                                        \
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, QUEUE<SizeBits>>::ConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>();   \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPops, ThreadCount * MaxSize);                            \
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, 0);                                               \
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<QUEUE>::Type<SizeBits>>::TConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>().Run();   \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPop, ThreadCount * MaxSize);                            \
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, 0);                                               \
     }                                                                                                           \
 // end BASIC_PUSH_POP_MUTLI_THREADS_SLOW
 
@@ -158,13 +160,13 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueMultiThreadsTests) {
         constexpr ui32 SizeBits = 10;
         constexpr ui32 MaxSize = 1 << SizeBits;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TVeryFastQueue<SizeBits>>::ConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>();
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedReallyFastPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessReallyFastPops, 0);
-        UNIT_ASSERT_LT(collector.Stats.FailedReallyFastPopAttempts, MaxSize); // lower than 10%
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInReallyFastPop, collector.Stats.FailedPops + collector.Stats.FailedReallyFastPopAttempts);
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TVeryFastQueue>::Type<SizeBits>>::TConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>().Run();
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedReallyFastPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessReallyFastPop, 0);
+        UNIT_ASSERT_LT(collector.Stats.FailedReallyFastPopAttempt, MaxSize); // lower than 10%
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInReallyFastPop, collector.Stats.FailedPop + collector.Stats.FailedReallyFastPopAttempt);
     }
 
     Y_UNIT_TEST(ConsumingEmptyQueue_TFastQueue) {
@@ -172,58 +174,58 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueMultiThreadsTests) {
         constexpr ui32 SizeBits = 10;
         constexpr ui32 MaxSize = 1 << SizeBits;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TFastQueue<SizeBits>>::ConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>();
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedFastPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPops, 0);
-        UNIT_ASSERT_LT(collector.Stats.FailedReallyFastPopAttempts, MaxSize); // lower than 10%
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInFastPop, collector.Stats.FailedPops + collector.Stats.FailedFastPopAttempts);
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TFastQueue>::Type<SizeBits>>::TConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>().Run();
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedFastPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPop, 0);
+        UNIT_ASSERT_LT(collector.Stats.FailedReallyFastPopAttempt, MaxSize); // lower than 10%
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInFastPop, collector.Stats.FailedPop + collector.Stats.FailedFastPopAttempt);
     }
 
     Y_UNIT_TEST(ConsumingEmptyQueue_TSlowQueue) {
         constexpr ui32 SizeBits = 10;
         constexpr ui32 MaxSize = 1 << SizeBits;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TSlowQueue<SizeBits>>::ConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>();
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInSlowPop, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPops, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPopAttempts, 0);
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TSlowQueue>::Type<SizeBits>>::TConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>().Run();
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPopAttempt, 0);
     }
 
     Y_UNIT_TEST(ConsumingEmptyQueue_TVerySlowQueue) {
         constexpr ui32 SizeBits = 10;
         constexpr ui32 MaxSize = 1 << SizeBits;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TVerySlowQueue<SizeBits>>::ConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>();
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedReallySlowPops, ThreadCount * MaxSize);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPops, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesReallySlowPopToSlowPop, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInSlowPop, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPops, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPopAttempts, 0);
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TVerySlowQueue>::Type<SizeBits>>::TConsumingEmptyQueue<TStatsCollector, ThreadCount, MaxSize>().Run();
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedReallySlowPop, ThreadCount * MaxSize);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeReallySlowPopToSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.FailedSlowPopAttempt, 0);
     }
 
     Y_UNIT_TEST(BasicProducingConsuming_TVeryFastQueue) {
         constexpr ui32 SizeBits = 15;
         constexpr ui32 ItemsPerThread = 1024;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TVeryFastQueue<SizeBits>>::BasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>();
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TVeryFastQueue>::Type<SizeBits>>::TBasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>().Run();
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes + collector.Stats.SuccessSlowPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes + collector.Stats.FailedPushes, collector.Stats.ChangesFastPushToSlowPush);
-        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPushes, collector.Stats.SuccessFastPushes);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush + collector.Stats.SuccessSlowPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush + collector.Stats.FailedPush, collector.Stats.ChangeFastPushToSlowPush);
+        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPush, collector.Stats.SuccessFastPush);
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessReallyFastPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInReallyFastPop, collector.Stats.FailedPops + collector.Stats.FailedReallyFastPopAttempts);
-        UNIT_ASSERT_LT(collector.Stats.InvalidatedSlotsInReallyFastPop, ItemsPerThread); // lower than 10%
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessReallyFastPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInReallyFastPop, collector.Stats.FailedPop + collector.Stats.FailedReallyFastPopAttempt);
+        UNIT_ASSERT_LT(collector.Stats.InvalidatedSlotInReallyFastPop, ItemsPerThread); // lower than 10%
 
         std::unordered_map<ui32, ui32> itemsCounts;
         for (auto &info : collector.ConsumerInfo) {
@@ -245,17 +247,17 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueMultiThreadsTests) {
         constexpr ui32 SizeBits = 15;
         constexpr ui32 ItemsPerThread = 1024;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TFastQueue<SizeBits>>::BasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>();
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TFastQueue>::Type<SizeBits>>::TBasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>().Run();
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes + collector.Stats.SuccessSlowPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes + collector.Stats.FailedPushes, collector.Stats.ChangesFastPushToSlowPush);
-        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPushes, collector.Stats.SuccessFastPushes);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush + collector.Stats.SuccessSlowPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush + collector.Stats.FailedPush, collector.Stats.ChangeFastPushToSlowPush);
+        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPush, collector.Stats.SuccessFastPush);
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInFastPop, collector.Stats.FailedPops + collector.Stats.FailedFastPopAttempts);
-        UNIT_ASSERT_LT(collector.Stats.InvalidatedSlotsInFastPop, ItemsPerThread); // lower than 10%
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInFastPop, collector.Stats.FailedPop + collector.Stats.FailedFastPopAttempt);
+        UNIT_ASSERT_LT(collector.Stats.InvalidatedSlotInFastPop, ItemsPerThread); // lower than 10%
 
         std::unordered_map<ui32, ui32> itemsCounts;
         for (auto &info : collector.ConsumerInfo) {
@@ -277,16 +279,16 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueMultiThreadsTests) {
         constexpr ui32 SizeBits = 15;
         constexpr ui32 ItemsPerThread = 1024;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TSlowQueue<SizeBits>>::BasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>();
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TSlowQueue>::Type<SizeBits>>::TBasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>().Run();
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, 0);
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInSlowPop, 0);
 
         std::unordered_map<ui32, ui32> itemsCounts;
         for (auto &info : collector.ConsumerInfo) {
@@ -308,16 +310,16 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueMultiThreadsTests) {
         constexpr ui32 SizeBits = 15;
         constexpr ui32 ItemsPerThread = 1024;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TVerySlowQueue<SizeBits>>::BasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>();
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TVerySlowQueue>::Type<SizeBits>>::TBasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>().Run();
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes, 0);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangesFastPushToSlowPush, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.ChangeFastPushToSlowPush, 0);
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotsInSlowPop, 0);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.InvalidatedSlotInSlowPop, 0);
 
         std::unordered_map<ui32, ui32> itemsCounts;
         for (auto &info : collector.ConsumerInfo) {
@@ -339,15 +341,15 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueMultiThreadsTests) {
         constexpr ui32 SizeBits = 15;
         constexpr ui32 ItemsPerThread = 1024;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TSingleQueue<SizeBits>>::BasicProducingConsuming<TStatsCollector, ThreadCount, 1, ItemsPerThread, ThreadCount * ItemsPerThread>();
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TSingleQueue>::Type<SizeBits>>::TBasicProducingConsuming<TStatsCollector, ThreadCount, 1, ItemsPerThread, ThreadCount * ItemsPerThread>().Run();
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes + collector.Stats.SuccessSlowPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes + collector.Stats.FailedPushes, collector.Stats.ChangesFastPushToSlowPush);
-        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPushes, collector.Stats.SuccessFastPushes);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush + collector.Stats.SuccessSlowPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush + collector.Stats.FailedPush, collector.Stats.ChangeFastPushToSlowPush);
+        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPush, collector.Stats.SuccessFastPush);
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSingleConsumerPops, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSingleConsumerPop, ThreadCount * ItemsPerThread);
 
         std::unordered_map<ui32, ui32> itemsCounts;
         for (auto &info : collector.ConsumerInfo) {
@@ -369,14 +371,14 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueMultiThreadsTests) {
         constexpr ui32 SizeBits = 15;
         constexpr ui32 ItemsPerThread = 1024;
         constexpr ui32 ThreadCount = 10;
-        TStatsCollector collector = TBenchCases<TMPMCRingQueue<SizeBits>, TAdaptiveQueue<SizeBits>>::BasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>();
+        TStatsCollector collector = TTestCases<TMPMCRingQueueWithStats<SizeBits>, TAdaptorWithStats<TAdaptiveQueue>::Type<SizeBits>>::TBasicProducingConsuming<TStatsCollector, ThreadCount, ThreadCount, ItemsPerThread, ItemsPerThread>().Run();
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPushes + collector.Stats.SuccessSlowPushes, ThreadCount * ItemsPerThread);
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPushes + collector.Stats.FailedPushes, collector.Stats.ChangesFastPushToSlowPush);
-        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPushes, collector.Stats.SuccessFastPushes);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessFastPush + collector.Stats.SuccessSlowPush, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessSlowPush + collector.Stats.FailedPush, collector.Stats.ChangeFastPushToSlowPush);
+        UNIT_ASSERT_LT(collector.Stats.SuccessSlowPush, collector.Stats.SuccessFastPush);
 
-        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPops, ThreadCount * ItemsPerThread);
+        UNIT_ASSERT_VALUES_EQUAL(collector.Stats.SuccessPop, ThreadCount * ItemsPerThread);
 
         std::unordered_map<ui32, ui32> itemsCounts;
         for (auto &info : collector.ConsumerInfo) {
diff --git a/ydb/library/actors/queues/mpmc_ring_queue_ut_single_thread.cpp b/ydb/library/actors/queues/mpmc_ring_queue_ut_single_thread.cpp
index 25b35cf936c5..1a4a6a97c143 100644
--- a/ydb/library/actors/queues/mpmc_ring_queue_ut_single_thread.cpp
+++ b/ydb/library/actors/queues/mpmc_ring_queue_ut_single_thread.cpp
@@ -19,32 +19,32 @@ namespace { // Tests
     struct TTestCases {
         static constexpr ui32 MaxSize = 1 << SizeBits;
 
-        static auto GetHead(const TMPMCRingQueue<SizeBits> &realQueue) {
-            if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits>>) {
+        static auto GetHead(const TMPMCRingQueueWithStats<SizeBits> &realQueue) {
+            if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits, TStatsObserver>>) {
                 return realQueue.LocalHead;
             } else {
                 return realQueue.Head.load();
             }
         }
 
-        static auto GetHeadGeneration(const TMPMCRingQueue<SizeBits> &realQueue) {
-            if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits>>) {
+        static auto GetHeadGeneration(const TMPMCRingQueueWithStats<SizeBits> &realQueue) {
+            if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits, TStatsObserver>>) {
                 return realQueue.LocalGeneration;
             } else {
                 return realQueue.Head.load() / MaxSize;
             }
         }
 
-        static auto GetTail(const TMPMCRingQueue<SizeBits> &realQueue) {
+        static auto GetTail(const TMPMCRingQueueWithStats<SizeBits> &realQueue) {
             return realQueue.Tail.load();
         }
 
-        static auto GetTailGeneration(const TMPMCRingQueue<SizeBits> &realQueue) {
+        static auto GetTailGeneration(const TMPMCRingQueueWithStats<SizeBits> &realQueue) {
             return realQueue.Tail.load() / MaxSize;
         }
 
         static void PushesPopsWithShift() {
-            TMPMCRingQueue<SizeBits> realQueue;
+            TMPMCRingQueueWithStats<SizeBits> realQueue;
             TQueueAdaptor<SizeBits> adaptor(&realQueue);
             
             for (ui32 it = 0; it < MaxSize; ++it) {
@@ -70,7 +70,7 @@ namespace { // Tests
                     UNIT_ASSERT_VALUES_EQUAL_C(realQueue.Buffer[realIdx].load(), idx, debugString);
                     std::optional<ui32> value = adaptor.TryPop();
                     UNIT_ASSERT_C(value, debugString);
-                    if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits>>) {
+                    if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits, TStatsObserver>>) {
                         UNIT_ASSERT_VALUES_EQUAL_C((head + 1) % MaxSize, GetHead(realQueue), debugString);
                     } else {
                         UNIT_ASSERT_VALUES_EQUAL_C(head + 1, GetHead(realQueue), debugString);
@@ -83,7 +83,7 @@ namespace { // Tests
         }
 
         static void PushesOverloadPops() {
-            TMPMCRingQueue<SizeBits> realQueue;
+            TMPMCRingQueueWithStats<SizeBits> realQueue;
             TQueueAdaptor<SizeBits> adaptor(&realQueue);
             
             for (ui32 it = 0; it < MaxSize; ++it) {
@@ -106,7 +106,7 @@ namespace { // Tests
                     UNIT_ASSERT_VALUES_EQUAL_C(realQueue.Buffer[idx].load(), idx, debugString);
                     std::optional<ui32> value = adaptor.TryPop();
                     UNIT_ASSERT_C(value, debugString);
-                    if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits>>) {
+                    if constexpr (std::is_same_v<TQueueAdaptor<SizeBits>, TSingleQueue<SizeBits, TStatsObserver>>) {
                         UNIT_ASSERT_VALUES_EQUAL_C((head + 1) % MaxSize, GetHead(realQueue), debugString);
                     } else {
                         UNIT_ASSERT_VALUES_EQUAL_C(head + 1, GetHead(realQueue), debugString);
@@ -122,7 +122,7 @@ namespace { // Tests
             if constexpr (MaxSize < 3) {
                 return;
             }
-            TMPMCRingQueue<SizeBits> realQueue;
+            TMPMCRingQueueWithStats<SizeBits> realQueue;
             TQueueAdaptor<SizeBits> adaptor(&realQueue);
 
             ui64 emptyZeroGeneration = (ui64(1) << 63);
@@ -156,7 +156,7 @@ namespace { // Tests
         }
 
         static void CheckSlowPops() {
-            TMPMCRingQueue<SizeBits> realQueue;
+            TMPMCRingQueueWithStats<SizeBits> realQueue;
             TQueueAdaptor<SizeBits> adaptor(&realQueue);
             ui64 emptyZeroGeneration = (ui64(1) << 63);
             for (ui32 it = 0; it < MaxSize; ++it) {
@@ -174,7 +174,7 @@ namespace { // Tests
         }
 
         static void CheckFastPops() {
-            TMPMCRingQueue<SizeBits> realQueue;
+            TMPMCRingQueueWithStats<SizeBits> realQueue;
             TQueueAdaptor<SizeBits> adaptor(&realQueue);
             for (ui32 it = 0; it < MaxSize; ++it) {
                 for (ui32 idx = 0; idx < MaxSize; ++idx) {
@@ -229,27 +229,27 @@ namespace { // Tests
 
 #define BASIC_QUEUE_TEST_CASES(SIZE_BITS, QUEUE)                 \
     Y_UNIT_TEST(PushesPopsWithShift_ ## QUEUE) {                 \
-        TTestCases<SIZE_BITS, QUEUE>::PushesPopsWithShift();     \
+        TTestCases<SIZE_BITS, TAdaptorWithStats<QUEUE>::Type>::PushesPopsWithShift();     \
     }                                                            \
                                                                  \
     Y_UNIT_TEST(PushesOverloadPops_ ## QUEUE) {                  \
-        TTestCases<SIZE_BITS, QUEUE>::PushesOverloadPops();      \
+        TTestCases<SIZE_BITS, TAdaptorWithStats<QUEUE>::Type>::PushesOverloadPops();      \
     }                                                            \
                                                                  \
     Y_UNIT_TEST(CheckPushes_ ## QUEUE) {                         \
-        TTestCases<SIZE_BITS, QUEUE>::CheckPushes();             \
+        TTestCases<SIZE_BITS, TAdaptorWithStats<QUEUE>::Type>::CheckPushes();             \
     }                                                            \
 // end BASIC_QUEUE_TEST_CASES
 
 #define CHECK_SLOW_POPS(SIZE_BITS, QUEUE)                  \
     Y_UNIT_TEST(CheckSlowPops_ ## QUEUE) {                 \
-        TTestCases<SIZE_BITS, QUEUE>::CheckSlowPops();     \
+        TTestCases<SIZE_BITS, TAdaptorWithStats<QUEUE>::Type>::CheckSlowPops();     \
     }                                                      \
 // end CHECK_SLOW_POPS
 
 #define CHECK_FAST_POPS(SIZE_BITS, QUEUE)                  \
     Y_UNIT_TEST(CheckFastPops_ ## QUEUE) {                 \
-        TTestCases<SIZE_BITS, QUEUE>::CheckFastPops();     \
+        TTestCases<SIZE_BITS, TAdaptorWithStats<QUEUE>::Type>::CheckFastPops();     \
     }                                                      \
 // end CHECK_FAST_POPS
 
@@ -271,35 +271,35 @@ Y_UNIT_TEST_SUITE(MPMCRingQueueSingleThreadTests) {
 
     Y_UNIT_TEST(RandomUsageFast) {
         return;
-        TMPMCRingQueue<SizeBits> realQueue;
+        TMPMCRingQueueWithStats<SizeBits> realQueue;
         TestRandomUsage(
             10'000,
             (ui64(1) << SizeBits),
-            TVeryFastQueue<SizeBits>(&realQueue),
-            TFastQueue<SizeBits>(&realQueue)
+            TAdaptorWithStats<TFastQueue>::Type<SizeBits>(&realQueue),
+            TAdaptorWithStats<TVeryFastQueue>::Type<SizeBits>(&realQueue)
         );
     }
 
     Y_UNIT_TEST(RandomUsageSlow) {
-        TMPMCRingQueue<SizeBits> realQueue;
+        TMPMCRingQueueWithStats<SizeBits> realQueue;
         TestRandomUsage(
             10'000,
             (ui64(1) << SizeBits),
-            TVerySlowQueue<SizeBits>(&realQueue),
-            TSlowQueue<SizeBits>(&realQueue)
+            TAdaptorWithStats<TVerySlowQueue>::Type<SizeBits>(&realQueue),
+            TAdaptorWithStats<TSlowQueue>::Type<SizeBits>(&realQueue)
         );
     }
 
     Y_UNIT_TEST(RandomUsageAll) {
         return;
-        TMPMCRingQueue<SizeBits> realQueue;
+        TMPMCRingQueueWithStats<SizeBits> realQueue;
         TestRandomUsage(
             100'000,
             (ui64(1) << SizeBits),
-            TVerySlowQueue<SizeBits>(&realQueue),
-            TSlowQueue<SizeBits>(&realQueue),
-            TFastQueue<SizeBits>(&realQueue),
-            TVeryFastQueue<SizeBits>(&realQueue)
+            TAdaptorWithStats<TVerySlowQueue>::Type<SizeBits>(&realQueue),
+            TAdaptorWithStats<TSlowQueue>::Type<SizeBits>(&realQueue),
+            TAdaptorWithStats<TFastQueue>::Type<SizeBits>(&realQueue),
+            TAdaptorWithStats<TVeryFastQueue>::Type<SizeBits>(&realQueue)
         );
     }
 }
diff --git a/ydb/library/actors/queues/observer/defs.h b/ydb/library/actors/queues/observer/defs.h
new file mode 100644
index 000000000000..9fd7f4ea2ced
--- /dev/null
+++ b/ydb/library/actors/queues/observer/defs.h
@@ -0,0 +1,15 @@
+#pragma once
+
+// unique tag to fix pragma once gcc glueing: ./library/actors/util/defs.h
+
+#include <util/system/defaults.h>
+#include <util/generic/bt_exception.h>
+#include <util/generic/noncopyable.h>
+#include <util/generic/ptr.h>
+#include <util/generic/string.h>
+#include <util/generic/yexception.h>
+#include <library/cpp/deprecated/atomic/atomic.h>
+#include <util/system/align.h>
+#include <util/generic/vector.h>
+#include <util/datetime/base.h>
+#include <util/generic/ylimits.h>
diff --git a/ydb/library/actors/queues/observer/observer.cpp b/ydb/library/actors/queues/observer/observer.cpp
new file mode 100644
index 000000000000..b4090b5fc054
--- /dev/null
+++ b/ydb/library/actors/queues/observer/observer.cpp
@@ -0,0 +1,3 @@
+#include "observer.h"
+
+thread_local NActors::TStatsObserver::TStats NActors::TStatsObserver::Stats;
diff --git a/ydb/library/actors/queues/observer/observer.h b/ydb/library/actors/queues/observer/observer.h
new file mode 100644
index 000000000000..888247224254
--- /dev/null
+++ b/ydb/library/actors/queues/observer/observer.h
@@ -0,0 +1,203 @@
+#pragma once
+
+#include "defs.h"
+
+namespace NActors {
+
+    struct TStatsObserver {
+
+        struct TStats {
+            ui64 SuccessPush = 0;
+            ui64 SuccessSlowPush = 0;
+            ui64 SuccessFastPush = 0;
+
+            ui64 FailedPush = 0;
+            ui64 FailedSlowPushAttempt = 0;
+
+            ui64 ChangeFastPushToSlowPush = 0;
+            ui64 ChangeReallySlowPopToSlowPop = 0;
+
+            ui64 SuccessPop = 0;
+            ui64 SuccessSingleConsumerPop = 0;
+            ui64 SuccessSlowPop = 0;
+            ui64 SuccessFastPop = 0;
+            ui64 SuccessReallyFastPop = 0;
+
+            ui64 FailedPop = 0;
+            ui64 FailedSingleConsumerPop = 0;
+            ui64 FailedSingleConsumerPopAttempt = 0;
+            ui64 FailedReallySlowPop = 0;
+            ui64 FailedSlowPop = 0;
+            ui64 FailedSlowPopAttempt = 0;
+            ui64 FailedFastPop = 0;
+            ui64 FailedFastPopAttempt = 0;
+            ui64 FailedReallyFastPop = 0;
+            ui64 FailedReallyFastPopAttempt = 0;
+
+
+            ui64 InvalidatedSlot = 0;
+            ui64 InvalidatedSlotInSlowPop = 0;
+            ui64 InvalidatedSlotInFastPop = 0;
+            ui64 InvalidatedSlotInReallyFastPop = 0;
+
+            ui64 MoveTailBecauseHeadOvertakesInReallySlowPop = 0;
+            ui64 MoveTailBecauseHeadOvertakesInSlowPop = 0;
+            ui64 MoveTailBecauseHeadOvertakesInFastPop = 0;
+
+            ui64 FoundOldSlot = 0;
+            ui64 FoundOldSlotInSlowPush = 0;
+            ui64 FoundOldSlotInFastPush = 0;
+            ui64 FoundOldSlotInSlowPop = 0;
+            ui64 FoundOldSlotInFastPop = 0;
+            ui64 FoundOldSlotInReallyFastPop = 0;
+
+            ui64 LongPush10It = 0;
+            ui64 LongSlowPop10It = 0;
+            ui64 LongFastPop10It = 0;
+            ui64 LongReallyFastPop10It = 0;
+
+            ui64 LongPush100It = 0;
+            ui64 LongSlowPop100It = 0;
+            ui64 LongFastPop100It = 0;
+            ui64 LongReallyFastPop100It = 0;
+
+            ui64 LongPush1000It = 0;
+            ui64 LongSlowPop1000It = 0;
+            ui64 LongFastPop1000It = 0;
+            ui64 LongReallyFastPop1000It = 0;
+
+            TStats& operator += (const TStats &other) {
+                SuccessPush += other.SuccessPush;
+                SuccessSlowPush += other.SuccessSlowPush;
+                SuccessFastPush += other.SuccessFastPush;
+                ChangeFastPushToSlowPush += other.ChangeFastPushToSlowPush;
+                ChangeReallySlowPopToSlowPop += other.ChangeReallySlowPopToSlowPop;
+                FailedPush += other.FailedPush;
+                FailedSlowPushAttempt += other.FailedSlowPushAttempt;
+
+                SuccessPop += other.SuccessPop;
+                SuccessSingleConsumerPop += other.SuccessSingleConsumerPop;
+                SuccessSlowPop += other.SuccessSlowPop;
+                SuccessFastPop += other.SuccessFastPop;
+                SuccessReallyFastPop += other.SuccessReallyFastPop;
+
+                FailedPop += other.FailedPop;
+                FailedSingleConsumerPop += other.FailedSingleConsumerPop;
+                FailedSingleConsumerPopAttempt += other.FailedSingleConsumerPopAttempt;
+                FailedReallySlowPop += other.FailedReallySlowPop;
+                FailedSlowPop += other.FailedSlowPop;
+                FailedSlowPopAttempt += other.FailedSlowPopAttempt;
+                FailedFastPop += other.FailedFastPop;
+                FailedFastPopAttempt += other.FailedFastPopAttempt;
+                FailedReallyFastPop += other.FailedReallyFastPop;
+                FailedReallyFastPopAttempt += other.FailedReallyFastPopAttempt;
+
+                MoveTailBecauseHeadOvertakesInReallySlowPop += other.MoveTailBecauseHeadOvertakesInReallySlowPop;
+                MoveTailBecauseHeadOvertakesInSlowPop += other.MoveTailBecauseHeadOvertakesInSlowPop;
+                MoveTailBecauseHeadOvertakesInFastPop += other.MoveTailBecauseHeadOvertakesInFastPop;
+
+                InvalidatedSlot += other.InvalidatedSlot;
+                InvalidatedSlotInSlowPop += other.InvalidatedSlotInSlowPop;
+                InvalidatedSlotInFastPop += other.InvalidatedSlotInFastPop;
+                InvalidatedSlotInReallyFastPop += other.InvalidatedSlotInReallyFastPop;
+
+                FoundOldSlot += other.FoundOldSlot;
+                FoundOldSlotInSlowPush += other.FoundOldSlotInSlowPush;
+                FoundOldSlotInFastPush += other.FoundOldSlotInFastPush;
+                FoundOldSlotInSlowPop += other.FoundOldSlotInSlowPop;
+                FoundOldSlotInFastPop += other.FoundOldSlotInFastPop;
+                FoundOldSlotInReallyFastPop += other.FoundOldSlotInReallyFastPop;
+
+                LongPush10It += other.LongPush10It;
+                LongSlowPop10It += other.LongSlowPop10It;
+                LongFastPop10It += other.LongFastPop10It;
+                LongReallyFastPop10It += other.LongReallyFastPop10It;
+
+                LongPush100It += other.LongPush100It;
+                LongSlowPop100It += other.LongSlowPop100It;
+                LongFastPop100It += other.LongFastPop100It;
+                LongReallyFastPop100It += other.LongReallyFastPop100It;
+
+                LongPush1000It += other.LongPush1000It;
+                LongSlowPop100It += other.LongSlowPop1000It;
+                LongFastPop1000It += other.LongFastPop1000It;
+                LongReallyFastPop1000It += other.LongReallyFastPop1000It;
+
+                return *this;
+            }
+        };
+        static thread_local TStats Stats;
+
+        template <typename  ...TArgs>
+        static void IncrementMetrics(TArgs& ...args) {
+            auto dummy = [](...) {};
+            dummy(++args...);
+        }
+
+    #define DEFINE_INCREMENT_STATS_1(M1)                \
+        static void Observe ## M1() {                      \
+            IncrementMetrics(Stats.M1);                 \
+        }                                               \
+    // end DEFINE_INCREMENT_STATS_1
+
+    #define DEFINE_INCREMENT_STATS_2(M1, M2)            \
+        static void Observe ## M1() {                      \
+            IncrementMetrics(Stats.M1, Stats.M2);       \
+        }                                               \
+    // end DEFINE_INCREMENT_STATS_2
+
+        DEFINE_INCREMENT_STATS_2(SuccessSlowPush, SuccessPush)
+        DEFINE_INCREMENT_STATS_2(SuccessFastPush, SuccessPush)
+        DEFINE_INCREMENT_STATS_1(ChangeFastPushToSlowPush)
+        DEFINE_INCREMENT_STATS_1(FailedPush)
+        DEFINE_INCREMENT_STATS_1(FailedSlowPushAttempt)
+        DEFINE_INCREMENT_STATS_2(SuccessSingleConsumerPop, SuccessPop)
+        DEFINE_INCREMENT_STATS_2(FailedSingleConsumerPop, FailedPop)
+        DEFINE_INCREMENT_STATS_1(FailedSingleConsumerPopAttempt)
+        DEFINE_INCREMENT_STATS_1(MoveTailBecauseHeadOvertakesInReallySlowPop)
+        DEFINE_INCREMENT_STATS_2(FailedReallySlowPop, FailedPop)
+        DEFINE_INCREMENT_STATS_2(SuccessSlowPop, SuccessPop)
+        DEFINE_INCREMENT_STATS_2(FailedSlowPop, FailedPop)
+        DEFINE_INCREMENT_STATS_1(FailedSlowPopAttempt)
+        DEFINE_INCREMENT_STATS_1(ChangeReallySlowPopToSlowPop)
+        DEFINE_INCREMENT_STATS_2(SuccessFastPop, SuccessPop)
+        DEFINE_INCREMENT_STATS_2(FailedFastPop, FailedPop)
+        DEFINE_INCREMENT_STATS_1(MoveTailBecauseHeadOvertakesInFastPop)
+        DEFINE_INCREMENT_STATS_1(MoveTailBecauseHeadOvertakesInSlowPop)
+        DEFINE_INCREMENT_STATS_1(FailedFastPopAttempt)
+        DEFINE_INCREMENT_STATS_2(SuccessReallyFastPop, SuccessPop)
+        DEFINE_INCREMENT_STATS_2(FailedReallyFastPop, FailedPop)
+        DEFINE_INCREMENT_STATS_1(FailedReallyFastPopAttempt)
+        DEFINE_INCREMENT_STATS_2(InvalidatedSlotInSlowPop, InvalidatedSlot)
+        DEFINE_INCREMENT_STATS_2(InvalidatedSlotInFastPop, InvalidatedSlot)
+        DEFINE_INCREMENT_STATS_2(InvalidatedSlotInReallyFastPop, InvalidatedSlot)
+        
+        DEFINE_INCREMENT_STATS_2(FoundOldSlotInSlowPush, FoundOldSlot)
+        DEFINE_INCREMENT_STATS_2(FoundOldSlotInFastPush, FoundOldSlot)
+        DEFINE_INCREMENT_STATS_2(FoundOldSlotInSlowPop, FoundOldSlot)
+        DEFINE_INCREMENT_STATS_2(FoundOldSlotInFastPop, FoundOldSlot)
+        DEFINE_INCREMENT_STATS_2(FoundOldSlotInReallyFastPop, FoundOldSlot)
+
+        DEFINE_INCREMENT_STATS_1(LongPush10It)
+        DEFINE_INCREMENT_STATS_1(LongSlowPop10It)
+        DEFINE_INCREMENT_STATS_1(LongFastPop10It)
+        DEFINE_INCREMENT_STATS_1(LongReallyFastPop10It)
+
+        DEFINE_INCREMENT_STATS_1(LongPush100It)
+        DEFINE_INCREMENT_STATS_1(LongSlowPop100It)
+        DEFINE_INCREMENT_STATS_1(LongFastPop100It)
+        DEFINE_INCREMENT_STATS_1(LongReallyFastPop100It)
+
+        DEFINE_INCREMENT_STATS_1(LongPush1000It)
+        DEFINE_INCREMENT_STATS_1(LongSlowPop1000It)
+        DEFINE_INCREMENT_STATS_1(LongFastPop1000It)
+        DEFINE_INCREMENT_STATS_1(LongReallyFastPop1000It)
+    #undef DEFINE_INCREMENT_STATS_1
+    #undef DEFINE_INCREMENT_STATS_2
+
+        static TStats GetLocalStats() {
+            return Stats;
+        }
+    };
+
+}
\ No newline at end of file
diff --git a/ydb/library/actors/queues/observer/ya.make b/ydb/library/actors/queues/observer/ya.make
new file mode 100644
index 000000000000..eb0ec9a2c3ba
--- /dev/null
+++ b/ydb/library/actors/queues/observer/ya.make
@@ -0,0 +1,8 @@
+LIBRARY()
+
+SRCS(
+    observer.cpp
+)
+
+END()
+
diff --git a/ydb/library/actors/queues/ut/ya.make b/ydb/library/actors/queues/ut/ya.make
index c5c4c5cd3e71..c0158d9dae28 100644
--- a/ydb/library/actors/queues/ut/ya.make
+++ b/ydb/library/actors/queues/ut/ya.make
@@ -10,4 +10,9 @@ SRCS(
     mpmc_ring_queue_ut_multi_threads.cpp
 )
 
+PEERDIR(
+    ydb/library/actors/queues/observer
+)
+
+
 END()
diff --git a/ydb/library/actors/queues/ya.make b/ydb/library/actors/queues/ya.make
index e7dee4eca579..fd22675c827c 100644
--- a/ydb/library/actors/queues/ya.make
+++ b/ydb/library/actors/queues/ya.make
@@ -1,11 +1,4 @@
-LIBRARY()
 
-SRCS(
-    activation_queue.h
-    mpmc_ring_queue.cpp
-)
-
-END()
 
 RECURSE_FOR_TESTS(
     ut