Rust SDK - OpenFeature - Westyx Nexus

The westyx-nexus-openfeature crate bridges Nexus to the OpenFeature Rust SDK. The provider wraps an existing client: it opens no second connection and keeps no second cache, so every resolution is an in-memory read rather than a network call.

Installation

[dependencies]
westyx-nexus = "0.14.0-beta.2"
westyx-nexus-openfeature = "0.14.0-beta.2"
open-feature = "0.3"

Usage

use open_feature::OpenFeature;
use westyx_nexus::{NexusClient, NexusConfig};
use westyx_nexus_openfeature::NexusFeatureProvider;

let client = NexusClient::create(NexusConfig {
    api_key: std::env::var("NEXUS_API_KEY")?,
    endpoint: std::env::var("NEXUS_ENDPOINT")?,
    ..Default::default()
})
.await?;
client.run_stream(); // keeps the snapshot fresh

let mut api = OpenFeature::singleton_mut().await;
api.set_provider(NexusFeatureProvider::new(client)).await;
drop(api);

let flags = OpenFeature::singleton().await.create_client();
let enabled = flags.get_bool_value("new-checkout", None, None).await.unwrap_or(false);

Resolution mapping

OpenFeature resolution	Nexus source
`resolve_bool_value`	feature flag, targeted per user when the context carries a targeting key; falls back to a boolean config of the same name
`resolve_string_value`	config value, must be a string
`resolve_int_value`	config value, must be a whole number
`resolve_float_value`	config value, must be a number
`resolve_struct_value`	config value, must be a JSON object, converted recursively

A missing key resolves to FlagNotFound, and a value of the wrong shape to TypeMismatch. In both cases the OpenFeature SDK returns the caller’s default. Three details of the value mapping:

Integers keep their precision. A config value of 9007199254740993 arrives as an i64, not a rounded float.
A whole number is an integer however it is written. JSON has one number type, so 5.0 resolves as 5. A fractional value is a TypeMismatch rather than a truncation.
A composite carrying a JSON null is a TypeMismatch. The OpenFeature value model has no null, so such a value cannot be represented faithfully - and dropping the null would shorten an array and shift every position after it. Read those through provider.client().get_config(..), which returns the raw serde_json::Value.

Every scalar resolution carries a variant - the lowercase string form of the value. A composite carries none.

Per-user targeting

A boolean evaluation whose context carries a targeting key is resolved through the Nexus A/B Testing add-on, so rollout percentages and cohort rules apply:

use open_feature::EvaluationContext;

let context = EvaluationContext::default()
    .with_targeting_key("user-42")
    .with_custom_field("plan", "pro");

let enabled = flags
    .get_bool_value("new-checkout", Some(&context), None)
    .await
    .unwrap_or(false);

One request covers every flag in the snapshot, and the results are memoised per targeting key, so a request handler reading eight flags for one user makes one round trip - the later reads report CACHED. Concurrent evaluations for the same user coalesce into a single call. An evaluation with no targeting key never reaches the network. Config resolutions are never targeted either: A/B evaluation is a flag concept.

Reason codes

Situation	Reason	Value
No targeting key	`STATIC`	the snapshot value
Memoised result for this user	`CACHED`	the memoised value
Fresh targeted evaluation	`TARGETING_MATCH`	the evaluated value
The flag is not in the snapshot	`DEFAULT` + `FLAG_NOT_FOUND`	your default
The targeted request failed	`STALE`	the snapshot value
The A/B Testing add-on is not active	`STATIC`	the snapshot value

Evaluation never throws, and a failed request is never reported as an error resolution. The specification requires an abnormal execution to return the default value, so signalling an error would hand you false for a flag that is genuinely on because one request failed. The snapshot value with STALE is honest: real, but not freshly targeted. When the add-on is not active the provider stops calling for five minutes. That window lapses on its own and is cleared by any success, so a project that buys the add-on starts getting targeted results within it with nothing to restart.

Attributes are strings

The service compares attribute values with eq, neq and in, so string equality is the whole of what a cohort rule can express. A context field of any other type is dropped and logged at debug level, never converted: stringifying a large number or a nested structure produces a value no cohort rule can match. Numeric and boolean targeting would need typed operators in the cohort matcher.

Tuning

use std::time::Duration;
use westyx_nexus_openfeature::{NexusFeatureProvider, NexusProviderOptions};

let provider = NexusFeatureProvider::with_options(
    client,
    NexusProviderOptions {
        targeting_ttl: Duration::from_secs(10),
        max_targeting_keys: 50_000,
        ..Default::default()
    },
)?;

Option	Default	What it bounds
`targeting_ttl`	30 s	How long a targeted result is reused, and how long a cohort change can appear not to take effect
`max_targeting_keys`	10 000	How many users the memo holds; expired entries are swept first, then the earliest-expiring one is evicted
`addon_suppression`	5 min	How long an inactive add-on is honoured before trying again

Each is validated when the provider is built, and a zero value is rejected naming the option.

Provider status

status() reports Ready: the wrapped client performs its initial sync during create, so a provider that exists can serve.

Minimum Rust version

Rust 1.88, the same floor as the core SDK.

Overview

Backend SDKs

Browser SDKs

OpenFeature Providers

Rust SDK - OpenFeature

Installation

Usage

Resolution mapping

Per-user targeting

Reason codes

Attributes are strings

Tuning

Provider status

Minimum Rust version

​Installation

​Usage

​Resolution mapping

​Per-user targeting

​Reason codes

​Attributes are strings

​Tuning

​Provider status

​Minimum Rust version

Installation

Usage

Resolution mapping

Per-user targeting

Reason codes

Attributes are strings

Tuning

Provider status

Minimum Rust version