cloud/blockstore/libs/storage/model/log_title.cpp - main - githubmirror/nbs

cloud/blockstore/libs/storage/model/log_title.cpp
381 строка9 KB
Tojiboev Zavqiddin
add log titile in mirror partition resync actors (#6347)
06 июл 2026, 19:31
06 июл 2026, 19:31defea54
#include "log_title.h"

#include <cloud/storage/core/libs/common/format.h>

#include <util/datetime/cputimer.h>
#include <util/generic/overloaded.h>
#include <util/string/builder.h>
#include <util/system/datetime.h>

namespace NCloud::NBlockStore::NStorage {

namespace {

////////////////////////////////////////////////////////////////////////////////

template <typename T>
struct TOptional
{
    const T& Value;
};

template <typename T>
TOptional(const T&) -> TOptional<T>;

template <typename T>
TStringBuilder& operator<<(TStringBuilder& stream, TOptional<T> opt)
{
    if (!opt.Value) {
        if constexpr (std::is_same_v<TString, T>) {
            stream << "???";
        } else {
            stream << "?";
        }
    } else {
        stream << opt.Value;
    }

    return stream;
}

////////////////////////////////////////////////////////////////////////////////

template<typename T>
concept HasDiskId = requires(T t) {
    t.DiskId = TString();
};

template<typename T>
concept HasGeneration = requires(T t) {
    t.Generation = ui32();
};

template<typename T>
concept HasTabletId = requires(T t) {
    t.TabletId = ui64();
};

////////////////////////////////////////////////////////////////////////////////

TString GetPartitionPrefix(
    const TString& title,
    ui64 tabletId,
    ui32 partitionIndex,
    ui32 partitionCount)
{
    auto builder = TStringBuilder();

    builder << title;
    if (partitionCount > 1) {
        builder << partitionIndex;
    }
    builder << ":";
    builder << tabletId;

    return builder;
}

////////////////////////////////////////////////////////////////////////////////

TString ToString(const TLogTitle::TVolume& data)
{
    TStringBuilder stream;

    stream << "[v:" << data.TabletId;
    stream << " g:" << TOptional{data.Generation};
    stream << " d:" << TOptional{data.DiskId};

    return stream;
}

TString ToString(const TLogTitle::TPartition& data)
{
    TStringBuilder stream;

    stream << "[";
    stream << TLogTitle::GetPartitionPrefix(
        data.TabletId,
        data.PartitionIndex,
        data.PartitionCount);
    stream << " g:" << TOptional{data.Generation};
    stream << " d:" << TOptional{data.DiskId};

    return stream;
}

TString ToString(const TLogTitle::TSession& data)
{
    TStringBuilder stream;

    stream << "[";
    if (data.TemporaryServer) {
        stream << "~";
    }
    stream << "vs:" << TOptional{data.TabletId};
    stream << " d:" << data.DiskId;
    stream << " s:" << data.SessionId;

    return stream;
}

TString ToString(const TLogTitle::TClient& data)
{
    TStringBuilder stream;

    stream << "[";
    if (data.TemporaryServer) {
        stream << "~";
    }
    stream << "vc:" << data.TabletId;
    stream << " d:" << data.DiskId;
    stream << " s:" << data.SessionId;
    stream << " c:" << data.ClientId;
    stream << " pg:" << TOptional{data.Generation};

    return stream;
}

TString ToString(const TLogTitle::TVolumeProxy& data)
{
    TStringBuilder stream;

    stream << "[";
    if (data.TemporaryServer) {
        stream << "~";
    }
    stream << "vp:" << TOptional{data.TabletId};
    stream << " d:" << data.DiskId;
    stream << " pg:" << data.Generation;

    return stream;
}

TString ToString(const TLogTitle::TPartitionNonrepl& data)
{
    return TStringBuilder() << "[nrd:" << data.DiskId;
}

TString ToString(const TLogTitle::TPartitionNonreplRdma& data)
{
    return TStringBuilder() << "[nrd_rdma:" << data.DiskId;
}

TString ToString(const TLogTitle::TPartitionMirror& data)
{
    return TStringBuilder() << "[md:" << data.DiskId;
}

TString ToString(const TLogTitle::TPartitionMigration& data)
{
    return TStringBuilder() << "[mig:" << data.DiskId;
}

TString ToString(const TLogTitle::TMirrorPartitionResync& data)
{
    return TStringBuilder() << "[MirrorPartitionResync:" << data.DiskId;
}

TString ToString(const TLogTitle::TDiskRegistry& data)
{
    return TStringBuilder() << "[dr:" << data.TabletId;
}

TString ToString(const TLogTitle::TFreshBlocksWriter& data)
{
    TStringBuilder stream;

    stream << "[";
    stream << GetPartitionPrefix(
        "fbw",
        data.TabletId,
        data.PartitionIndex,
        data.PartitionCount);
    stream << " g:" << TOptional{data.Generation};
    stream << " d:" << TOptional{data.DiskId};

    return stream;
}

TString ToString(const TLogTitle::TAgentAvailabilityMonitoringActor& data)
{
    return TStringBuilder()
           << "[aam:" << data.DiskId << " agent:" << data.AgentId;
}

}   // namespace

////////////////////////////////////////////////////////////////////////////////

// static
TString TLogTitle::GetPartitionPrefix(
    ui64 tabletId,
    ui32 partitionIndex,
    ui32 partitionCount)
{
    return ::NCloud::NBlockStore::NStorage::GetPartitionPrefix(
        "p",
        tabletId,
        partitionIndex,
        partitionCount);
}

TChildLogTitle TLogTitle::GetChild(const ui64 startTime) const
{
    TStringBuilder childPrefix;
    childPrefix << CachedPrefix;
    const auto duration = CyclesToDurationSafe(startTime - StartTime);
    childPrefix << " t:" << FormatDuration(duration);

    return {childPrefix, startTime};
}

TChildLogTitle TLogTitle::GetChildWithTags(
    const ui64 startTime,
    TPrintableParams additionalTags) const
{
    TStringBuilder childPrefix;
    childPrefix << CachedPrefix;

    if (!additionalTags.empty()) {
        childPrefix << " " << PrintParams(additionalTags);
    }

    const auto duration = CyclesToDurationSafe(startTime - StartTime);
    childPrefix << " t:" << FormatDuration(duration);

    return {childPrefix, startTime};
}

TChildLogTitle TLogTitle::GetChildWithTags(
    const ui64 startTime,
    std::initializer_list<std::pair<TStringBuf, TPrintableValue>>
        additionalTags) const
{
    return GetChildWithTags(startTime, TPrintableParams(additionalTags));
}

TString TLogTitle::Get(EDetails details) const
{
    TStringBuilder result;
    result << CachedPrefix;

    switch (details) {
        case EDetails::Brief: {
            break;
        }
        case EDetails::WithTime: {
            const auto duration =
                CyclesToDurationSafe(GetCycleCount() - StartTime);
            result << " t:" << FormatDuration(duration);
            break;
        }
    }

    result << "]";
    return result;
}

TString TLogTitle::GetWithTime() const
{
    return Get(EDetails::WithTime);
}

TString TLogTitle::GetBrief() const
{
    return Get(EDetails::Brief);
}

void TLogTitle::SetDiskId(TString diskId)
{
    std::visit(
        [this, &diskId](auto& data)
        {
            if constexpr (HasDiskId<decltype(data)>) {
                data.DiskId = diskId;
            }
            CachedPrefix = ToString(data);
        },
        Data);
}

void TLogTitle::SetGeneration(ui32 generation)
{
    std::visit(
        [this, generation]<typename T>(T& data)
        {
            if constexpr (HasGeneration<decltype(data)>) {
                data.Generation = generation;
            }
            CachedPrefix = ToString(data);
        },
        Data);
}

void TLogTitle::SetTabletId(ui64 tabletId)
{
    std::visit(
        [this, tabletId]<typename T>(T& data)
        {
            if constexpr (HasTabletId<decltype(data)>) {
                data.TabletId = tabletId;
            }
            CachedPrefix = ToString(data);
        },
        Data);
}

void TLogTitle::Rebuild()
{
    std::visit([this](auto& data) { CachedPrefix = ToString(data); }, Data);
}

////////////////////////////////////////////////////////////////////////////////

TChildLogTitle::TChildLogTitle(TString cachedPrefix, ui64 startTime)
    : CachedPrefix(std::move(cachedPrefix))
    , StartTime(startTime)
{}

TChildLogTitle TChildLogTitle::GetChild(const ui64 startTime) const
{
    TStringBuilder childPrefix;
    childPrefix << CachedPrefix;
    const auto duration = CyclesToDurationSafe(startTime - StartTime);
    childPrefix << " + " << FormatDuration(duration);
    return {childPrefix, startTime};
}

TChildLogTitle TChildLogTitle::GetChildWithTags(
    const ui64 startTime,
    const TPrintableParams& additionalTags) const
{
    TStringBuilder childPrefix;
    childPrefix << CachedPrefix;

    if (!additionalTags.empty()) {
        childPrefix << " " << PrintParams(additionalTags);
    }

    const auto duration = CyclesToDurationSafe(startTime - StartTime);
    childPrefix << " + " << FormatDuration(duration);

    return {childPrefix, startTime};
}

TChildLogTitle TChildLogTitle::GetChildWithTags(
    const ui64 startTime,
    std::initializer_list<std::pair<TStringBuf, TPrintableValue>>
        additionalTags) const
{
    return GetChildWithTags(startTime, TPrintableParams(additionalTags));
}

TString TChildLogTitle::GetWithTime() const
{
    const auto duration = CyclesToDurationSafe(GetCycleCount() - StartTime);
    TStringBuilder builder;
    builder << CachedPrefix << " + " << FormatDuration(duration) << "]";
    return builder;
}

}   // namespace NCloud::NBlockStore::NStorage