profiler_stats.cpp

#include "profiler_stats.hpp"

#include <charconv>

namespace {

void
append_to_string(std::string& s, size_t value)
{
    char buf[128];
    auto [ptr, ec] = std::to_chars(std::begin(buf), std::end(buf), value);
    s.append(buf, ptr);
}

void
append_optional_bool(std::string& s, const char* key, const std::optional<bool>& value)
{
    if (!value.has_value()) {
        return;
    }
    s += '"';
    s += key;
    s += "\": ";
    s += *value ? "true" : "false";
    s += ',';
}

} // namespace

void
Datadog::ProfilerStats::increment_sampling_event_count(size_t k_sampling_event_count)
{
    sampling_event_count += k_sampling_event_count;
}

size_t
Datadog::ProfilerStats::get_sampling_event_count() const
{
    return sampling_event_count;
}

void
Datadog::ProfilerStats::increment_sample_count(size_t k_sample_count)
{
    sample_count += k_sample_count;
}

size_t
Datadog::ProfilerStats::get_sample_count() const
{
    return sample_count;
}

void
Datadog::ProfilerStats::reset_state()
{
    sample_count = 0;
    sampling_event_count = 0;
    sampling_interval_us = std::nullopt;
    string_table_count = std::nullopt;
    copy_memory_error_count = 0;
    heap_tracker_size = std::nullopt;
    heap_tracker_cap_drops = std::nullopt;
    asyncio_task_count = std::nullopt;
    greenlet_count = std::nullopt;
    sample_capture_cpu_time_us = 0;
    wall_sample_capture_cpu_time_us = 0;
    cpu_timer_drain_cpu_time_us = 0;
    // fast_copy_memory_* static fields are intentionally not reset (see setters).
}

void
Datadog::ProfilerStats::set_fast_copy_memory_enabled(bool enabled)
{
    fast_copy_memory_enabled = enabled;
}

std::optional<bool>
Datadog::ProfilerStats::get_fast_copy_memory_enabled() const
{
    return fast_copy_memory_enabled;
}

void
Datadog::ProfilerStats::set_fast_copy_memory_user_disabled(bool disabled)
{
    fast_copy_memory_user_disabled = disabled;
}

std::optional<bool>
Datadog::ProfilerStats::get_fast_copy_memory_user_disabled() const
{
    return fast_copy_memory_user_disabled;
}

void
Datadog::ProfilerStats::set_fast_copy_memory_capable(bool capable)
{
    fast_copy_memory_capable = capable;
}

std::optional<bool>
Datadog::ProfilerStats::get_fast_copy_memory_capable() const
{
    return fast_copy_memory_capable;
}

void
Datadog::ProfilerStats::set_fast_copy_memory_syscall_fallback(bool fallback)
{
    fast_copy_memory_syscall_fallback = fallback;
}

std::optional<bool>
Datadog::ProfilerStats::get_fast_copy_memory_syscall_fallback() const
{
    return fast_copy_memory_syscall_fallback;
}

void
Datadog::ProfilerStats::copy_fast_copy_metadata_from(const ProfilerStats& other)
{
    if (auto value = other.get_fast_copy_memory_user_disabled()) {
        set_fast_copy_memory_user_disabled(*value);
    }
    if (auto value = other.get_fast_copy_memory_capable()) {
        set_fast_copy_memory_capable(*value);
    }
    if (auto value = other.get_fast_copy_memory_syscall_fallback()) {
        set_fast_copy_memory_syscall_fallback(*value);
    }
    if (auto value = other.get_fast_copy_memory_enabled()) {
        set_fast_copy_memory_enabled(*value);
    }
}

void
Datadog::ProfilerStats::add_copy_memory_error_count(size_t count)
{
    copy_memory_error_count += count;
}

size_t
Datadog::ProfilerStats::get_copy_memory_error_count() const
{
    return copy_memory_error_count;
}

void
Datadog::ProfilerStats::set_sampling_interval_us(size_t interval_us)
{
    sampling_interval_us = interval_us;
}

std::optional<size_t>
Datadog::ProfilerStats::get_sampling_interval_us() const
{
    return sampling_interval_us;
}

void
Datadog::ProfilerStats::set_string_table_count(size_t count)
{
    string_table_count = count;
}

std::optional<size_t>
Datadog::ProfilerStats::get_string_table_count() const
{
    return string_table_count;
}

void
Datadog::ProfilerStats::set_heap_tracker_size(size_t count)
{
    heap_tracker_size = count;
}

std::optional<size_t>
Datadog::ProfilerStats::get_heap_tracker_size() const
{
    return heap_tracker_size;
}

void
Datadog::ProfilerStats::set_heap_tracker_cap_drops(size_t count)
{
    heap_tracker_cap_drops = count;
}

std::optional<size_t>
Datadog::ProfilerStats::get_heap_tracker_cap_drops() const
{
    return heap_tracker_cap_drops;
}

