refactor(profiling): split stack sampler helpers

Author: taegyunkim

ddtrace/internal/datadog/profiling/stack/src/echion/threads.cc

@@ -707,29 +707,19 @@ ThreadInfo::unwind_greenlets(EchionSampler& echion, PyThreadState* tstate, unsig
     }
 }
 
-// ----------------------------------------------------------------------------
-Result<void>
-ThreadInfo::sample(EchionSampler& echion, PyThreadState* tstate, microsecond_t delta)
+namespace {
+
+void
+render_unwound_stacks(EchionSampler& echion, ThreadInfo& thread)
 {
     auto& renderer = echion.renderer();
-    renderer.render_thread_begin(tstate, name, delta, thread_id, native_id);
-
-    microsecond_t previous_cpu_time = cpu_time;
-    auto update_cpu_time_success = update_cpu_time();
-    if (!update_cpu_time_success) {
-        return ErrorKind::CpuTimeError;
-    }
-
-    renderer.render_cpu_time(cpu_time - previous_cpu_time);
-
-    this->unwind(echion, tstate);
 
     // Render in this order of priority
     // 1. asyncio Tasks stacks (if any)
     // 2. Greenlets stacks (if any)
     // 3. The normal thread stack (if no asyncio tasks or greenlets)
-    if (!current_tasks.empty()) {
-        for (auto& task_stack_info : current_tasks) {
+    if (!thread.current_tasks.empty()) {
+        for (auto& task_stack_info : thread.current_tasks) {
             task_stack_info->task_name.visit_string(
               [&](std::string_view task_name) { renderer.render_task_begin(task_name, task_stack_info->on_cpu); });
 
@@ -738,9 +728,9 @@ ThreadInfo::sample(EchionSampler& echion, PyThreadState* tstate, microsecond_t d
             renderer.render_stack_end();
         }
 
-        current_tasks.clear();
-    } else if (!current_greenlets.empty()) {
-        for (auto& greenlet_stack : current_greenlets) {
+        thread.current_tasks.clear();
+    } else if (!thread.current_greenlets.empty()) {
+        for (auto& greenlet_stack : thread.current_greenlets) {
             greenlet_stack->task_name.visit_string(
               [&](std::string_view task_name) { renderer.render_task_begin(task_name, greenlet_stack->on_cpu); });
 
@@ -750,11 +740,32 @@ ThreadInfo::sample(EchionSampler& echion, PyThreadState* tstate, microsecond_t d
             renderer.render_stack_end();
         }
 
-        current_greenlets.clear();
+        thread.current_greenlets.clear();
     } else {
-        python_stack.render(echion);
+        thread.python_stack.render(echion);
         renderer.render_stack_end();
     }
+}
+
+} // namespace
+
+// ----------------------------------------------------------------------------
+Result<void>
+ThreadInfo::sample(EchionSampler& echion, PyThreadState* tstate, microsecond_t delta)
+{
+    auto& renderer = echion.renderer();
+    renderer.render_thread_begin(tstate, name, delta, thread_id, native_id);
+
+    microsecond_t previous_cpu_time = cpu_time;
+    auto update_cpu_time_success = update_cpu_time();
+    if (!update_cpu_time_success) {
+        return ErrorKind::CpuTimeError;
+    }
+
+    renderer.render_cpu_time(cpu_time - previous_cpu_time);
+
+    this->unwind(echion, tstate);
+    render_unwound_stacks(echion, *this);
 
     return Result<void>::ok();
 }

ddtrace/internal/datadog/profiling/stack/src/sampler.cpp

@@ -80,6 +80,17 @@ create_thread_with_stack(size_t stack_size, Sampler* sampler, uint64_t seq_num)
 
 namespace {
 
+void
+log_thread_registration_failure_once(uint64_t id, uint64_t native_id, const char* name)
+{
+    static bool has_errored = false;
+    if (!has_errored) {
+        has_errored = true;
+        std::cerr << "Failed to register thread: " << std::hex << id << std::dec << " (" << native_id << ") " << name
+                  << std::endl;
+    }
+}
+
 // Returns the CPU time of the calling thread in microseconds, or 0 on error.
 uint64_t
 get_thread_cpu_time_us()
@@ -600,29 +611,20 @@ Sampler::register_thread(uint64_t id, uint64_t native_id, const char* name)
     // Registering threads requires coordinating with one of echion's global locks, which we take here.
     const std::lock_guard<std::mutex> thread_info_guard{ echion->thread_info_map_lock() };
 
-    static bool has_errored = false;
     auto it = echion->thread_info_map().find(id);
     if (it == echion->thread_info_map().end()) {
         auto maybe_thread_info = ThreadInfo::create(id, native_id, name);
         if (maybe_thread_info) {
             echion->thread_info_map().emplace(id, std::move(*maybe_thread_info));
         } else {
-            if (!has_errored) {
-                has_errored = true;
-                std::cerr << "Failed to register thread: " << std::hex << id << std::dec << " (" << native_id << ") "
-                          << name << std::endl;
-            }
+            log_thread_registration_failure_once(id, native_id, name);
         }
     } else {
         auto maybe_thread_info = ThreadInfo::create(id, native_id, name);
         if (maybe_thread_info) {
             it->second = std::move(*maybe_thread_info);
         } else {
-            if (!has_errored) {
-                has_errored = true;
-                std::cerr << "Failed to register thread: " << std::hex << id << std::dec << " (" << native_id << ") "
-                          << name << std::endl;
-            }
+            log_thread_registration_failure_once(id, native_id, name);
         }
     }
 }