Restoring authorship annotation for <iddqd@yandex-team.ru>. Commit 1 of 2.

author: iddqd <iddqd@yandex-team.ru> 2022-02-10 16:49:45 +0300
committer: Daniil Cherednik <dcherednik@yandex-team.ru> 2022-02-10 16:49:45 +0300
commit: 07fce9c5f7771600d0b3d70e1f88fd8a7e164d85 (patch)
tree: e4aa4750fbb864d70f8c06cf03d2750e979ea3bf /library
parent: af42068bf6cd93c976b80dd0388fa48cdf65da11 (diff)
download: ydb-07fce9c5f7771600d0b3d70e1f88fd8a7e164d85.tar.gz
70 files changed, 1325 insertions, 1325 deletions
diff --git a/library/cpp/actors/core/executor_thread.cpp b/library/cpp/actors/core/executor_thread.cpp
index 446b651efd..3f2742262c 100644
--- a/library/cpp/actors/core/executor_thread.cpp
+++ b/library/cpp/actors/core/executor_thread.cpp
@@ -10,9 +10,9 @@
 #include <library/cpp/actors/util/datetime.h>
 #include <library/cpp/actors/util/thread.h>
 
-#ifdef BALLOC
+#ifdef BALLOC 
 #include <library/cpp/balloc/optional/operators.h>
-#endif
+#endif 
 
 #ifdef _linux_
 #include <sys/syscall.h>
