feat: fastly compute service to perform assignments (FF-3552)

.github/workflows/ci.yml

@@ -23,6 +23,12 @@ jobs:
           submodules: true
       - run: npm ci
       - run: rustup update ${{ matrix.toolchain }} && rustup default ${{ matrix.toolchain }}
-      - run: cargo build --verbose --all-targets
-      - run: cargo test --verbose
+      # Add WASM target
+      - run: rustup target add wasm32-wasi
+      # Build non-WASM targets
+      - run: cargo build --verbose --all-targets --workspace --exclude fastly-edge-assignments
+      # Build WASM target separately
+      - run: cargo build --verbose -p fastly-edge-assignments --target wasm32-wasi
+      # Run tests (excluding WASM package)
+      - run: cargo test --verbose --workspace --exclude fastly-edge-assignments
       - run: cargo doc --verbose

Cargo.toml

@@ -1,10 +1,11 @@
 [workspace]
 resolver = "2"
 members = [
-  "eppo_core",
-  "rust-sdk",
-  "python-sdk",
-  "ruby-sdk/ext/eppo_client",
+    "eppo_core",
+    "rust-sdk",
+    "python-sdk",
+    "ruby-sdk/ext/eppo_client",
+    "fastly-edge-assignments",
 ]
 
 [patch.crates-io]

Makefile

@@ -1,28 +1,47 @@
-# Make settings - @see https://tech.davis-hansson.com/p/make/
 SHELL := bash
 .ONESHELL:
 .SHELLFLAGS := -eu -o pipefail -c
 .DELETE_ON_ERROR:
 MAKEFLAGS += --warn-undefined-variables
 MAKEFLAGS += --no-builtin-rules
 
-# Log levels
-DEBUG := $(shell printf "\e[2D\e[35m")
-INFO  := $(shell printf "\e[2D\e[36m🔵 ")
-OK    := $(shell printf "\e[2D\e[32m🟢 ")
-WARN  := $(shell printf "\e[2D\e[33m🟡 ")
-ERROR := $(shell printf "\e[2D\e[31m🔴 ")
-END   := $(shell printf "\e[0m")
+WASM_TARGET=wasm32-wasi
+FASTLY_PACKAGE=fastly-edge-assignments
+BUILD_DIR=target/$(WASM_TARGET)/release
+WASM_FILE=$(BUILD_DIR)/$(FASTLY_PACKAGE).wasm
 
-.PHONY: default
-default: help
-
-## help - Print help message.
+# Help target for easy documentation
 .PHONY: help
-help: Makefile
-	@echo "usage: make <target>"
-	@sed -n 's/^##//p' $<
+help:
+	@echo "Available targets:"
+	@echo "  all                           - Default target (build workspace)"
+	@echo "  workspace-build               - Build the entire workspace excluding the Fastly package"
+	@echo "  workspace-test                - Test the entire workspace excluding the Fastly package"
+	@echo "  fastly-edge-assignments-build - Build only the Fastly package for WASM"
+	@echo "  fastly-edge-assignments-test  - Test only the Fastly package"
+	@echo "  clean                         - Clean all build artifacts"
 
 .PHONY: test
 test: ${testDataDir}
 	npm test
+
+# Build the entire workspace excluding the `fastly-edge-assignments` package
+.PHONY: workspace-build
+workspace-build:
+	cargo build --workspace --exclude $(FASTLY_PACKAGE)
+
+# Run tests for the entire workspace excluding the `fastly-edge-assignments` package
+.PHONY: workspace-test
+workspace-test:
+	cargo test --workspace --exclude $(FASTLY_PACKAGE)
+
+# Build only the `fastly-edge-assignments` package for WASM
+.PHONY: fastly-edge-assignments-build
+fastly-edge-assignments-build:
+	rustup target add $(WASM_TARGET)
+	cargo build --release --target $(WASM_TARGET) --package $(FASTLY_PACKAGE)
+
+# Test only the `fastly-edge-assignments` package
+.PHONY: fastly-edge-assignments-test
+fastly-edge-assignments-test:
+	cargo test --target $(WASM_TARGET) --package $(FASTLY_PACKAGE)

eppo_core/src/lib.rs

