WIP separate phases. Passes but has a memory leak

src/metric.cpp

@@ -19,6 +19,7 @@
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
+#include <variant>
 #include <vector>
 
 #include <immintrin.h>
@@ -655,6 +656,505 @@ struct Metric {
     std::vector<std::vector<HistogramLabelData>> histogram_data;
   };
 
+  // Instruction types for the execute phase
+  struct CallCounterCallback {
+    const MetricCallback<Counter>
+        *callback_ptr; // Safe: callback lifetime guaranteed by family map
+  };
+
+  struct CallGaugeCallback {
+    const MetricCallback<Gauge>
+        *callback_ptr; // Safe: callback lifetime guaranteed by family map
+  };
+
+  struct AggregateCounter {
+    std::vector<Counter::State *> thread_states;
+    Counter::State *global_state;
+  };
+
+  struct AggregateGauge {
+    Gauge::State *instance_state;
+  };
+
+  struct AggregateHistogram {
+    std::vector<Histogram::State *> thread_states;
+    Histogram::State *global_state;
+    size_t bucket_count;
+    std::span<const double> buckets; // For bucket threshold formatting
+  };
+
+  // Use a simpler enum-based approach to avoid variant issues
+  enum class InstructionType {
+    CALL_COUNTER_CALLBACK,
+    CALL_GAUGE_CALLBACK,
+    AGGREGATE_COUNTER,
+    AGGREGATE_GAUGE,
+    AGGREGATE_HISTOGRAM
+  };
+
+  struct RenderInstruction {
+    InstructionType type;
+    union {
+      CallCounterCallback counter_callback;
+      CallGaugeCallback gauge_callback;
+      AggregateCounter aggregate_counter;
+      AggregateGauge aggregate_gauge;
+      AggregateHistogram aggregate_histogram;
+    };
+
+    // Constructors
+    RenderInstruction(CallCounterCallback cb)
+        : type(InstructionType::CALL_COUNTER_CALLBACK) {
+      new (&counter_callback) CallCounterCallback(cb);
+    }
+    RenderInstruction(CallGaugeCallback cb)
+        : type(InstructionType::CALL_GAUGE_CALLBACK) {
+      new (&gauge_callback) CallGaugeCallback(cb);
+    }
+    RenderInstruction(AggregateCounter ac)
+        : type(InstructionType::AGGREGATE_COUNTER) {
+      new (&aggregate_counter) AggregateCounter(ac);
+    }
+    RenderInstruction(AggregateGauge ag)
+        : type(InstructionType::AGGREGATE_GAUGE) {
+      new (&aggregate_gauge) AggregateGauge(ag);
+    }
+    RenderInstruction(AggregateHistogram ah)
+        : type(InstructionType::AGGREGATE_HISTOGRAM) {
+      new (&aggregate_histogram) AggregateHistogram(ah);
+    }
+
+    // Destructor
+    ~RenderInstruction() {
+      switch (type) {
+      case InstructionType::CALL_COUNTER_CALLBACK:
+        counter_callback.~CallCounterCallback();
+        break;
+      case InstructionType::CALL_GAUGE_CALLBACK:
+        gauge_callback.~CallGaugeCallback();
+        break;
+      case InstructionType::AGGREGATE_COUNTER:
+        aggregate_counter.~AggregateCounter();
+        break;
+      case InstructionType::AGGREGATE_GAUGE:
+        aggregate_gauge.~AggregateGauge();
+        break;
+      case InstructionType::AGGREGATE_HISTOGRAM:
+        aggregate_histogram.~AggregateHistogram();
+        break;
+      }
+    }
+
+    // Copy constructor and assignment
+    RenderInstruction(const RenderInstruction &other) : type(other.type) {
+      switch (type) {
+      case InstructionType::CALL_COUNTER_CALLBACK:
+        new (&counter_callback) CallCounterCallback(other.counter_callback);
+        break;
+      case InstructionType::CALL_GAUGE_CALLBACK:
+        new (&gauge_callback) CallGaugeCallback(other.gauge_callback);
+        break;
+      case InstructionType::AGGREGATE_COUNTER:
+        new (&aggregate_counter) AggregateCounter(other.aggregate_counter);
+        break;
+      case InstructionType::AGGREGATE_GAUGE:
+        new (&aggregate_gauge) AggregateGauge(other.aggregate_gauge);
+        break;
+      case InstructionType::AGGREGATE_HISTOGRAM:
+        new (&aggregate_histogram)
+            AggregateHistogram(other.aggregate_histogram);
+        break;
+      }
+    }
+
+    RenderInstruction &operator=(const RenderInstruction &other) {
+      if (this != &other) {
+        // Destroy current object
+        this->~RenderInstruction();
+        // Reconstruct with new type and data
+        type = other.type;
+        switch (type) {
+        case InstructionType::CALL_COUNTER_CALLBACK:
+          new (&counter_callback) CallCounterCallback(other.counter_callback);
+          break;
+        case InstructionType::CALL_GAUGE_CALLBACK:
+          new (&gauge_callback) CallGaugeCallback(other.gauge_callback);
+          break;
+        case InstructionType::AGGREGATE_COUNTER:
+          new (&aggregate_counter) AggregateCounter(other.aggregate_counter);
+          break;
+        case InstructionType::AGGREGATE_GAUGE:
+          new (&aggregate_gauge) AggregateGauge(other.aggregate_gauge);
+          break;
+        case InstructionType::AGGREGATE_HISTOGRAM:
+          new (&aggregate_histogram)
+              AggregateHistogram(other.aggregate_histogram);
+          break;
+        }
+      }
+      return *this;
+    }
+  };
+
+  // Three-phase rendering system
+  struct RenderPlan {
+    ArenaVector<std::string_view> static_text;
+    ArenaVector<RenderInstruction> instructions;
+
+    RenderPlan(ArenaAllocator *arena)
+        : static_text(arena), instructions(arena) {}
+  };
+
+  // Phase 1: Compile phase - generate static text and instructions
+  static RenderPlan compile_render_plan(ArenaAllocator &arena,
+                                        const LabelSets &label_sets) {
+    RenderPlan plan(&arena);
+
+    // Helper function to append an additional label to existing Prometheus
+    // format
+    auto append_label_to_format =
+        [&](std::string_view base_format, std::string_view key,
+            std::string_view value) -> std::string_view {
+      // Calculate size for key="value" with escaping
+      size_t key_value_size = key.length() + 3 + value.length(); // key="value"
+      for (char c : value) {
+        if (c == '\\' || c == '"' || c == '\n') {
+          key_value_size++;
+        }
+      }
+
+      if (base_format.empty()) {
+        // Create new format: {key="value"}
+        size_t required_size = 2 + key_value_size; // {}
+        char *buf = arena.allocate<char>(required_size);
+        char *p = buf;
+        *p++ = '{';
+        std::memcpy(p, key.data(), key.length());
+        p += key.length();
+        *p++ = '=';
+        *p++ = '"';
+        for (char c : value) {
+          switch (c) {
+          case '\\':
+            *p++ = '\\';
+            *p++ = '\\';
+            break;
+          case '"':
+            *p++ = '\\';
+            *p++ = '"';
+            break;
+          case '\n':
+            *p++ = '\\';
+            *p++ = 'n';
+            break;
+          default:
+            *p++ = c;
+            break;
+          }
+        }
+        *p++ = '"';
+        *p++ = '}';
+        return std::string_view(buf, p - buf);
+      } else {
+        // Append to existing format: {existing,key="value"}
+        size_t required_size = base_format.length() + 1 +
+                               key_value_size; // comma + key="value", replace }
+        char *buf = arena.allocate<char>(required_size);
+        char *p = buf;
+        // Copy everything except the closing }
+        std::memcpy(p, base_format.data(), base_format.length() - 1);
+        p += base_format.length() - 1;
+        *p++ = ',';
+        std::memcpy(p, key.data(), key.length());
+        p += key.length();
+        *p++ = '=';
+        *p++ = '"';
+        for (char c : value) {
+          switch (c) {
+          case '\\':
+            *p++ = '\\';
+            *p++ = '\\';
+            break;
+          case '"':
+            *p++ = '\\';
+            *p++ = '"';
+            break;
+          case '\n':
+            *p++ = '\\';
+            *p++ = 'n';
+            break;
+          default:
+            *p++ = c;
+            break;
+          }
+        }
+        *p++ = '"';
+        *p++ = '}';
+        return std::string_view(buf, p - buf);
+      }
+    };
+
+    // Track if this is the first static text entry (no leading newline)
+    bool is_first_static = true;
+
+    // Generate counters
+    size_t counter_family_idx = 0;
+    for (const auto &[name, family] : get_counter_families()) {
+      // Add HELP line
+      auto help_line = format(
+          arena, "%s# HELP %.*s %.*s\n# TYPE %.*s counter",
+          is_first_static ? "" : "\n", static_cast<int>(name.length()),
+          name.data(), static_cast<int>(family->help.length()),
+          family->help.data(), static_cast<int>(name.length()), name.data());
+      is_first_static = false;
+
+      // Callback instructions and static text
+      for (const auto &[labels_key, callback] : family->callbacks) {
+        plan.instructions.push_back(CallCounterCallback{&callback});
+        plan.static_text.push_back(arena_copy_string(
+            format(arena, "%.*s\n%.*s%.*s ", static_cast<int>(help_line.size()),
+                   help_line.data(), static_cast<int>(name.length()),
+                   name.data(),
+                   static_cast<int>(labels_key.prometheus_format.length()),
+                   labels_key.prometheus_format.data()),
+            arena));
+        help_line = "";
+      }
+
+      // Instance instructions and static text
+      const auto &family_data = label_sets.counter_data[counter_family_idx++];
+      for (const auto &data : family_data) {
+        plan.instructions.push_back(
+            AggregateCounter{data.thread_states, data.global_state});
+        plan.static_text.push_back(arena_copy_string(
+            format(arena, "%.*s\n%.*s%.*s ", static_cast<int>(help_line.size()),
+                   help_line.data(), static_cast<int>(name.length()),
+                   name.data(),
+                   static_cast<int>(data.labels_key.prometheus_format.length()),
+                   data.labels_key.prometheus_format.data()),
+            arena));
+        help_line = "";
+      }
+    }
+
+    // Generate gauges
+    size_t gauge_family_idx = 0;
+    for (const auto &[name, family] : get_gauge_families()) {
+      // Add HELP line
+      auto help_line = format(
+          arena, "%s# HELP %.*s %.*s\n# TYPE %.*s gauge",
+          is_first_static ? "" : "\n", static_cast<int>(name.length()),
+          name.data(), static_cast<int>(family->help.length()),
+          family->help.data(), static_cast<int>(name.length()), name.data());
+      is_first_static = false;
+
+      // Callback instructions and static text
+      for (const auto &[labels_key, callback] : family->callbacks) {
+        plan.instructions.push_back(CallCounterCallback{&callback});
+        plan.static_text.push_back(arena_copy_string(
+            format(arena, "%.*s\n%.*s%.*s ", static_cast<int>(help_line.size()),
+                   help_line.data(), static_cast<int>(name.length()),
+                   name.data(),
+                   static_cast<int>(labels_key.prometheus_format.length()),
+                   labels_key.prometheus_format.data()),
+            arena));
+        help_line = "";
+      }
+
+      // Instance instructions and static text
+      const auto &family_data = label_sets.gauge_data[gauge_family_idx++];
+      for (const auto &data : family_data) {
+        plan.instructions.push_back(AggregateGauge{data.instance_state});
+        plan.static_text.push_back(arena_copy_string(
+            format(arena, "%.*s\n%.*s%.*s ", static_cast<int>(help_line.size()),
+                   help_line.data(), static_cast<int>(name.length()),
+                   name.data(),
+                   static_cast<int>(data.labels_key.prometheus_format.length()),
+                   data.labels_key.prometheus_format.data()),
+            arena));
+        help_line = "";
+      }
+    }
+
+    // Generate histograms
+    size_t histogram_family_idx = 0;
+    for (const auto &[name, family] : get_histogram_families()) {
+      auto help_line = format(
+          arena, "%s# HELP %.*s %.*s\n# TYPE %.*s histogram",
+          is_first_static ? "" : "\n", static_cast<int>(name.length()),
+          name.data(), static_cast<int>(family->help.length()),
+          family->help.data(), static_cast<int>(name.length()), name.data());
+
+      const auto &family_data =
+          label_sets.histogram_data[histogram_family_idx++];
+      for (const auto &data : family_data) {
+        plan.instructions.push_back(
+            AggregateHistogram{data.thread_states, data.global_state,
+                               data.bucket_count, family->buckets});
+
+        // Static text for explicit buckets
+        for (size_t i = 0; i < data.bucket_count; ++i) {
+          auto bucket_value = static_format(arena, family->buckets[i]);
+          auto labels = append_label_to_format(
+              data.labels_key.prometheus_format, "le", bucket_value);
+          plan.static_text.push_back(arena_copy_string(
+              format(arena, "%.*s\n%.*s_bucket%.*s ",
+                     static_cast<int>(help_line.size()), help_line.data(),
+                     static_cast<int>(name.length()), name.data(),
+                     static_cast<int>(labels.length()), labels.data()),
+              arena));
+          help_line = "";
+        }
+
+        // Static text for +Inf bucket
+        auto inf_labels = append_label_to_format(
+            data.labels_key.prometheus_format, "le", "+Inf");
+        plan.static_text.push_back(arena_copy_string(
+            format(arena, "\n%.*s_bucket%.*s ", static_cast<int>(name.length()),
+                   name.data(), static_cast<int>(inf_labels.length()),
+                   inf_labels.data()),
+            arena));
+
+        // Static text for sum
+        plan.static_text.push_back(arena_copy_string(
+            format(arena, "\n%.*s_sum%.*s ", static_cast<int>(name.length()),
+                   name.data(),
+                   static_cast<int>(data.labels_key.prometheus_format.length()),
+                   data.labels_key.prometheus_format.data()),
+            arena));
+
+        // Static text for count
+        plan.static_text.push_back(arena_copy_string(
+            format(arena, "\n%.*s_count%.*s ", static_cast<int>(name.length()),
+                   name.data(),
+                   static_cast<int>(data.labels_key.prometheus_format.length()),
+                   data.labels_key.prometheus_format.data()),
+            arena));
+      }
+    }
+
+    return plan;
+  }
+
+  // Phase 2: Execute phase - run instructions and generate dynamic text
+  static ArenaVector<std::string_view>
+  execute_render_plan(ArenaAllocator &arena,
+                      const ArenaVector<RenderInstruction> &instructions) {
+    ArenaVector<std::string_view> dynamic_text(&arena);
+
+    for (const auto &instruction : instructions) {
+      switch (instruction.type) {
+      case InstructionType::CALL_COUNTER_CALLBACK: {
+        double value = (*instruction.counter_callback.callback_ptr)();
+        dynamic_text.push_back(static_format(arena, value));
+        break;
+      }
+      case InstructionType::CALL_GAUGE_CALLBACK: {
+        double value = (*instruction.gauge_callback.callback_ptr)();
+        dynamic_text.push_back(static_format(arena, value));
+        break;
+      }
+      case InstructionType::AGGREGATE_COUNTER: {
+        double total_value = 0.0;
+        // Sum thread-local values
+        for (auto *state_ptr : instruction.aggregate_counter.thread_states) {
+          double value;
+          __atomic_load(&state_ptr->value, &value, __ATOMIC_RELAXED);
+          total_value += value;
+        }
+        // Add global accumulated value
+        if (instruction.aggregate_counter.global_state) {
+          total_value += instruction.aggregate_counter.global_state->value;
+        }
+        dynamic_text.push_back(static_format(arena, total_value));
+        break;
+      }
+      case InstructionType::AGGREGATE_GAUGE: {
+        double value = std::bit_cast<double>(
+            instruction.aggregate_gauge.instance_state->value.load(
+                std::memory_order_relaxed));
+        dynamic_text.push_back(static_format(arena, value));
+        break;
+      }
+      case InstructionType::AGGREGATE_HISTOGRAM: {
+        // Aggregate histogram data
+        size_t bucket_count = instruction.aggregate_histogram.bucket_count;
+        uint64_t *total_counts_data = arena.allocate<uint64_t>(bucket_count);
+        std::memset(total_counts_data, 0, bucket_count * sizeof(uint64_t));
+        std::span<uint64_t> total_counts(total_counts_data, bucket_count);
+        double total_sum = 0.0;
+        uint64_t total_observations = 0;
+
+        // Sum thread-local values
+        for (auto *instance : instruction.aggregate_histogram.thread_states) {
+          uint64_t *counts_snapshot = arena.allocate<uint64_t>(bucket_count);
+          double sum_snapshot;
+          uint64_t observations_snapshot;
+
+          {
+            std::lock_guard<std::mutex> lock(instance->mutex);
+            for (size_t i = 0; i < instance->counts.size(); ++i) {
+              counts_snapshot[i] = instance->counts[i];
+            }
+            sum_snapshot = instance->sum;
+            observations_snapshot = instance->observations;
+          }
+
+          for (size_t i = 0; i < bucket_count; ++i) {
+            total_counts[i] += counts_snapshot[i];
+          }
+          total_sum += sum_snapshot;
+          total_observations += observations_snapshot;
+        }
+
+        // Add global accumulated values
+        if (instruction.aggregate_histogram.global_state) {
+          auto *global_state = instruction.aggregate_histogram.global_state;
+          for (size_t i = 0; i < global_state->counts.size(); ++i) {
+            total_counts[i] += global_state->counts[i];
+          }
+          total_sum += global_state->sum;
+          total_observations += global_state->observations;
+        }
+
+        // Format explicit bucket counts
+        for (size_t i = 0; i < total_counts.size(); ++i) {
+          dynamic_text.push_back(static_format(arena, total_counts[i]));
+        }
+        // Format +Inf bucket (total observations)
+        dynamic_text.push_back(static_format(arena, total_observations));
+        // Format sum
+        dynamic_text.push_back(static_format(arena, total_sum));
+        // Format count
+        dynamic_text.push_back(static_format(arena, total_observations));
+        break;
+      }
+      }
+    }
+
+    return dynamic_text;
+  }
+
+  // Phase 3: Present phase - interleave static and dynamic text
+  static ArenaVector<std::string_view>
+  present_render_output(ArenaAllocator &arena,
+                        const ArenaVector<std::string_view> &static_text,
+                        const ArenaVector<std::string_view> &dynamic_text) {
+    ArenaVector<std::string_view> output(&arena);
+
+    for (size_t i = 0; i < static_text.size(); ++i) {
+      // Copy static text into caller's arena
+      output.push_back(arena_copy_string(static_text[i], arena));
+
+      // Add corresponding dynamic text
+      output.push_back(dynamic_text[i]);
+    }
+    // Trailing newline
+    output.push_back("\n");
+
+    return output;
+  }
+
   // Build label sets once for reuse in both phases
   static LabelSets build_label_sets(ArenaAllocator &arena) {
     LabelSets label_sets;
@@ -1099,10 +1599,10 @@ union MetricValue {
   uint64_t as_uint64;
 };
 
-// Phase 1: Compute all metric values in deterministic order
+// Legacy function kept for reference - will be replaced
 static ArenaVector<MetricValue>
-compute_metric_values(ArenaAllocator &arena,
-                      const Metric::LabelSets &label_sets) {
+compute_metric_values_legacy(ArenaAllocator &arena,
+                             const Metric::LabelSets &label_sets) {
   ArenaVector<MetricValue> values(&arena);
 
   // Compute counter values - ITERATION ORDER MUST MATCH FORMAT PHASE
@@ -1221,8 +1721,33 @@ compute_metric_values(ArenaAllocator &arena,
   return values;
 }
 
-// Phase 2: Format metrics using pre-computed values
+// Forward declaration
+std::span<std::string_view> render_legacy(ArenaAllocator &arena);
+
+// New three-phase render implementation
 std::span<std::string_view> render(ArenaAllocator &arena) {
+  // Hold lock throughout all phases to prevent registry changes
+  std::unique_lock<std::mutex> _{Metric::mutex};
+
+  // Build label sets once for all phases
+  Metric::LabelSets label_sets = Metric::build_label_sets(arena);
+
+  // Phase 1: Compile - generate static text and instructions
+  Metric::RenderPlan plan = Metric::compile_render_plan(arena, label_sets);
+
+  // Phase 2: Execute - run instructions and generate dynamic text
+  ArenaVector<std::string_view> dynamic_text =
+      Metric::execute_render_plan(arena, plan.instructions);
+
+  // Phase 3: Present - interleave static and dynamic text
+  ArenaVector<std::string_view> output =
+      Metric::present_render_output(arena, plan.static_text, dynamic_text);
+
+  return output;
+}
+
+// Legacy render function - kept for reference during transition
+std::span<std::string_view> render_legacy(ArenaAllocator &arena) {
   // Hold lock throughout both phases to prevent registry changes
   std::unique_lock<std::mutex> _{Metric::mutex};
 
@@ -1231,7 +1756,7 @@ std::span<std::string_view> render(ArenaAllocator &arena) {
 
   // Phase 1: Compute all metric values
   ArenaVector<MetricValue> metric_values =
-      compute_metric_values(arena, label_sets);
+      compute_metric_values_legacy(arena, label_sets);
   const MetricValue *next_value = metric_values.data();
 
   ArenaVector<std::string_view> output(&arena);