feat(ffe): evaluate dependent flags with prerequisite telemetry

libdd-ffe-test-suite/Cargo.toml

@@ -10,6 +10,11 @@ publish = false
 [lib]
 bench = false
 
+[[bench]]
+name = "dependent-flags"
+harness = false
+path = "benches/dependent_flags.rs"
+
 [dev-dependencies]
 libdd-ffe = { path = "../libdd-ffe", features = ["flagevaluation-evp"] }
 chrono = { workspace = true, features = ["now", "serde"] }

libdd-ffe-test-suite/benches/dependent_flags.rs

@@ -0,0 +1,53 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use criterion::{Criterion, criterion_group, criterion_main};
+use libdd_ffe::rules_based::{
+    Configuration, EvaluationContext, ExpectedFlagType, UniversalFlagConfig,
+};
+use serde_json::json;
+use std::hint::black_box;
+
+fn bench_dependencies(c: &mut Criterion) {
+    let parent = json!({"key":"parent","enabled":true,"variationType":"BOOLEAN",
+        "variations":{"on":{"key":"on","value":true}},
+        "allocations":[{"key":"default","splits":[{"shards":[],"variationKey":"on"}]}]});
+    for (name, repeated) in [
+        ("legacy", 0),
+        ("one_prerequisite", 1),
+        ("memoized_16_references", 16),
+    ] {
+        let mut root = parent.clone();
+        root["key"] = json!("root");
+        if repeated > 0 {
+            root["allocations"][0]["rules"] = json!([{"conditions": (0..repeated).map(|_|
+                json!({"flagEvaluation":{"key":"parent"},"operator":"ONE_OF","value":["on"]})
+            ).collect::<Vec<_>>()}]);
+        }
+        let config = Configuration::from_server_response(
+            UniversalFlagConfig::from_json(
+                serde_json::to_vec(
+                    &json!({"createdAt":"2026-10-28T00:00:00Z","environment":{"name":"test"},
+                "flags":{"root":root,"parent":parent}}),
+                )
+                .unwrap(),
+            )
+            .unwrap(),
+        );
+        let context = EvaluationContext::new(Some("subject".into()), Default::default());
+        let now = chrono::Utc::now();
+        c.bench_function(&format!("dependent_flags/{name}"), |b| {
+            b.iter(|| {
+                black_box(config.eval_flag(
+                    black_box("root"),
+                    black_box(&context),
+                    ExpectedFlagType::Boolean,
+                    now,
+                ))
+                .unwrap()
+            })
+        });
+    }
+}
+criterion_group!(benches, bench_dependencies);
+criterion_main!(benches);

libdd-ffe/README.md

@@ -113,3 +113,30 @@ This library change does not enable PHP EVP emission or change flag evaluation
 results. PHP capture/admission/lifecycle integration and its end-to-end release
 validation are separate work. Native matched-build IPC/HTTP tests are not a
 substitute for PHP upgrade tests or Windows CI.
+
+## Dependent flags
+
+Rules may mix ordinary attribute conditions with `flagEvaluation` references. A reference
+compares the prerequisite's selected **variant key**, using `ONE_OF` or `NOT_ONE_OF` with a
+string array, including an empty array. References contain only a nonempty `key` and cannot
+also specify an `attribute`. Conditions run in authored order and short-circuit. A mismatch
+rejects the rule; a reached missing, disabled, malformed, or unassigned prerequisite fails
+the root with `DependencyEvaluationFailed`, preserving its cause.
+
+Each root evaluation uses one configuration, context, timestamp, and experimentation opt-out
+policy. Completed prerequisites are memoized only within that invocation. Cycles fail;
+`evaluatorParams.maxDependencyDepth` limits dependency edges (default 10, accepted range
+0–255). The limit is validated only when a dependency condition executes. Invalid values,
+including explicit `null`, fail that evaluation with `ConfigurationParseError` without
+preventing configuration loading, independent evaluations, or skipped dependency conditions.
+Cached results retain the deepest dependency visited, including rejected rules, so reuse
+from a deeper path cannot bypass the limit.
+
+`Configuration::eval_flag_with_trace` additionally returns unique prerequisite evaluation
+records, including prerequisites rejected by the depth limit and excluding the requested root.
+SDKs can log these evaluations even if a later condition rejects their rule. Only records
+marked `exposure_eligible` belong to the root's successful rule/split path; a failed root has
+no eligible prerequisite exposures. SDKs must
+also apply each assignment's `do_log`, consent, and ordinary exposure deduplication policy.
+The trace does not emit telemetry itself. SDKs should advertise dependent-flag support only
+after integrating and testing both evaluation and exposure reporting.

libdd-ffe/src/rules_based/error.rs

@@ -14,6 +14,22 @@ use crate::rules_based::{ExpectedFlagType, FlagType, Str};
 #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
 #[non_exhaustive]
 pub enum EvaluationError {
+    /// A prerequisite failed. Its cause is preserved, while SDKs can distinguish this from
+    /// a directly requested flag's normal disabled/default result.
+    #[error("prerequisite {flag_key} failed: {source}")]
+    DependencyEvaluationFailed {
+        /// Referenced prerequisite key.
+        flag_key: Str,
+        /// Original prerequisite failure.
+        source: Box<EvaluationError>,
+    },
+    /// A reached prerequisite references a flag already being evaluated.
+    #[error("flag dependency cycle")]
+    DependencyCycle,
+
+    /// A reached prerequisite exceeds the configuration's dependency depth limit.
+    #[error("flag dependency depth exceeded")]
+    DependencyDepthExceeded,
     /// Requested flag has unexpected type.
     #[error("invalid flag type (expected: {expected:?}, found: {found:?})")]
     TypeMismatch {