feat: collect metrics + impact metrics flatbuffers + ygg ffi (#81)

daveleek · web-flow · commit bec1737d5415 · 2026-02-13T11:27:29.000+01:00
diff --git a/dotnet-engine/Yggdrasil.Engine/yggdrasil/messaging/CollectMetricsResponse.cs b/dotnet-engine/Yggdrasil.Engine/yggdrasil/messaging/CollectMetricsResponse.cs
@@ -0,0 +1,67 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace yggdrasil.messaging
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+public struct CollectMetricsResponse : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static CollectMetricsResponse GetRootAsCollectMetricsResponse(ByteBuffer _bb) { return GetRootAsCollectMetricsResponse(_bb, new CollectMetricsResponse()); }
+  public static CollectMetricsResponse GetRootAsCollectMetricsResponse(ByteBuffer _bb, CollectMetricsResponse obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CollectMetricsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public string Response { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetResponseBytes() { return __p.__vector_as_span<byte>(4, 1); }
+#else
+  public ArraySegment<byte>? GetResponseBytes() { return __p.__vector_as_arraysegment(4); }
+#endif
+  public byte[] GetResponseArray() { return __p.__vector_as_array<byte>(4); }
+  public string Error { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetErrorBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetErrorBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetErrorArray() { return __p.__vector_as_array<byte>(6); }
+
+  public static Offset<yggdrasil.messaging.CollectMetricsResponse> CreateCollectMetricsResponse(FlatBufferBuilder builder,
+      StringOffset responseOffset = default(StringOffset),
+      StringOffset errorOffset = default(StringOffset)) {
+    builder.StartTable(2);
+    CollectMetricsResponse.AddError(builder, errorOffset);
+    CollectMetricsResponse.AddResponse(builder, responseOffset);
+    return CollectMetricsResponse.EndCollectMetricsResponse(builder);
+  }
+
+  public static void StartCollectMetricsResponse(FlatBufferBuilder builder) { builder.StartTable(2); }
+  public static void AddResponse(FlatBufferBuilder builder, StringOffset responseOffset) { builder.AddOffset(0, responseOffset.Value, 0); }
+  public static void AddError(FlatBufferBuilder builder, StringOffset errorOffset) { builder.AddOffset(1, errorOffset.Value, 0); }
+  public static Offset<yggdrasil.messaging.CollectMetricsResponse> EndCollectMetricsResponse(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<yggdrasil.messaging.CollectMetricsResponse>(o);
+  }
+}
+
+
+static public class CollectMetricsResponseVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Response*/, false)
+      && verifier.VerifyString(tablePos, 6 /*Error*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/flat-buffer-defs/enabled-message.fbs b/flat-buffer-defs/enabled-message.fbs
@@ -198,6 +198,11 @@ table ObserveHistogram {
     labels: [SampleLabelEntry];
 }
 
+table CollectMetricsResponse {
+  response: string;
+  error: string;
+}
+
 root_type Response;
 root_type ContextMessage;
 root_type MetricsResponse;
diff --git a/yggdrasilffi/src/flat/enabled-message_generated.rs b/yggdrasilffi/src/flat/enabled-message_generated.rs
@@ -4532,6 +4532,120 @@ impl core::fmt::Debug for ObserveHistogram<'_> {
       ds.finish()
   }
 }
+pub enum CollectMetricsResponseOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct CollectMetricsResponse<'a> {
+  pub _tab: flatbuffers::Table<'a>,
+}
+
+impl<'a> flatbuffers::Follow<'a> for CollectMetricsResponse<'a> {
+  type Inner = CollectMetricsResponse<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: flatbuffers::Table::new(buf, loc) }
+  }
+}
+
+impl<'a> CollectMetricsResponse<'a> {
+  pub const VT_RESPONSE: flatbuffers::VOffsetT = 4;
+  pub const VT_ERROR: flatbuffers::VOffsetT = 6;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    CollectMetricsResponse { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args CollectMetricsResponseArgs<'args>
+  ) -> flatbuffers::WIPOffset<CollectMetricsResponse<'bldr>> {
+    let mut builder = CollectMetricsResponseBuilder::new(_fbb);
+    if let Some(x) = args.error { builder.add_error(x); }
+    if let Some(x) = args.response { builder.add_response(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn response(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(CollectMetricsResponse::VT_RESPONSE, None)}
+  }
+  #[inline]
+  pub fn error(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(CollectMetricsResponse::VT_ERROR, None)}
+  }
+}
+
+impl flatbuffers::Verifiable for CollectMetricsResponse<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    v.visit_table(pos)?
+     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("response", Self::VT_RESPONSE, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("error", Self::VT_ERROR, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct CollectMetricsResponseArgs<'a> {
+    pub response: Option<flatbuffers::WIPOffset<&'a str>>,
+    pub error: Option<flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for CollectMetricsResponseArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    CollectMetricsResponseArgs {
+      response: None,
+      error: None,
+    }
+  }
+}
+
+pub struct CollectMetricsResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> CollectMetricsResponseBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_response(&mut self, response: flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CollectMetricsResponse::VT_RESPONSE, response);
+  }
+  #[inline]
+  pub fn add_error(&mut self, error: flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CollectMetricsResponse::VT_ERROR, error);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> CollectMetricsResponseBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    CollectMetricsResponseBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> flatbuffers::WIPOffset<CollectMetricsResponse<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl core::fmt::Debug for CollectMetricsResponse<'_> {
+  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    let mut ds = f.debug_struct("CollectMetricsResponse");
+      ds.field("response", &self.response());
+      ds.field("error", &self.error());
+      ds.finish()
+  }
+}
 #[inline]
 /// Verifies that a buffer of bytes contains a `VoidResponse`
 /// and returns it.
diff --git a/yggdrasilffi/src/flat/mod.rs b/yggdrasilffi/src/flat/mod.rs
@@ -11,8 +11,10 @@ use std::borrow::Cow;
 use std::ffi::{c_char, c_void};
 use unleash_yggdrasil::impact_metrics::MetricOptions;
 
-use crate::flat::messaging::yggdrasil::messaging::{DefineCounter, VoidResponse};
-use crate::flat::serialisation::{Buf, TakeStateResult};
+use crate::flat::messaging::yggdrasil::messaging::{
+    CollectMetricsResponse, DefineCounter, VoidResponse,
+};
+use crate::flat::serialisation::{Buf, MetricMeasurement, TakeStateResult};
 use crate::{get_json, ManagedEngine, RawPointerDataType};
 use chrono::Utc;
 use messaging::yggdrasil::messaging::{
@@ -343,6 +345,32 @@ pub unsafe extern "C" fn flat_define_counter(
     VoidResponse::build_response(result)
 }
 
+/// Collects and returns metrics and impact metrics
+///
+/// # Safety
+///
+/// passing an invalid engine_ptr will cause UB
+/// the returned Buf should be freed by calling flat_buf_free, otherwise you're leaking memory
+///
+#[no_mangle]
+pub unsafe extern "C" fn flat_collect_metrics(engine_ptr: *mut c_void) -> Buf {
+    let result = guard_result::<MetricMeasurement, _>(|| {
+        let guard = get_engine(engine_ptr)?;
+        let mut engine = recover_lock(&guard);
+        let impact_metrics = engine.collect_impact_metrics();
+        let bucket = engine.get_metrics(Utc::now());
+        if bucket.is_none() && impact_metrics.is_empty() {
+            return Ok(None);
+        }
+        Ok(Some(MetricMeasurement {
+            metrics: bucket,
+            impact_metrics,
+        }))
+    });
+
+    CollectMetricsResponse::build_response(result)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/yggdrasilffi/src/flat/serialisation.rs b/yggdrasilffi/src/flat/serialisation.rs
@@ -1,20 +1,22 @@
 use flatbuffers::{FlatBufferBuilder, Follow, WIPOffset};
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::{
     cell::RefCell,
     fmt::{Display, Formatter},
 };
 use unleash_types::client_metrics::MetricBucket;
+use unleash_yggdrasil::impact_metrics::CollectedMetric;
 use unleash_yggdrasil::{EvalWarning, ExtendedVariantDef, ToggleDefinition};
 
 use crate::flat::messaging::yggdrasil::messaging::{
-    BuiltInStrategies, BuiltInStrategiesBuilder, CoreVersion, CoreVersionBuilder,
-    FeatureDefBuilder, FeatureDefs, FeatureDefsBuilder, MetricsResponse, MetricsResponseBuilder,
-    Response, ResponseBuilder, StrategyDefinition, StrategyDefinitionArgs, StrategyFeature,
-    StrategyFeatureArgs, StrategyParameter, StrategyParameterArgs, TakeStateResponse,
-    TakeStateResponseArgs, TakeStateResponseBuilder, ToggleEntryBuilder, ToggleStatsBuilder,
-    Variant, VariantBuilder, VariantEntryBuilder, VariantPayloadBuilder, VoidResponse,
-    VoidResponseBuilder,
+    BuiltInStrategies, BuiltInStrategiesBuilder, CollectMetricsResponse,
+    CollectMetricsResponseBuilder, CoreVersion, CoreVersionBuilder, FeatureDefBuilder, FeatureDefs,
+    FeatureDefsBuilder, MetricsResponse, MetricsResponseBuilder, Response, ResponseBuilder,
+    StrategyDefinition, StrategyDefinitionArgs, StrategyFeature, StrategyFeatureArgs,
+    StrategyParameter, StrategyParameterArgs, TakeStateResponse, TakeStateResponseArgs,
+    TakeStateResponseBuilder, ToggleEntryBuilder, ToggleStatsBuilder, Variant, VariantBuilder,
+    VariantEntryBuilder, VariantPayloadBuilder, VoidResponse, VoidResponseBuilder,
 };
 
 thread_local! {
@@ -44,6 +46,12 @@ pub struct TakeStateResult {
     pub feature_strategies_map: BTreeMap<String, BTreeMap<String, BTreeMap<String, String>>>,
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct MetricMeasurement {
+    pub metrics: Option<MetricBucket>,
+    pub impact_metrics: Vec<CollectedMetric>,
+}
+
 #[repr(C)]
 pub struct Buf {
     pub ptr: *mut u8, // points to heap memory owned by Rust
@@ -259,6 +267,43 @@ impl FlatMessage<Result<Option<()>, FlatError>> for VoidResponse<'static> {
     }
 }
 
+impl FlatMessage<Result<Option<MetricMeasurement>, FlatError>> for CollectMetricsResponse<'static> {
+    fn as_flat_buffer(
+        builder: &mut FlatBufferBuilder<'static>,
+        from: Result<Option<MetricMeasurement>, FlatError>,
+    ) -> WIPOffset<Self> {
+        match from {
+            Err(error) => {
+                let error_offset = builder.create_string(&error.to_string());
+                let mut response_builder = CollectMetricsResponseBuilder::new(builder);
+                response_builder.add_error(error_offset);
+                response_builder.finish()
+            }
+            Ok(Some(measurement)) => {
+                let metrics_str = serde_json::to_string(&measurement);
+                match metrics_str {
+                    Err(error) => {
+                        let error_offset = builder.create_string(&error.to_string());
+                        let mut response_builder = CollectMetricsResponseBuilder::new(builder);
+                        response_builder.add_error(error_offset);
+                        response_builder.finish()
+                    }
+                    Ok(m_str) => {
+                        let collect_response = builder.create_string(&m_str);
+                        let mut response_builder = CollectMetricsResponseBuilder::new(builder);
+                        response_builder.add_response(collect_response);
+                        response_builder.finish()
+                    }
+                }
+            }
+            Ok(None) => {
+                let resp_builder = CollectMetricsResponseBuilder::new(builder);
+                resp_builder.finish()
+            }
+        }
+    }
+}
+
 impl FlatMessage<Result<Option<ResponseMessage<ExtendedVariantDef>>, FlatError>>
     for Variant<'static>
 {