void
Datadog::ProfilerStats::set_asyncio_task_count(size_t count)
{
    // Track the peak (max) asyncio task count observed across sampling cycles
    // within a profile period
    if (!asyncio_task_count.has_value() || count > *asyncio_task_count) {
        asyncio_task_count = count;
    }
}

std::optional<size_t>
Datadog::ProfilerStats::get_asyncio_task_count() const
{
    return asyncio_task_count;
}

void
Datadog::ProfilerStats::set_greenlet_count(size_t count)
{
    greenlet_count = count;
}

std::optional<size_t>
Datadog::ProfilerStats::get_greenlet_count() const
{
    return greenlet_count;
}

void
Datadog::ProfilerStats::add_sample_capture_cpu_time_us(size_t cpu_time_us)
{
    sample_capture_cpu_time_us += cpu_time_us;
}

size_t
Datadog::ProfilerStats::get_sample_capture_cpu_time_us() const
{
    return sample_capture_cpu_time_us;
}

void
Datadog::ProfilerStats::add_wall_sample_capture_cpu_time_us(size_t cpu_time_us)
{
    wall_sample_capture_cpu_time_us += cpu_time_us;
}

void
Datadog::ProfilerStats::add_cpu_timer_drain_cpu_time_us(size_t cpu_time_us)
{
    cpu_timer_drain_cpu_time_us += cpu_time_us;
}

std::string
Datadog::ProfilerStats::get_internal_metadata_json()
{
    std::string internal_metadata_json;
    internal_metadata_json.reserve(128);

    internal_metadata_json += "{";

    auto maybe_sampling_interval = get_sampling_interval_us();
    if (maybe_sampling_interval) {
        internal_metadata_json += R"("sampling_interval_us": )";
        append_to_string(internal_metadata_json, *maybe_sampling_interval);
        internal_metadata_json += ",";
    }

    auto maybe_string_table_count = get_string_table_count();
    if (maybe_string_table_count) {
        internal_metadata_json += R"("string_table_count": )";
        append_to_string(internal_metadata_json, *maybe_string_table_count);
        internal_metadata_json += ",";
    }

    internal_metadata_json += R"("sample_count": )";
    append_to_string(internal_metadata_json, sample_count);
    internal_metadata_json += ",";

    internal_metadata_json += R"("sampling_event_count": )";
    append_to_string(internal_metadata_json, sampling_event_count);
    internal_metadata_json += ",";

    auto maybe_fast_copy_enabled = get_fast_copy_memory_enabled();
    if (maybe_fast_copy_enabled) {
        internal_metadata_json += R"("fast_copy_memory_enabled": )";
        internal_metadata_json += *maybe_fast_copy_enabled ? "true" : "false";
        internal_metadata_json += ",";
    }

    append_optional_bool(internal_metadata_json, "fast_copy_memory_user_disabled", fast_copy_memory_user_disabled);
    append_optional_bool(internal_metadata_json, "fast_copy_memory_capable", fast_copy_memory_capable);
    append_optional_bool(
      internal_metadata_json, "fast_copy_memory_syscall_fallback", fast_copy_memory_syscall_fallback);

    auto maybe_heap_tracker_count = get_heap_tracker_size();
    if (maybe_heap_tracker_count) {
        internal_metadata_json += R"("heap_tracker_count": )";
        append_to_string(internal_metadata_json, *maybe_heap_tracker_count);
        internal_metadata_json += ",";
    }

    auto maybe_heap_cap_drops = get_heap_tracker_cap_drops();
    if (maybe_heap_cap_drops) {
        internal_metadata_json += R"("heap_tracker_cap_drops": )";
        append_to_string(internal_metadata_json, *maybe_heap_cap_drops);
        internal_metadata_json += ",";
    }

    auto maybe_asyncio_task_count = get_asyncio_task_count();
    if (maybe_asyncio_task_count) {
        internal_metadata_json += R"("asyncio_task_count": )";
        append_to_string(internal_metadata_json, *maybe_asyncio_task_count);
        internal_metadata_json += ",";
    }

    auto maybe_greenlet_count = get_greenlet_count();
    if (maybe_greenlet_count) {
        internal_metadata_json += R"("greenlet_count": )";
        append_to_string(internal_metadata_json, *maybe_greenlet_count);
        internal_metadata_json += ",";
    }

    internal_metadata_json += R"("copy_memory_error_count": )";
    append_to_string(internal_metadata_json, copy_memory_error_count);
    internal_metadata_json += ",";

    internal_metadata_json += R"("sample_capture_cpu_time_us": )";
    append_to_string(internal_metadata_json, sample_capture_cpu_time_us);
    internal_metadata_json += ",";

    internal_metadata_json += R"("wall_sample_capture_cpu_time_us": )";
    append_to_string(internal_metadata_json, wall_sample_capture_cpu_time_us);
    internal_metadata_json += ",";

    internal_metadata_json += R"("cpu_timer_drain_cpu_time_us": )";
    append_to_string(internal_metadata_json, cpu_timer_drain_cpu_time_us);

    internal_metadata_json += "}";

    return internal_metadata_json;
}