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

8 files changed, 283 insertions, 283 deletions

diff --git a/library/cpp/lwtrace/control.h b/library/cpp/lwtrace/control.h
index 51e13a11b2..16b24eafd2 100644
--- a/library/cpp/lwtrace/control.h
+++ b/library/cpp/lwtrace/control.h
@@ -123,7 +123,7 @@ namespace NLWTrace {
         TCyclicDepot CyclicDepot;
         TDurationDepot DurationDepot;
         TAtomic LastTrackId;
-        TAtomic LastSpanId; 
+        TAtomic LastSpanId;
         typedef TVector<std::pair<TProbe*, IExecutor*>> TProbes;
         TProbes Probes;
         bool Attached;
diff --git a/library/cpp/lwtrace/log_shuttle.cpp b/library/cpp/lwtrace/log_shuttle.cpp
index 874f103697..695aa90b31 100644
--- a/library/cpp/lwtrace/log_shuttle.cpp
+++ b/library/cpp/lwtrace/log_shuttle.cpp
@@ -1,67 +1,67 @@
 #include "log_shuttle.h"
-#include "probes.h" 
+#include "probes.h"
 
 namespace NLWTrace {
-    LWTRACE_USING(LWTRACE_INTERNAL_PROVIDER); 
- 
-#ifdef LWTRACE_DISABLE 
- 
-    template <class TDepot> 
+    LWTRACE_USING(LWTRACE_INTERNAL_PROVIDER);
+
+#ifdef LWTRACE_DISABLE
+
+    template <class TDepot>
     bool TLogShuttle<TDepot>::DoFork(TShuttlePtr& child) {
         Y_UNUSED(child);
-        return false; 
-    } 
- 
-    template <class TDepot> 
+        return false;
+    }
+
+    template <class TDepot>
     bool TLogShuttle<TDepot>::DoJoin(const TShuttlePtr& child) {
         Y_UNUSED(child);
-        return false; 
-    } 
- 
-#else 
- 
-    template <class TDepot> 
+        return false;
+    }
+
+#else
+
+    template <class TDepot>
     bool TLogShuttle<TDepot>::DoFork(TShuttlePtr& child) {
         if (child = Executor->RentShuttle()) {
             child->SetParentSpanId(GetSpanId());
             Executor->Cast(child)->SetIgnore(true);
-            TParams params; 
+            TParams params;
             params.Param[0].CopyConstruct<ui64>(child->GetSpanId());
-            bool result = DoAddProbe(&LWTRACE_GET_NAME(Fork).Probe, params, 0); 
-            TUserSignature<ui64>::DestroyParams(params); 
-            return result; 
-        } 
-        AtomicIncrement(ForkFailed); 
-        return false; 
-    } 
- 
-    template <class TDepot> 
-    bool TLogShuttle<TDepot>::DoJoin(const TShuttlePtr& shuttle) { 
-        auto* child = Executor->Cast(shuttle); 
-        TParams params; 
-        params.Param[0].CopyConstruct<ui64>(child->GetSpanId()); 
-        params.Param[1].CopyConstruct<ui64>(child->TrackLog.Items.size()); 
-        bool result = DoAddProbe(&LWTRACE_GET_NAME(Join).Probe, params, 0); 
-        TUserSignature<ui64, ui64>::DestroyParams(params); 
-        if (result) { 
-            with_lock (Lock) { 
-                ssize_t n = MaxTrackLength - TrackLog.Items.size(); 
-                for (auto& item: child->TrackLog.Items) { 
-                    if (n-- <= 0) { 
-                        TrackLog.Truncated = true; 
-                        break; 
-                    } 
-                    TrackLog.Items.emplace_back(item); 
-                } 
-            } 
-        } 
-        AtomicAdd(ForkFailed, AtomicGet(child->ForkFailed)); 
-        Executor->ParkShuttle(child); 
-        return result; 
-    } 
- 
-#endif 
- 
-    template class TLogShuttle<TDurationDepot>; 
-    template class TLogShuttle<TCyclicDepot>; 
+            bool result = DoAddProbe(&LWTRACE_GET_NAME(Fork).Probe, params, 0);
+            TUserSignature<ui64>::DestroyParams(params);
+            return result;
+        }
+        AtomicIncrement(ForkFailed);
+        return false;
+    }
+
+    template <class TDepot>
+    bool TLogShuttle<TDepot>::DoJoin(const TShuttlePtr& shuttle) {
+        auto* child = Executor->Cast(shuttle);
+        TParams params;
+        params.Param[0].CopyConstruct<ui64>(child->GetSpanId());
+        params.Param[1].CopyConstruct<ui64>(child->TrackLog.Items.size());
+        bool result = DoAddProbe(&LWTRACE_GET_NAME(Join).Probe, params, 0);
+        TUserSignature<ui64, ui64>::DestroyParams(params);
+        if (result) {
+            with_lock (Lock) {
+                ssize_t n = MaxTrackLength - TrackLog.Items.size();
+                for (auto& item: child->TrackLog.Items) {
+                    if (n-- <= 0) {
+                        TrackLog.Truncated = true;
+                        break;
+                    }
+                    TrackLog.Items.emplace_back(item);
+                }
+            }
+        }
+        AtomicAdd(ForkFailed, AtomicGet(child->ForkFailed));
+        Executor->ParkShuttle(child);
+        return result;
+    }
+
+#endif
+
+    template class TLogShuttle<TDurationDepot>;
+    template class TLogShuttle<TCyclicDepot>;
 }
