Tracing levels proposal implementation (#2415)

domwst · web-flow · commit 34372a661327 · 2024-03-05T13:19:09.000+01:00
diff --git a/ydb/core/keyvalue/keyvalue_intermediate.cpp b/ydb/core/keyvalue/keyvalue_intermediate.cpp
@@ -80,7 +80,7 @@ TIntermediate::TIntermediate(TActorId respondTo, TActorId keyValueActorId, ui64
     , CreatedAtGeneration(channelGeneration)
     , CreatedAtStep(channelStep)
     , IsReplied(false)
-    , Span(TWilsonTablet::Tablet, std::move(traceId), "KeyValue.Intermediate", NWilson::EFlags::AUTO_END)
+    , Span(TWilsonTablet::TabletTopLevel, std::move(traceId), "KeyValue.Intermediate", NWilson::EFlags::AUTO_END)
 {
     Stat.IntermediateCreatedAt = TAppData::TimeProvider->Now();
     Stat.RequestType = requestType;
@@ -106,7 +106,7 @@ void TIntermediate::UpdateStat() {
                 }
             }
         } else {
-        Stat.IndexRangeRead++;
+            Stat.IndexRangeRead++;
         }
     };
 
diff --git a/ydb/core/keyvalue/keyvalue_storage_read_request.cpp b/ydb/core/keyvalue/keyvalue_storage_read_request.cpp
@@ -511,7 +511,7 @@ class TKeyValueStorageReadRequest : public TActorBootstrapped<TKeyValueStorageRe
         : IntermediateResult(std::move(intermediate))
         , TabletInfo(const_cast<TTabletStorageInfo*>(tabletInfo))
         , TabletGeneration(tabletGeneration)
-        , Span(TWilsonTablet::Tablet, IntermediateResult->Span.GetTraceId(), "KeyValue.StorageReadRequest")
+        , Span(TWilsonTablet::TabletBasic, IntermediateResult->Span.GetTraceId(), "KeyValue.StorageReadRequest")
     {}
 };
 
diff --git a/ydb/core/keyvalue/keyvalue_storage_request.cpp b/ydb/core/keyvalue/keyvalue_storage_request.cpp
@@ -78,7 +78,7 @@ class TKeyValueStorageRequest : public TActorBootstrapped<TKeyValueStorageReques
         , TabletGeneration(tabletGeneration)
         , IntermediateResults(std::move(intermediate))
         , TabletInfo(const_cast<TTabletStorageInfo*>(tabletInfo))
-        , Span(TWilsonTablet::Tablet, IntermediateResults->Span.GetTraceId(), "KeyValue.StorageRequest")
+        , Span(TWilsonTablet::TabletBasic, IntermediateResults->Span.GetTraceId(), "KeyValue.StorageRequest")
     {
         IntermediateResults->Stat.KeyvalueStorageRequestSentAt = TAppData::TimeProvider->Now();
     }