@@ -55,6 +55,7 @@ pub mod configuration_store;
 pub mod eval;
 pub mod events;
 pub mod poller_thread;
+pub mod precomputed_assignments;
 #[cfg(feature = "pyo3")]
 pub mod pyo3;
 pub mod sharder;

eppo_core/src/precomputed_assignments.rs

@@ -0,0 +1,86 @@
+use crate::ufc::{Assignment, AssignmentFormat, Environment, VariationType};
+use crate::{Attributes, Configuration, Str};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+// Request
+#[derive(Debug, Deserialize)]
+pub struct PrecomputedAssignmentsServiceRequestBody {
+    pub subject_key: Str,
+    pub subject_attributes: Arc<Attributes>,
+    // TODO: Add bandit actions
+    // #[serde(rename = "banditActions")]
+    // #[serde(skip_serializing_if = "Option::is_none")]
+    // bandit_actions: Option<HashMap<String, serde_json::Value>>,
+}
+
+// Response
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FlagAssignment {
+    pub allocation_key: Str,
+    pub variation_key: Str,
+    pub variation_type: VariationType,
+    pub variation_value: serde_json::Value,
+    /// Additional user-defined logging fields for capturing extra information related to the
+    /// assignment.
+    #[serde(flatten)]
+    pub extra_logging: HashMap<String, String>,
+    pub do_log: bool,
+}
+
+impl FlagAssignment {
+    pub fn try_from_assignment(assignment: Assignment) -> Option<Self> {
+        // WARNING! There is a problem here. The event is only populated for splits
+        // that have `do_log` set to true in the wire format. This means that
+        // all the ones present here are logged, but any splits that are not
+        // logged are not present here.
+        //
+        // This is a problem for us because we want to be able to return
+        // precomputed assignments for any split, logged or not, since we
+        // want to be able to return them for all flags.
+        //
+        // We need to fix this.
+        assignment.event.as_ref().map(|event| Self {
+            allocation_key: event.base.allocation.clone(),
+            variation_key: event.base.variation.clone(),
+            variation_type: assignment.value.variation_type(),
+            variation_value: assignment.value.variation_value(),
+            extra_logging: event
+                .base
+                .extra_logging
+                .iter()
+                .map(|(k, v)| (k.clone(), v.clone()))
+                .collect(),
+            do_log: true,
+        })
+    }
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PrecomputedAssignmentsServiceResponse {
+    created_at: chrono::DateTime<chrono::Utc>,
+    format: AssignmentFormat,
+    environment: Environment,
+    flags: HashMap<String, FlagAssignment>,
+}
+
+impl PrecomputedAssignmentsServiceResponse {
+    pub fn from_configuration(
+        configuration: Arc<Configuration>,
+        flags: HashMap<String, FlagAssignment>,
+    ) -> Self {
+        Self {
+            created_at: chrono::Utc::now(),
+            format: AssignmentFormat::Precomputed,
+            environment: {
+                Environment {
+                    name: configuration.flags.compiled.environment.name.clone(),
+                }
+            },
+            flags,
+        }
+    }
+}

eppo_core/src/ufc/assignment.rs

@@ -4,6 +4,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::{events::AssignmentEvent, Str};
 
+use crate::ufc::VariationType;
+
 /// Result of assignment evaluation.
 #[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
@@ -231,6 +233,52 @@ impl AssignmentValue {
             _ => None,
         }
     }
