feat(datadog-ffe): server-side EVP flagevaluation payload + bincode-safe sidecar delivery

datadog-ffe-test-suite/Cargo.toml

@@ -11,7 +11,7 @@ publish = false
 bench = false
 
 [dev-dependencies]
-datadog-ffe = { path = "../datadog-ffe" }
+datadog-ffe = { path = "../datadog-ffe", features = ["flagevaluation-evp"] }
 chrono = { version = "0.4.38", default-features = false, features = ["now", "serde"] }
 criterion = { version = "0.5", features = ["html_reports"] }
 env_logger = "0.10"

datadog-ffe-test-suite/benches/eval.rs

@@ -1,9 +1,21 @@
 // Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-use criterion::{black_box, criterion_group, criterion_main, Bencher, Criterion};
+use criterion::{
+    black_box, criterion_group, criterion_main, BatchSize, Bencher, Criterion, Throughput,
+};
+use datadog_ffe::telemetry::flagevaluation::{
+    encode_flag_evaluation_payloads, AllocationKey, ContextDD, FfeFlagEvaluationBatch,
+    FfeFlagEvaluationEvent, FlagEvalEventContext, FlagEvaluationEvpCoalescer, FlagKey, VariantKey,
+    EVP_PAYLOAD_SIZE_LIMIT,
+};
+use datadog_ffe::telemetry::FfeTelemetryContext;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, fs, sync::Arc};
+use std::{
+    collections::{BTreeMap, HashMap},
+    fs,
+    sync::Arc,
+};
 
 use datadog_ffe::rules_based::{
     get_assignment, Attribute, Configuration, EvaluationContext, ExpectedFlagType, FlagType, Str,
@@ -140,5 +152,142 @@ fn bench_single_flag(c: &mut Criterion) {
     group.finish();
 }
 
-criterion_group!(benches, bench_sdk_test_data, bench_single_flag);
+#[derive(Clone, Copy)]
+struct FlagEvalBenchProfile {
+    name: &'static str,
+    num_flags: usize,
+    num_users: usize,
+    num_fields: usize,
+}
+
+const FLAG_EVAL_BENCH_PROFILES: [FlagEvalBenchProfile; 3] = [
+    FlagEvalBenchProfile {
+        name: "typical/100flags_50users_10fields",
+        num_flags: 100,
+        num_users: 50,
+        num_fields: 10,
+    },
+    FlagEvalBenchProfile {
+        name: "stress/10flags_1000users_250fields",
+        num_flags: 10,
+        num_users: 1_000,
+        num_fields: 250,
+    },
+    FlagEvalBenchProfile {
+        name: "scale/2500flags_500users_20fields",
+        num_flags: 2_500,
+        num_users: 500,
+        num_fields: 20,
+    },
+];
+
+fn flag_eval_context() -> FfeTelemetryContext {
+    FfeTelemetryContext {
+        service: "bench-service".to_string(),
+        env: "ci".to_string(),
+        version: "1.0.0".to_string(),
+    }
+}
+
+fn flag_eval_attrs(num_fields: usize) -> String {
+    let attrs = (0..num_fields)
+        .map(|i| {
+            (
+                format!("field{i}"),
+                serde_json::Value::String("value".to_string()),
+            )
+        })
+        .collect::<BTreeMap<_, _>>();
+    serde_json::to_string(&attrs).expect("benchmark attrs must encode")
+}
+
+fn flag_eval_events(profile: FlagEvalBenchProfile) -> Vec<FfeFlagEvaluationEvent> {
+    let attrs = flag_eval_attrs(profile.num_fields);
+    let cycle_count = profile.num_flags.max(profile.num_users);
+    (0..cycle_count)
+        .map(|i| FfeFlagEvaluationEvent {
+            timestamp: 1_760_000_000_000,
+            flag: FlagKey {
+                key: format!("bench-flag-{}", i % profile.num_flags),
+            },
+            first_evaluation: 1_760_000_000_000 + i as i64,
+            last_evaluation: 1_760_000_000_000 + i as i64,
+            evaluation_count: 1,
+            variant: Some(VariantKey {
+                key: format!("variant-{}", i % 4),
+            }),
+            allocation: Some(AllocationKey {
+                key: format!("alloc-{}", i % profile.num_flags),
+            }),
+            targeting_rule: None,
+            targeting_key: Some(format!("bench-user-{}", i % profile.num_users)),
+            context: Some(FlagEvalEventContext {
+                evaluation: Some(attrs.clone()),
+                dd: Some(ContextDD {
+                    service: "bench-service".to_string(),
+                }),
+            }),
+            error: None,
+            runtime_default_used: false,
+        })
+        .collect()
+}
+
+fn flag_eval_batch(profile: FlagEvalBenchProfile) -> FfeFlagEvaluationBatch {
+    FfeFlagEvaluationBatch {
+        context: flag_eval_context(),
+        flag_evaluations: flag_eval_events(profile),
+    }
+}
+
+fn bench_flagevaluation_evp_coalescer(c: &mut Criterion) {
+    let mut group = c.benchmark_group("flagevaluation_evp/coalescer");
+    for profile in FLAG_EVAL_BENCH_PROFILES {
+        let batch = flag_eval_batch(profile);
+        group.throughput(Throughput::Elements(batch.flag_evaluations.len() as u64));
+        group.bench_function(profile.name, |b| {
+            b.iter_batched(
+                || batch.clone(),
+                |batch| {
+                    let coalescer = FlagEvaluationEvpCoalescer::<String>::default();
+                    coalescer.enqueue("agent".to_string(), black_box(batch));
+                    let batches = coalescer.take_batches();
+                    coalescer.finish_flush_cycle();
+                    black_box(batches);
+                },
+                BatchSize::SmallInput,
+            )
+        });
+    }
+    group.finish();
+}
+
+fn bench_flagevaluation_evp_payloads(c: &mut Criterion) {
+    let mut group = c.benchmark_group("flagevaluation_evp/payloads");
+    for profile in FLAG_EVAL_BENCH_PROFILES {
+        let batch = flag_eval_batch(profile);
+        group.throughput(Throughput::Elements(batch.flag_evaluations.len() as u64));
+        group.bench_function(profile.name, |b| {
+            b.iter_batched(
+                || batch.clone(),
+                |batch| {
+                    let payloads =
+                        encode_flag_evaluation_payloads(black_box(batch), EVP_PAYLOAD_SIZE_LIMIT)
+                            .expect("benchmark payload should encode");
+                    black_box(payloads);
+                },
+                BatchSize::SmallInput,
+            )
+        });
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_sdk_test_data,
+    bench_single_flag,
+    bench_flagevaluation_evp_coalescer,
+    bench_flagevaluation_evp_payloads
+);
 criterion_main!(benches);

datadog-ffe/Cargo.toml

@@ -20,6 +20,9 @@ derive_more = { version = "2.0.0", default-features = false, features = ["from",
 log = { version = "0.4.21", default-features = false, features = ["kv", "kv_serde"] }
 md5 = { version = "0.7.0", default-features = false }
 libdd-common = { version = "5.0.0", path = "../libdd-common", default-features = false, features = ["require-regex-full"] }
+libdd-capabilities = { path = "../libdd-capabilities", version = "2.0.0", optional = true }
+http = { version = "1.1", optional = true }
+tokio = { version = "1.49.0", features = ["time"], optional = true }
 semver = "1.0"
 serde-bool = { version = "0.1.3", default-features = false }
 serde_with = { version = "3.11.0", default-features = false, features = ["base64", "hex", "macros"] }
@@ -30,9 +33,18 @@ libdd-trace-protobuf = { path = "../libdd-trace-protobuf", optional = true }
 prost = { version = "0.14.1", optional = true }
 pyo3 = { version = "0.28", optional = true, default-features = false, features = ["macros"] }
 
+[dev-dependencies]
+# Matches the sidecar's bincode version. Used by the flagevaluation bincode
+# round-trip test, which guards against `skip_serializing_if` reintroducing the
+# worker→sidecar IPC field-misalignment bug (bincode is non-self-describing).
+bincode = { version = "1.3.3" }
+httpmock = "0.8.0-alpha.1"
+libdd-capabilities-impl = { path = "../libdd-capabilities-impl" }
+
 [features]
 default = ["remote-config"]
 exposure-events = ["dep:lru"]
 evaluation-metrics = ["dep:libdd-trace-protobuf", "dep:prost"]
+flagevaluation-evp = ["dep:http", "dep:libdd-capabilities", "dep:tokio"]
 pyo3 = ["dep:pyo3"]
 remote-config = ["dep:libdd-remote-config"]

datadog-ffe/src/lib.rs

@@ -6,7 +6,11 @@ mod flag_type;
 #[cfg(feature = "remote-config")]
 mod remote_config;
 pub mod rules_based;
-#[cfg(any(feature = "exposure-events", feature = "evaluation-metrics"))]
+#[cfg(any(
+    feature = "exposure-events",
+    feature = "evaluation-metrics",
+    feature = "flagevaluation-evp"
+))]
 pub mod telemetry;
 
 pub use flag_type::{ExpectedFlagType, FlagType};