diff --git a/library/cpp/lwtrace/log_shuttle.h b/library/cpp/lwtrace/log_shuttle.h
index 34d4cb4a85..729a38615f 100644
--- a/library/cpp/lwtrace/log_shuttle.h
+++ b/library/cpp/lwtrace/log_shuttle.h
@@ -46,19 +46,19 @@ namespace NLWTrace {
     template <class TDepot>
     class TLogShuttle: public IShuttle {
     private:
-        using TExecutor = TRunLogShuttleActionExecutor<TDepot>; 
+        using TExecutor = TRunLogShuttleActionExecutor<TDepot>;
         TTrackLog TrackLog;
-        TExecutor* Executor; 
+        TExecutor* Executor;
         bool Ignore = false;
         size_t MaxTrackLength;
         TAdaptiveLock Lock;
-        TAtomic ForkFailed = 0; 
+        TAtomic ForkFailed = 0;
 
     public:
-        explicit TLogShuttle(TExecutor* executor) 
-            : IShuttle(executor->GetTraceIdx(), executor->NewSpanId()) 
-            , Executor(executor) 
-            , MaxTrackLength(Executor->GetAction().GetMaxTrackLength() ? Executor->GetAction().GetMaxTrackLength() : 100) 
+        explicit TLogShuttle(TExecutor* executor)
+            : IShuttle(executor->GetTraceIdx(), executor->NewSpanId())
+            , Executor(executor)
+            , MaxTrackLength(Executor->GetAction().GetMaxTrackLength() ? Executor->GetAction().GetMaxTrackLength() : 100)
         {
         }
 
@@ -67,7 +67,7 @@ namespace NLWTrace {
         void DoDrop() override;
         void DoSerialize(TShuttleTrace& msg) override;
         bool DoFork(TShuttlePtr& child) override;
-        bool DoJoin(const TShuttlePtr& child) override; 
+        bool DoJoin(const TShuttlePtr& child) override;
 
         void SetIgnore(bool ignore);
         void Clear();
@@ -110,19 +110,19 @@ namespace NLWTrace {
 
         TAtomic MissedTracks = 0;
         TAtomic* LastTrackId;
-        TAtomic* LastSpanId; 
+        TAtomic* LastSpanId;
 
         static constexpr int MaxShuttles = 100000;
 
     public:
-        TRunLogShuttleActionExecutor(ui64 traceIdx, const TRunLogShuttleAction& action, TDepot* depot, TAtomic* lastTrackId, TAtomic* lastSpanId); 
+        TRunLogShuttleActionExecutor(ui64 traceIdx, const TRunLogShuttleAction& action, TDepot* depot, TAtomic* lastTrackId, TAtomic* lastSpanId);
         ~TRunLogShuttleActionExecutor();
         bool DoExecute(TOrbit& orbit, const TParams& params) override;
         void RecordShuttle(TLogShuttle<TDepot>* shuttle);
         void ParkShuttle(TLogShuttle<TDepot>* shuttle);
-        void DiscardShuttle(); 
-        TShuttlePtr RentShuttle(); 
-        ui64 NewSpanId(); 
+        void DiscardShuttle();
+        TShuttlePtr RentShuttle();
+        ui64 NewSpanId();
         const TRunLogShuttleAction& GetAction() const {
             return Action;
         }
@@ -178,19 +178,19 @@ namespace NLWTrace {
     void TLogShuttle<TDepot>::DoEndOfTrack() {
         // Record track log if not ignored
         if (!Ignore) {
-            if (AtomicGet(ForkFailed)) { 
-                Executor->DiscardShuttle(); 
-            } else { 
-                Executor->RecordShuttle(this); 
-            } 
+            if (AtomicGet(ForkFailed)) {
+                Executor->DiscardShuttle();
+            } else {
+                Executor->RecordShuttle(this);
+            }
         }
-        Executor->ParkShuttle(this); 
+        Executor->ParkShuttle(this);
     }
 
     template <class TDepot>
     void TLogShuttle<TDepot>::DoDrop() {
         // Do not track log results of dropped shuttles
-        Executor->ParkShuttle(this); 
+        Executor->ParkShuttle(this);
     }
 
     template <class TDepot>
@@ -239,13 +239,13 @@ namespace NLWTrace {
         ui64 traceIdx,
         const TRunLogShuttleAction& action,
         TDepot* depot,
-        TAtomic* lastTrackId, 
-        TAtomic* lastSpanId) 
+        TAtomic* lastTrackId,
+        TAtomic* lastSpanId)
         : TLogShuttleActionBase<TDepot>(traceIdx)
         , Action(action)
         , Depot(depot)
         , LastTrackId(lastTrackId)
-        , LastSpanId(lastSpanId) 
+        , LastSpanId(lastSpanId)
     {
         ui64 size = Min<ui64>(Action.GetShuttlesCount() ? Action.GetShuttlesCount() : 1000, MaxShuttles); // Do not allow to allocate too much memory
         AllShuttles.reserve(size);
@@ -277,11 +277,11 @@ namespace NLWTrace {
     }
 
     template <class TDepot>
-    void TRunLogShuttleActionExecutor<TDepot>::DiscardShuttle() { 
-        AtomicIncrement(MissedTracks); 
-    } 
- 
-    template <class TDepot> 
+    void TRunLogShuttleActionExecutor<TDepot>::DiscardShuttle() {
+        AtomicIncrement(MissedTracks);
+    }
+
+    template <class TDepot>
     void TRunLogShuttleActionExecutor<TDepot>::RecordShuttle(TLogShuttle<TDepot>* shuttle) {
         if (Depot == nullptr) {
             return;
@@ -312,12 +312,12 @@ namespace NLWTrace {
         Parking.emplace_back(shuttle);
     }
 
-    template <class TDepot> 
-    ui64 TRunLogShuttleActionExecutor<TDepot>::NewSpanId() 
-    { 
-        return LastSpanId ? AtomicIncrement(*LastSpanId) : 0; 
-    } 
- 
+    template <class TDepot>
+    ui64 TRunLogShuttleActionExecutor<TDepot>::NewSpanId()
+    {
+        return LastSpanId ? AtomicIncrement(*LastSpanId) : 0;
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
 
     template <class TDepot>
diff --git a/library/cpp/lwtrace/probes.h b/library/cpp/lwtrace/probes.h
index bff2fb455f..68810bd118 100644
--- a/library/cpp/lwtrace/probes.h
+++ b/library/cpp/lwtrace/probes.h
@@ -9,12 +9,12 @@
     PROBE(DeserializationError, GROUPS("LWTraceError"),                  \
           TYPES(TString, TString),                                       \
           NAMES("probeName", "providerName"))                            \
-    PROBE(Fork, GROUPS(),                                                \ 
-          TYPES(ui64),                                                   \ 
-          NAMES("spanId"))                                               \ 
-    PROBE(Join, GROUPS(),                                                \ 
-          TYPES(ui64, ui64),                                             \ 
-          NAMES("spanId", "trackLength"))                                \ 
+    PROBE(Fork, GROUPS(),                                                \
+          TYPES(ui64),                                                   \
+          NAMES("spanId"))                                               \
+    PROBE(Join, GROUPS(),                                                \
+          TYPES(ui64, ui64),                                             \
+          NAMES("spanId", "trackLength"))                                \
     PROBE(OrbitIsUsedConcurrentlyError, GROUPS("LWTraceError"),          \
           TYPES(TString),                                                \
           NAMES("backtrace"))                                            \
diff --git a/library/cpp/lwtrace/shuttle.h b/library/cpp/lwtrace/shuttle.h
index fc1703aeb0..85c6e4da61 100644
--- a/library/cpp/lwtrace/shuttle.h
+++ b/library/cpp/lwtrace/shuttle.h
@@ -20,16 +20,16 @@ namespace NLWTrace {
     class alignas(8) IShuttle: public TThrRefBase {
     private:
         ui64 TraceIdx;
-        ui64 SpanId; 
-        ui64 ParentSpanId = 0; 
+        ui64 SpanId;
+        ui64 ParentSpanId = 0;
         TAtomic Status = 0;
         static constexpr ui64 DeadFlag = 0x1ull;
         TShuttlePtr Next;
 
     public:
-        explicit IShuttle(ui64 traceIdx, ui64 spanId) 
+        explicit IShuttle(ui64 traceIdx, ui64 spanId)
             : TraceIdx(traceIdx)
-            , SpanId(spanId) 
+            , SpanId(spanId)
         {
         }
 
@@ -40,18 +40,18 @@ namespace NLWTrace {
             return TraceIdx;
         }
 
-        ui64 GetSpanId() const { 
-            return SpanId; 
-        } 
- 
-        ui64 GetParentSpanId() const { 
-            return ParentSpanId; 
-        } 
- 
-        void SetParentSpanId(ui64 parentSpanId) { 
-            ParentSpanId = parentSpanId; 
-        } 
- 
+        ui64 GetSpanId() const {
+            return SpanId;
+        }
+
+        ui64 GetParentSpanId() const {
+            return ParentSpanId;
+        }
+
+        void SetParentSpanId(ui64 parentSpanId) {
+            ParentSpanId = parentSpanId;
+        }
+
         template <class F, class R>
         R UnlessDead(F func, R dead) {
             while (true) {
@@ -113,12 +113,12 @@ namespace NLWTrace {
             UnlessDead([&] {
                 DoDrop();
             });
-            return Detach(); // Detached from orbit on Drop 
-        } 
- 
-        TShuttlePtr Detach() { 
+            return Detach(); // Detached from orbit on Drop
+        }
+
+        TShuttlePtr Detach() {
             TShuttlePtr result;
-            result.Swap(Next); 
+            result.Swap(Next);
             return result;
         }
 
@@ -148,25 +148,25 @@ namespace NLWTrace {
             return UnlessDead([&] {
                 return DoFork(child);
             }, true);
-        } 
- 
-        bool Join(TShuttlePtr& child) { 
+        }
+
+        bool Join(TShuttlePtr& child) {
             return UnlessDead([&] {
                 return DoJoin(child);
             }, false);
-        } 
- 
-        bool IsDead() { 
-            return AtomicGet(Status) & DeadFlag; 
-        } 
- 
+        }
+
+        bool IsDead() {
+            return AtomicGet(Status) & DeadFlag;
+        }
+
     protected:
         virtual bool DoAddProbe(TProbe* probe, const TParams& params, ui64 timestamp) = 0;
         virtual void DoEndOfTrack() = 0;
         virtual void DoDrop() = 0;
         virtual void DoSerialize(TShuttleTrace& msg) = 0;
         virtual bool DoFork(TShuttlePtr& child) = 0;
-        virtual bool DoJoin(const TShuttlePtr& child) = 0; 
+        virtual bool DoJoin(const TShuttlePtr& child) = 0;
     };
 
     // Not thread-safe orbit
@@ -274,8 +274,8 @@ namespace NLWTrace {
                 return false;
             });
         }
- 
-        bool Fork(TOrbit& child) { 
+
+        bool Fork(TOrbit& child) {
             return NotConcurrent([&] (TShuttlePtr& head) {
                 return child.NotConcurrent([&] (TShuttlePtr& cHead) {
                     bool result = true;
@@ -291,9 +291,9 @@ namespace NLWTrace {
                     return result;
                 });
             });
-        } 
- 
-        void Join(TOrbit& child) { 
+        }
+
+        void Join(TOrbit& child) {
             NotConcurrent([&] (TShuttlePtr& head) {
                 child.NotConcurrent([&] (TShuttlePtr& cHead) {
                     TShuttlePtr* ref = &head;
@@ -307,21 +307,21 @@ namespace NLWTrace {
                     }
                 });
             });
-        } 
- 
+        }
+
     private:
         static void Join(TShuttlePtr& head, IShuttle* parent) {
             TShuttlePtr* ref = &head;
-            while (IShuttle* child = ref->Get()) { 
-                if (parent->GetTraceIdx() == child->GetTraceIdx() && parent->GetSpanId() == child->GetParentSpanId()) { 
-                    TShuttlePtr next = child->Detach(); 
-                    parent->Join(*ref); 
-                    *ref = next; 
-                } else { 
-                    ref = &child->GetNext(); 
-                } 
-            } 
-        } 
+            while (IShuttle* child = ref->Get()) {
+                if (parent->GetTraceIdx() == child->GetTraceIdx() && parent->GetSpanId() == child->GetParentSpanId()) {
+                    TShuttlePtr next = child->Detach();
+                    parent->Join(*ref);
+                    *ref = next;
+                } else {
+                    ref = &child->GetNext();
+                }
+            }
+        }
 
         template <class TFunc>
         typename std::invoke_result<TFunc, TShuttlePtr&>::type NotConcurrent(TFunc func) {
diff --git a/library/cpp/lwtrace/trace.cpp b/library/cpp/lwtrace/trace.cpp
index defcbfa434..3c974c85a0 100644
--- a/library/cpp/lwtrace/trace.cpp
+++ b/library/cpp/lwtrace/trace.cpp
@@ -631,9 +631,9 @@ namespace NLWTrace {
                 }
             } else if (action.HasRunLogShuttleAction()) {
                 if (Query.GetLogDurationUs()) {
-                    actExec.Reset(new TRunLogShuttleActionExecutor<TDurationDepot>(TraceIdx, action.GetRunLogShuttleAction(), &DurationDepot, &LastTrackId, &LastSpanId)); 
+                    actExec.Reset(new TRunLogShuttleActionExecutor<TDurationDepot>(TraceIdx, action.GetRunLogShuttleAction(), &DurationDepot, &LastTrackId, &LastSpanId));
                 } else {
-                    actExec.Reset(new TRunLogShuttleActionExecutor<TCyclicDepot>(TraceIdx, action.GetRunLogShuttleAction(), &CyclicDepot, &LastTrackId, &LastSpanId)); 
+                    actExec.Reset(new TRunLogShuttleActionExecutor<TCyclicDepot>(TraceIdx, action.GetRunLogShuttleAction(), &CyclicDepot, &LastTrackId, &LastSpanId));
                 }
             } else if (action.HasEditLogShuttleAction()) {
                 if (Query.GetLogDurationUs()) {
@@ -863,7 +863,7 @@ namespace NLWTrace {
         , CyclicDepot(query.GetPerThreadLogSize() ? query.GetPerThreadLogSize() : 1000)
         , DurationDepot(StoreDuration)
         , LastTrackId(0)
-        , LastSpanId(0) 
+        , LastSpanId(0)
         , Attached(true)
         , Query(query)
     {
@@ -993,7 +993,7 @@ namespace NLWTrace {
     TManager::TManager(TProbeRegistry& registry, bool allowDestructiveActions)
         : Registry(registry)
         , DestructiveActionsAllowed(allowDestructiveActions)
-        , SerializingExecutor(new TRunLogShuttleActionExecutor<TCyclicDepot>(0, {}, nullptr, nullptr, nullptr)) 
+        , SerializingExecutor(new TRunLogShuttleActionExecutor<TCyclicDepot>(0, {}, nullptr, nullptr, nullptr))
     {
     }
 
diff --git a/library/cpp/lwtrace/trace_ut.cpp b/library/cpp/lwtrace/trace_ut.cpp
index 412b7107ae..cb03e4fbde 100644
--- a/library/cpp/lwtrace/trace_ut.cpp
+++ b/library/cpp/lwtrace/trace_ut.cpp
@@ -739,142 +739,142 @@ Y_UNIT_TEST_SUITE(LWTraceTrace) {
             manager.HandleTraceResponse(resp, manager.GetProbesMap(), orbit1).IsSuccess,
             true);
     }
- 
-    Y_UNIT_TEST(TrackForkJoin) { 
-        TManager mngr(*Singleton<TProbeRegistry>(), true); 
-        TQuery q; 
-        bool parsed = NProtoBuf::TextFormat::ParseFromString(R"END( 
-            Blocks { 
-                ProbeDesc { 
-                    Name: "NoParam" 
-                    Provider: "LWTRACE_UT_PROVIDER" 
-                } 
-                Action { 
-                    RunLogShuttleAction { } 
-                } 
-            } 
+
+    Y_UNIT_TEST(TrackForkJoin) {
+        TManager mngr(*Singleton<TProbeRegistry>(), true);
+        TQuery q;
+        bool parsed = NProtoBuf::TextFormat::ParseFromString(R"END(
+            Blocks {
+                ProbeDesc {
+                    Name: "NoParam"
+                    Provider: "LWTRACE_UT_PROVIDER"
+                }
+                Action {
+                    RunLogShuttleAction { }
+                }
+            }
         )END", &q);
- 
-        UNIT_ASSERT(parsed); 
-        mngr.New("Query1", q); 
- 
-        { 
-            TOrbit a, b, c, d; 
- 
-            // Graph: 
-            //         c 
-            //        / \ 
-            //     b-f-b-j-b 
-            //    /         \ 
-            // a-f-a-f-a-j-a-j-a 
-            //        \ / 
-            //         d 
-            // 
-            // Merged track: 
-            //   a-f(b)-a-f(d)-a-j(d,1)-d-a-j(b,6)-b-f(c)-b-j(c,1)-c-b-a 
- 
-            LWTRACK(NoParam, a); 
-            a.Fork(b); 
-            LWTRACK(IntParam, a, 1); 
-            a.Fork(d); 
-            LWTRACK(IntParam, a, 2); 
- 
-            LWTRACK(IntParam, b, 3); 
-            b.Fork(c); 
-            LWTRACK(IntParam, b, 4); 
- 
-            LWTRACK(IntParam, c, 5); 
-            b.Join(c); 
-            LWTRACK(IntParam, b, 6); 
- 
-            LWTRACK(IntParam, d, 7); 
-            a.Join(d); 
-            LWTRACK(IntParam, a, 8); 
- 
-            a.Join(b); 
-            LWTRACK(IntParam, a, 9); 
-        } 
- 
-        struct { 
-            void Push(TThread::TId, const TTrackLog& tl) { 
-                UNIT_ASSERT(tl.Items.size() == 16); 
-                UNIT_ASSERT(TString(tl.Items[0].Probe->Event.Name) == "NoParam"); 
-                UNIT_ASSERT(TString(tl.Items[1].Probe->Event.Name) == "Fork"); 
-                UNIT_ASSERT(tl.Items[2].Params.Param[0].Get<ui64>() == 1); 
-                UNIT_ASSERT(TString(tl.Items[3].Probe->Event.Name) == "Fork"); 
-                UNIT_ASSERT(tl.Items[4].Params.Param[0].Get<ui64>() == 2); 
-                UNIT_ASSERT(TString(tl.Items[5].Probe->Event.Name) == "Join"); 
-                UNIT_ASSERT(tl.Items[6].Params.Param[0].Get<ui64>() == 7); 
-                UNIT_ASSERT(tl.Items[7].Params.Param[0].Get<ui64>() == 8); 
-                UNIT_ASSERT(TString(tl.Items[8].Probe->Event.Name) == "Join"); 
-                UNIT_ASSERT(tl.Items[9].Params.Param[0].Get<ui64>() == 3); 
-                UNIT_ASSERT(TString(tl.Items[10].Probe->Event.Name) == "Fork"); 
-                UNIT_ASSERT(tl.Items[11].Params.Param[0].Get<ui64>() == 4); 
-                UNIT_ASSERT(TString(tl.Items[12].Probe->Event.Name) == "Join"); 
-                UNIT_ASSERT(tl.Items[13].Params.Param[0].Get<ui64>() == 5); 
-                UNIT_ASSERT(tl.Items[14].Params.Param[0].Get<ui64>() == 6); 
-                UNIT_ASSERT(tl.Items[15].Params.Param[0].Get<ui64>() == 9); 
-            } 
-        } reader; 
-        mngr.ReadDepot("Query1", reader); 
-    } 
- 
-    Y_UNIT_TEST(TrackForkError) { 
-        TManager mngr(*Singleton<TProbeRegistry>(), true); 
-        TQuery q; 
-        bool parsed = NProtoBuf::TextFormat::ParseFromString(R"END( 
-            Blocks { 
-                ProbeDesc { 
-                    Name: "NoParam" 
-                    Provider: "LWTRACE_UT_PROVIDER" 
-                } 
-                Action { 
-                    RunLogShuttleAction { 
-                        MaxTrackLength: 100 
-                    } 
-                } 
-            } 
+
+        UNIT_ASSERT(parsed);
+        mngr.New("Query1", q);
+
+        {
+            TOrbit a, b, c, d;
+
+            // Graph:
+            //         c
+            //        / \
+            //     b-f-b-j-b
+            //    /         \
+            // a-f-a-f-a-j-a-j-a
+            //        \ /
+            //         d
+            //
+            // Merged track:
+            //   a-f(b)-a-f(d)-a-j(d,1)-d-a-j(b,6)-b-f(c)-b-j(c,1)-c-b-a
+
+            LWTRACK(NoParam, a);
+            a.Fork(b);
+            LWTRACK(IntParam, a, 1);
+            a.Fork(d);
+            LWTRACK(IntParam, a, 2);
+
+            LWTRACK(IntParam, b, 3);
+            b.Fork(c);
+            LWTRACK(IntParam, b, 4);
+
+            LWTRACK(IntParam, c, 5);
+            b.Join(c);
+            LWTRACK(IntParam, b, 6);
+
+            LWTRACK(IntParam, d, 7);
+            a.Join(d);
+            LWTRACK(IntParam, a, 8);
+
+            a.Join(b);
+            LWTRACK(IntParam, a, 9);
+        }
+
+        struct {
+            void Push(TThread::TId, const TTrackLog& tl) {
+                UNIT_ASSERT(tl.Items.size() == 16);
+                UNIT_ASSERT(TString(tl.Items[0].Probe->Event.Name) == "NoParam");
+                UNIT_ASSERT(TString(tl.Items[1].Probe->Event.Name) == "Fork");
+                UNIT_ASSERT(tl.Items[2].Params.Param[0].Get<ui64>() == 1);
+                UNIT_ASSERT(TString(tl.Items[3].Probe->Event.Name) == "Fork");
+                UNIT_ASSERT(tl.Items[4].Params.Param[0].Get<ui64>() == 2);
+                UNIT_ASSERT(TString(tl.Items[5].Probe->Event.Name) == "Join");
+                UNIT_ASSERT(tl.Items[6].Params.Param[0].Get<ui64>() == 7);
+                UNIT_ASSERT(tl.Items[7].Params.Param[0].Get<ui64>() == 8);
+                UNIT_ASSERT(TString(tl.Items[8].Probe->Event.Name) == "Join");
+                UNIT_ASSERT(tl.Items[9].Params.Param[0].Get<ui64>() == 3);
+                UNIT_ASSERT(TString(tl.Items[10].Probe->Event.Name) == "Fork");
+                UNIT_ASSERT(tl.Items[11].Params.Param[0].Get<ui64>() == 4);
+                UNIT_ASSERT(TString(tl.Items[12].Probe->Event.Name) == "Join");
+                UNIT_ASSERT(tl.Items[13].Params.Param[0].Get<ui64>() == 5);
+                UNIT_ASSERT(tl.Items[14].Params.Param[0].Get<ui64>() == 6);
+                UNIT_ASSERT(tl.Items[15].Params.Param[0].Get<ui64>() == 9);
+            }
+        } reader;
+        mngr.ReadDepot("Query1", reader);
+    }
+
+    Y_UNIT_TEST(TrackForkError) {
+        TManager mngr(*Singleton<TProbeRegistry>(), true);
+        TQuery q;
+        bool parsed = NProtoBuf::TextFormat::ParseFromString(R"END(
+            Blocks {
+                ProbeDesc {
+                    Name: "NoParam"
+                    Provider: "LWTRACE_UT_PROVIDER"
+                }
+                Action {
+                    RunLogShuttleAction {
+                        MaxTrackLength: 100
+                    }
+                }
+            }
         )END", &q);
- 
-        UNIT_ASSERT(parsed); 
-        mngr.New("Query1", q); 
- 
-        constexpr size_t n = (100 + 2) / 3 + 1; 
- 
-        { 
-            TVector<TVector<TOrbit>> span; 
- 
-            while (1) { 
-                TVector<TOrbit> orbit(n); 
- 
-                LWTRACK(NoParam, orbit[0]); 
-                if (!orbit[0].HasShuttles()) { 
-                    break; 
-                } 
-                for (size_t i = 1; i < n; i++) { 
-                    if (!orbit[i - 1].Fork(orbit[i])) { 
-                        break; 
-                    } 
-                    LWTRACK(IntParam, orbit[i], i); 
-                } 
- 
-                span.emplace_back(std::move(orbit)); 
-            } 
- 
-            for (auto& orbit: span) { 
-                for (auto it = orbit.rbegin(); it + 1 != orbit.rend(); it++) { 
-                    (it + 1)->Join(*it); 
-                } 
-            } 
-        } 
- 
-        struct { 
-            void Push(TThread::TId, const TTrackLog& tl) { 
-                UNIT_ASSERT(tl.Items.size() == 100); 
-                UNIT_ASSERT(tl.Truncated); 
-            } 
-        } reader; 
-        mngr.ReadDepot("Query1", reader); 
-    } 
+
+        UNIT_ASSERT(parsed);
+        mngr.New("Query1", q);
+
+        constexpr size_t n = (100 + 2) / 3 + 1;
+
+        {
+            TVector<TVector<TOrbit>> span;
+
+            while (1) {
+                TVector<TOrbit> orbit(n);
+
+                LWTRACK(NoParam, orbit[0]);
+                if (!orbit[0].HasShuttles()) {
+                    break;
+                }
+                for (size_t i = 1; i < n; i++) {
+                    if (!orbit[i - 1].Fork(orbit[i])) {
+                        break;
+                    }
+                    LWTRACK(IntParam, orbit[i], i);
+                }
+
+                span.emplace_back(std::move(orbit));
+            }
+
+            for (auto& orbit: span) {
+                for (auto it = orbit.rbegin(); it + 1 != orbit.rend(); it++) {
+                    (it + 1)->Join(*it);
+                }
+            }
+        }
+
+        struct {
+            void Push(TThread::TId, const TTrackLog& tl) {
+                UNIT_ASSERT(tl.Items.size() == 100);
+                UNIT_ASSERT(tl.Truncated);
+            }
+        } reader;
+        mngr.ReadDepot("Query1", reader);
+    }
 #endif // LWTRACE_DISABLE
 }
diff --git a/library/cpp/lwtrace/ya.make b/library/cpp/lwtrace/ya.make
index b11e3f916d..d9accb3006 100644
--- a/library/cpp/lwtrace/ya.make
+++ b/library/cpp/lwtrace/ya.make
@@ -11,7 +11,7 @@ SRCS(
     control.cpp
     custom_action.cpp
     kill_action.cpp
-    log_shuttle.cpp 
+    log_shuttle.cpp
     perf.cpp
     probes.cpp
     shuttle.cpp