+
+    /// Returns the type of the variation as a string.
+    ///
+    /// # Returns
+    /// - A string representing the type of the variation ("STRING", "INTEGER", "NUMERIC", "BOOLEAN", or "JSON").
+    ///
+    /// # Examples
+    /// ```
+    /// # use eppo_core::ufc::AssignmentValue;
+    /// # use eppo_core::ufc::VariationType;
+    /// let value = AssignmentValue::String("example".into());
+    /// assert_eq!(value.variation_type(), VariationType::String);
+    /// ```
+    pub fn variation_type(&self) -> VariationType {
+        match self {
+            AssignmentValue::String(_) => VariationType::String,
+            AssignmentValue::Integer(_) => VariationType::Integer,
+            AssignmentValue::Numeric(_) => VariationType::Numeric,
+            AssignmentValue::Boolean(_) => VariationType::Boolean,
+            AssignmentValue::Json(_) => VariationType::Json,
+        }
+    }
+
+    /// Returns the raw value of the variation.
+    ///
+    /// # Returns
+    /// - A JSON Value containing the variation value.
+    ///
+    /// # Examples
+    /// ```
+    /// # use eppo_core::ufc::AssignmentValue;
+    /// # use serde_json::json;
+    /// let value = AssignmentValue::String("example".into());
+    /// assert_eq!(value.variation_value(), json!("example"));
+    /// ```
+    pub fn variation_value(&self) -> serde_json::Value {
+        match self {
+            AssignmentValue::String(s) => serde_json::Value::String(s.to_string()),
+            AssignmentValue::Integer(i) => serde_json::Value::Number((*i).into()),
+            AssignmentValue::Numeric(n) => serde_json::Value::Number(
+                serde_json::Number::from_f64(*n).unwrap_or_else(|| serde_json::Number::from(0)),
+            ),
+            AssignmentValue::Boolean(b) => serde_json::Value::Bool(*b),
+            AssignmentValue::Json(j) => j.as_ref().clone(),
+        }
+    }
 }
 
 #[cfg(feature = "pyo3")]

eppo_core/src/ufc/models.rs

@@ -18,6 +18,7 @@ pub type Timestamp = chrono::DateTime<chrono::Utc>;
 pub(crate) struct UniversalFlagConfigWire {
     /// When configuration was last updated.
     pub created_at: Timestamp,
+    pub format: AssignmentFormat,
     /// Environment this configuration belongs to.
     pub environment: Environment,
     /// Flags configuration.
@@ -31,6 +32,14 @@ pub(crate) struct UniversalFlagConfigWire {
     pub bandits: HashMap<String, Vec<BanditVariationWire>>,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "UPPERCASE")]
+pub(crate) enum AssignmentFormat {
+    Client,
+    Precomputed,
+    Server,
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct Environment {
@@ -540,6 +549,7 @@ mod tests {
             &r#"
               {
                 "createdAt": "2024-07-18T00:00:00Z",
+                "format": "SERVER",
                 "environment": {"name": "test"},
                 "flags": {
                   "success": {

fastly-edge-assignments/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-wasi"

fastly-edge-assignments/.gitignore

@@ -0,0 +1,2 @@
+pkg/
+bin/

fastly-edge-assignments/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "fastly-edge-assignments"
+version = "0.1.0"
+edition = "2021"
+# Remove this line if you want to be able to publish this crate as open source on crates.io.
+# Otherwise, `publish = false` prevents an accidental `cargo publish` from revealing private source.
+publish = false
+
+[dependencies]
+base64-url = "2.0.0"
+chrono = "0.4.19"
+eppo_core = { version = "=4.1.1", path = "../eppo_core" }
+fastly = "0.11.0"
+serde_json = "1.0.132"
+serde = "1.0.192"
+sha2 = "0.10.0"

fastly-edge-assignments/README.md

@@ -0,0 +1,3 @@
+# Eppo Assignments on Fastly Compute@Edge
+
+TODO: Add a description

fastly-edge-assignments/fastly.toml

@@ -0,0 +1,17 @@
+# This file describes a Fastly Compute package. To learn more visit:
+# https://www.fastly.com/documentation/reference/compute/fastly-toml
+
+authors = ["[email protected]"]
+name = "Eppo Assignments on Fastly Compute@Edge"
+description = "Edge compute service for pre-computed Eppo flag assignments"
+language = "rust"
+manifest_version = 3
+
+[scripts]
+build = "cargo build --bin fastly-edge-assignments --release --target wasm32-wasi --color always"
+
+[local_server]
+  [local_server.kv_stores]
+    [[local_server.kv_stores.edge-assignment-kv-store]]
+      key = "ufc-by-sdk-key-token-hash-V--77TScV5Etm78nIMTSOdiroOh1__NsupwUwsetEVM"
+      file = "../sdk-test-data/ufc/flags-v1.json"

fastly-edge-assignments/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "stable"
+targets = [ "wasm32-wasi" ]