diff --git a/ydb/core/tablet/tablet_req_writelog.cpp b/ydb/core/tablet/tablet_req_writelog.cpp
@@ -154,7 +154,7 @@ class TTabletReqWriteLog : public TActorBootstrapped<TTabletReqWriteLog> {
         , CommitTactic(commitTactic)
         , Info(info)
         , RepliesToWait(Max<ui32>())
-        , RequestSpan(TWilsonTablet::Tablet, std::move(traceId), "Tablet.WriteLog")
+        , RequestSpan(TWilsonTablet::TabletDetailed, std::move(traceId), "Tablet.WriteLog")
     {
         References.swap(refs);
         Y_ABORT_UNLESS(Info);
@@ -171,9 +171,9 @@ class TTabletReqWriteLog : public TActorBootstrapped<TTabletReqWriteLog> {
             NWilson::TTraceId innerTraceId;
 
             if (RequestSpan) {
-                auto res = BlobSpans.try_emplace(ref.Id, TWilsonTablet::Tablet, RequestSpan.GetTraceId(), "Tablet.WriteLog.Reference");
+                auto res = BlobSpans.try_emplace(ref.Id, TWilsonTablet::TabletFull, RequestSpan.GetTraceId(), "Tablet.WriteLog.Reference");
 
-                innerTraceId = std::move(res.first->second.GetTraceId());
+                innerTraceId = res.first->second.GetTraceId();
             }
 
             SendToBS(ref.Id, ref.Buffer, ctx, handleClass, ref.Tactic ? *ref.Tactic : CommitTactic, std::move(innerTraceId));
@@ -191,7 +191,7 @@ class TTabletReqWriteLog : public TActorBootstrapped<TTabletReqWriteLog> {
         NWilson::TTraceId traceId;
 
         if (RequestSpan) {
-            auto res = BlobSpans.try_emplace(actualLogEntryId, TWilsonTablet::Tablet, RequestSpan.GetTraceId(), "Tablet.WriteLog.LogEntry");
+            auto res = BlobSpans.try_emplace(actualLogEntryId, TWilsonTablet::TabletFull, RequestSpan.GetTraceId(), "Tablet.WriteLog.LogEntry");
 
             traceId = std::move(res.first->second.GetTraceId());
         }
diff --git a/ydb/core/tablet_flat/flat_exec_seat.h b/ydb/core/tablet_flat/flat_exec_seat.h
@@ -35,15 +35,15 @@ namespace NTabletFlatExecutor {
         void Terminate(ETerminationReason reason, const TActorContext& ctx) noexcept;
 
         void StartEnqueuedSpan() noexcept {
-            WaitingSpan = NWilson::TSpan(TWilsonTablet::Tablet, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Enqueued");
+            WaitingSpan = NWilson::TSpan(TWilsonTablet::TabletDetailed, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Enqueued");
         }
 
         void FinishEnqueuedSpan() noexcept {
             WaitingSpan.EndOk();
         }
 
         void CreatePendingSpan() noexcept {
-            WaitingSpan = NWilson::TSpan(TWilsonTablet::Tablet, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Pending");
+            WaitingSpan = NWilson::TSpan(TWilsonTablet::TabletDetailed, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Pending");
         }
 
         void FinishPendingSpan() noexcept {
diff --git a/ydb/core/tablet_flat/flat_executor.cpp b/ydb/core/tablet_flat/flat_executor.cpp
@@ -4234,7 +4234,7 @@ TString TExecutor::CheckBorrowConsistency() {
 
 TTransactionWaitPad::TTransactionWaitPad(THolder<TSeat> seat)
     : Seat(std::move(seat))
-    , WaitingSpan(NWilson::TSpan(TWilsonTablet::Tablet, Seat->GetTxTraceId(), "Tablet.Transaction.Wait"))
+    , WaitingSpan(NWilson::TSpan(TWilsonTablet::TabletDetailed, Seat->GetTxTraceId(), "Tablet.Transaction.Wait"))
 {}
 
 TTransactionWaitPad::~TTransactionWaitPad()
diff --git a/ydb/core/tablet_flat/tablet_flat_executor.h b/ydb/core/tablet_flat/tablet_flat_executor.h
@@ -229,7 +229,7 @@ class TTransactionContext : public TTxMemoryProviderBase {
     }
 
     void StartExecutionSpan() noexcept {
-        TransactionExecutionSpan = NWilson::TSpan(TWilsonTablet::Tablet, TransactionSpan.GetTraceId(), "Tablet.Transaction.Execute");
+        TransactionExecutionSpan = NWilson::TSpan(TWilsonTablet::TabletDetailed, TransactionSpan.GetTraceId(), "Tablet.Transaction.Execute");
     }
 
     void FinishExecutionSpan() noexcept {
@@ -289,7 +289,7 @@ class ITransaction : TNonCopyable {
     { }
 
     ITransaction(NWilson::TTraceId &&traceId)
-        : TxSpan(NWilson::TSpan(TWilsonTablet::Tablet, std::move(traceId), "Tablet.Transaction"))
+        : TxSpan(NWilson::TSpan(TWilsonTablet::TabletBasic, std::move(traceId), "Tablet.Transaction"))
     { }
 
     virtual ~ITransaction() = default;
@@ -314,7 +314,7 @@ class ITransaction : TNonCopyable {
     }
 
     void SetupTxSpan(NWilson::TTraceId traceId) noexcept {
-        TxSpan = NWilson::TSpan(TWilsonTablet::Tablet, std::move(traceId), "Tablet.Transaction");
+        TxSpan = NWilson::TSpan(TWilsonTablet::TabletBasic, std::move(traceId), "Tablet.Transaction");
         if (TxSpan) {
             TxSpan.Attribute("Type", TypeName(*this));
         }
diff --git a/ydb/core/tx/datashard/datashard.cpp b/ydb/core/tx/datashard/datashard.cpp
@@ -2905,8 +2905,10 @@ void TDataShard::ProposeTransaction(TEvDataShard::TEvProposeTransaction::TPtr &&
         UpdateProposeQueueSize();
     } else {
         // Prepare planned transactions as soon as possible
-        NWilson::TSpan datashardTransactionSpan(TWilsonTablet::Tablet, std::move(ev->TraceId), "Datashard.Transaction", NWilson::EFlags::AUTO_END);
-        datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+        NWilson::TSpan datashardTransactionSpan(TWilsonTablet::TabletTopLevel, std::move(ev->TraceId), "Datashard.Transaction", NWilson::EFlags::AUTO_END);
+        if (datashardTransactionSpan) {
+            datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+        }
 
         Execute(new TTxProposeTransactionBase(this, std::move(ev), TAppData::TimeProvider->Now(), NextTieBreakerIndex++, /* delayed */ false, std::move(datashardTransactionSpan)), ctx);
     }
@@ -2926,8 +2928,10 @@ void TDataShard::ProposeTransaction(NEvents::TDataEvents::TEvWrite::TPtr&& ev, c
         UpdateProposeQueueSize();
     } else {
         // Prepare planned transactions as soon as possible
-        NWilson::TSpan datashardTransactionSpan(TWilsonTablet::Tablet, std::move(ev->TraceId), "Datashard.WriteTransaction", NWilson::EFlags::AUTO_END);
-        datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+        NWilson::TSpan datashardTransactionSpan(TWilsonTablet::TabletTopLevel, std::move(ev->TraceId), "Datashard.WriteTransaction", NWilson::EFlags::AUTO_END);
+        if (datashardTransactionSpan) {
+            datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+        }
 
         Execute(new TTxWrite(this, std::move(ev), TAppData::TimeProvider->Now(), NextTieBreakerIndex++, /* delayed */ false, std::move(datashardTransactionSpan)), ctx);
     }
@@ -2994,16 +2998,20 @@ void TDataShard::Handle(TEvPrivate::TEvDelayedProposeTransaction::TPtr &ev, cons
             switch (item.Event->GetTypeRewrite()) {
                 case TEvDataShard::TEvProposeTransaction::EventType: {
                     auto event = IEventHandle::Downcast<TEvDataShard::TEvProposeTransaction>(std::move(item.Event));
-                    NWilson::TSpan datashardTransactionSpan(TWilsonTablet::Tablet, std::move(event->TraceId), "Datashard.Transaction", NWilson::EFlags::AUTO_END);
-                    datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+                    NWilson::TSpan datashardTransactionSpan(TWilsonTablet::TabletTopLevel, std::move(event->TraceId), "Datashard.Transaction", NWilson::EFlags::AUTO_END);
+                    if (datashardTransactionSpan) {
+                        datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+                    }
                     
                     Execute(new TTxProposeTransactionBase(this, std::move(event), item.ReceivedAt, item.TieBreakerIndex, /* delayed */ true, std::move(datashardTransactionSpan)), ctx);
                     return;
                 }
                 case NEvents::TDataEvents::TEvWrite::EventType: {
                     auto event = IEventHandle::Downcast<NEvents::TDataEvents::TEvWrite>(std::move(item.Event));
-                    NWilson::TSpan datashardTransactionSpan(TWilsonTablet::Tablet, std::move(event->TraceId), "Datashard.WriteTransaction", NWilson::EFlags::AUTO_END);
-                    datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+                    NWilson::TSpan datashardTransactionSpan(TWilsonTablet::TabletTopLevel, std::move(event->TraceId), "Datashard.WriteTransaction", NWilson::EFlags::AUTO_END);
+                    if (datashardTransactionSpan) {
+                        datashardTransactionSpan.Attribute("Shard", std::to_string(TabletID()));
+                    }
 
                     Execute(new TTxWrite(this, std::move(event), item.ReceivedAt, item.TieBreakerIndex, /* delayed */ true, std::move(datashardTransactionSpan)), ctx);
                     return;
diff --git a/ydb/core/tx/datashard/datashard__read_iterator.cpp b/ydb/core/tx/datashard/datashard__read_iterator.cpp
@@ -2545,7 +2545,7 @@ void TDataShard::Handle(TEvDataShard::TEvRead::TPtr& ev, const TActorContext& ct
     auto* request = ev->Get();
     
     if (!request->ReadSpan) {
-        request->ReadSpan = NWilson::TSpan(TWilsonTablet::Tablet, std::move(ev->TraceId), "Datashard.Read", NWilson::EFlags::AUTO_END);
+        request->ReadSpan = NWilson::TSpan(TWilsonTablet::TabletTopLevel, std::move(ev->TraceId), "Datashard.Read", NWilson::EFlags::AUTO_END);
         request->ReadSpan.Attribute("Shard", std::to_string(TabletID()));
     }
 
diff --git a/ydb/core/tx/datashard/datashard_pipeline.cpp b/ydb/core/tx/datashard/datashard_pipeline.cpp
@@ -1783,7 +1783,7 @@ EExecutionStatus TPipeline::RunExecutionPlan(TOperation::TPtr op,
             return EExecutionStatus::Reschedule;
         }
 
-        NWilson::TSpan unitSpan(TWilsonTablet::Tablet, txc.TransactionExecutionSpan.GetTraceId(), "Datashard.Unit");
+        NWilson::TSpan unitSpan(TWilsonTablet::TabletFull, txc.TransactionExecutionSpan.GetTraceId(), "Datashard.Unit");
         
         NCpuTime::TCpuTimer timer;
         auto status = unit.Execute(op, txc, ctx);
diff --git a/ydb/library/wilson_ids/wilson.h b/ydb/library/wilson_ids/wilson.h
@@ -1,62 +1,95 @@
 #pragma once
 
+#include <util/system/types.h>
+
 namespace NKikimr {
+    struct TComponentTracingLevels {
+#ifdef DEFINE_TRACING_LEVELS
+#error "Macro collision: DEFINE_TRACING_LEVELS"
+#endif
+
+#define DEFINE_TRACING_LEVELS(COMPONENT, MINIMAL, BASIC, DETAILED, FULL, DIAGNOSTIC, TRACE) \
+        struct COMPONENT { \
+            enum : ui8 { \
+                TopLevel = MINIMAL, \
+                Basic = BASIC, \
+                Detailed = DETAILED, \
+                Full = FULL, \
+                Diagnostic = DIAGNOSTIC, \
+                Trace = TRACE, \
+            }; \
+        };
+
+
+        DEFINE_TRACING_LEVELS(TGrpcProxy, 0, 5, 9, 13, 14, 15)
+        DEFINE_TRACING_LEVELS(TQueryProcessor, 1, 5, 9, 13, 14, 15)
+        DEFINE_TRACING_LEVELS(TDistributedTransactions, 2, 6, 10, 13, 14, 15)
+        DEFINE_TRACING_LEVELS(TTablet, 3, 7, 11, 13, 14, 15)
+        DEFINE_TRACING_LEVELS(TDistributedStorage, 4, 8, 12, 13, 14, 15)
+
+#undef DEFINE_TRACING_LEVELS
+    };
+
 
     struct TWilson {
         enum {
-            BlobStorage = 8, // DS proxy and lower levels
-            DsProxyInternals = 9,
-            VDiskTopLevel = 12,
-            VDiskInternals = 13,
-            PDisk = 14,
+            BlobStorage = TComponentTracingLevels::TDistributedStorage::TopLevel,
+            DsProxyInternals = TComponentTracingLevels::TDistributedStorage::Detailed,
+            VDiskTopLevel = TComponentTracingLevels::TDistributedStorage::Basic,
+            VDiskInternals = TComponentTracingLevels::TDistributedStorage::Detailed,
+            PDisk = TComponentTracingLevels::TDistributedStorage::Detailed,
+            PDiskInternals = TComponentTracingLevels::TDistributedStorage::Full,
         };
     };
 
     struct TWilsonKqp {
         enum {
-            KqpSession = 8,
-                CompileService = 9,
-                CompileActor = 9,
-                SessionAcquireSnapshot = 9,
+            KqpSession = TComponentTracingLevels::TQueryProcessor::TopLevel,
+                CompileService = TComponentTracingLevels::TQueryProcessor::Basic,
+                CompileActor = TComponentTracingLevels::TQueryProcessor::Basic,
+                SessionAcquireSnapshot = TComponentTracingLevels::TQueryProcessor::Basic,
 
-                    ExecuterTableResolve = 10,
-                    ExecuterShardsResolve = 10,
+                    ExecuterTableResolve = TComponentTracingLevels::TQueryProcessor::Detailed,
+                    ExecuterShardsResolve = TComponentTracingLevels::TQueryProcessor::Detailed,
 
-                LiteralExecuter = 9,
+                LiteralExecuter = TComponentTracingLevels::TQueryProcessor::Basic,
 
-                DataExecuter = 9,
-                    DataExecuterAcquireSnapshot = 10,
-                    DataExecuterRunTasks = 10,
+                DataExecuter = TComponentTracingLevels::TQueryProcessor::Basic,
+                    DataExecuterAcquireSnapshot = TComponentTracingLevels::TQueryProcessor::Detailed,
+                    DataExecuterRunTasks = TComponentTracingLevels::TQueryProcessor::Detailed,
 
-                ScanExecuter = 9,
-                    ScanExecuterRunTasks = 10,
+                ScanExecuter = TComponentTracingLevels::TQueryProcessor::Basic,
+                    ScanExecuterRunTasks = TComponentTracingLevels::TQueryProcessor::Detailed,
 
-                KqpNodeSendTasks = 9,
+                KqpNodeSendTasks = TComponentTracingLevels::TQueryProcessor::Basic,
 
-                ProposeTransaction = 9,
+                ProposeTransaction = TComponentTracingLevels::TQueryProcessor::Basic,
 
-                ComputeActor = 9,
+                ComputeActor = TComponentTracingLevels::TQueryProcessor::Basic,
 
-                ReadActor = 9,
-                    ReadActorShardsResolve = 10,
+                ReadActor = TComponentTracingLevels::TQueryProcessor::Basic,
+                    ReadActorShardsResolve = TComponentTracingLevels::TQueryProcessor::Detailed,
 
-                LookupActor = 9,
-                    LookupActorShardsResolve = 10,
+                LookupActor = TComponentTracingLevels::TQueryProcessor::Basic,
+                    LookupActorShardsResolve = TComponentTracingLevels::TQueryProcessor::Detailed,
                 
-                BulkUpsertActor = 9,
+            BulkUpsertActor = TComponentTracingLevels::TQueryProcessor::TopLevel,
         };
     };
 
     struct TWilsonTablet {
         enum {
-            Tablet = 15
+            TabletTopLevel = TComponentTracingLevels::TTablet::TopLevel,
+            TabletBasic = TComponentTracingLevels::TTablet::Basic,
+            TabletDetailed = TComponentTracingLevels::TTablet::Detailed,
+            TabletFull = TComponentTracingLevels::TTablet::Full,
         };
     };
 
     struct TWilsonGrpc {
         enum {
-            RequestProxy = 9,
-            RequestActor = 9,
+            RequestProxy = TComponentTracingLevels::TGrpcProxy::TopLevel,
+            RequestActor = TComponentTracingLevels::TGrpcProxy::TopLevel,
         };
     };
 

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ TIntermediate::TIntermediate(TActorId respondTo, TActorId keyValueActorId, ui64`
`80`	`80`	`, CreatedAtGeneration(channelGeneration)`
`81`	`81`	`, CreatedAtStep(channelStep)`
`82`	`82`	`, IsReplied(false)`
`83`		`- , Span(TWilsonTablet::Tablet, std::move(traceId), "KeyValue.Intermediate", NWilson::EFlags::AUTO_END)`
	`83`	`+ , Span(TWilsonTablet::TabletTopLevel, std::move(traceId), "KeyValue.Intermediate", NWilson::EFlags::AUTO_END)`
`84`	`84`	`{`
`85`	`85`	`Stat.IntermediateCreatedAt = TAppData::TimeProvider->Now();`
`86`	`86`	`Stat.RequestType = requestType;`
`@@ -106,7 +106,7 @@ void TIntermediate::UpdateStat() {`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`} else {`
`109`		`- Stat.IndexRangeRead++;`
	`109`	`+ Stat.IndexRangeRead++;`
`110`	`110`	`}`
`111`	`111`	`};`
`112`	`112`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ class TKeyValueStorageRequest : public TActorBootstrapped<TKeyValueStorageReques`
`78`	`78`	`, TabletGeneration(tabletGeneration)`
`79`	`79`	`, IntermediateResults(std::move(intermediate))`
`80`	`80`	`, TabletInfo(const_cast<TTabletStorageInfo*>(tabletInfo))`
`81`		`- , Span(TWilsonTablet::Tablet, IntermediateResults->Span.GetTraceId(), "KeyValue.StorageRequest")`
	`81`	`+ , Span(TWilsonTablet::TabletBasic, IntermediateResults->Span.GetTraceId(), "KeyValue.StorageRequest")`
`82`	`82`	`{`
`83`	`83`	`IntermediateResults->Stat.KeyvalueStorageRequestSentAt = TAppData::TimeProvider->Now();`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,15 +35,15 @@ namespace NTabletFlatExecutor {`
`35`	`35`	`void Terminate(ETerminationReason reason, const TActorContext& ctx) noexcept;`
`36`	`36`
`37`	`37`	`void StartEnqueuedSpan() noexcept {`
`38`		`- WaitingSpan = NWilson::TSpan(TWilsonTablet::Tablet, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Enqueued");`
	`38`	`+ WaitingSpan = NWilson::TSpan(TWilsonTablet::TabletDetailed, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Enqueued");`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`void FinishEnqueuedSpan() noexcept {`
`42`	`42`	`WaitingSpan.EndOk();`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`void CreatePendingSpan() noexcept {`
`46`		`- WaitingSpan = NWilson::TSpan(TWilsonTablet::Tablet, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Pending");`
	`46`	`+ WaitingSpan = NWilson::TSpan(TWilsonTablet::TabletDetailed, Self->TxSpan.GetTraceId(), "Tablet.Transaction.Pending");`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`void FinishPendingSpan() noexcept {`
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ class TTransactionContext : public TTxMemoryProviderBase {`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`void StartExecutionSpan() noexcept {`
`232`		`- TransactionExecutionSpan = NWilson::TSpan(TWilsonTablet::Tablet, TransactionSpan.GetTraceId(), "Tablet.Transaction.Execute");`
	`232`	`+ TransactionExecutionSpan = NWilson::TSpan(TWilsonTablet::TabletDetailed, TransactionSpan.GetTraceId(), "Tablet.Transaction.Execute");`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`void FinishExecutionSpan() noexcept {`
`@@ -289,7 +289,7 @@ class ITransaction : TNonCopyable {`
`289`	`289`	`{ }`
`290`	`290`
`291`	`291`	`ITransaction(NWilson::TTraceId &&traceId)`
`292`		`- : TxSpan(NWilson::TSpan(TWilsonTablet::Tablet, std::move(traceId), "Tablet.Transaction"))`
	`292`	`+ : TxSpan(NWilson::TSpan(TWilsonTablet::TabletBasic, std::move(traceId), "Tablet.Transaction"))`
`293`	`293`	`{ }`
`294`	`294`
`295`	`295`	`virtual ~ITransaction() = default;`
`@@ -314,7 +314,7 @@ class ITransaction : TNonCopyable {`
`314`	`314`	`}`
`315`	`315`
`316`	`316`	`void SetupTxSpan(NWilson::TTraceId traceId) noexcept {`
`317`		`- TxSpan = NWilson::TSpan(TWilsonTablet::Tablet, std::move(traceId), "Tablet.Transaction");`
	`317`	`+ TxSpan = NWilson::TSpan(TWilsonTablet::TabletBasic, std::move(traceId), "Tablet.Transaction");`
`318`	`318`	`if (TxSpan) {`
`319`	`319`	`TxSpan.Attribute("Type", TypeName(*this));`
`320`	`320`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2545,7 +2545,7 @@ void TDataShard::Handle(TEvDataShard::TEvRead::TPtr& ev, const TActorContext& ct`
`2545`	`2545`	`auto* request = ev->Get();`
`2546`	`2546`
`2547`	`2547`	`if (!request->ReadSpan) {`
`2548`		`- request->ReadSpan = NWilson::TSpan(TWilsonTablet::Tablet, std::move(ev->TraceId), "Datashard.Read", NWilson::EFlags::AUTO_END);`
	`2548`	`+ request->ReadSpan = NWilson::TSpan(TWilsonTablet::TabletTopLevel, std::move(ev->TraceId), "Datashard.Read", NWilson::EFlags::AUTO_END);`
`2549`	`2549`	`request->ReadSpan.Attribute("Shard", std::to_string(TabletID()));`
`2550`	`2550`	`}`
`2551`	`2551`
Original file line number	Diff line number	Diff line change
`@@ -1783,7 +1783,7 @@ EExecutionStatus TPipeline::RunExecutionPlan(TOperation::TPtr op,`
`1783`	`1783`	`return EExecutionStatus::Reschedule;`
`1784`	`1784`	`}`
`1785`	`1785`
`1786`		`- NWilson::TSpan unitSpan(TWilsonTablet::Tablet, txc.TransactionExecutionSpan.GetTraceId(), "Datashard.Unit");`
	`1786`	`+ NWilson::TSpan unitSpan(TWilsonTablet::TabletFull, txc.TransactionExecutionSpan.GetTraceId(), "Datashard.Unit");`
`1787`	`1787`
`1788`	`1788`	`NCpuTime::TCpuTimer timer;`
`1789`	`1789`	`auto status = unit.Execute(op, txc, ctx);`