@@ -293,9 +293,9 @@ namespace NActors {
         AtomicSet(ThreadId, (ui64)tid);
 #endif
 
-#ifdef BALLOC
-        ThreadDisableBalloc();
-#endif
+#ifdef BALLOC 
+        ThreadDisableBalloc(); 
+#endif 
 
         if (ThreadName) {
             ::SetCurrentThreadName(ThreadName);
diff --git a/library/cpp/actors/core/scheduler_basic.cpp b/library/cpp/actors/core/scheduler_basic.cpp
index fba200e16b..c9b9b836d8 100644
--- a/library/cpp/actors/core/scheduler_basic.cpp
+++ b/library/cpp/actors/core/scheduler_basic.cpp
@@ -4,9 +4,9 @@
 #include <library/cpp/actors/util/datetime.h>
 #include <library/cpp/actors/util/thread.h>
 
-#ifdef BALLOC
+#ifdef BALLOC 
 #include <library/cpp/balloc/optional/operators.h>
-#endif
+#endif 
 
 namespace NActors {
 
@@ -50,9 +50,9 @@ namespace NActors {
     }
 
     void TBasicSchedulerThread::CycleFunc() {
-#ifdef BALLOC
-        ThreadDisableBalloc();
-#endif
+#ifdef BALLOC 
+        ThreadDisableBalloc(); 
+#endif 
         ::SetCurrentThreadName("Scheduler");
 
         ui64 currentMonotonic = RelaxedLoad(CurrentMonotonic);
diff --git a/library/cpp/actors/core/ya.make b/library/cpp/actors/core/ya.make
index 880a9d00db..afaf58f12f 100644
--- a/library/cpp/actors/core/ya.make
+++ b/library/cpp/actors/core/ya.make
@@ -16,8 +16,8 @@ IF (ALLOCATOR == "B" OR ALLOCATOR == "BS" OR ALLOCATOR == "C")
     PEERDIR(
         library/cpp/balloc/optional
     )
-ENDIF()
-
+ENDIF() 
+ 
 SRCS(
     actor_bootstrapped.h
     actor_coroutine.cpp
diff --git a/library/cpp/balloc/balloc.cpp b/library/cpp/balloc/balloc.cpp
index fab489db4c..5996f84529 100644
--- a/library/cpp/balloc/balloc.cpp
+++ b/library/cpp/balloc/balloc.cpp
@@ -24,7 +24,7 @@ namespace NBalloc {
             // ltls.Mode == Disabled
             const size_t extsize = size + sizeof(TAllocHeader);
             TAllocHeader* allocHeader = (TAllocHeader*)LibcMalloc(extsize);
-            allocHeader->Encode(allocHeader, size, DISABLED_SIGNATURE);
+            allocHeader->Encode(allocHeader, size, DISABLED_SIGNATURE); 
             return allocHeader + 1;
         }
     }
diff --git a/library/cpp/bucket_quoter/bucket_quoter.h b/library/cpp/bucket_quoter/bucket_quoter.h
index 3d92ef8450..5f22b6d833 100644
--- a/library/cpp/bucket_quoter/bucket_quoter.h
+++ b/library/cpp/bucket_quoter/bucket_quoter.h
@@ -155,7 +155,7 @@ public:
         return Max<i64>(0, Bucket);
     }
 
-    void Use(ui64 tokens, bool sleep = false) {
+    void Use(ui64 tokens, bool sleep = false) { 
         TGuard<Lock> g(BucketMutex);
         UseNoLock(tokens, sleep);
     }
diff --git a/library/cpp/cache/thread_safe_cache.h b/library/cpp/cache/thread_safe_cache.h
index 71e1442717..99659a5194 100644
--- a/library/cpp/cache/thread_safe_cache.h
+++ b/library/cpp/cache/thread_safe_cache.h
@@ -1,11 +1,11 @@
-#pragma once
-
-#include "cache.h"
-
-#include <util/generic/singleton.h>
-#include <util/system/rwlock.h>
-
-namespace NPrivate {
+#pragma once 
+ 
+#include "cache.h" 
+ 
+#include <util/generic/singleton.h> 
+#include <util/system/rwlock.h> 
+ 
+namespace NPrivate { 
     // We are interested in getters promotion policy _here_ because of Read-Write-Lock optimizations.
     enum class EGettersPromotionPolicy {
         Promoted,   // LRU, TLRU, MRU, etc.
@@ -13,29 +13,29 @@ namespace NPrivate {
     };
 
     template <class Key, class Value, template <class, class> class List, EGettersPromotionPolicy GettersPromotionPolicy, class... TArgs>
-    class TThreadSafeCache {
-    public:
+    class TThreadSafeCache { 
+    public: 
         using TPtr = TAtomicSharedPtr<Value>;
 
-        class ICallbacks {
-        public:
-            using TKey = Key;
-            using TValue = Value;
+        class ICallbacks { 
+        public: 
+            using TKey = Key; 
+            using TValue = Value; 
             using TOwner = TThreadSafeCache<Key, Value, List, GettersPromotionPolicy, TArgs...>;
-
-        public:
+ 
+        public: 
             virtual ~ICallbacks() = default;
-            virtual TKey GetKey(TArgs... args) const = 0;
-            virtual TValue* CreateObject(TArgs... args) const = 0;
-        };
-
-    public:
+            virtual TKey GetKey(TArgs... args) const = 0; 
+            virtual TValue* CreateObject(TArgs... args) const = 0; 
+        }; 
+ 
+    public: 
         TThreadSafeCache(const ICallbacks& callbacks, size_t maxSize = Max<size_t>())
-            : Callbacks(callbacks)
+            : Callbacks(callbacks) 
             , Cache(maxSize)
         {
         }
-
+ 
         bool Insert(const Key& key, const TPtr& value) {
             if (!Contains(key)) {
                 TWriteGuard w(Mutex);
@@ -51,17 +51,17 @@ namespace NPrivate {
 
         const TPtr Get(TArgs... args) const {
             return GetValue<true>(args...);
-        }
-
+        } 
+ 
         const TPtr GetUnsafe(TArgs... args) const {
             return GetValue<false>(args...);
         }
 
-        void Clear() {
-            TWriteGuard w(Mutex);
-            Cache.Clear();
-        }
-
+        void Clear() { 
+            TWriteGuard w(Mutex); 
+            Cache.Clear(); 
+        } 
+ 
         void Erase(TArgs... args) {
             Key key = Callbacks.GetKey(args...);
             if (!Contains(key)) {
@@ -83,19 +83,19 @@ namespace NPrivate {
 
         template <class TCallbacks>
         static const TPtr Get(TArgs... args) {
-            return TThreadSafeCacheSingleton<TCallbacks>::Get(args...);
-        }
-
+            return TThreadSafeCacheSingleton<TCallbacks>::Get(args...); 
+        } 
+ 
         template <class TCallbacks>
         static const TPtr Erase(TArgs... args) {
             return TThreadSafeCacheSingleton<TCallbacks>::Erase(args...);
         }
 
         template <class TCallbacks>
-        static void Clear() {
-            return TThreadSafeCacheSingleton<TCallbacks>::Clear();
-        }
-
+        static void Clear() { 
+            return TThreadSafeCacheSingleton<TCallbacks>::Clear(); 
+        } 
+ 
         size_t GetMaxSize() const {
             TReadGuard w(Mutex);
             return Cache.GetMaxSize();
@@ -106,7 +106,7 @@ namespace NPrivate {
             Cache.SetMaxSize(newSize);
         }
 
-    private:
+    private: 
         template <bool AllowNullValues>
         const TPtr GetValue(TArgs... args) const {
             Key key = Callbacks.GetKey(args...);
@@ -136,53 +136,53 @@ namespace NPrivate {
 
     private:
         using TInternalCache = TCache<Key, TPtr, List<Key, TPtr>, TNoopDelete>;
-
-        template <class TCallbacks>
-        class TThreadSafeCacheSingleton {
-        public:
+ 
+        template <class TCallbacks> 
+        class TThreadSafeCacheSingleton { 
+        public: 
             static const TPtr Get(TArgs... args) {
-                return Singleton<TThreadSafeCacheSingleton>()->Cache.Get(args...);
-            }
-
+                return Singleton<TThreadSafeCacheSingleton>()->Cache.Get(args...); 
+            } 
+ 
             static const TPtr Erase(TArgs... args) {
                 return Singleton<TThreadSafeCacheSingleton>()->Cache.Erase(args...);
             }
 
-            static void Clear() {
-                return Singleton<TThreadSafeCacheSingleton>()->Cache.Clear();
-            }
-
-            TThreadSafeCacheSingleton()
-                : Cache(Callbacks)
+            static void Clear() { 
+                return Singleton<TThreadSafeCacheSingleton>()->Cache.Clear(); 
+            } 
+ 
+            TThreadSafeCacheSingleton() 
+                : Cache(Callbacks) 
             {
             }
-
-        private:
-            TCallbacks Callbacks;
-            typename TCallbacks::TOwner Cache;
-        };
-
-    private:
-        TRWMutex Mutex;
-        const ICallbacks& Callbacks;
+ 
+        private: 
+            TCallbacks Callbacks; 
+            typename TCallbacks::TOwner Cache; 
+        }; 
+ 
+    private: 
+        TRWMutex Mutex; 
+        const ICallbacks& Callbacks; 
         mutable TInternalCache Cache;
-    };
-
-    struct TLWHelper {
-        template <class TValue>
-        struct TConstWeighter {
-            static int Weight(const TValue& /*value*/) {
-                return 0;
-            }
-        };
-
-        template <class TKey, class TValue>
+    }; 
+ 
+    struct TLWHelper { 
+        template <class TValue> 
+        struct TConstWeighter { 
+            static int Weight(const TValue& /*value*/) { 
+                return 0; 
+            } 
+        }; 
+ 
+        template <class TKey, class TValue> 
         using TListType = TLWList<TKey, TValue, int, TConstWeighter<TValue>>;
-
-        template <class TKey, class TValue, class... TArgs>
+ 
+        template <class TKey, class TValue, class... TArgs> 
         using TCache = TThreadSafeCache<TKey, TValue, TListType, EGettersPromotionPolicy::Unpromoted, TArgs...>;
-    };
-
+    }; 
+ 
     struct TLRUHelper {
         template <class TKey, class TValue>
         using TListType = TLRUList<TKey, TValue>;
@@ -191,10 +191,10 @@ namespace NPrivate {
         using TCache = TThreadSafeCache<TKey, TValue, TListType, EGettersPromotionPolicy::Promoted, TArgs...>;
     };
 
-}
-
-template <class TKey, class TValue, class... TArgs>
-using TThreadSafeCache = typename NPrivate::TLWHelper::template TCache<TKey, TValue, TArgs...>;
+} 
+ 
+template <class TKey, class TValue, class... TArgs> 
+using TThreadSafeCache = typename NPrivate::TLWHelper::template TCache<TKey, TValue, TArgs...>; 
 
 template <class TKey, class TValue, class... TArgs>
 using TThreadSafeLRUCache = typename NPrivate::TLRUHelper::template TCache<TKey, TValue, TArgs...>;
diff --git a/library/cpp/cache/ut/cache_ut.cpp b/library/cpp/cache/ut/cache_ut.cpp
index 329872cfde..c3b984995e 100644
--- a/library/cpp/cache/ut/cache_ut.cpp
+++ b/library/cpp/cache/ut/cache_ut.cpp
@@ -356,30 +356,30 @@ Y_UNIT_TEST_SUITE(TCacheTest) {
         UNIT_ASSERT(s.Find(1) != s.End()); // Key 2 should have been deleted
     }
 }
-
+ 
 Y_UNIT_TEST_SUITE(TThreadSafeCacheTest) {
     typedef TThreadSafeCache<ui32, TString, ui32> TCache;
-
-    const char* VALS[] = {"abcd", "defg", "hjkl"};
-
+ 
+    const char* VALS[] = {"abcd", "defg", "hjkl"}; 
+ 
     class TCallbacks: public TCache::ICallbacks {
-    public:
+    public: 
         TKey GetKey(ui32 i) const override {
-            return i;
-        }
+            return i; 
+        } 
         TValue* CreateObject(ui32 i) const override {
             Creations++;
             return new TString(VALS[i]);
-        }
+        } 
 
         mutable i32 Creations = 0;
-    };
-
+    }; 
+ 
     Y_UNIT_TEST(SimpleTest) {
         for (ui32 i = 0; i < Y_ARRAY_SIZE(VALS); ++i) {
             const TString data = *TCache::Get<TCallbacks>(i);
             UNIT_ASSERT(data == VALS[i]);
-        }
+        } 
     }
 
     Y_UNIT_TEST(InsertUpdateTest) {
@@ -404,7 +404,7 @@ Y_UNIT_TEST_SUITE(TThreadSafeCacheTest) {
         UNIT_ASSERT(callbacks.Creations == 0);
         UNIT_ASSERT(*item == "hjk");
     }
-}
+} 
 
 Y_UNIT_TEST_SUITE(TThreadSafeCacheUnsafeTest) {
     typedef TThreadSafeCache<ui32, TString, ui32> TCache;
diff --git a/library/cpp/digest/md5/md5.h b/library/cpp/digest/md5/md5.h
index 2c17aa0518..49367658a3 100644
--- a/library/cpp/digest/md5/md5.h
+++ b/library/cpp/digest/md5/md5.h
@@ -13,7 +13,7 @@ public:
 
     void Init();
 
-    inline MD5& Update(const void* data, size_t len) {
+    inline MD5& Update(const void* data, size_t len) { 
         return Update(MakeArrayRef(static_cast<const ui8*>(data), len));
     }
 
@@ -23,7 +23,7 @@ public:
 
     inline MD5& Update(const TArrayRef<const ui8> data) {
         UpdatePart(data);
-        return *this;
+        return *this; 
     }
 
     void Pad();
diff --git a/library/cpp/histogram/ya.make b/library/cpp/histogram/ya.make
index 77cfd96902..d06b9f6838 100644
--- a/library/cpp/histogram/ya.make
+++ b/library/cpp/histogram/ya.make
@@ -4,6 +4,6 @@ RECURSE(
     hdr/ut
     simple
     simple/ut
-    rt
-    rt/ut
+    rt 
+    rt/ut 
 )
diff --git a/library/cpp/http/io/stream_ut.cpp b/library/cpp/http/io/stream_ut.cpp
index 1ea35df675..286f73259d 100644
--- a/library/cpp/http/io/stream_ut.cpp
+++ b/library/cpp/http/io/stream_ut.cpp
@@ -266,27 +266,27 @@ Y_UNIT_TEST_SUITE(THttpStreamTest) {
         TString res = "qqqqqq\r\n\r\nsdasdsad\r\n";
         TPortManager pm;
         const ui16 port = pm.GetPort();
-
-        TTestHttpServer serverImpl(res);
-        THttpServer server(&serverImpl, THttpServer::TOptions(port).EnableKeepAlive(true).EnableCompression(true));
-
-        UNIT_ASSERT(server.Start());
-
-        TNetworkAddress addr("localhost", port);
-
-        TSocket s(addr);
-
+ 
+        TTestHttpServer serverImpl(res); 
+        THttpServer server(&serverImpl, THttpServer::TOptions(port).EnableKeepAlive(true).EnableCompression(true)); 
+ 
+        UNIT_ASSERT(server.Start()); 
+ 
+        TNetworkAddress addr("localhost", port); 
+ 
+        TSocket s(addr); 
+ 
         SendMinimalHttpRequest(s, "www.yandex.ru", "/");
-
-        TSocketInput si(s);
-        THttpInput input(&si);
-        unsigned httpCode = ParseHttpRetCode(input.FirstLine());
-        UNIT_ASSERT_VALUES_EQUAL(httpCode, 200u);
+ 
+        TSocketInput si(s); 
+        THttpInput input(&si); 
+        unsigned httpCode = ParseHttpRetCode(input.FirstLine()); 
+        UNIT_ASSERT_VALUES_EQUAL(httpCode, 200u); 
         TString reply = input.ReadAll();
-        UNIT_ASSERT_VALUES_EQUAL(reply, res);
-        server.Stop();
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL(reply, res); 
+        server.Stop(); 
+    } 
+ 
     Y_UNIT_TEST(TestOutputFlush) {
         TString str;
         TStringOutput strOut(str);
diff --git a/library/cpp/http/server/http.cpp b/library/cpp/http/server/http.cpp
index 128583bdd7..bd6b13ca85 100644
--- a/library/cpp/http/server/http.cpp
+++ b/library/cpp/http/server/http.cpp
@@ -429,7 +429,7 @@ public:
     inline void DecreaseConnections() noexcept {
         AtomicDecrement(ConnectionCount);
     }
-
+ 
     inline void IncreaseConnections() noexcept {
         AtomicIncrement(ConnectionCount);
     }
@@ -495,10 +495,10 @@ THttpServer::THttpServer(ICallBack* cb, TMtpQueueRef mainWorkers, TMtpQueueRef f
 THttpServer::~THttpServer() {
 }
 
-i64 THttpServer::GetClientCount() const {
-    return Impl_->GetClientCount();
-}
-
+i64 THttpServer::GetClientCount() const { 
+    return Impl_->GetClientCount(); 
+} 
+ 
 bool THttpServer::Start() {
     return Impl_->Start();
 }
diff --git a/library/cpp/lfalloc/lf_allocX64.cpp b/library/cpp/lfalloc/lf_allocX64.cpp
index 2eb90761fe..e3dcac8e96 100644
--- a/library/cpp/lfalloc/lf_allocX64.cpp
+++ b/library/cpp/lfalloc/lf_allocX64.cpp
@@ -1,4 +1,4 @@
-#include "lf_allocX64.h"
+#include "lf_allocX64.h" 
 
 //////////////////////////////////////////////////////////////////////////
 // hooks
@@ -8,14 +8,14 @@
 #define OP_THROWNOTHING
 #endif
 
-#ifndef _darwin_
+#ifndef _darwin_ 
 #if !defined(YMAKE)
 void* operator new(size_t size) {
-    return LFAlloc(size);
+    return LFAlloc(size); 
 }
 
 void* operator new(size_t size, const std::nothrow_t&) OP_THROWNOTHING {
-    return LFAlloc(size);
+    return LFAlloc(size); 
 }
 
 void operator delete(void* p)OP_THROWNOTHING {
@@ -27,11 +27,11 @@ void operator delete(void* p, const std::nothrow_t&)OP_THROWNOTHING {
 }
 
 void* operator new[](size_t size) {
-    return LFAlloc(size);
+    return LFAlloc(size); 
 }
 
 void* operator new[](size_t size, const std::nothrow_t&) OP_THROWNOTHING {
-    return LFAlloc(size);
+    return LFAlloc(size); 
 }
 
 void operator delete[](void* p) OP_THROWNOTHING {
@@ -46,20 +46,20 @@ void operator delete[](void* p, const std::nothrow_t&) OP_THROWNOTHING {
 //#ifndef _MSC_VER
 
 extern "C" void* malloc(size_t size) {
-    return LFAlloc(size);
+    return LFAlloc(size); 
 }
 
 extern "C" void* valloc(size_t size) {
-    return LFVAlloc(size);
+    return LFVAlloc(size); 
 }
 
 extern "C" int posix_memalign(void** memptr, size_t alignment, size_t size) {
-    return LFPosixMemalign(memptr, alignment, size);
+    return LFPosixMemalign(memptr, alignment, size); 
 }
 
 extern "C" void* memalign(size_t alignment, size_t size) {
     void* ptr;
-    int res = LFPosixMemalign(&ptr, alignment, size);
+    int res = LFPosixMemalign(&ptr, alignment, size); 
     return res ? nullptr : ptr;
 }
 
@@ -84,7 +84,7 @@ extern "C" void* calloc(size_t n, size_t elem_size) {
     if (elem_size != 0 && size / elem_size != n)
         return nullptr;
 
-    void* result = LFAlloc(size);
+    void* result = LFAlloc(size); 
     if (result != nullptr) {
         memset(result, 0, size);
     }
@@ -97,7 +97,7 @@ extern "C" void cfree(void* ptr) {
 
 extern "C" void* realloc(void* old_ptr, size_t new_size) {
     if (old_ptr == nullptr) {
-        void* result = LFAlloc(new_size);
+        void* result = LFAlloc(new_size); 
         return result;
     }
     if (new_size == 0) {
@@ -105,7 +105,7 @@ extern "C" void* realloc(void* old_ptr, size_t new_size) {
         return nullptr;
     }
 
-    void* new_ptr = LFAlloc(new_size);
+    void* new_ptr = LFAlloc(new_size); 
     if (new_ptr == nullptr) {
         return nullptr;
     }
@@ -122,20 +122,20 @@ extern "C" size_t malloc_usable_size(void* ptr) {
     return LFGetSize(ptr);
 }
 
-NMalloc::TMallocInfo NMalloc::MallocInfo() {
-    NMalloc::TMallocInfo r;
-#if defined(LFALLOC_DBG)
-    r.Name = "lfalloc_dbg";
-#elif defined(LFALLOC_YT)
-    r.Name = "lfalloc_yt";
-#else
-    r.Name = "lfalloc";
-#endif
-    r.SetParam = &LFAlloc_SetParam;
-    r.GetParam = &LFAlloc_GetParam;
-    return r;
-}
+NMalloc::TMallocInfo NMalloc::MallocInfo() { 
+    NMalloc::TMallocInfo r; 
+#if defined(LFALLOC_DBG) 
+    r.Name = "lfalloc_dbg"; 
+#elif defined(LFALLOC_YT) 
+    r.Name = "lfalloc_yt"; 
 #else
+    r.Name = "lfalloc"; 
+#endif 
+    r.SetParam = &LFAlloc_SetParam; 
+    r.GetParam = &LFAlloc_GetParam; 
+    return r; 
+} 
+#else 
 NMalloc::TMallocInfo NMalloc::MallocInfo() {
     NMalloc::TMallocInfo r;
     r.Name = "system-darwin";
diff --git a/library/cpp/lfalloc/lf_allocX64.h b/library/cpp/lfalloc/lf_allocX64.h
index fd2a906d6f..6b13d74102 100644
--- a/library/cpp/lfalloc/lf_allocX64.h
+++ b/library/cpp/lfalloc/lf_allocX64.h
@@ -1,5 +1,5 @@
-#pragma once
-
+#pragma once 
+ 
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
@@ -1504,7 +1504,7 @@ extern "C" void GetPerTagAllocInfo(
 #endif // LFALLOC_DBG
 
 //////////////////////////////////////////////////////////////////////////
-static Y_FORCE_INLINE void* LFAllocImpl(size_t _nSize) {
+static Y_FORCE_INLINE void* LFAllocImpl(size_t _nSize) { 
 #if defined(LFALLOC_DBG)
     size_t size = _nSize;
     _nSize += sizeof(TAllocHeader);
@@ -1571,13 +1571,13 @@ static Y_FORCE_INLINE void* LFAllocImpl(size_t _nSize) {
     }
 }
 
-static Y_FORCE_INLINE void* LFAlloc(size_t _nSize) {
-    void* res = LFAllocImpl(_nSize);
+static Y_FORCE_INLINE void* LFAlloc(size_t _nSize) { 
+    void* res = LFAllocImpl(_nSize); 
 #ifdef DBG_FILL_MEMORY
     if (FillMemoryOnAllocation && res && (_nSize <= DBG_FILL_MAX_SIZE)) {
         memset(res, 0xcf, _nSize);
     }
-#endif
+#endif 
     return res;
 }
 
@@ -1868,7 +1868,7 @@ static const char* LFAlloc_GetParam(const char* param) {
     return nullptr;
 }
 
-static Y_FORCE_INLINE int LFPosixMemalign(void** memptr, size_t alignment, size_t size) {
+static Y_FORCE_INLINE int LFPosixMemalign(void** memptr, size_t alignment, size_t size) { 
     if (Y_UNLIKELY(alignment > 4096)) {
         const char* error = "Larger alignment are not guaranteed with this implementation\n";
 #ifdef _win_
@@ -1888,7 +1888,7 @@ static Y_FORCE_INLINE int LFPosixMemalign(void** memptr, size_t alignment, size_
     }
 #endif
 
-    *memptr = LFAlloc(bigsize);
+    *memptr = LFAlloc(bigsize); 
 
 #if defined(LFALLOC_DBG)
     if (alignment > sizeof(TAllocHeader)) {
diff --git a/library/cpp/logger/backend_creator.cpp b/library/cpp/logger/backend_creator.cpp
index ea430edb83..fdcdd02f7e 100644
--- a/library/cpp/logger/backend_creator.cpp
+++ b/library/cpp/logger/backend_creator.cpp
@@ -1,45 +1,45 @@
-#include "backend_creator.h"
-#include "stream.h"
-#include "uninitialized_creator.h"
-#include <util/system/yassert.h>
-#include <util/stream/debug.h>
-#include <util/stream/output.h>
-
-
-THolder<TLogBackend> ILogBackendCreator::CreateLogBackend() const {
-    try {
-        return DoCreateLogBackend();
-    } catch(...) {
-        Cdbg << "Warning: " << CurrentExceptionMessage() << ". Use stderr instead." << Endl;
-    }
-    return MakeHolder<TStreamLogBackend>(&Cerr);
-}
-
-bool ILogBackendCreator::Init(const IInitContext& /*ctx*/) {
-    return true;
-}
-
-
-NJson::TJsonValue ILogBackendCreator::AsJson() const {
-    NJson::TJsonValue json;
-    ToJson(json);
-    return json;
-}
-
-THolder<ILogBackendCreator> ILogBackendCreator::Create(const IInitContext& ctx) {
-    auto res = MakeHolder<TLogBackendCreatorUninitialized>();
-    if(!res->Init(ctx)) {
-        Cdbg << "Cannot init log backend creator";
-        return nullptr;
-    }
-    return res;
-}
-
-TLogBackendCreatorBase::TLogBackendCreatorBase(const TString& type)
-    : Type(type)
-{}
-
-void TLogBackendCreatorBase::ToJson(NJson::TJsonValue& value) const {
-    value["LoggerType"] = Type;
-    DoToJson(value);
-}
+#include "backend_creator.h" 
+#include "stream.h" 
+#include "uninitialized_creator.h" 
+#include <util/system/yassert.h> 
+#include <util/stream/debug.h> 
+#include <util/stream/output.h> 
+ 
+ 
+THolder<TLogBackend> ILogBackendCreator::CreateLogBackend() const { 
+    try { 
+        return DoCreateLogBackend(); 
+    } catch(...) { 
+        Cdbg << "Warning: " << CurrentExceptionMessage() << ". Use stderr instead." << Endl; 
+    } 
+    return MakeHolder<TStreamLogBackend>(&Cerr); 
+} 
+ 
+bool ILogBackendCreator::Init(const IInitContext& /*ctx*/) { 
+    return true; 
+} 
+ 
+ 
+NJson::TJsonValue ILogBackendCreator::AsJson() const { 
+    NJson::TJsonValue json; 
+    ToJson(json); 
+    return json; 
+} 
+ 
+THolder<ILogBackendCreator> ILogBackendCreator::Create(const IInitContext& ctx) { 
+    auto res = MakeHolder<TLogBackendCreatorUninitialized>(); 
+    if(!res->Init(ctx)) { 
+        Cdbg << "Cannot init log backend creator"; 
+        return nullptr; 
+    } 
+    return res; 
+} 
+ 
+TLogBackendCreatorBase::TLogBackendCreatorBase(const TString& type) 
+    : Type(type) 
+{} 
+ 
+void TLogBackendCreatorBase::ToJson(NJson::TJsonValue& value) const { 
+    value["LoggerType"] = Type; 
+    DoToJson(value); 
+} 
diff --git a/library/cpp/logger/backend_creator.h b/library/cpp/logger/backend_creator.h
index 4f0ca24a4e..0394b9ccdb 100644
--- a/library/cpp/logger/backend_creator.h
+++ b/library/cpp/logger/backend_creator.h
@@ -1,59 +1,59 @@
-#pragma once
-
-#include "backend.h"
-#include <library/cpp/object_factory/object_factory.h>
-#include <library/cpp/json/json_value.h>
-#include <util/generic/vector.h>
-#include <util/generic/ptr.h>
-#include <util/string/cast.h>
-
-class ILogBackendCreator {
-public:
-    using TFactory = NObjectFactory::TObjectFactory<ILogBackendCreator, TString>;
-
-    class IInitContext {
-    public:
-        template<class T>
-        bool GetValue(TStringBuf name, T& var) const {
-            TString tmp;
-            if (!GetValue(name, tmp)) {
-                return false;
-            }
-            var = FromString<T>(tmp);
-            return true;
-        }
-
-        template<class T>
-        T GetOrElse(TStringBuf name, const T& def) const {
-            T res;
-            return GetValue(name, res) ? res : def;
-        }
-
-        virtual ~IInitContext() = default;
-        virtual bool GetValue(TStringBuf name, TString& var) const = 0;
-        virtual TVector<THolder<IInitContext>> GetChildren(TStringBuf name) const = 0;
-    };
-
-public:
-    virtual ~ILogBackendCreator() = default;
-    THolder<TLogBackend> CreateLogBackend() const;
-    virtual bool Init(const IInitContext& ctx);
-
-    NJson::TJsonValue AsJson() const;
-    virtual void ToJson(NJson::TJsonValue& value) const = 0;
-
-    static THolder<ILogBackendCreator> Create(const IInitContext& ctx);
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const = 0;
-};
-
-class TLogBackendCreatorBase: public ILogBackendCreator {
-public:
-    TLogBackendCreatorBase(const TString& type);
-    virtual void ToJson(NJson::TJsonValue& value) const override final;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const = 0;
-    TString Type;
-};
+#pragma once 
+ 
+#include "backend.h" 
+#include <library/cpp/object_factory/object_factory.h> 
+#include <library/cpp/json/json_value.h> 
+#include <util/generic/vector.h> 
+#include <util/generic/ptr.h> 
+#include <util/string/cast.h> 
+ 
+class ILogBackendCreator { 
+public: 
+    using TFactory = NObjectFactory::TObjectFactory<ILogBackendCreator, TString>; 
+ 
+    class IInitContext { 
+    public: 
+        template<class T> 
+        bool GetValue(TStringBuf name, T& var) const { 
+            TString tmp; 
+            if (!GetValue(name, tmp)) { 
+                return false; 
+            } 
+            var = FromString<T>(tmp); 
+            return true; 
+        } 
+ 
+        template<class T> 
+        T GetOrElse(TStringBuf name, const T& def) const { 
+            T res; 
+            return GetValue(name, res) ? res : def; 
+        } 
+ 
+        virtual ~IInitContext() = default; 
+        virtual bool GetValue(TStringBuf name, TString& var) const = 0; 
+        virtual TVector<THolder<IInitContext>> GetChildren(TStringBuf name) const = 0; 
+    }; 
+ 
+public: 
+    virtual ~ILogBackendCreator() = default; 
+    THolder<TLogBackend> CreateLogBackend() const; 
+    virtual bool Init(const IInitContext& ctx); 
+ 
+    NJson::TJsonValue AsJson() const; 
+    virtual void ToJson(NJson::TJsonValue& value) const = 0; 
+ 
+    static THolder<ILogBackendCreator> Create(const IInitContext& ctx); 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const = 0; 
+}; 
+ 
+class TLogBackendCreatorBase: public ILogBackendCreator { 
+public: 
+    TLogBackendCreatorBase(const TString& type); 
+    virtual void ToJson(NJson::TJsonValue& value) const override final; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const = 0; 
+    TString Type; 
+}; 
diff --git a/library/cpp/logger/composite.cpp b/library/cpp/logger/composite.cpp
index 3ce0154ced..669dc44525 100644
--- a/library/cpp/logger/composite.cpp
+++ b/library/cpp/logger/composite.cpp
@@ -1,18 +1,18 @@
-#include "composite.h"
-#include "uninitialized_creator.h"
-
-void TCompositeLogBackend::WriteData(const TLogRecord& rec) {
-    for (auto& slave: Slaves) {
-        slave->WriteData(rec);
-    }
-}
-
-void TCompositeLogBackend::ReopenLog() {
-    for (auto& slave : Slaves) {
-        slave->ReopenLog();
-    }
-}
-
-void TCompositeLogBackend::AddLogBackend(THolder<TLogBackend>&& backend) {
-    Slaves.emplace_back(std::move(backend));
-}
+#include "composite.h" 
+#include "uninitialized_creator.h" 
+ 
+void TCompositeLogBackend::WriteData(const TLogRecord& rec) { 
+    for (auto& slave: Slaves) { 
+        slave->WriteData(rec); 
+    } 
+} 
+ 
+void TCompositeLogBackend::ReopenLog() { 
+    for (auto& slave : Slaves) { 
+        slave->ReopenLog(); 
+    } 
+} 
+ 
+void TCompositeLogBackend::AddLogBackend(THolder<TLogBackend>&& backend) { 
+    Slaves.emplace_back(std::move(backend)); 
+} 
diff --git a/library/cpp/logger/composite.h b/library/cpp/logger/composite.h
index 142c61b8d5..7dd9bec5fa 100644
--- a/library/cpp/logger/composite.h
+++ b/library/cpp/logger/composite.h
@@ -1,14 +1,14 @@
-#pragma once
-
-#include "backend.h"
-#include <util/generic/vector.h>
-
-class TCompositeLogBackend: public TLogBackend {
-public:
-    virtual void WriteData(const TLogRecord& rec) override;
-    virtual void ReopenLog() override;
-    virtual void AddLogBackend(THolder<TLogBackend>&& backend);
-
-private:
-    TVector<THolder<TLogBackend>> Slaves;
-};
+#pragma once 
+ 
+#include "backend.h" 
+#include <util/generic/vector.h> 
+ 
+class TCompositeLogBackend: public TLogBackend { 
+public: 
+    virtual void WriteData(const TLogRecord& rec) override; 
+    virtual void ReopenLog() override; 
+    virtual void AddLogBackend(THolder<TLogBackend>&& backend); 
+ 
+private: 
+    TVector<THolder<TLogBackend>> Slaves; 
+}; 
diff --git a/library/cpp/logger/composite_creator.cpp b/library/cpp/logger/composite_creator.cpp
index 2064265766..f85e9ebb69 100644
--- a/library/cpp/logger/composite_creator.cpp
+++ b/library/cpp/logger/composite_creator.cpp
@@ -1,34 +1,34 @@
-#include "composite_creator.h"
-#include "composite.h"
-#include "uninitialized_creator.h"
-
-THolder<TLogBackend> TCompositeBackendCreator::DoCreateLogBackend() const {
-    auto res = MakeHolder<TCompositeLogBackend>();
-    for (const auto& child : Children) {
-        res->AddLogBackend(child->CreateLogBackend());
-    }
-    return std::move(res);
-}
-
-
-TCompositeBackendCreator::TCompositeBackendCreator()
-    : TLogBackendCreatorBase("composite")
-{}
-
-bool TCompositeBackendCreator::Init(const IInitContext& ctx) {
-    for (const auto& child : ctx.GetChildren("SubLogger")) {
-        Children.emplace_back(MakeHolder<TLogBackendCreatorUninitialized>());
-        if (!Children.back()->Init(*child)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TCompositeBackendCreator> TCompositeBackendCreator::Registrar("composite");
-
-void TCompositeBackendCreator::DoToJson(NJson::TJsonValue& value) const {
-    for (const auto& child: Children) {
-        child->ToJson(value["SubLogger"].AppendValue(NJson::JSON_MAP));
-    }
-}
+#include "composite_creator.h" 
+#include "composite.h" 
+#include "uninitialized_creator.h" 
+ 
+THolder<TLogBackend> TCompositeBackendCreator::DoCreateLogBackend() const { 
+    auto res = MakeHolder<TCompositeLogBackend>(); 
+    for (const auto& child : Children) { 
+        res->AddLogBackend(child->CreateLogBackend()); 
+    } 
+    return std::move(res); 
+} 
+ 
+ 
+TCompositeBackendCreator::TCompositeBackendCreator() 
+    : TLogBackendCreatorBase("composite") 
+{} 
+ 
+bool TCompositeBackendCreator::Init(const IInitContext& ctx) { 
+    for (const auto& child : ctx.GetChildren("SubLogger")) { 
+        Children.emplace_back(MakeHolder<TLogBackendCreatorUninitialized>()); 
+        if (!Children.back()->Init(*child)) { 
+            return false; 
+        } 
+    } 
+    return true; 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TCompositeBackendCreator> TCompositeBackendCreator::Registrar("composite"); 
+ 
+void TCompositeBackendCreator::DoToJson(NJson::TJsonValue& value) const { 
+    for (const auto& child: Children) { 
+        child->ToJson(value["SubLogger"].AppendValue(NJson::JSON_MAP)); 
+    } 
+} 
diff --git a/library/cpp/logger/composite_creator.h b/library/cpp/logger/composite_creator.h
index 877d3a2b33..7ec0cef67b 100644
--- a/library/cpp/logger/composite_creator.h
+++ b/library/cpp/logger/composite_creator.h
@@ -1,18 +1,18 @@
-#pragma once
-
-#include "backend_creator.h"
-#include <util/generic/vector.h>
-
-class TCompositeBackendCreator : public TLogBackendCreatorBase {
-public:
-    TCompositeBackendCreator();
-    virtual bool Init(const IInitContext& ctx) override;
-    static TFactory::TRegistrator<TCompositeBackendCreator> Registrar;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-    TVector<THolder<ILogBackendCreator>> Children;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+#include <util/generic/vector.h> 
+ 
+class TCompositeBackendCreator : public TLogBackendCreatorBase { 
+public: 
+    TCompositeBackendCreator(); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    static TFactory::TRegistrator<TCompositeBackendCreator> Registrar; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+    TVector<THolder<ILogBackendCreator>> Children; 
+}; 
diff --git a/library/cpp/logger/composite_ut.cpp b/library/cpp/logger/composite_ut.cpp
index f330419271..a75122eb57 100644
--- a/library/cpp/logger/composite_ut.cpp
+++ b/library/cpp/logger/composite_ut.cpp
@@ -1,98 +1,98 @@
-#include "log.h"
-#include <library/cpp/logger/init_context/config.h>
-#include <library/cpp/logger/init_context/yconf.h>
-#include <library/cpp/testing/unittest/registar.h>
-#include <library/cpp/yconf/patcher/unstrict_config.h>
-#include <util/stream/file.h>
-#include <util/system/fs.h>
-
-Y_UNIT_TEST_SUITE(TCompositeLogTest)
-{
-    TVector<TString> ReadLines(const TString & filename) {
-        TVector<TString> lines;
-        TIFStream fin(filename);
-        TString line;
-        while (fin.ReadLine(line)) {
-            lines.push_back(std::move(line));
-        }
-        return lines;
-    }
-
-    void Clear(const TString & filename) {
-        NFs::Remove(filename + "1");
-        NFs::Remove(filename + "2");
-    }
-
-    void DoTestComposite(const ILogBackendCreator::IInitContext& ctx, const TString & filename) {
-        Clear(filename);
-        {
-            TLog log;
-            {
-                auto creator = ILogBackendCreator::Create(ctx);
-                log.ResetBackend(creator->CreateLogBackend());
-                log.ReopenLog();
-            }
-            log.Write(TLOG_ERR, "first\n");
-            log.Write(TLOG_DEBUG, "second\n");
-        }
-        auto data1 = ReadLines(filename + "1");
-        auto data2 = ReadLines(filename + "2");
-        UNIT_ASSERT_VALUES_EQUAL(data1.size(), 2);
-        UNIT_ASSERT(data1[0] == "first");
-        UNIT_ASSERT(data1[1] == "second");
-
-        UNIT_ASSERT_VALUES_EQUAL(data2.size(), 1);
-        UNIT_ASSERT(data2[0] == "first");
-        Clear(filename);
-    }
-
-    Y_UNIT_TEST(TestCompositeConfig) {
-        TString s(R"(
-{
-    "LoggerType": "composite",
-    "SubLogger":[
-        {
-            "LoggerType": "file",
-            "Path": "config_log_1"
-        }, {
-            "LoggerType": "config_log_2",
-            "LogLevel": "INFO"
-        }
-    ]
-})");
-        TStringInput si(s);
-        NConfig::TConfig cfg = NConfig::TConfig::FromJson(si);
-        //Прогоняем конфигурацию через серализацию и десериализацию
-        TLogBackendCreatorInitContextConfig ctx(cfg);
-        TString newCfg = ILogBackendCreator::Create(ctx)->AsJson().GetStringRobust();
-        TStringInput si2(newCfg);
-        DoTestComposite(TLogBackendCreatorInitContextConfig(NConfig::TConfig::FromJson(si2)), "config_log_");
-
-    }
-    Y_UNIT_TEST(TestCompositeYConf) {
-        constexpr const char* CONFIG = R"(
-<Logger>
-    LoggerType: composite
-    <SubLogger>
-        LoggerType: file
-        Path: yconf_log_1
-    </SubLogger>
-    <SubLogger>
-        LoggerType: yconf_log_2
-        LogLevel: INFO
-    </SubLogger>
-</Logger>
-)";
-        TUnstrictConfig cfg;
-        if (!cfg.ParseMemory(CONFIG)) {
-            TString errors;
-            cfg.PrintErrors(errors);
-            UNIT_ASSERT_C(false, errors);
-        }
-        TLogBackendCreatorInitContextYConf ctx(*cfg.GetFirstChild("Logger"));
-        //Прогоняем конфигурацию через серализацию и десериализацию
-        TUnstrictConfig newCfg;
-        UNIT_ASSERT(newCfg.ParseJson(ILogBackendCreator::Create(ctx)->AsJson()));
-        DoTestComposite(TLogBackendCreatorInitContextYConf(*newCfg.GetRootSection()), "yconf_log_");
-    }
-};
+#include "log.h" 
+#include <library/cpp/logger/init_context/config.h> 
+#include <library/cpp/logger/init_context/yconf.h> 
+#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/yconf/patcher/unstrict_config.h> 
+#include <util/stream/file.h> 
+#include <util/system/fs.h> 
+ 
+Y_UNIT_TEST_SUITE(TCompositeLogTest) 
+{ 
+    TVector<TString> ReadLines(const TString & filename) { 
+        TVector<TString> lines; 
+        TIFStream fin(filename); 
+        TString line; 
+        while (fin.ReadLine(line)) { 
+            lines.push_back(std::move(line)); 
+        } 
+        return lines; 
+    } 
+ 
+    void Clear(const TString & filename) { 
+        NFs::Remove(filename + "1"); 
+        NFs::Remove(filename + "2"); 
+    } 
+ 
+    void DoTestComposite(const ILogBackendCreator::IInitContext& ctx, const TString & filename) { 
+        Clear(filename); 
+        { 
+            TLog log; 
+            { 
+                auto creator = ILogBackendCreator::Create(ctx); 
+                log.ResetBackend(creator->CreateLogBackend()); 
+                log.ReopenLog(); 
+            } 
+            log.Write(TLOG_ERR, "first\n"); 
+            log.Write(TLOG_DEBUG, "second\n"); 
+        } 
+        auto data1 = ReadLines(filename + "1"); 
+        auto data2 = ReadLines(filename + "2"); 
+        UNIT_ASSERT_VALUES_EQUAL(data1.size(), 2); 
+        UNIT_ASSERT(data1[0] == "first"); 
+        UNIT_ASSERT(data1[1] == "second"); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(data2.size(), 1); 
+        UNIT_ASSERT(data2[0] == "first"); 
+        Clear(filename); 
+    } 
+ 
+    Y_UNIT_TEST(TestCompositeConfig) { 
+        TString s(R"( 
+{ 
+    "LoggerType": "composite", 
+    "SubLogger":[ 
+        { 
+            "LoggerType": "file", 
+            "Path": "config_log_1" 
+        }, { 
+            "LoggerType": "config_log_2", 
+            "LogLevel": "INFO" 
+        } 
+    ] 
+})"); 
+        TStringInput si(s); 
+        NConfig::TConfig cfg = NConfig::TConfig::FromJson(si); 
+        //Прогоняем конфигурацию через серализацию и десериализацию 
+        TLogBackendCreatorInitContextConfig ctx(cfg); 
+        TString newCfg = ILogBackendCreator::Create(ctx)->AsJson().GetStringRobust(); 
+        TStringInput si2(newCfg); 
+        DoTestComposite(TLogBackendCreatorInitContextConfig(NConfig::TConfig::FromJson(si2)), "config_log_"); 
+ 
+    } 
+    Y_UNIT_TEST(TestCompositeYConf) { 
+        constexpr const char* CONFIG = R"( 
+<Logger> 
+    LoggerType: composite 
+    <SubLogger> 
+        LoggerType: file 
+        Path: yconf_log_1 
+    </SubLogger> 
+    <SubLogger> 
+        LoggerType: yconf_log_2 
+        LogLevel: INFO 
+    </SubLogger> 
+</Logger> 
+)"; 
+        TUnstrictConfig cfg; 
+        if (!cfg.ParseMemory(CONFIG)) { 
+            TString errors; 
+            cfg.PrintErrors(errors); 
+            UNIT_ASSERT_C(false, errors); 
+        } 
+        TLogBackendCreatorInitContextYConf ctx(*cfg.GetFirstChild("Logger")); 
+        //Прогоняем конфигурацию через серализацию и десериализацию 
+        TUnstrictConfig newCfg; 
+        UNIT_ASSERT(newCfg.ParseJson(ILogBackendCreator::Create(ctx)->AsJson())); 
+        DoTestComposite(TLogBackendCreatorInitContextYConf(*newCfg.GetRootSection()), "yconf_log_"); 
+    } 
+}; 
diff --git a/library/cpp/logger/file_creator.cpp b/library/cpp/logger/file_creator.cpp
index 0a84469e43..2807171017 100644
--- a/library/cpp/logger/file_creator.cpp
+++ b/library/cpp/logger/file_creator.cpp
@@ -1,22 +1,22 @@
-#include "file_creator.h"
-#include "file.h"
-
-TFileLogBackendCreator::TFileLogBackendCreator(const TString& path /*= TString()*/, const TString& type /*= "file"*/)
-    : TLogBackendCreatorBase(type)
-    , Path(path)
-{}
-
-THolder<TLogBackend> TFileLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TFileLogBackend>(Path);
-}
-
-bool TFileLogBackendCreator::Init(const IInitContext& ctx) {
-    ctx.GetValue("Path", Path);
-    return !!Path;
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TFileLogBackendCreator> TFileLogBackendCreator::Registrar("file");
-
-void TFileLogBackendCreator::DoToJson(NJson::TJsonValue& value) const {
-    value["Path"] = Path;
-}
+#include "file_creator.h" 
+#include "file.h" 
+ 
+TFileLogBackendCreator::TFileLogBackendCreator(const TString& path /*= TString()*/, const TString& type /*= "file"*/) 
+    : TLogBackendCreatorBase(type) 
+    , Path(path) 
+{} 
+ 
+THolder<TLogBackend> TFileLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TFileLogBackend>(Path); 
+} 
+ 
+bool TFileLogBackendCreator::Init(const IInitContext& ctx) { 
+    ctx.GetValue("Path", Path); 
+    return !!Path; 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TFileLogBackendCreator> TFileLogBackendCreator::Registrar("file"); 
+ 
+void TFileLogBackendCreator::DoToJson(NJson::TJsonValue& value) const { 
+    value["Path"] = Path; 
+} 
diff --git a/library/cpp/logger/file_creator.h b/library/cpp/logger/file_creator.h
index 73e55261ad..95543d2550 100644
--- a/library/cpp/logger/file_creator.h
+++ b/library/cpp/logger/file_creator.h
@@ -1,17 +1,17 @@
-#pragma once
-
-#include "backend_creator.h"
-
-class TFileLogBackendCreator : public TLogBackendCreatorBase {
-public:
-    TFileLogBackendCreator(const TString& path = TString(), const TString& type = "file");
-    virtual bool Init(const IInitContext& ctx) override;
-    static TFactory::TRegistrator<TFileLogBackendCreator> Registrar;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-    TString Path;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+ 
+class TFileLogBackendCreator : public TLogBackendCreatorBase { 
+public: 
+    TFileLogBackendCreator(const TString& path = TString(), const TString& type = "file"); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    static TFactory::TRegistrator<TFileLogBackendCreator> Registrar; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+    TString Path; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+}; 
diff --git a/library/cpp/logger/filter.h b/library/cpp/logger/filter.h
index 9ef83fb58c..7278a40ff9 100644
--- a/library/cpp/logger/filter.h
+++ b/library/cpp/logger/filter.h
@@ -6,12 +6,12 @@
 #include <util/generic/ptr.h>
 
 class TFilteredLogBackend: public TLogBackend {
-    THolder<TLogBackend> Backend;
+    THolder<TLogBackend> Backend; 
     ELogPriority Level;
 
 public:
-    TFilteredLogBackend(THolder<TLogBackend>&& t, ELogPriority level = LOG_MAX_PRIORITY) noexcept
-        : Backend(std::move(t))
+    TFilteredLogBackend(THolder<TLogBackend>&& t, ELogPriority level = LOG_MAX_PRIORITY) noexcept 
+        : Backend(std::move(t)) 
         , Level(level)
     {
     }
diff --git a/library/cpp/logger/filter_creator.cpp b/library/cpp/logger/filter_creator.cpp
index fd5618087b..f9783f115a 100644
--- a/library/cpp/logger/filter_creator.cpp
+++ b/library/cpp/logger/filter_creator.cpp
@@ -1,20 +1,20 @@
-#include "filter_creator.h"
-#include "filter.h"
-
-TFilteredBackendCreator::TFilteredBackendCreator(THolder<ILogBackendCreator> slave, ELogPriority priority)
-    : Slave(std::move(slave))
-    , Priority(priority)
-{}
-
-THolder<TLogBackend> TFilteredBackendCreator::DoCreateLogBackend() const {
+#include "filter_creator.h" 
+#include "filter.h" 
+ 
+TFilteredBackendCreator::TFilteredBackendCreator(THolder<ILogBackendCreator> slave, ELogPriority priority) 
+    : Slave(std::move(slave)) 
+    , Priority(priority) 
+{} 
+ 
+THolder<TLogBackend> TFilteredBackendCreator::DoCreateLogBackend() const { 
     return MakeHolder<TFilteredLogBackend>(Slave->CreateLogBackend(), Priority);
-}
-
-bool TFilteredBackendCreator::Init(const IInitContext& ctx) {
-    return Slave->Init(ctx);
-}
-
-void TFilteredBackendCreator::ToJson(NJson::TJsonValue& value) const {
-    value["LogLevel"] = ToString(Priority);
-    Slave->ToJson(value);
-}
+} 
+ 
+bool TFilteredBackendCreator::Init(const IInitContext& ctx) { 
+    return Slave->Init(ctx); 
+} 
+ 
+void TFilteredBackendCreator::ToJson(NJson::TJsonValue& value) const { 
+    value["LogLevel"] = ToString(Priority); 
+    Slave->ToJson(value); 
+} 
diff --git a/library/cpp/logger/filter_creator.h b/library/cpp/logger/filter_creator.h
index 0f301457a0..d4a44d32ff 100644
--- a/library/cpp/logger/filter_creator.h
+++ b/library/cpp/logger/filter_creator.h
@@ -1,16 +1,16 @@
-#pragma once
-
-#include "backend_creator.h"
-#include "priority.h"
-
-class TFilteredBackendCreator : public ILogBackendCreator {
-public:
-    TFilteredBackendCreator(THolder<ILogBackendCreator> slave, ELogPriority priority);
-    virtual bool Init(const IInitContext& ctx) override;
-    virtual void ToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-    THolder<ILogBackendCreator> Slave;
-    ELogPriority Priority;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+#include "priority.h" 
+ 
+class TFilteredBackendCreator : public ILogBackendCreator { 
+public: 
+    TFilteredBackendCreator(THolder<ILogBackendCreator> slave, ELogPriority priority); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    virtual void ToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+    THolder<ILogBackendCreator> Slave; 
+    ELogPriority Priority; 
+}; 
diff --git a/library/cpp/logger/global/common.cpp b/library/cpp/logger/global/common.cpp
index 4fb05c19b4..9cfd1b0386 100644
--- a/library/cpp/logger/global/common.cpp
+++ b/library/cpp/logger/global/common.cpp
@@ -1,12 +1,12 @@
 #include "common.h"
-
+ 
 #include <util/generic/yexception.h>
 
-namespace NLoggingImpl {
+namespace NLoggingImpl { 
     TString GetLocalTimeSSimple() {
-        struct tm tm;
-        return Strftime("%b%d_%H%M%S", Now().LocalTime(&tm));
-    }
+        struct tm tm; 
+        return Strftime("%b%d_%H%M%S", Now().LocalTime(&tm)); 
+    } 
 
     TString PrepareToOpenLog(TString logType, const int logLevel, const bool rotation, const bool startAsDaemon) {
         Y_ENSURE(logLevel >= 0 && logLevel <= (int)LOG_MAX_PRIORITY, "Incorrect log level");
@@ -21,16 +21,16 @@ namespace NLoggingImpl {
 
         return logType;
     }
-}
-
+} 
+ 
 bool TLogFilter::CheckLoggingContext(TLog& log, const TLogRecordContext& context) {
     return context.Priority <= log.FiltrationLevel();
 }
 
-TSimpleSharedPtr<TLogElement> TLogFilter::StartRecord(TLog& logger, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) {
-    if (earlier)
-        return earlier;
-    TSimpleSharedPtr<TLogElement> result(new TLogElement(&logger));
-    *result << context.Priority;
-    return result;
-}
+TSimpleSharedPtr<TLogElement> TLogFilter::StartRecord(TLog& logger, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) { 
+    if (earlier) 
+        return earlier; 
+    TSimpleSharedPtr<TLogElement> result(new TLogElement(&logger)); 
+    *result << context.Priority; 
+    return result; 
+} 
diff --git a/library/cpp/logger/global/common.h b/library/cpp/logger/global/common.h
index 7dcf650dec..a7a422c786 100644
--- a/library/cpp/logger/global/common.h
+++ b/library/cpp/logger/global/common.h
@@ -1,26 +1,26 @@
-#pragma once
-
-#include <util/datetime/base.h>
-
-#include <util/folder/path.h>
-#include <util/generic/singleton.h>
+#pragma once 
+ 
+#include <util/datetime/base.h> 
+ 
+#include <util/folder/path.h> 
+#include <util/generic/singleton.h> 
 #include <util/generic/string.h>
-#include <util/generic/ptr.h>
-#include <util/generic/yexception.h>
-#include <util/string/printf.h>
-#include <util/system/src_location.h>
-
+#include <util/generic/ptr.h> 
+#include <util/generic/yexception.h> 
+#include <util/string/printf.h> 
+#include <util/system/src_location.h> 
+ 
 #include <library/cpp/logger/log.h>
-
+ 
 namespace NLoggingImpl {
     const size_t SingletonPriority = 500;
 }
 
-template <class T>
-T* CreateDefaultLogger() {
-    return nullptr;
-}
-
+template <class T> 
+T* CreateDefaultLogger() { 
+    return nullptr; 
+} 
+ 
 namespace NLoggingImpl {
     template<class T, class TTraits>
     class TOperatorBase {
@@ -37,7 +37,7 @@ namespace NLoggingImpl {
         inline static bool Usage() {
             return SingletonWithPriority<TPtr, SingletonPriority>()->Instance.Get();
         }
-
+ 
         inline static T* Get() {
             return SingletonWithPriority<TPtr, SingletonPriority>()->Instance.Get();
         }
@@ -45,8 +45,8 @@ namespace NLoggingImpl {
         inline static void Set(T* v) {
             SingletonWithPriority<TPtr, SingletonPriority>()->Instance.Reset(v);
         }
-    };
-
+    }; 
+ 
     template<class T>
     struct TLoggerTraits {
         static T* CreateDefault() {
@@ -54,20 +54,20 @@ namespace NLoggingImpl {
         }
     };
 }
-
+ 
 template <class T>
 class TLoggerOperator : public NLoggingImpl::TOperatorBase<T, NLoggingImpl::TLoggerTraits<T>>  {
 public:
-    inline static TLog& Log() {
+    inline static TLog& Log() { 
         Y_ASSERT(TLoggerOperator::Usage());
         return *TLoggerOperator::Get();
-    }
+    } 
 };
 
-namespace NLoggingImpl {
-
+namespace NLoggingImpl { 
+ 
     TString GetLocalTimeSSimple();
-
+ 
     // Returns correct log type to use
     TString PrepareToOpenLog(TString logType, int logLevel, bool rotation, bool startAsDaemon);
 
@@ -75,64 +75,64 @@ namespace NLoggingImpl {
     void InitLogImpl(TString logType, const int logLevel, const bool rotation, const bool startAsDaemon) {
         TLoggerOperator<TLoggerType>::Set(new TLoggerType(PrepareToOpenLog(logType, logLevel, rotation, startAsDaemon), (ELogPriority)logLevel));
     }
-}
-
-struct TLogRecordContext {
+} 
+ 
+struct TLogRecordContext { 
     constexpr TLogRecordContext(const TSourceLocation& sourceLocation, TStringBuf customMessage, ELogPriority priority)
         : SourceLocation(sourceLocation)
         , CustomMessage(customMessage)
         , Priority(priority)
     {}
-
-    TSourceLocation SourceLocation;
-    TStringBuf CustomMessage;
+ 
+    TSourceLocation SourceLocation; 
+    TStringBuf CustomMessage; 
     ELogPriority Priority;
-};
-
-template <class... R>
-struct TLogRecordPreprocessor;
-
-template <>
-struct TLogRecordPreprocessor<> {
+}; 
+ 
+template <class... R> 
+struct TLogRecordPreprocessor; 
+ 
+template <> 
+struct TLogRecordPreprocessor<> { 
     inline static bool CheckLoggingContext(TLog& /*log*/, const TLogRecordContext& /*context*/) {
         return true;
     }
 
-    inline static TSimpleSharedPtr<TLogElement> StartRecord(TLog& log, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) {
+    inline static TSimpleSharedPtr<TLogElement> StartRecord(TLog& log, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) { 
         if (earlier)
-            return earlier;
-        TSimpleSharedPtr<TLogElement> result(new TLogElement(&log));
-        *result << context.Priority;
-        return result;
-    }
-};
-
-template <class H, class... R>
-struct TLogRecordPreprocessor<H, R...> {
+            return earlier; 
+        TSimpleSharedPtr<TLogElement> result(new TLogElement(&log)); 
+        *result << context.Priority; 
+        return result; 
+    } 
+}; 
+ 
+template <class H, class... R> 
+struct TLogRecordPreprocessor<H, R...> { 
     inline static bool CheckLoggingContext(TLog& log, const TLogRecordContext& context) {
         return H::CheckLoggingContext(log, context) && TLogRecordPreprocessor<R...>::CheckLoggingContext(log, context);
     }
 
-    inline static TSimpleSharedPtr<TLogElement> StartRecord(TLog& log, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) {
-        TSimpleSharedPtr<TLogElement> first = H::StartRecord(log, context, earlier);
-        return TLogRecordPreprocessor<R...>::StartRecord(log, context, first);
-    }
-};
-
-struct TLogFilter {
+    inline static TSimpleSharedPtr<TLogElement> StartRecord(TLog& log, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) { 
+        TSimpleSharedPtr<TLogElement> first = H::StartRecord(log, context, earlier); 
+        return TLogRecordPreprocessor<R...>::StartRecord(log, context, first); 
+    } 
+}; 
+ 
+struct TLogFilter { 
     static bool CheckLoggingContext(TLog& log, const TLogRecordContext& context);
     static TSimpleSharedPtr<TLogElement> StartRecord(TLog& log, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier);
-};
-
-class TNullLog;
-
-template <class TPreprocessor>
-TSimpleSharedPtr<TLogElement> GetLoggerForce(TLog& log, const TLogRecordContext& context) {
-    if (TSimpleSharedPtr<TLogElement> result = TPreprocessor::StartRecord(log, context, nullptr))
-        return result;
-    return new TLogElement(&TLoggerOperator<TNullLog>::Log());
-}
-
+}; 
+ 
+class TNullLog; 
+ 
+template <class TPreprocessor> 
+TSimpleSharedPtr<TLogElement> GetLoggerForce(TLog& log, const TLogRecordContext& context) { 
+    if (TSimpleSharedPtr<TLogElement> result = TPreprocessor::StartRecord(log, context, nullptr)) 
+        return result; 
+    return new TLogElement(&TLoggerOperator<TNullLog>::Log()); 
+} 
+ 
 namespace NPrivateGlobalLogger {
     struct TEatStream {
         Y_FORCE_INLINE bool operator|(const IOutputStream&) const {
@@ -141,9 +141,9 @@ namespace NPrivateGlobalLogger {
     };
 }
 
-#define LOGGER_GENERIC_LOG_CHECKED(logger, preprocessor, level, message) (*GetLoggerForce<preprocessor>(logger, TLogRecordContext(__LOCATION__, message, level)))
+#define LOGGER_GENERIC_LOG_CHECKED(logger, preprocessor, level, message) (*GetLoggerForce<preprocessor>(logger, TLogRecordContext(__LOCATION__, message, level))) 
 #define LOGGER_CHECKED_GENERIC_LOG(logger, preprocessor, level, message) \
     (preprocessor::CheckLoggingContext(logger, TLogRecordContext(__LOCATION__, message, level))) && NPrivateGlobalLogger::TEatStream() | (*(preprocessor::StartRecord(logger, TLogRecordContext(__LOCATION__, message, level), nullptr)))
-
-#define SINGLETON_GENERIC_LOG_CHECKED(type, preprocessor, level, message) LOGGER_GENERIC_LOG_CHECKED(TLoggerOperator<type>::Log(), preprocessor, level, message)
-#define SINGLETON_CHECKED_GENERIC_LOG(type, preprocessor, level, message) LOGGER_CHECKED_GENERIC_LOG(TLoggerOperator<type>::Log(), preprocessor, level, message)
+ 
+#define SINGLETON_GENERIC_LOG_CHECKED(type, preprocessor, level, message) LOGGER_GENERIC_LOG_CHECKED(TLoggerOperator<type>::Log(), preprocessor, level, message) 
+#define SINGLETON_CHECKED_GENERIC_LOG(type, preprocessor, level, message) LOGGER_CHECKED_GENERIC_LOG(TLoggerOperator<type>::Log(), preprocessor, level, message) 
diff --git a/library/cpp/logger/global/global.cpp b/library/cpp/logger/global/global.cpp
index 9fbd10f666..72991b610b 100644
--- a/library/cpp/logger/global/global.cpp
+++ b/library/cpp/logger/global/global.cpp
@@ -25,16 +25,16 @@ void DoInitGlobalLog(THolder<TLogBackend> backend, THolder<ILoggerFormatter> for
 bool GlobalLogInitialized() {
     return TLoggerOperator<TGlobalLog>::Usage();
 }
-
+ 
 template <>
-TGlobalLog* CreateDefaultLogger<TGlobalLog>() {
-    return new TGlobalLog("console", TLOG_INFO);
-}
-
+TGlobalLog* CreateDefaultLogger<TGlobalLog>() { 
+    return new TGlobalLog("console", TLOG_INFO); 
+} 
+ 
 template <>
-TNullLog* CreateDefaultLogger<TNullLog>() {
-    return new TNullLog("null");
-}
+TNullLog* CreateDefaultLogger<TNullLog>() { 
+    return new TNullLog("null"); 
+} 
 
 NPrivateGlobalLogger::TVerifyEvent::~TVerifyEvent() {
     const TString info = Str();
diff --git a/library/cpp/logger/global/global.h b/library/cpp/logger/global/global.h
index cbe71b16ea..762e31297e 100644
--- a/library/cpp/logger/global/global.h
+++ b/library/cpp/logger/global/global.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "common.h"
-#include "rty_formater.h"
+#include "rty_formater.h" 
 
 // ATTENTION! MUST CALL DoInitGlobalLog BEFORE USAGE
 
@@ -21,8 +21,8 @@ class TGlobalLog: public TLog {
 public:
     TGlobalLog(const TString& logType, ELogPriority priority = LOG_MAX_PRIORITY)
         : TLog(logType, priority)
-    {
-    }
+    { 
+    } 
 
     TGlobalLog(THolder<TLogBackend> backend)
         : TLog(std::move(backend))
@@ -31,14 +31,14 @@ public:
 };
 
 template <>
-TGlobalLog* CreateDefaultLogger<TGlobalLog>();
-
+TGlobalLog* CreateDefaultLogger<TGlobalLog>(); 
+ 
 class TNullLog: public TLog {
 public:
     TNullLog(const TString& logType, ELogPriority priority = LOG_MAX_PRIORITY)
         : TLog(logType, priority)
-    {
-    }
+    { 
+    } 
 
     TNullLog(THolder<TLogBackend> backend)
         : TLog(std::move(backend))
@@ -47,43 +47,43 @@ public:
 };
 
 template <>
-TNullLog* CreateDefaultLogger<TNullLog>();
-
-template <>
-class TSingletonTraits<TLoggerOperator<TGlobalLog>::TPtr> {
-public:
-    static const size_t Priority = NLoggingImpl::SingletonPriority;
-};
-
-template <>
-class TSingletonTraits<TLoggerOperator<TNullLog>::TPtr> {
-public:
-    static const size_t Priority = NLoggingImpl::SingletonPriority;
-};
-
-#define FATAL_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_CRIT, "CRITICAL_INFO")
+TNullLog* CreateDefaultLogger<TNullLog>(); 
+ 
+template <> 
+class TSingletonTraits<TLoggerOperator<TGlobalLog>::TPtr> { 
+public: 
+    static const size_t Priority = NLoggingImpl::SingletonPriority; 
+}; 
+ 
+template <> 
+class TSingletonTraits<TLoggerOperator<TNullLog>::TPtr> { 
+public: 
+    static const size_t Priority = NLoggingImpl::SingletonPriority; 
+}; 
+ 
+#define FATAL_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_CRIT, "CRITICAL_INFO") 
 #define ALERT_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_ALERT, "ALERT")
-#define ERROR_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_ERR, "ERROR")
-#define WARNING_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_WARNING, "WARNING")
-#define NOTICE_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_NOTICE, "NOTICE")
-#define INFO_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_INFO, "INFO")
-#define DEBUG_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_DEBUG, "DEBUG")
+#define ERROR_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_ERR, "ERROR") 
+#define WARNING_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_WARNING, "WARNING") 
+#define NOTICE_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_NOTICE, "NOTICE") 
+#define INFO_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_INFO, "INFO") 
+#define DEBUG_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_DEBUG, "DEBUG") 
 #define RESOURCES_LOG SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, TLOG_RESOURCES, "RESOURCES")
 
 #define TEMPLATE_LOG(logLevel) SINGLETON_CHECKED_GENERIC_LOG(TGlobalLog, TRTYLogPreprocessor, logLevel, ToString(logLevel).data())
 
 #define IS_LOG_ACTIVE(logLevel) (TLoggerOperator<TGlobalLog>::Log().FiltrationLevel() >= logLevel)
 
-#define RTY_MEM_LOG(Action) \
-    { NOTICE_LOG << "RESOURCES On " << Action << ": " << NLoggingImpl::GetSystemResources() << Endl; };
+#define RTY_MEM_LOG(Action) \ 
+    { NOTICE_LOG << "RESOURCES On " << Action << ": " << NLoggingImpl::GetSystemResources() << Endl; }; 
 
-#define VERIFY_WITH_LOG(expr, msg, ...)                       \
-    do {                                                      \
+#define VERIFY_WITH_LOG(expr, msg, ...)                       \ 
+    do {                                                      \ 
         if (Y_UNLIKELY(!(expr))) {                            \
-            FATAL_LOG << Sprintf(msg, ##__VA_ARGS__) << Endl; \
+            FATAL_LOG << Sprintf(msg, ##__VA_ARGS__) << Endl; \ 
             Y_VERIFY(false, msg, ##__VA_ARGS__);              \
-        };                                                    \
-    } while (0);
+        };                                                    \ 
+    } while (0); 
 
 namespace NPrivateGlobalLogger {
     class TVerifyEvent: public TStringStream {
@@ -121,5 +121,5 @@ namespace NPrivateGlobalLogger {
 #define CHECK_EQ_WITH_LOG(a, b) CHECK_WITH_LOG((a) == (b)) << a << " != " << b;
 #define CHECK_LEQ_WITH_LOG(a, b) CHECK_WITH_LOG((a) <= (b)) << a << " > " << b;
 
-#define FAIL_LOG(msg, ...) VERIFY_WITH_LOG(false, msg, ##__VA_ARGS__)
+#define FAIL_LOG(msg, ...) VERIFY_WITH_LOG(false, msg, ##__VA_ARGS__) 
 #define S_FAIL_LOG CHECK_WITH_LOG(false)
diff --git a/library/cpp/logger/global/rty_formater.cpp b/library/cpp/logger/global/rty_formater.cpp
index 305f8470c5..5f171cafde 100644
--- a/library/cpp/logger/global/rty_formater.cpp
+++ b/library/cpp/logger/global/rty_formater.cpp
@@ -1,20 +1,20 @@
-#include "rty_formater.h"
-#include <util/datetime/base.h>
+#include "rty_formater.h" 
+#include <util/datetime/base.h> 
 #include <util/datetime/systime.h>
-#include <util/stream/str.h>
-#include <util/stream/printf.h>
-#include <util/system/mem_info.h>
+#include <util/stream/str.h> 
+#include <util/stream/printf.h> 
+#include <util/system/mem_info.h> 
 #include <util/system/yassert.h>
 #include <inttypes.h>
 #include <cstdio>
-
+ 
 namespace {
     constexpr size_t LocalTimeSBufferSize = sizeof("2017-07-24 12:20:34.313 +0300");
 
     size_t PrintLocalTimeS(const TInstant instant, char* const begin, const char* const end) {
         Y_VERIFY(static_cast<size_t>(end - begin) >= LocalTimeSBufferSize);
 
-        struct tm tm;
+        struct tm tm; 
         instant.LocalTime(&tm);
 
         // both stftime and sprintf exclude the terminating null byte from the return value
@@ -24,9 +24,9 @@ namespace {
         pos += strftime(pos, end - pos, " %z", &tm);
         Y_VERIFY(LocalTimeSBufferSize - 1 == pos - begin); // together with Y_VERIFY above this also implies pos<=end
         return (pos - begin);
-    }
+    } 
 }
-
+ 
 namespace NLoggingImpl {
     IOutputStream& operator<<(IOutputStream& out, TLocalTimeS localTimeS) {
         char buffer[LocalTimeSBufferSize];
@@ -48,20 +48,20 @@ namespace NLoggingImpl {
         return res;
     }
 
-    TStringBuf StripFileName(TStringBuf string) {
-        return string.RNextTok(LOCSLASH_C);
-    }
-
+    TStringBuf StripFileName(TStringBuf string) { 
+        return string.RNextTok(LOCSLASH_C); 
+    } 
+ 
     TString GetSystemResources() {
-        NMemInfo::TMemInfo mi = NMemInfo::GetMemInfo();
+        NMemInfo::TMemInfo mi = NMemInfo::GetMemInfo(); 
         return PrintSystemResources(mi);
     }
 
     TString PrintSystemResources(const NMemInfo::TMemInfo& mi) {
-        return Sprintf(" rss=%0.3fMb, vms=%0.3fMb", mi.RSS * 1.0 / (1024 * 1024), mi.VMS * 1.0 / (1024 * 1024));
-    }
-}
-
+        return Sprintf(" rss=%0.3fMb, vms=%0.3fMb", mi.RSS * 1.0 / (1024 * 1024), mi.VMS * 1.0 / (1024 * 1024)); 
+    } 
+} 
+ 
 namespace {
     class TRtyLoggerFormatter : public ILoggerFormatter {
     public:
@@ -84,11 +84,11 @@ bool TRTYMessageFormater::CheckLoggingContext(TLog& /*logger*/, const TLogRecord
     return true;
 }
 
-TSimpleSharedPtr<TLogElement> TRTYMessageFormater::StartRecord(TLog& logger, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) {
+TSimpleSharedPtr<TLogElement> TRTYMessageFormater::StartRecord(TLog& logger, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier) { 
     if (!earlier) {
-        earlier.Reset(new TLogElement(&logger));
+        earlier.Reset(new TLogElement(&logger)); 
     }
 
     TLoggerFormatterOperator::Get()->Format(context, *earlier);
-    return earlier;
-}
+    return earlier; 
+} 
diff --git a/library/cpp/logger/global/rty_formater.h b/library/cpp/logger/global/rty_formater.h
index 6532e1d769..57bd86ac3f 100644
--- a/library/cpp/logger/global/rty_formater.h
+++ b/library/cpp/logger/global/rty_formater.h
@@ -1,7 +1,7 @@
-#pragma once
-
-#include "common.h"
+#pragma once 
 
+#include "common.h" 
+ 
 namespace NMemInfo {
     struct TMemInfo;
 }
@@ -15,7 +15,7 @@ public:
 
 ILoggerFormatter* CreateRtyLoggerFormatter();
 
-namespace NLoggingImpl {
+namespace NLoggingImpl { 
     class TLocalTimeS {
     public:
         TLocalTimeS(TInstant instant = TInstant::Now())
@@ -48,14 +48,14 @@ namespace NLoggingImpl {
             return CreateRtyLoggerFormatter();
         }
     };
-}
-
+} 
+ 
 class TLoggerFormatterOperator : public NLoggingImpl::TOperatorBase<ILoggerFormatter, NLoggingImpl::TLoggerFormatterTraits> {
 };
 
-struct TRTYMessageFormater {
+struct TRTYMessageFormater { 
     static bool CheckLoggingContext(TLog& logger, const TLogRecordContext& context);
-    static TSimpleSharedPtr<TLogElement> StartRecord(TLog& logger, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier);
-};
-
-using TRTYLogPreprocessor = TLogRecordPreprocessor<TLogFilter, TRTYMessageFormater>;
+    static TSimpleSharedPtr<TLogElement> StartRecord(TLog& logger, const TLogRecordContext& context, TSimpleSharedPtr<TLogElement> earlier); 
+}; 
+ 
+using TRTYLogPreprocessor = TLogRecordPreprocessor<TLogFilter, TRTYMessageFormater>; 
diff --git a/library/cpp/logger/global/ya.make b/library/cpp/logger/global/ya.make
index 20eb361e72..9563c8801c 100644
--- a/library/cpp/logger/global/ya.make
+++ b/library/cpp/logger/global/ya.make
@@ -1,19 +1,19 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(g:geosaas)
-
-PEERDIR(
+ 
+PEERDIR( 
     library/cpp/logger
-)
-
+) 
+ 
 IF (OS_WINDOWS)
     NO_WERROR()
 ENDIF()
 
-SRCS(
-    common.cpp
-    global.cpp
-    rty_formater.cpp
-)
-
-END()
+SRCS( 
+    common.cpp 
+    global.cpp 
+    rty_formater.cpp 
+) 
+ 
+END() 
diff --git a/library/cpp/logger/init_context/README.md b/library/cpp/logger/init_context/README.md
index 93564e4890..bc0103a2f6 100644
--- a/library/cpp/logger/init_context/README.md
+++ b/library/cpp/logger/init_context/README.md
@@ -1,5 +1,5 @@
-Эта библиотека содержит две раплизации InitContext для TLogBackendCreator.
-
-TLogBackendCreatorInitContextYConf работает с YandexConfig (library/cpp/yconf).
-
-TLogBackendCreatorInitContextConfig работает с NConfig::TConfig (library/cpp/config).
+Эта библиотека содержит две раплизации InitContext для TLogBackendCreator. 
+ 
+TLogBackendCreatorInitContextYConf работает с YandexConfig (library/cpp/yconf). 
+ 
+TLogBackendCreatorInitContextConfig работает с NConfig::TConfig (library/cpp/config). 
diff --git a/library/cpp/logger/init_context/config.cpp b/library/cpp/logger/init_context/config.cpp
index 30efa13333..2fe503fbc8 100644
--- a/library/cpp/logger/init_context/config.cpp
+++ b/library/cpp/logger/init_context/config.cpp
@@ -1,26 +1,26 @@
-#include "config.h"
-
-TLogBackendCreatorInitContextConfig::TLogBackendCreatorInitContextConfig(const NConfig::TConfig& config)
-    : Config(config)
-{}
-
-bool TLogBackendCreatorInitContextConfig::GetValue(TStringBuf name, TString& var) const {
-    if (Config.Has(name)) {
-        var = Config[name].Get<TString>();
-        return true;
-    }
-    return false;
-}
-
-TVector<THolder<ILogBackendCreator::IInitContext>> TLogBackendCreatorInitContextConfig::GetChildren(TStringBuf name) const {
-    TVector<THolder<IInitContext>> result;
-    const NConfig::TConfig& child = Config[name];
-    if (child.IsA<NConfig::TArray>()) {
-        for (const auto& i: child.Get<NConfig::TArray>()) {
-            result.emplace_back(MakeHolder<TLogBackendCreatorInitContextConfig>(i));
-        }
-    } else if (!child.IsNull()) {
-        result.emplace_back(MakeHolder<TLogBackendCreatorInitContextConfig>(child));
-    }
-    return result;
-}
+#include "config.h" 
+ 
+TLogBackendCreatorInitContextConfig::TLogBackendCreatorInitContextConfig(const NConfig::TConfig& config) 
+    : Config(config) 
+{} 
+ 
+bool TLogBackendCreatorInitContextConfig::GetValue(TStringBuf name, TString& var) const { 
+    if (Config.Has(name)) { 
+        var = Config[name].Get<TString>(); 
+        return true; 
+    } 
+    return false; 
+} 
+ 
+TVector<THolder<ILogBackendCreator::IInitContext>> TLogBackendCreatorInitContextConfig::GetChildren(TStringBuf name) const { 
+    TVector<THolder<IInitContext>> result; 
+    const NConfig::TConfig& child = Config[name]; 
+    if (child.IsA<NConfig::TArray>()) { 
+        for (const auto& i: child.Get<NConfig::TArray>()) { 
+            result.emplace_back(MakeHolder<TLogBackendCreatorInitContextConfig>(i)); 
+        } 
+    } else if (!child.IsNull()) { 
+        result.emplace_back(MakeHolder<TLogBackendCreatorInitContextConfig>(child)); 
+    } 
+    return result; 
+} 
diff --git a/library/cpp/logger/init_context/config.h b/library/cpp/logger/init_context/config.h
index 8227d13176..579deeb9e4 100644
--- a/library/cpp/logger/init_context/config.h
+++ b/library/cpp/logger/init_context/config.h
@@ -1,14 +1,14 @@
-#pragma once
-
-#include <library/cpp/logger/backend_creator.h>
-#include <library/cpp/config/config.h>
-
-class TLogBackendCreatorInitContextConfig : public ILogBackendCreator::IInitContext {
-public:
-    TLogBackendCreatorInitContextConfig(const NConfig::TConfig& config);
-    virtual bool GetValue(TStringBuf name, TString& var) const override;
-    virtual TVector<THolder<IInitContext>> GetChildren(TStringBuf name) const override;
-
-private:
-    const NConfig::TConfig& Config;
-};
+#pragma once 
+ 
+#include <library/cpp/logger/backend_creator.h> 
+#include <library/cpp/config/config.h> 
+ 
+class TLogBackendCreatorInitContextConfig : public ILogBackendCreator::IInitContext { 
+public: 
+    TLogBackendCreatorInitContextConfig(const NConfig::TConfig& config); 
+    virtual bool GetValue(TStringBuf name, TString& var) const override; 
+    virtual TVector<THolder<IInitContext>> GetChildren(TStringBuf name) const override; 
+ 
+private: 
+    const NConfig::TConfig& Config; 
+}; 
diff --git a/library/cpp/logger/init_context/ya.make b/library/cpp/logger/init_context/ya.make
index 9572a34c60..450a3e4fe7 100644
--- a/library/cpp/logger/init_context/ya.make
+++ b/library/cpp/logger/init_context/ya.make
@@ -1,20 +1,20 @@
-OWNER(
-    pg
-    mvel
-    g:util
-    g:base
-)
-
-LIBRARY()
-
-PEERDIR(
-    library/cpp/logger
-    library/cpp/config
-    library/cpp/yconf
-)
-SRCS(
-    config.cpp
-    yconf.cpp
-)
-
-END()
+OWNER( 
+    pg 
+    mvel 
+    g:util 
+    g:base 
+) 
+ 
+LIBRARY() 
+ 
+PEERDIR( 
+    library/cpp/logger 
+    library/cpp/config 
+    library/cpp/yconf 
+) 
+SRCS( 
+    config.cpp 
+    yconf.cpp 
+) 
+ 
+END() 
diff --git a/library/cpp/logger/init_context/yconf.cpp b/library/cpp/logger/init_context/yconf.cpp
index c7da1d607c..5a7a7d2500 100644
--- a/library/cpp/logger/init_context/yconf.cpp
+++ b/library/cpp/logger/init_context/yconf.cpp
@@ -1,18 +1,18 @@
-#include "yconf.h"
-
-TLogBackendCreatorInitContextYConf::TLogBackendCreatorInitContextYConf(const TYandexConfig::Section& section)
-    : Section(section)
-{}
-
-bool TLogBackendCreatorInitContextYConf::GetValue(TStringBuf name, TString& var) const {
-    return Section.GetDirectives().GetValue(name, var);
-}
-
-TVector<THolder<ILogBackendCreator::IInitContext>> TLogBackendCreatorInitContextYConf::GetChildren(TStringBuf name) const {
-    TVector<THolder<IInitContext>> result;
-    auto children = Section.GetAllChildren();
-    for (auto range = children.equal_range(TCiString(name)); range.first != range.second; ++range.first) {
-        result.emplace_back(MakeHolder<TLogBackendCreatorInitContextYConf>(*range.first->second));
-    }
-    return result;
-}
+#include "yconf.h" 
+ 
+TLogBackendCreatorInitContextYConf::TLogBackendCreatorInitContextYConf(const TYandexConfig::Section& section) 
+    : Section(section) 
+{} 
+ 
+bool TLogBackendCreatorInitContextYConf::GetValue(TStringBuf name, TString& var) const { 
+    return Section.GetDirectives().GetValue(name, var); 
+} 
+ 
+TVector<THolder<ILogBackendCreator::IInitContext>> TLogBackendCreatorInitContextYConf::GetChildren(TStringBuf name) const { 
+    TVector<THolder<IInitContext>> result; 
+    auto children = Section.GetAllChildren(); 
+    for (auto range = children.equal_range(TCiString(name)); range.first != range.second; ++range.first) { 
+        result.emplace_back(MakeHolder<TLogBackendCreatorInitContextYConf>(*range.first->second)); 
+    } 
+    return result; 
+} 
diff --git a/library/cpp/logger/init_context/yconf.h b/library/cpp/logger/init_context/yconf.h
index b1867d271d..574cb617ef 100644
--- a/library/cpp/logger/init_context/yconf.h
+++ b/library/cpp/logger/init_context/yconf.h
@@ -1,13 +1,13 @@
-#pragma once
-
-#include <library/cpp/logger/backend_creator.h>
-#include <library/cpp/yconf/conf.h>
-
-class TLogBackendCreatorInitContextYConf: public ILogBackendCreator::IInitContext {
-public:
-    TLogBackendCreatorInitContextYConf(const TYandexConfig::Section& section);
-    virtual bool GetValue(TStringBuf name, TString& var) const override;
-    virtual TVector<THolder<IInitContext>> GetChildren(TStringBuf name) const override;
-private:
-    const TYandexConfig::Section& Section;
-};
+#pragma once 
+ 
+#include <library/cpp/logger/backend_creator.h> 
+#include <library/cpp/yconf/conf.h> 
+ 
+class TLogBackendCreatorInitContextYConf: public ILogBackendCreator::IInitContext { 
+public: 
+    TLogBackendCreatorInitContextYConf(const TYandexConfig::Section& section); 
+    virtual bool GetValue(TStringBuf name, TString& var) const override; 
+    virtual TVector<THolder<IInitContext>> GetChildren(TStringBuf name) const override; 
+private: 
+    const TYandexConfig::Section& Section; 
+}; 
diff --git a/library/cpp/logger/log.cpp b/library/cpp/logger/log.cpp
index e1d70cc3d2..8d83a61196 100644
--- a/library/cpp/logger/log.cpp
+++ b/library/cpp/logger/log.cpp
@@ -1,5 +1,5 @@
-#include "log.h"
-#include "uninitialized_creator.h"
+#include "log.h" 
+#include "uninitialized_creator.h" 
 #include "filter.h"
 #include "null.h"
 #include "stream.h"
@@ -13,9 +13,9 @@
 #include <util/generic/yexception.h>
 
 THolder<TLogBackend> CreateLogBackend(const TString& fname, ELogPriority priority, bool threaded) {
-    TLogBackendCreatorUninitialized creator;
-    creator.InitCustom(fname, priority, threaded);
-    return creator.CreateLogBackend();
+    TLogBackendCreatorUninitialized creator; 
+    creator.InitCustom(fname, priority, threaded); 
+    return creator.CreateLogBackend(); 
 }
 
 THolder<TLogBackend> CreateFilteredOwningThreadedLogBackend(const TString& fname, ELogPriority priority, size_t queueLen) {
@@ -23,7 +23,7 @@ THolder<TLogBackend> CreateFilteredOwningThreadedLogBackend(const TString& fname
 }
 
 THolder<TOwningThreadedLogBackend> CreateOwningThreadedLogBackend(const TString& fname, size_t queueLen) {
-    return MakeHolder<TOwningThreadedLogBackend>(CreateLogBackend(fname, LOG_MAX_PRIORITY, false).Release(), queueLen);
+    return MakeHolder<TOwningThreadedLogBackend>(CreateLogBackend(fname, LOG_MAX_PRIORITY, false).Release(), queueLen); 
 }
 
 class TLog::TImpl: public TAtomicRefCount<TImpl> {
@@ -131,7 +131,7 @@ TLog::TLog()
 }
 
 TLog::TLog(const TString& fname, ELogPriority priority)
-    : TLog(CreateLogBackend(fname, priority, false))
+    : TLog(CreateLogBackend(fname, priority, false)) 
 {
 }
 
@@ -206,7 +206,7 @@ ELogPriority TLog::DefaultPriority() const noexcept {
 
 bool TLog::OpenLog(const char* path, ELogPriority lp) {
     if (path) {
-        ResetBackend(CreateLogBackend(path, lp));
+        ResetBackend(CreateLogBackend(path, lp)); 
     } else {
         ResetBackend(MakeHolder<TStreamLogBackend>(&Cerr));
     }
diff --git a/library/cpp/logger/null_creator.cpp b/library/cpp/logger/null_creator.cpp
index 9f63d5c739..4258fb25fd 100644
--- a/library/cpp/logger/null_creator.cpp
+++ b/library/cpp/logger/null_creator.cpp
@@ -1,17 +1,17 @@
-#include "null_creator.h"
-#include "null.h"
-
-THolder<TLogBackend> TNullLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TNullLogBackend>();
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TNullLogBackendCreator> TNullLogBackendCreator::RegistrarDevNull("/dev/null");
-ILogBackendCreator::TFactory::TRegistrator<TNullLogBackendCreator> TNullLogBackendCreator::RegistrarNull("null");
-
-
-void TNullLogBackendCreator::DoToJson(NJson::TJsonValue& /*value*/) const {
-}
-
-TNullLogBackendCreator::TNullLogBackendCreator()
-    : TLogBackendCreatorBase("null")
-{}
+#include "null_creator.h" 
+#include "null.h" 
+ 
+THolder<TLogBackend> TNullLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TNullLogBackend>(); 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TNullLogBackendCreator> TNullLogBackendCreator::RegistrarDevNull("/dev/null"); 
+ILogBackendCreator::TFactory::TRegistrator<TNullLogBackendCreator> TNullLogBackendCreator::RegistrarNull("null"); 
+ 
+ 
+void TNullLogBackendCreator::DoToJson(NJson::TJsonValue& /*value*/) const { 
+} 
+ 
+TNullLogBackendCreator::TNullLogBackendCreator() 
+    : TLogBackendCreatorBase("null") 
+{} 
diff --git a/library/cpp/logger/null_creator.h b/library/cpp/logger/null_creator.h
index a5bcab63f9..a262b3701f 100644
--- a/library/cpp/logger/null_creator.h
+++ b/library/cpp/logger/null_creator.h
@@ -1,15 +1,15 @@
-#pragma once
-
-#include "backend_creator.h"
-
-class TNullLogBackendCreator : public TLogBackendCreatorBase {
-public:
-    TNullLogBackendCreator();
-    static TFactory::TRegistrator<TNullLogBackendCreator> RegistrarNull;
-    static TFactory::TRegistrator<TNullLogBackendCreator> RegistrarDevNull;
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+ 
+class TNullLogBackendCreator : public TLogBackendCreatorBase { 
+public: 
+    TNullLogBackendCreator(); 
+    static TFactory::TRegistrator<TNullLogBackendCreator> RegistrarNull; 
+    static TFactory::TRegistrator<TNullLogBackendCreator> RegistrarDevNull; 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+}; 
diff --git a/library/cpp/logger/priority.h b/library/cpp/logger/priority.h
index d2a9fa0a07..4e6fbf1365 100644
--- a/library/cpp/logger/priority.h
+++ b/library/cpp/logger/priority.h
@@ -11,5 +11,5 @@ enum ELogPriority {
     TLOG_DEBUG = 7 /* "DEBUG" */,
     TLOG_RESOURCES = 8 /* "RESOURCES" */
 };
-#define LOG_MAX_PRIORITY TLOG_RESOURCES
+#define LOG_MAX_PRIORITY TLOG_RESOURCES 
 #define LOG_DEF_PRIORITY TLOG_INFO
diff --git a/library/cpp/logger/rotating_file_creator.cpp b/library/cpp/logger/rotating_file_creator.cpp
index 6f71b68573..8b4f981b5c 100644
--- a/library/cpp/logger/rotating_file_creator.cpp
+++ b/library/cpp/logger/rotating_file_creator.cpp
@@ -1,28 +1,28 @@
-#include "rotating_file_creator.h"
-#include "rotating_file.h"
-
-THolder<TLogBackend> TRotatingFileLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TRotatingFileLogBackend>(Path, MaxSizeBytes, RotatedFilesCount);
-}
-
-
-TRotatingFileLogBackendCreator::TRotatingFileLogBackendCreator()
-    : TFileLogBackendCreator("", "rotating")
-{}
-
-bool TRotatingFileLogBackendCreator::Init(const IInitContext& ctx) {
-    if (!TFileLogBackendCreator::Init(ctx)) {
-        return false;
-    }
-    ctx.GetValue("MaxSizeBytes", MaxSizeBytes);
-    ctx.GetValue("RotatedFilesCount", RotatedFilesCount);
-    return true;
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TRotatingFileLogBackendCreator> TRotatingFileLogBackendCreator::Registrar("rotating");
-
-void TRotatingFileLogBackendCreator::DoToJson(NJson::TJsonValue& value) const {
-    TFileLogBackendCreator::DoToJson(value);
-    value["MaxSizeBytes"] = MaxSizeBytes;
-    value["RotatedFilesCount"] = RotatedFilesCount;
-}
+#include "rotating_file_creator.h" 
+#include "rotating_file.h" 
+ 
+THolder<TLogBackend> TRotatingFileLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TRotatingFileLogBackend>(Path, MaxSizeBytes, RotatedFilesCount); 
+} 
+ 
+ 
+TRotatingFileLogBackendCreator::TRotatingFileLogBackendCreator() 
+    : TFileLogBackendCreator("", "rotating") 
+{} 
+ 
+bool TRotatingFileLogBackendCreator::Init(const IInitContext& ctx) { 
+    if (!TFileLogBackendCreator::Init(ctx)) { 
+        return false; 
+    } 
+    ctx.GetValue("MaxSizeBytes", MaxSizeBytes); 
+    ctx.GetValue("RotatedFilesCount", RotatedFilesCount); 
+    return true; 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TRotatingFileLogBackendCreator> TRotatingFileLogBackendCreator::Registrar("rotating"); 
+ 
+void TRotatingFileLogBackendCreator::DoToJson(NJson::TJsonValue& value) const { 
+    TFileLogBackendCreator::DoToJson(value); 
+    value["MaxSizeBytes"] = MaxSizeBytes; 
+    value["RotatedFilesCount"] = RotatedFilesCount; 
+} 
diff --git a/library/cpp/logger/rotating_file_creator.h b/library/cpp/logger/rotating_file_creator.h
index b2e94584da..ee2e7e6a6c 100644
--- a/library/cpp/logger/rotating_file_creator.h
+++ b/library/cpp/logger/rotating_file_creator.h
@@ -1,18 +1,18 @@
-#pragma once
-
-#include "file_creator.h"
-
-class TRotatingFileLogBackendCreator : public TFileLogBackendCreator {
-public:
-    TRotatingFileLogBackendCreator();
-    virtual bool Init(const IInitContext& ctx) override;
-    static TFactory::TRegistrator<TRotatingFileLogBackendCreator> Registrar;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-    ui64 MaxSizeBytes = Max<ui64>();
-    ui64 RotatedFilesCount = Max<ui64>();
-};
+#pragma once 
+ 
+#include "file_creator.h" 
+ 
+class TRotatingFileLogBackendCreator : public TFileLogBackendCreator { 
+public: 
+    TRotatingFileLogBackendCreator(); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    static TFactory::TRegistrator<TRotatingFileLogBackendCreator> Registrar; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+    ui64 MaxSizeBytes = Max<ui64>(); 
+    ui64 RotatedFilesCount = Max<ui64>(); 
+}; 
diff --git a/library/cpp/logger/stream_creator.cpp b/library/cpp/logger/stream_creator.cpp
index 6246f9bf9c..fafdcfbfb3 100644
--- a/library/cpp/logger/stream_creator.cpp
+++ b/library/cpp/logger/stream_creator.cpp
@@ -1,32 +1,32 @@
-#include "stream_creator.h"
-#include "stream.h"
-
-THolder<TLogBackend> TCerrLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TStreamLogBackend>(&Cerr);
-}
-
-
-TCerrLogBackendCreator::TCerrLogBackendCreator()
-    : TLogBackendCreatorBase("cerr")
-{}
-
-void TCerrLogBackendCreator::DoToJson(NJson::TJsonValue& /*value*/) const {
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TCerrLogBackendCreator> TCerrLogBackendCreator::RegistrarCerr("cerr");
-ILogBackendCreator::TFactory::TRegistrator<TCerrLogBackendCreator> TCerrLogBackendCreator::RegistrarConsole("console");
-
-
-THolder<TLogBackend> TCoutLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TStreamLogBackend>(&Cout);
-}
-
-
-TCoutLogBackendCreator::TCoutLogBackendCreator()
-    : TLogBackendCreatorBase("cout")
-{}
-
-ILogBackendCreator::TFactory::TRegistrator<TCoutLogBackendCreator> TCoutLogBackendCreator::Registrar("cout");
-
-void TCoutLogBackendCreator::DoToJson(NJson::TJsonValue& /*value*/) const {
-}
+#include "stream_creator.h" 
+#include "stream.h" 
+ 
+THolder<TLogBackend> TCerrLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TStreamLogBackend>(&Cerr); 
+} 
+ 
+ 
+TCerrLogBackendCreator::TCerrLogBackendCreator() 
+    : TLogBackendCreatorBase("cerr") 
+{} 
+ 
+void TCerrLogBackendCreator::DoToJson(NJson::TJsonValue& /*value*/) const { 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TCerrLogBackendCreator> TCerrLogBackendCreator::RegistrarCerr("cerr"); 
+ILogBackendCreator::TFactory::TRegistrator<TCerrLogBackendCreator> TCerrLogBackendCreator::RegistrarConsole("console"); 
+ 
+ 
+THolder<TLogBackend> TCoutLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TStreamLogBackend>(&Cout); 
+} 
+ 
+ 
+TCoutLogBackendCreator::TCoutLogBackendCreator() 
+    : TLogBackendCreatorBase("cout") 
+{} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TCoutLogBackendCreator> TCoutLogBackendCreator::Registrar("cout"); 
+ 
+void TCoutLogBackendCreator::DoToJson(NJson::TJsonValue& /*value*/) const { 
+} 
diff --git a/library/cpp/logger/stream_creator.h b/library/cpp/logger/stream_creator.h
index cd66e986c0..73c43b4955 100644
--- a/library/cpp/logger/stream_creator.h
+++ b/library/cpp/logger/stream_creator.h
@@ -1,28 +1,28 @@
-#pragma once
-
-#include "backend_creator.h"
-
-class TCerrLogBackendCreator : public TLogBackendCreatorBase {
-public:
-    TCerrLogBackendCreator();
-    static TFactory::TRegistrator<TCerrLogBackendCreator> RegistrarCerr;
-    static TFactory::TRegistrator<TCerrLogBackendCreator> RegistrarConsole;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-};
-
-class TCoutLogBackendCreator : public TLogBackendCreatorBase {
-public:
-    TCoutLogBackendCreator();
-    static TFactory::TRegistrator<TCoutLogBackendCreator> Registrar;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+ 
+class TCerrLogBackendCreator : public TLogBackendCreatorBase { 
+public: 
+    TCerrLogBackendCreator(); 
+    static TFactory::TRegistrator<TCerrLogBackendCreator> RegistrarCerr; 
+    static TFactory::TRegistrator<TCerrLogBackendCreator> RegistrarConsole; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+}; 
+ 
+class TCoutLogBackendCreator : public TLogBackendCreatorBase { 
+public: 
+    TCoutLogBackendCreator(); 
+    static TFactory::TRegistrator<TCoutLogBackendCreator> Registrar; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+}; 
diff --git a/library/cpp/logger/sync_page_cache_file_creator.cpp b/library/cpp/logger/sync_page_cache_file_creator.cpp
index bf91d20c23..9820e440bc 100644
--- a/library/cpp/logger/sync_page_cache_file_creator.cpp
+++ b/library/cpp/logger/sync_page_cache_file_creator.cpp
@@ -1,28 +1,28 @@
-#include "sync_page_cache_file_creator.h"
-#include "sync_page_cache_file.h"
-
-THolder<TLogBackend> TSyncPageCacheFileLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TSyncPageCacheFileLogBackend>(Path, MaxBufferSize, MaxPendingCacheSize);
-}
-
-
-TSyncPageCacheFileLogBackendCreator::TSyncPageCacheFileLogBackendCreator()
-    : TFileLogBackendCreator("", "sync_page")
-{}
-
-bool TSyncPageCacheFileLogBackendCreator::Init(const IInitContext& ctx) {
-    if (!TFileLogBackendCreator::Init(ctx)) {
-        return false;
-    }
-    ctx.GetValue("MaxBufferSize", MaxBufferSize);
-    ctx.GetValue("MaxPendingCacheSize", MaxPendingCacheSize);
-    return true;
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TSyncPageCacheFileLogBackendCreator> TSyncPageCacheFileLogBackendCreator::Registrar("sync_page");
-
-void TSyncPageCacheFileLogBackendCreator::DoToJson(NJson::TJsonValue& value) const {
-    TFileLogBackendCreator::DoToJson(value);
-    value["MaxBufferSize"] = MaxBufferSize;
-    value["MaxPendingCacheSize"] = MaxPendingCacheSize;
-}
+#include "sync_page_cache_file_creator.h" 
+#include "sync_page_cache_file.h" 
+ 
+THolder<TLogBackend> TSyncPageCacheFileLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TSyncPageCacheFileLogBackend>(Path, MaxBufferSize, MaxPendingCacheSize); 
+} 
+ 
+ 
+TSyncPageCacheFileLogBackendCreator::TSyncPageCacheFileLogBackendCreator() 
+    : TFileLogBackendCreator("", "sync_page") 
+{} 
+ 
+bool TSyncPageCacheFileLogBackendCreator::Init(const IInitContext& ctx) { 
+    if (!TFileLogBackendCreator::Init(ctx)) { 
+        return false; 
+    } 
+    ctx.GetValue("MaxBufferSize", MaxBufferSize); 
+    ctx.GetValue("MaxPendingCacheSize", MaxPendingCacheSize); 
+    return true; 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TSyncPageCacheFileLogBackendCreator> TSyncPageCacheFileLogBackendCreator::Registrar("sync_page"); 
+ 
+void TSyncPageCacheFileLogBackendCreator::DoToJson(NJson::TJsonValue& value) const { 
+    TFileLogBackendCreator::DoToJson(value); 
+    value["MaxBufferSize"] = MaxBufferSize; 
+    value["MaxPendingCacheSize"] = MaxPendingCacheSize; 
+} 
diff --git a/library/cpp/logger/sync_page_cache_file_creator.h b/library/cpp/logger/sync_page_cache_file_creator.h
index 7148150222..3962c54abf 100644
--- a/library/cpp/logger/sync_page_cache_file_creator.h
+++ b/library/cpp/logger/sync_page_cache_file_creator.h
@@ -1,18 +1,18 @@
-#pragma once
-
-#include "file_creator.h"
-
-class TSyncPageCacheFileLogBackendCreator : public TFileLogBackendCreator {
-public:
-    TSyncPageCacheFileLogBackendCreator();
-    virtual bool Init(const IInitContext& ctx) override;
-    static TFactory::TRegistrator<TSyncPageCacheFileLogBackendCreator> Registrar;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-    size_t MaxBufferSize = Max<size_t>();
-    size_t MaxPendingCacheSize = Max<size_t>();
-};
+#pragma once 
+ 
+#include "file_creator.h" 
+ 
+class TSyncPageCacheFileLogBackendCreator : public TFileLogBackendCreator { 
+public: 
+    TSyncPageCacheFileLogBackendCreator(); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    static TFactory::TRegistrator<TSyncPageCacheFileLogBackendCreator> Registrar; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+    size_t MaxBufferSize = Max<size_t>(); 
+    size_t MaxPendingCacheSize = Max<size_t>(); 
+}; 
diff --git a/library/cpp/logger/system_creator.cpp b/library/cpp/logger/system_creator.cpp
index e1cd02d422..efcc2c2acb 100644
--- a/library/cpp/logger/system_creator.cpp
+++ b/library/cpp/logger/system_creator.cpp
@@ -1,25 +1,25 @@
-#include "system_creator.h"
-
-THolder<TLogBackend> TSysLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TSysLogBackend>(Ident.c_str(), Facility, Flags);
-}
-
-
-TSysLogBackendCreator::TSysLogBackendCreator()
-    : TLogBackendCreatorBase("system")
-{}
-
-bool TSysLogBackendCreator::Init(const IInitContext& ctx) {
-    ctx.GetValue("Ident", Ident);
-    ctx.GetValue("Facility", (int&)Facility);
-    ctx.GetValue("Flags", Flags);
-    return true;
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TSysLogBackendCreator> TSysLogBackendCreator::Registrar("system");
-
-void TSysLogBackendCreator::DoToJson(NJson::TJsonValue& value) const {
-    value["Ident"] = Ident;
-    value["Facility"] = (int&)Facility;
-    value["Flags"] = Flags;
-}
+#include "system_creator.h" 
+ 
+THolder<TLogBackend> TSysLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TSysLogBackend>(Ident.c_str(), Facility, Flags); 
+} 
+ 
+ 
+TSysLogBackendCreator::TSysLogBackendCreator() 
+    : TLogBackendCreatorBase("system") 
+{} 
+ 
+bool TSysLogBackendCreator::Init(const IInitContext& ctx) { 
+    ctx.GetValue("Ident", Ident); 
+    ctx.GetValue("Facility", (int&)Facility); 
+    ctx.GetValue("Flags", Flags); 
+    return true; 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TSysLogBackendCreator> TSysLogBackendCreator::Registrar("system"); 
+ 
+void TSysLogBackendCreator::DoToJson(NJson::TJsonValue& value) const { 
+    value["Ident"] = Ident; 
+    value["Facility"] = (int&)Facility; 
+    value["Flags"] = Flags; 
+} 
diff --git a/library/cpp/logger/system_creator.h b/library/cpp/logger/system_creator.h
index e5321267e9..3f2677bad6 100644
--- a/library/cpp/logger/system_creator.h
+++ b/library/cpp/logger/system_creator.h
@@ -1,20 +1,20 @@
-#pragma once
-
-#include "backend_creator.h"
-#include "system.h"
-
-class TSysLogBackendCreator : public TLogBackendCreatorBase {
-public:
-    TSysLogBackendCreator();
-    virtual bool Init(const IInitContext& ctx) override;
-    static TFactory::TRegistrator<TSysLogBackendCreator> Registrar;
-
-protected:
-    virtual void DoToJson(NJson::TJsonValue& value) const override;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-    TString Ident;
-    TSysLogBackend::EFacility Facility = TSysLogBackend::TSYSLOG_LOCAL0;
-    int Flags = 0;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+#include "system.h" 
+ 
+class TSysLogBackendCreator : public TLogBackendCreatorBase { 
+public: 
+    TSysLogBackendCreator(); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    static TFactory::TRegistrator<TSysLogBackendCreator> Registrar; 
+ 
+protected: 
+    virtual void DoToJson(NJson::TJsonValue& value) const override; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+    TString Ident; 
+    TSysLogBackend::EFacility Facility = TSysLogBackend::TSYSLOG_LOCAL0; 
+    int Flags = 0; 
+}; 
diff --git a/library/cpp/logger/thread_creator.cpp b/library/cpp/logger/thread_creator.cpp
index 8f5cfe2782..7e2eaba109 100644
--- a/library/cpp/logger/thread_creator.cpp
+++ b/library/cpp/logger/thread_creator.cpp
@@ -1,30 +1,30 @@
-#include "thread_creator.h"
-#include "thread.h"
-
-TOwningThreadedLogBackendCreator::TOwningThreadedLogBackendCreator(THolder<ILogBackendCreator>&& slave)
-    : Slave(std::move(slave))
-{}
-
-THolder<TLogBackend> TOwningThreadedLogBackendCreator::DoCreateLogBackend() const {
-    return MakeHolder<TOwningThreadedLogBackend>(Slave->CreateLogBackend().Release(), QueueLen, QueueOverflowCallback);
-}
-
-bool TOwningThreadedLogBackendCreator::Init(const IInitContext& ctx) {
-    ctx.GetValue("QueueLen", QueueLen);
-    return Slave->Init(ctx);
-}
-
-
-void TOwningThreadedLogBackendCreator::ToJson(NJson::TJsonValue& value) const {
-    value["QueueLen"] =  QueueLen;
-    value["Threaded"] = true;
-    Slave->ToJson(value);
-}
-
-void TOwningThreadedLogBackendCreator::SetQueueOverflowCallback(std::function<void()> callback) {
-    QueueOverflowCallback = std::move(callback);
-}
-
-void TOwningThreadedLogBackendCreator::SetQueueLen(size_t len) {
-    QueueLen = len;
-}
+#include "thread_creator.h" 
+#include "thread.h" 
+ 
+TOwningThreadedLogBackendCreator::TOwningThreadedLogBackendCreator(THolder<ILogBackendCreator>&& slave) 
+    : Slave(std::move(slave)) 
+{} 
+ 
+THolder<TLogBackend> TOwningThreadedLogBackendCreator::DoCreateLogBackend() const { 
+    return MakeHolder<TOwningThreadedLogBackend>(Slave->CreateLogBackend().Release(), QueueLen, QueueOverflowCallback); 
+} 
+ 
+bool TOwningThreadedLogBackendCreator::Init(const IInitContext& ctx) { 
+    ctx.GetValue("QueueLen", QueueLen); 
+    return Slave->Init(ctx); 
+} 
+ 
+ 
+void TOwningThreadedLogBackendCreator::ToJson(NJson::TJsonValue& value) const { 
+    value["QueueLen"] =  QueueLen; 
+    value["Threaded"] = true; 
+    Slave->ToJson(value); 
+} 
+ 
+void TOwningThreadedLogBackendCreator::SetQueueOverflowCallback(std::function<void()> callback) { 
+    QueueOverflowCallback = std::move(callback); 
+} 
+ 
+void TOwningThreadedLogBackendCreator::SetQueueLen(size_t len) { 
+    QueueLen = len; 
+} 
diff --git a/library/cpp/logger/thread_creator.h b/library/cpp/logger/thread_creator.h
index 9e5ee9571d..61fd001a92 100644
--- a/library/cpp/logger/thread_creator.h
+++ b/library/cpp/logger/thread_creator.h
@@ -1,20 +1,20 @@
-#pragma once
-
-#include "backend_creator.h"
-
-#include <functional>
-
-class TOwningThreadedLogBackendCreator: public ILogBackendCreator {
-public:
-    TOwningThreadedLogBackendCreator(THolder<ILogBackendCreator>&& slave);
-    virtual bool Init(const IInitContext& ctx) override;
-    virtual void ToJson(NJson::TJsonValue& value) const override;
-    void SetQueueOverflowCallback(std::function<void()> callback);
-    void SetQueueLen(size_t len);
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-    THolder<ILogBackendCreator> Slave;
-    std::function<void()> QueueOverflowCallback = {};
-    size_t QueueLen = 0;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+ 
+#include <functional> 
+ 
+class TOwningThreadedLogBackendCreator: public ILogBackendCreator { 
+public: 
+    TOwningThreadedLogBackendCreator(THolder<ILogBackendCreator>&& slave); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    virtual void ToJson(NJson::TJsonValue& value) const override; 
+    void SetQueueOverflowCallback(std::function<void()> callback); 
+    void SetQueueLen(size_t len); 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+    THolder<ILogBackendCreator> Slave; 
+    std::function<void()> QueueOverflowCallback = {}; 
+    size_t QueueLen = 0; 
+}; 
diff --git a/library/cpp/logger/uninitialized_creator.cpp b/library/cpp/logger/uninitialized_creator.cpp
index 26dd168529..5d7528ae23 100644
--- a/library/cpp/logger/uninitialized_creator.cpp
+++ b/library/cpp/logger/uninitialized_creator.cpp
@@ -1,50 +1,50 @@
-#include "uninitialized_creator.h"
-#include "filter_creator.h"
-#include "thread_creator.h"
-#include "file_creator.h"
-#include "null_creator.h"
-#include <util/string/cast.h>
-
-THolder<TLogBackend> TLogBackendCreatorUninitialized::DoCreateLogBackend() const {
-    return Slave->CreateLogBackend();
-}
-
-void TLogBackendCreatorUninitialized::InitCustom(const TString& type, ELogPriority priority, bool threaded) {
-    if (!type) {
-        Slave = MakeHolder<TNullLogBackendCreator>();
-    } else if (TFactory::Has(type)) {
-        Slave = TFactory::MakeHolder(type);
-    } else {
-        Slave = MakeHolder<TFileLogBackendCreator>(type);
-    }
-
-    if (threaded) {
-        Slave = MakeHolder<TOwningThreadedLogBackendCreator>(std::move(Slave));
-    }
-
-    if (priority != LOG_MAX_PRIORITY) {
-        Slave = MakeHolder<TFilteredBackendCreator>(std::move(Slave), priority);
-    }
-}
-
-bool TLogBackendCreatorUninitialized::Init(const IInitContext& ctx) {
-    auto type = ctx.GetOrElse("LoggerType", TString());
-    bool threaded = ctx.GetOrElse("Threaded", false);
-    ELogPriority priority = LOG_MAX_PRIORITY;
-    TString prStr;
-    if (ctx.GetValue("LogLevel", prStr)) {
-        if (!TryFromString(prStr, priority)) {
-            priority = (ELogPriority)FromString<int>(prStr);
-        }
-    }
-    InitCustom(type, priority, threaded);
-    return Slave->Init(ctx);
-}
-
-
-void TLogBackendCreatorUninitialized::ToJson(NJson::TJsonValue& value) const {
-    Y_VERIFY(Slave, "Serialization off uninitialized LogBackendCreator");
-    Slave->ToJson(value);
-}
-
-ILogBackendCreator::TFactory::TRegistrator<TLogBackendCreatorUninitialized> TLogBackendCreatorUninitialized::Registrar("");
+#include "uninitialized_creator.h" 
+#include "filter_creator.h" 
+#include "thread_creator.h" 
+#include "file_creator.h" 
+#include "null_creator.h" 
+#include <util/string/cast.h> 
+ 
+THolder<TLogBackend> TLogBackendCreatorUninitialized::DoCreateLogBackend() const { 
+    return Slave->CreateLogBackend(); 
+} 
+ 
+void TLogBackendCreatorUninitialized::InitCustom(const TString& type, ELogPriority priority, bool threaded) { 
+    if (!type) { 
+        Slave = MakeHolder<TNullLogBackendCreator>(); 
+    } else if (TFactory::Has(type)) { 
+        Slave = TFactory::MakeHolder(type); 
+    } else { 
+        Slave = MakeHolder<TFileLogBackendCreator>(type); 
+    } 
+ 
+    if (threaded) { 
+        Slave = MakeHolder<TOwningThreadedLogBackendCreator>(std::move(Slave)); 
+    } 
+ 
+    if (priority != LOG_MAX_PRIORITY) { 
+        Slave = MakeHolder<TFilteredBackendCreator>(std::move(Slave), priority); 
+    } 
+} 
+ 
+bool TLogBackendCreatorUninitialized::Init(const IInitContext& ctx) { 
+    auto type = ctx.GetOrElse("LoggerType", TString()); 
+    bool threaded = ctx.GetOrElse("Threaded", false); 
+    ELogPriority priority = LOG_MAX_PRIORITY; 
+    TString prStr; 
+    if (ctx.GetValue("LogLevel", prStr)) { 
+        if (!TryFromString(prStr, priority)) { 
+            priority = (ELogPriority)FromString<int>(prStr); 
+        } 
+    } 
+    InitCustom(type, priority, threaded); 
+    return Slave->Init(ctx); 
+} 
+ 
+ 
+void TLogBackendCreatorUninitialized::ToJson(NJson::TJsonValue& value) const { 
+    Y_VERIFY(Slave, "Serialization off uninitialized LogBackendCreator"); 
+    Slave->ToJson(value); 
+} 
+ 
+ILogBackendCreator::TFactory::TRegistrator<TLogBackendCreatorUninitialized> TLogBackendCreatorUninitialized::Registrar(""); 
diff --git a/library/cpp/logger/uninitialized_creator.h b/library/cpp/logger/uninitialized_creator.h
index 16ee0b92f6..0340995338 100644
--- a/library/cpp/logger/uninitialized_creator.h
+++ b/library/cpp/logger/uninitialized_creator.h
@@ -1,16 +1,16 @@
-#pragma once
-
-#include "backend_creator.h"
-
-class TLogBackendCreatorUninitialized : public ILogBackendCreator {
-public:
-    void InitCustom(const TString& type, ELogPriority priority, bool threaded);
-    virtual bool Init(const IInitContext& ctx) override;
-    virtual void ToJson(NJson::TJsonValue& value) const override;
-
-    static TFactory::TRegistrator<TLogBackendCreatorUninitialized> Registrar;
-
-private:
-    virtual THolder<TLogBackend> DoCreateLogBackend() const override;
-    THolder<ILogBackendCreator> Slave;
-};
+#pragma once 
+ 
+#include "backend_creator.h" 
+ 
+class TLogBackendCreatorUninitialized : public ILogBackendCreator { 
+public: 
+    void InitCustom(const TString& type, ELogPriority priority, bool threaded); 
+    virtual bool Init(const IInitContext& ctx) override; 
+    virtual void ToJson(NJson::TJsonValue& value) const override; 
+ 
+    static TFactory::TRegistrator<TLogBackendCreatorUninitialized> Registrar; 
+ 
+private: 
+    virtual THolder<TLogBackend> DoCreateLogBackend() const override; 
+    THolder<ILogBackendCreator> Slave; 
+}; 
diff --git a/library/cpp/logger/ut/ya.make b/library/cpp/logger/ut/ya.make
index 2a461c1353..211c97c8a9 100644
--- a/library/cpp/logger/ut/ya.make
+++ b/library/cpp/logger/ut/ya.make
@@ -4,8 +4,8 @@ OWNER(pg)
 
 PEERDIR(
     ADDINCL library/cpp/logger
-    library/cpp/logger/init_context
-    library/cpp/yconf/patcher
+    library/cpp/logger/init_context 
+    library/cpp/yconf/patcher 
 )
 
 SRCDIR(library/cpp/logger)
@@ -14,7 +14,7 @@ SRCS(
     log_ut.cpp
     element_ut.cpp
     rotating_file_ut.cpp
-    composite_ut.cpp
+    composite_ut.cpp 
 )
 
 END()
diff --git a/library/cpp/logger/ya.make b/library/cpp/logger/ya.make
index 00a5263cba..ba98035b10 100644
--- a/library/cpp/logger/ya.make
+++ b/library/cpp/logger/ya.make
@@ -9,37 +9,37 @@ LIBRARY()
 
 GENERATE_ENUM_SERIALIZATION(priority.h)
 
-PEERDIR (
-    library/cpp/json
-)
-
+PEERDIR ( 
+    library/cpp/json 
+) 
+ 
 SRCS(
-    all.h
-    backend.cpp
-    backend_creator.cpp
-    composite.cpp
-    GLOBAL composite_creator.cpp
-    element.cpp
-    file.cpp
-    GLOBAL file_creator.cpp
-    filter.cpp
-    filter_creator.cpp
+    all.h 
+    backend.cpp 
+    backend_creator.cpp 
+    composite.cpp 
+    GLOBAL composite_creator.cpp 
+    element.cpp 
+    file.cpp 
+    GLOBAL file_creator.cpp 
+    filter.cpp 
+    filter_creator.cpp 
     log.cpp
-    null.cpp
-    GLOBAL null_creator.cpp
-    priority.h
-    record.h
+    null.cpp 
+    GLOBAL null_creator.cpp 
+    priority.h 
+    record.h 
     rotating_file.cpp
-    GLOBAL rotating_file_creator.cpp
+    GLOBAL rotating_file_creator.cpp 
     stream.cpp
-    GLOBAL stream_creator.cpp
+    GLOBAL stream_creator.cpp 
     sync_page_cache_file.cpp
-    GLOBAL sync_page_cache_file_creator.cpp
-    system.cpp
-    GLOBAL system_creator.cpp
-    thread.cpp
-    thread_creator.cpp
-    GLOBAL uninitialized_creator.cpp
+    GLOBAL sync_page_cache_file_creator.cpp 
+    system.cpp 
+    GLOBAL system_creator.cpp 
+    thread.cpp 
+    thread_creator.cpp 
+    GLOBAL uninitialized_creator.cpp 
 )
 
 END()
diff --git a/library/cpp/malloc/api/malloc.h b/library/cpp/malloc/api/malloc.h
index ebd545d6dd..bd9300aede 100644
--- a/library/cpp/malloc/api/malloc.h
+++ b/library/cpp/malloc/api/malloc.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <string.h>
-#include <util/system/compiler.h>
+#include <util/system/compiler.h> 
 
 namespace NMalloc {
     struct TMallocInfo {
@@ -20,13 +20,13 @@ namespace NMalloc {
 
     // this function should be implemented by malloc implementations
     TMallocInfo MallocInfo();
-
-    struct TAllocHeader {
-        void* Block;
-        size_t AllocSize;
-        void Y_FORCE_INLINE Encode(void* block, size_t size, size_t signature) {
-            Block = block;
-            AllocSize = size | signature;
-        }
-    };
+ 
+    struct TAllocHeader { 
+        void* Block; 
+        size_t AllocSize; 
+        void Y_FORCE_INLINE Encode(void* block, size_t size, size_t signature) { 
+            Block = block; 
+            AllocSize = size | signature; 
+        } 
+    }; 
 }
diff --git a/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp b/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp
index fd9debb060..4a0b9c36f9 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp
+++ b/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp
@@ -367,48 +367,48 @@ Y_UNIT_TEST_SUITE(TPrometheusEncoderTest) {
             "bytesRx_count{host=\"solomon-sas-01\", dc=\"sas\", } 17 1512216010000\n"
             "\n");
     }
-
-    Y_UNIT_TEST(CommonLables) {
-        auto result = EncodeToString([](IMetricEncoder* e) {
-            e->OnStreamBegin();
-            { // common time
-                e->OnCommonTime(TInstant::Seconds(1500000000));
-            }
-            { // common labels
-                e->OnLabelsBegin();
-                e->OnLabel("project", "solomon");
-                e->OnLabelsEnd();
-            }
-            { // metric #1
-                e->OnMetricBegin(EMetricType::COUNTER);
-                {
-                    e->OnLabelsBegin();
-                    e->OnLabel("sensor", "single");
-                    e->OnLabel("labels", "l1");
-                    e->OnLabelsEnd();
-                }
-                e->OnUint64(TInstant::ParseIso8601Deprecated("2017-12-02T12:00:10Z"), 17);
-                e->OnMetricEnd();
-            }
-            { // metric #2
-                e->OnMetricBegin(EMetricType::COUNTER);
-                {
-                    e->OnLabelsBegin();
-                    e->OnLabel("sensor", "two");
-                    e->OnLabel("labels", "l2");
-                    e->OnLabelsEnd();
-                }
-                e->OnUint64(TInstant::Zero(), 42);
-                e->OnMetricEnd();
-            }
-            e->OnStreamEnd();
-        });
-    UNIT_ASSERT_STRINGS_EQUAL(result,
-R"(# TYPE single counter
-single{labels="l1", project="solomon", } 17 1512216010000
-# TYPE two counter
-two{labels="l2", project="solomon", } 42 1500000000000
-
-)");
-    }
+ 
+    Y_UNIT_TEST(CommonLables) { 
+        auto result = EncodeToString([](IMetricEncoder* e) { 
+            e->OnStreamBegin(); 
+            { // common time 
+                e->OnCommonTime(TInstant::Seconds(1500000000)); 
+            } 
+            { // common labels 
+                e->OnLabelsBegin(); 
+                e->OnLabel("project", "solomon"); 
+                e->OnLabelsEnd(); 
+            } 
+            { // metric #1 
+                e->OnMetricBegin(EMetricType::COUNTER); 
+                { 
+                    e->OnLabelsBegin(); 
+                    e->OnLabel("sensor", "single"); 
+                    e->OnLabel("labels", "l1"); 
+                    e->OnLabelsEnd(); 
+                } 
+                e->OnUint64(TInstant::ParseIso8601Deprecated("2017-12-02T12:00:10Z"), 17); 
+                e->OnMetricEnd(); 
+            } 
+            { // metric #2 
+                e->OnMetricBegin(EMetricType::COUNTER); 
+                { 
+                    e->OnLabelsBegin(); 
+                    e->OnLabel("sensor", "two"); 
+                    e->OnLabel("labels", "l2"); 
+                    e->OnLabelsEnd(); 
+                } 
+                e->OnUint64(TInstant::Zero(), 42); 
+                e->OnMetricEnd(); 
+            } 
+            e->OnStreamEnd(); 
+        }); 
+    UNIT_ASSERT_STRINGS_EQUAL(result, 
+R"(# TYPE single counter 
+single{labels="l1", project="solomon", } 17 1512216010000 
+# TYPE two counter 
+two{labels="l2", project="solomon", } 42 1500000000000 
+ 
+)"); 
+    } 
 }
diff --git a/library/cpp/monlib/service/pages/registry_mon_page.cpp b/library/cpp/monlib/service/pages/registry_mon_page.cpp
index c59e50f622..35c499e0dc 100644
--- a/library/cpp/monlib/service/pages/registry_mon_page.cpp
+++ b/library/cpp/monlib/service/pages/registry_mon_page.cpp
@@ -2,7 +2,7 @@
 
 #include <library/cpp/monlib/encode/text/text.h>
 #include <library/cpp/monlib/encode/json/json.h>
-#include <library/cpp/monlib/encode/prometheus/prometheus.h>
+#include <library/cpp/monlib/encode/prometheus/prometheus.h> 
 #include <library/cpp/monlib/encode/spack/spack_v1.h>
 #include <library/cpp/monlib/service/format.h>
 
@@ -22,9 +22,9 @@ namespace NMonitoring {
                 resp = HTTPOKSPACK;
                 const auto compression = ParseCompression(request);
                 encoder = NMonitoring::EncoderSpackV1(&out, ETimePrecision::SECONDS, compression);
-            } else if (formatStr == TStringBuf("prometheus")) {
-                resp = HTTPOKPROMETHEUS;
-                encoder = NMonitoring::EncoderPrometheus(&out);
+            } else if (formatStr == TStringBuf("prometheus")) { 
+                resp = HTTPOKPROMETHEUS; 
+                encoder = NMonitoring::EncoderPrometheus(&out); 
             } else {
                 ythrow yexception() << "unsupported metric encoding format: " << formatStr;
             }
diff --git a/library/cpp/monlib/service/pages/registry_mon_page.h b/library/cpp/monlib/service/pages/registry_mon_page.h
index 2d26d3319c..f76017c3a7 100644
--- a/library/cpp/monlib/service/pages/registry_mon_page.h
+++ b/library/cpp/monlib/service/pages/registry_mon_page.h
@@ -5,7 +5,7 @@
 #include <library/cpp/monlib/metrics/metric_registry.h>
 
 namespace NMonitoring {
-    // For now this class can only enumerate all metrics without any grouping or serve JSON/Spack/Prometheus
+    // For now this class can only enumerate all metrics without any grouping or serve JSON/Spack/Prometheus 
     class TMetricRegistryPage: public TPreMonPage {
     public:
         TMetricRegistryPage(const TString& path, const TString& title, TAtomicSharedPtr<IMetricSupplier> registry)
diff --git a/library/cpp/monlib/service/pages/ya.make b/library/cpp/monlib/service/pages/ya.make
index 48d44a0838..6af26f73f4 100644
--- a/library/cpp/monlib/service/pages/ya.make
+++ b/library/cpp/monlib/service/pages/ya.make
@@ -25,7 +25,7 @@ PEERDIR(
     library/cpp/monlib/encode/json
     library/cpp/monlib/encode/text
     library/cpp/monlib/encode/spack
-    library/cpp/monlib/encode/prometheus
+    library/cpp/monlib/encode/prometheus 
 )
 
 END()
diff --git a/library/cpp/monlib/service/service.cpp b/library/cpp/monlib/service/service.cpp
index 929efbf816..8571549b14 100644
--- a/library/cpp/monlib/service/service.cpp
+++ b/library/cpp/monlib/service/service.cpp
@@ -47,10 +47,10 @@ namespace NMonitoring {
                 Handler(out, *this);
                 out.Finish();
             } catch (...) {
-                auto msg = CurrentExceptionMessage();
-                out << "HTTP/1.1 500 Internal server error\r\nConnection: Close\r\n\r\n" << msg;
-                out.Finish();
-                YSYSLOG(TLOG_ERR, "THttpClient: error while serving monitoring request: %s", msg.data());
+                auto msg = CurrentExceptionMessage(); 
+                out << "HTTP/1.1 500 Internal server error\r\nConnection: Close\r\n\r\n" << msg; 
+                out.Finish(); 
+                YSYSLOG(TLOG_ERR, "THttpClient: error while serving monitoring request: %s", msg.data()); 
             }
         }
 
diff --git a/library/cpp/object_factory/object_factory.h b/library/cpp/object_factory/object_factory.h
index 96cc11bcfd..a6183dab48 100644
--- a/library/cpp/object_factory/object_factory.h
+++ b/library/cpp/object_factory/object_factory.h
@@ -1,12 +1,12 @@
-#pragma once
-
-#include <util/system/guard.h>
+#pragma once 
+ 
+#include <util/system/guard.h> 
 #include <util/system/rwlock.h>
-#include <util/generic/map.h>
-#include <util/generic/set.h>
+#include <util/generic/map.h> 
+#include <util/generic/set.h> 
 #include <util/generic/singleton.h>
 #include <util/generic/yexception.h>
-
+ 
 namespace NObjectFactory {
     template <class TProduct, class... TArgs>
     class IFactoryObjectCreator {
@@ -62,7 +62,7 @@ namespace NObjectFactory {
             if (!Creators.insert(typename ICreators::value_type(key, creator)).second)
                 ythrow yexception() << "Product with key " << key << " already registered";
         }
-
+ 
         template <class TDerivedProduct>
         void Register(const TKey& key) {
             Register<TDerivedProduct>(key, new TFactoryObjectCreator<TProduct, TDerivedProduct, TArgs...>);
@@ -74,8 +74,8 @@ namespace NObjectFactory {
             for (typename ICreators::const_iterator i = Creators.begin(), e = Creators.end(); i != e; ++i) {
                 keys.insert(i->first);
             }
-        }
-
+        } 
+ 
     protected:
         IFactoryObjectCreator<TProduct, TArgs...>* GetCreator(const TKey& key) const {
             TReadGuard guard(CreatorsLock);
@@ -94,7 +94,7 @@ namespace NObjectFactory {
         ICreators Creators;
         TRWMutex CreatorsLock;
     };
-
+ 
     template <class TProduct, class TKey>
     class TObjectFactory: public IObjectFactory<TProduct, TKey, void> {
     public:
@@ -132,11 +132,11 @@ namespace NObjectFactory {
             return result;
         }
 
-        template<class... Args>
-        static THolder<TProduct> MakeHolder(Args&&... args) {
+        template<class... Args> 
+        static THolder<TProduct> MakeHolder(Args&&... args) { 
             return THolder<TProduct>(Construct(std::forward<Args>(args)...));
-        }
-
+        } 
+ 
         static bool Has(const TKey& key) {
             return Singleton<TObjectFactory<TProduct, TKey>>()->HasImpl(key);
         }
@@ -144,7 +144,7 @@ namespace NObjectFactory {
         static void GetRegisteredKeys(TSet<TKey>& keys) {
             return Singleton<TObjectFactory<TProduct, TKey>>()->GetKeys(keys);
         }
-
+ 
         static TSet<TKey> GetRegisteredKeys() {
             TSet<TKey> keys;
             Singleton<TObjectFactory<TProduct, TKey>>()->GetKeys(keys);
@@ -182,16 +182,16 @@ namespace NObjectFactory {
 
     template <class TProduct, class TKey, class... TArgs>
     class TParametrizedObjectFactory: public IObjectFactory<TProduct, TKey, TArgs...> {
-    public:
+    public: 
         TProduct* Create(const TKey& key, TArgs... args) const {
             IFactoryObjectCreator<TProduct, TArgs...>* creator = IObjectFactory<TProduct, TKey, TArgs...>::GetCreator(key);
             return creator == nullptr ? nullptr : creator->Create(std::forward<TArgs>(args)...);
-        }
+        } 
 
         static bool Has(const TKey& key) {
             return Singleton<TParametrizedObjectFactory<TProduct, TKey, TArgs...>>()->HasImpl(key);
         }
-
+ 
         static TProduct* Construct(const TKey& key, TArgs... args) {
             return Singleton<TParametrizedObjectFactory<TProduct, TKey, TArgs...>>()->Create(key, std::forward<TArgs>(args)...);
         }
@@ -203,11 +203,11 @@ namespace NObjectFactory {
             return result;
         }
 
-        template<class... Args>
-        static THolder<TProduct> MakeHolder(Args&&... args) {
-            return THolder<TProduct>(Construct(std::forward<Args>(args)...));
-        }
-
+        template<class... Args> 
+        static THolder<TProduct> MakeHolder(Args&&... args) { 
+            return THolder<TProduct>(Construct(std::forward<Args>(args)...)); 
+        } 
+ 
         static void GetRegisteredKeys(TSet<TKey>& keys) {
             return Singleton<TParametrizedObjectFactory<TProduct, TKey, TArgs...>>()->GetKeys(keys);
         }
@@ -238,6 +238,6 @@ namespace NObjectFactory {
                 return Product::GetTypeName();
             }
         };
-    };
+    }; 
 
 }
diff --git a/library/cpp/protobuf/json/proto2json.h b/library/cpp/protobuf/json/proto2json.h
index 89a1781a40..71daeeb4ab 100644
--- a/library/cpp/protobuf/json/proto2json.h
+++ b/library/cpp/protobuf/json/proto2json.h
@@ -9,7 +9,7 @@
 
 #include <util/generic/fwd.h>
 #include <util/generic/vector.h>
-#include <util/generic/yexception.h>
+#include <util/generic/yexception.h> 
 #include <util/stream/str.h>
 
 #include <functional>
diff --git a/library/cpp/protobuf/json/ut/proto2json_ut.cpp b/library/cpp/protobuf/json/ut/proto2json_ut.cpp
index 07e52d7f2f..0a2f5652c0 100644
--- a/library/cpp/protobuf/json/ut/proto2json_ut.cpp
+++ b/library/cpp/protobuf/json/ut/proto2json_ut.cpp
@@ -27,12 +27,12 @@ using namespace NProtobufJsonTest;
 
 Y_UNIT_TEST_SUITE(TProto2JsonFlatTest) {
     Y_UNIT_TEST(TestFlatDefault) {
-        using namespace ::google::protobuf;
-        TFlatDefault proto;
-        NJson::TJsonValue json;
-        TProto2JsonConfig cfg;
-        cfg.SetMissingSingleKeyMode(TProto2JsonConfig::MissingKeyDefault);
-        UNIT_ASSERT_NO_EXCEPTION(Proto2Json(proto, json, cfg));
+        using namespace ::google::protobuf; 
+        TFlatDefault proto; 
+        NJson::TJsonValue json; 
+        TProto2JsonConfig cfg; 
+        cfg.SetMissingSingleKeyMode(TProto2JsonConfig::MissingKeyDefault); 
+        UNIT_ASSERT_NO_EXCEPTION(Proto2Json(proto, json, cfg)); 
 #define DEFINE_FIELD(name, value)                                                                     \
     {                                                                                                 \
         auto descr = proto.GetMetadata().descriptor->FindFieldByName(#name);                          \
@@ -71,9 +71,9 @@ Y_UNIT_TEST_SUITE(TProto2JsonFlatTest) {
         }                                                                                             \
     }
 #include <library/cpp/protobuf/json/ut/fields.incl>
-#undef DEFINE_FIELD
-    }
-
+#undef DEFINE_FIELD 
+    } 
+ 
     Y_UNIT_TEST(TestNameGenerator) {
         TNameGeneratorType proto;
         proto.SetField(42);
diff --git a/library/cpp/protobuf/json/ut/test.proto b/library/cpp/protobuf/json/ut/test.proto
index 0fa996fd41..0a207232c6 100644
--- a/library/cpp/protobuf/json/ut/test.proto
+++ b/library/cpp/protobuf/json/ut/test.proto
@@ -91,34 +91,34 @@ message TFlatRepeated {
     repeated string UserID = 20;
 };
 
-message TFlatDefault {
-    optional int32 I32 = 1 [default = 132];
-    optional int64 I64 = 2 [default = 164];
-    optional uint32 UI32 = 3 [default = 232];
-    optional uint64 UI64 = 4 [default = 264];
-    optional sint32 SI32 = 5 [default = 332];
-    optional sint64 SI64 = 6 [default = 364];
-    optional fixed32 FI32 = 7 [default = 432];
-    optional fixed64 FI64 = 8 [default = 464];
-    optional sfixed32 SFI32 = 9 [default = 532];
-    optional sfixed64 SFI64 = 10 [default = 564];
-
-    optional bool Bool = 11 [default = true];
-
-    optional string String = 12 [default = "string"];
-    optional bytes Bytes = 13 [default = "bytes"];
-
-    optional EEnum Enum = 14 [default = E_2];
-
-    optional float Float = 15 [default = 0.123];
-    optional double Double = 16 [default = 0.456];
+message TFlatDefault { 
+    optional int32 I32 = 1 [default = 132]; 
+    optional int64 I64 = 2 [default = 164]; 
+    optional uint32 UI32 = 3 [default = 232]; 
+    optional uint64 UI64 = 4 [default = 264]; 
+    optional sint32 SI32 = 5 [default = 332]; 
+    optional sint64 SI64 = 6 [default = 364]; 
+    optional fixed32 FI32 = 7 [default = 432]; 
+    optional fixed64 FI64 = 8 [default = 464]; 
+    optional sfixed32 SFI32 = 9 [default = 532]; 
+    optional sfixed64 SFI64 = 10 [default = 564]; 
+ 
+    optional bool Bool = 11 [default = true]; 
+ 
+    optional string String = 12 [default = "string"]; 
+    optional bytes Bytes = 13 [default = "bytes"]; 
+ 
+    optional EEnum Enum = 14 [default = E_2]; 
+ 
+    optional float Float = 15 [default = 0.123]; 
+    optional double Double = 16 [default = 0.456]; 
 
     optional string OneString = 17 [default = "string"];
     optional string OneTwoString = 18 [default = "string"];
     optional string ABC = 19 [default = "abc"];
     optional string UserID = 20 [default = "some_id"];
-};
-
+}; 
+ 
 message TCompositeOptional {
     optional TFlatOptional Part = 1;
 };
diff --git a/library/cpp/testing/unittest/gtest.cpp b/library/cpp/testing/unittest/gtest.cpp
index ebad1ea4d6..e064938f13 100644
--- a/library/cpp/testing/unittest/gtest.cpp
+++ b/library/cpp/testing/unittest/gtest.cpp
@@ -46,7 +46,7 @@ namespace {
             return new TCurrentTest(Test);
         }
 
-        void AddTest(const char* name, void (*body)(TTestContext&), bool forceFork) override {
+        void AddTest(const char* name, void (*body)(TTestContext&), bool forceFork) override { 
             Test.Tests.push_back(TBaseTestCase(name, body, forceFork));
         }
 
diff --git a/library/cpp/testing/unittest/gtest.h b/library/cpp/testing/unittest/gtest.h
index b6768b1bf0..7dc5eac4a2 100644
--- a/library/cpp/testing/unittest/gtest.h
+++ b/library/cpp/testing/unittest/gtest.h
@@ -15,7 +15,7 @@ namespace NUnitTest {
         struct IGTestFactory: public ITestBaseFactory {
             ~IGTestFactory() override;
 
-            virtual void AddTest(const char* name, void (*body)(TTestContext&), bool forceFork) = 0;
+            virtual void AddTest(const char* name, void (*body)(TTestContext&), bool forceFork) = 0; 
         };
 
         IGTestFactory* ByName(const char* name);
@@ -42,7 +42,7 @@ namespace testing {
 }
 
 #define TEST_IMPL(N, NN, FF)                                                         \
-    void Test##N##NN(NUnitTest::TTestContext&);                                      \
+    void Test##N##NN(NUnitTest::TTestContext&);                                      \ 
     namespace NTestSuite##N##NN {                                                    \
         struct TReg {                                                                \
             inline TReg() {                                                          \
@@ -51,7 +51,7 @@ namespace testing {
         };                                                                           \
         static TReg reg;                                                             \
     }                                                                                \
-    void Test##N##NN(NUnitTest::TTestContext&)
+    void Test##N##NN(NUnitTest::TTestContext&) 
 
 #define TEST_F_IMPL(N, NN, FF)                \
     namespace NTestSuite##N##NN {             \
diff --git a/library/cpp/testing/unittest/registar.h b/library/cpp/testing/unittest/registar.h
index 44517a0092..dd62a5110b 100644
--- a/library/cpp/testing/unittest/registar.h
+++ b/library/cpp/testing/unittest/registar.h
@@ -62,7 +62,7 @@ namespace NUnitTest {
 
     class ITestSuiteProcessor;
 
-    struct TTestContext {
+    struct TTestContext { 
         TTestContext()
             : Processor(nullptr)
         {
@@ -74,11 +74,11 @@ namespace NUnitTest {
         }
 
         using TMetrics = THashMap<TString, double>;
-        TMetrics Metrics;
+        TMetrics Metrics; 
 
         ITestSuiteProcessor* Processor;
-    };
-
+    }; 
+ 
     class ITestSuiteProcessor {
     public:
         struct TUnit {
@@ -285,8 +285,8 @@ private:                                                   \
 #define CATCH_REACTION(FN, e, context) this->AddError(("(" + TypeName(e) + ") " + e.what()).data(), context)
 #define CATCH_REACTION_BT(FN, e, context) this->AddError(("(" + TypeName(e) + ") " + e.what()).data(), (e.BackTrace() ? e.BackTrace()->PrintToString() : TString()), context)
 #else
-#define CATCH_REACTION(FN, e, context) throw
-#define CATCH_REACTION_BT(FN, e, context) throw
+#define CATCH_REACTION(FN, e, context) throw 
+#define CATCH_REACTION_BT(FN, e, context) throw 
 #endif
 
 #define UNIT_TEST_CHECK_TEST_IS_DECLARED_ONLY_ONCE(F)                                       \
@@ -334,7 +334,7 @@ private:                                                   \
     if (this->GetForkTests() && !this->GetIsForked()) {                                                                \
         UNIT_TEST_IMPL(F, false);                                                                                      \
         /* forked process (or main without "--fork-tests") treats some exceptions as success - it's exception test! */ \
-    } else {                                                                                                           \
+    } else {                                                                                                           \ 
         NUnitTest::TTestContext context(this->TTestBase::Processor());                                                 \
         if (this->CheckAccessTest((#F))) {                                                                             \
             try {                                                                                                      \
@@ -350,9 +350,9 @@ private:                                                   \
             } catch (...) {                                                                                            \
                 this->AddError("non-std exception!", &context);                                                        \
             }                                                                                                          \
-            this->Finish((#F), &context);                                                                              \
-        }                                                                                                              \
-    }
+            this->Finish((#F), &context);                                                                              \ 
+        }                                                                                                              \ 
+    } 
 
 #define UNIT_TEST_SUITE_END() \
     this->AtEnd();            \
@@ -753,7 +753,7 @@ public:                       \
 #define UNIT_ASSERT_TEST_FAILS(A) UNIT_ASSERT_TEST_FAILS_C(A, "")
 
 #define UNIT_ADD_METRIC(name, value) ut_context.Metrics[name] = value
-
+ 
     class TTestFactory {
         friend class TTestBase;
         friend class ITestBaseFactory;
@@ -1010,7 +1010,7 @@ public:                       \
 #define Y_UNIT_TEST_IMPL(N, FF, F)      \
     Y_UNIT_TEST_IMPL_REGISTER(N, FF, F) \
     void TTestCase##N::Execute_(NUnitTest::TTestContext& ut_context Y_DECLARE_UNUSED)
-
+ 
 #define Y_UNIT_TEST(N) Y_UNIT_TEST_IMPL(N, false, TCurrentTestCase)
 #define Y_UNIT_TEST_F(N, F) Y_UNIT_TEST_IMPL(N, false, F)
 #define SIMPLE_UNIT_FORKED_TEST(N) Y_UNIT_TEST_IMPL(N, true, TCurrentTestCase)
diff --git a/library/cpp/testing/unittest/utmain.cpp b/library/cpp/testing/unittest/utmain.cpp
index 305bc6b40f..2c1dcc4208 100644
--- a/library/cpp/testing/unittest/utmain.cpp
+++ b/library/cpp/testing/unittest/utmain.cpp
@@ -89,11 +89,11 @@ private:
         event.InsertValue("status", status);
         event.InsertValue("comment", comment.data());
         event.InsertValue("time", (now - PrevTime).SecondsFloat());
-        if (context) {
-            for (const auto& metric : context->Metrics) {
-                event["metrics"].InsertValue(metric.first, metric.second);
-            }
-        }
+        if (context) { 
+            for (const auto& metric : context->Metrics) { 
+                event["metrics"].InsertValue(metric.first, metric.second); 
+            } 
+        } 
         Trace("subtest-finished", event);
 
         PrevTime = now;
author	iddqd <iddqd@yandex-team.ru>	2022-02-10 16:49:45 +0300
committer	Daniil Cherednik <dcherednik@yandex-team.ru>	2022-02-10 16:49:45 +0300
commit	07fce9c5f7771600d0b3d70e1f88fd8a7e164d85 (patch)
tree	e4aa4750fbb864d70f8c06cf03d2750e979ea3bf /library
parent	af42068bf6cd93c976b80dd0388fa48cdf65da11 (diff)
download	ydb-07fce9c5f7771600d0b3d70e1f88fd8a7e164d85.tar.gz