[FFL-1284] Create datadog-ffe-ffi crate

.github/CODEOWNERS

@@ -23,6 +23,7 @@ data-pipeline*/             @Datadog/libdatadog-apm
 datadog-tracer-flare        @Datadog/libdatadog-apm
 ddsketch                    @Datadog/libdatadog-apm @Datadog/libdatadog-telemetry
 datadog-ffe                 @Datadog/feature-flagging-and-experimentation-sdk
+datadog-ffe-ffi             @Datadog/feature-flagging-and-experimentation-sdk
 
 # Most of the bin_tests are owned by the profiling team, but some are owned by the core team
 bin_tests/                  @Datadog/libdatadog-profiling

Cargo.toml

@@ -8,6 +8,7 @@ members = [
   "datadog-crashtracker",
   "datadog-crashtracker-ffi",
   "datadog-ffe",
+  "datadog-ffe-ffi",
   "datadog-ipc",
   "datadog-ipc-macros",
   "datadog-library-config",

LICENSE-3rdparty.yml

@@ -1,4 +1,4 @@
-root_name: builder, build_common, tools, datadog-alloc, datadog-crashtracker, ddcommon, ddtelemetry, datadog-ddsketch, datadog-crashtracker-ffi, ddcommon-ffi, datadog-ffe, datadog-ipc, datadog-ipc-macros, tarpc, tarpc-plugins, tinybytes, spawn_worker, datadog-library-config, datadog-library-config-ffi, datadog-live-debugger, datadog-live-debugger-ffi, datadog-profiling, datadog-profiling-protobuf, datadog-profiling-ffi, data-pipeline-ffi, data-pipeline, datadog-trace-protobuf, datadog-trace-stats, datadog-trace-utils, datadog-trace-normalization, dogstatsd-client, datadog-log, datadog-log-ffi, ddsketch-ffi, ddtelemetry-ffi, symbolizer-ffi, datadog-profiling-replayer, datadog-remote-config, datadog-sidecar, datadog-sidecar-macros, datadog-sidecar-ffi, datadog-trace-obfuscation, datadog-tracer-flare, sidecar_mockgen, test_spawn_from_lib
+root_name: builder, build_common, tools, datadog-alloc, datadog-crashtracker, ddcommon, ddtelemetry, datadog-ddsketch, datadog-crashtracker-ffi, ddcommon-ffi, datadog-ffe, datadog-ffe-ffi, datadog-ipc, datadog-ipc-macros, tarpc, tarpc-plugins, tinybytes, spawn_worker, datadog-library-config, datadog-library-config-ffi, datadog-live-debugger, datadog-live-debugger-ffi, datadog-profiling, datadog-profiling-protobuf, datadog-profiling-ffi, data-pipeline-ffi, data-pipeline, datadog-trace-protobuf, datadog-trace-stats, datadog-trace-utils, datadog-trace-normalization, dogstatsd-client, datadog-log, datadog-log-ffi, ddsketch-ffi, ddtelemetry-ffi, symbolizer-ffi, datadog-profiling-replayer, datadog-remote-config, datadog-sidecar, datadog-sidecar-macros, datadog-sidecar-ffi, datadog-trace-obfuscation, datadog-tracer-flare, sidecar_mockgen, test_spawn_from_lib
 third_party_libraries:
 - package_name: addr2line
   package_version: 0.24.2

datadog-ffe-ffi/Cargo.toml

@@ -0,0 +1,28 @@
+# Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "datadog-ffe-ffi"
+edition.workspace = true
+version = "0.1.0"
+rust-version.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["lib", "staticlib", "cdylib"]
+bench = false
+
+[features]
+default = ["cbindgen"]
+cbindgen = ["build_common/cbindgen", "ddcommon-ffi/cbindgen"]
+
+[build-dependencies]
+build_common = { path = "../build-common" }
+
+[dependencies]
+anyhow = "1.0.93"
+datadog-ffe = { path = "../datadog-ffe", version = "=0.1.0" }
+ddcommon-ffi = { path = "../ddcommon-ffi", default-features = false }
+function_name = "0.3.0"
+
+[dev-dependencies]

datadog-ffe-ffi/build.rs

@@ -0,0 +1,11 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+extern crate build_common;
+
+use build_common::generate_and_configure_header;
+
+fn main() {
+    println!("cargo:rerun-if-changed=src/*");
+    let header_name = "datadog_ffe.h";
+    generate_and_configure_header(header_name);
+}

datadog-ffe-ffi/cbindgen.toml

@@ -0,0 +1,41 @@
+# Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+language = "C"
+cpp_compat = true
+tab_width = 2
+header = """// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+"""
+include_guard = "DDOG_FFE_H"
+style = "tag"
+usize_is_size_t = true
+pragma_once = true
+
+no_includes = true
+sys_includes = ["stdbool.h", "stddef.h", "stdint.h"]
+includes = ["common.h"]
+
+[export]
+include = ["datadog-ffe-ffi"]
+prefix = "ddog_ffe_"
+renaming_overrides_prefixing = true
+
+[export.rename]
+"VoidResult" = "ddog_VoidResult"
+"Error" = "ddog_Error"
+"Vec_u8" = "ddog_Vec_U8"
+
+[export.mangle]
+rename_types = "PascalCase"
+
+[enum]
+prefix_with_name = true
+rename_variants = "ScreamingSnakeCase"
+
+[fn]
+must_use = "DDOG_CHECK_RETURN"
+
+[parse]
+parse_deps = true
+include = ["ddcommon-ffi", "datadog-ffe"]

datadog-ffe-ffi/src/assignment.rs

@@ -0,0 +1,177 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use std::ffi::{c_char, c_uchar, CStr};
+
+use datadog_ffe::rules_based::{
+    now, Assignment, AssignmentValue, Configuration, EvaluationContext, EvaluationError, Str,
+    VariationType,
+};
+
+use crate::Handle;
+
+/// Opaque type representing a result of evaluation.
+#[allow(unused)]
+pub struct ResolutionDetails(Result<Assignment, EvaluationError>);
+
+#[repr(C)]
+pub enum FlagType {
+    Unknown,
+    String,
+    Integer,
+    Float,
+    Boolean,
+    Object,
+}
+
+impl From<VariationType> for FlagType {
+    fn from(value: VariationType) -> Self {
+        match value {
+            VariationType::String => FlagType::String,
+            VariationType::Integer => FlagType::Integer,
+            VariationType::Numeric => FlagType::Float,
+            VariationType::Boolean => FlagType::Boolean,
+            VariationType::Json => FlagType::Object,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum ErrorCode {
+    Ok,
+    TypeMismatch,
+    ParseError,
+    FlagNotFound,
+    TargetingKeyMissing,
+    InvalidContext,
+    ProviderNotReady,
+    General,
+}
+
+#[repr(C)]
+pub enum Reason {
+    Static,
+    Default,
+    TargetingMatch,
+    Split,
+    Disabled,
+    Error,
+}
+
+/// Evaluates a feature flag.
+///
+/// # Ownership
+///
+/// The caller must call `ddog_ffe_assignment_drop` on the returned value to free resources.
+///
+/// # Safety
+/// - `config` must be a valid `Configuration` handle
+/// - `flag_key` must be a valid C string
+/// - `context` must be a valid `EvaluationContext` handle
+#[no_mangle]
+pub unsafe extern "C" fn ddog_ffe_get_assignment(
+    config: Handle<Configuration>,
+    flag_key: *const c_char,
+    _expected_type: FlagType,
+    context: Handle<EvaluationContext>,
+) -> Handle<ResolutionDetails> {
+    if flag_key.is_null() {
+        return Handle::from(ResolutionDetails(Err(EvaluationError::Internal(
+            Str::from_static_str("ddog_ffe_get_assignment: flag_key must not be NULL"),
+        ))));
+    }
+
+    let config = unsafe { config.as_ref() };
+    let context = unsafe { context.as_ref() };
+
+    let Ok(flag_key) = unsafe {
+        // SAFETY: we checked that flag_key is not NULL
+        CStr::from_ptr(flag_key)
+    }
+    .to_str() else {
+        return Handle::from(ResolutionDetails(Err(EvaluationError::Internal(
+            Str::from_static_str("ddog_ffe_get_assignment: flag_key is not a valid UTF-8 string"),
+        ))));
+    };
+
+    let assignment_result = config.eval_flag(flag_key, context, None, now());
+
+    Handle::from(ResolutionDetails(assignment_result))
+}
+
+#[repr(C)]
+pub enum VariantValue {
+    /// Evaluation did not produce any value.
+    None,
+    String(*const c_uchar),
+    Integer(i64),
+    Float(f64),
+    Boolean(bool),
+    Object(*const c_char),
+}
+
+/// Get value produced by evaluation.
+///
+/// # Ownership
+///
+/// The returned `VariantValue` borrows from `assignment`. It must not be used after `assignment` is
+/// freed.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_ffe_assignment_get_value(
+    assignment: Handle<ResolutionDetails>,
+) -> VariantValue {
+    match unsafe { assignment.as_ref() } {
+        ResolutionDetails(Ok(assignment)) => match &assignment.value {
+            AssignmentValue::String(s) => VariantValue::String(s.as_ptr()),
+            AssignmentValue::Integer(v) => VariantValue::Integer(*v),
+            AssignmentValue::Float(v) => VariantValue::Float(*v),
+            AssignmentValue::Boolean(v) => VariantValue::Boolean(*v),
+            AssignmentValue::Json(_value) => todo!("make AssignmentValue hold onto raw json value"),
+        },
+        _ => VariantValue::None,
+    }
+}
+
+/// Get variant key produced by evaluation. Returns `NULL` if evaluation did not produce any value.
+///
+/// # Ownership
+///
+/// The returned string borrows from `assignment`. It must not be used after `assignment` is
+/// freed.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_ffe_assignment_get_variant(
+    assignment: Handle<ResolutionDetails>,
+) -> *const c_uchar {
+    match unsafe { assignment.as_ref() } {
+        ResolutionDetails(Ok(assignment)) => assignment.variation_key.as_ptr(),
+        _ => std::ptr::null(),
+    }
+}
+
+/// Get allocation key produced by evaluation. Returns `NULL` if evaluation did not produce any
+/// value.
+///
+/// # Ownership
+///
+/// The returned string borrows from `assignment`. It must not be used after `assignment` is
+/// freed.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_ffe_assignment_get_allocation_key(
+    assignment: Handle<ResolutionDetails>,
+) -> *const c_uchar {
+    match unsafe { assignment.as_ref() } {
+        ResolutionDetails(Ok(assignment)) => assignment.allocation_key.as_ptr(),
+        _ => std::ptr::null(),
+    }
+}
+
+// TODO: add accessors for various data inside ResolutionDetails.
+
+/// Frees an Assignment handle.
+///
+/// # Safety
+/// - `assignment` must be a valid Assignment handle
+#[no_mangle]
+pub unsafe extern "C" fn ddog_ffe_assignment_drop(assignment: *mut Handle<ResolutionDetails>) {
+    unsafe { Handle::free(assignment) }
+}

datadog-ffe-ffi/src/configuration.rs

@@ -0,0 +1,49 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use std::ffi::{c_char, CStr};
+
+use anyhow::ensure;
+use function_name::named;
+
+use datadog_ffe::rules_based::{Configuration, UniversalFlagConfig};
+use ddcommon_ffi::{wrap_with_ffi_result, Result};
+
+use crate::Handle;
+
+/// Creates a new Configuration from JSON bytes.
+///
+/// # Ownership
+///
+/// The caller must call `ddog_ffe_configuration_drop` to release resources allocated for
+/// configuration.
+///
+/// # Safety
+///
+/// - `json_str` must be a valid C string.
+#[no_mangle]
+#[named]
+pub unsafe extern "C" fn ddog_ffe_configuration_new(
+    json_str: *const c_char,
+) -> Result<Handle<Configuration>> {
+    wrap_with_ffi_result!({
+        ensure!(!json_str.is_null(), "json_str must not be NULL");
+
+        let json_bytes = unsafe { CStr::from_ptr(json_str) }.to_bytes().to_vec();
+
+        let configuration =
+            Configuration::from_server_response(UniversalFlagConfig::from_json(json_bytes)?);
+
+        Ok(Handle::from(configuration))
+    })
+}
+
+/// Frees a Configuration.
+///
+/// # Safety
+///
+/// `config` must be a valid Configuration handle created by `ddog_ffe_configuration_new`.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_ffe_configuration_drop(config: *mut Handle<Configuration>) {
+    unsafe { Handle::free(config) };
+}