statsig_rust/
statsig_types.rs

1use crate::evaluation::evaluation_details::EvaluationDetails;
2use crate::evaluation::evaluation_types::{
3    DynamicConfigEvaluation, ExperimentEvaluation, ExtraExposureInfo, GateEvaluation,
4    LayerEvaluation,
5};
6use crate::event_logging::event_logger::{EventLogger, ExposureTrigger};
7use crate::event_logging::event_queue::queued_layer_param_expo::EnqueueLayerParamExpoOp;
8use crate::interned_string::InternedString;
9use crate::specs_response::param_store_types::Parameter;
10use crate::statsig_core_api_options::ParameterStoreEvaluationOptions;
11use crate::user::StatsigUserLoggable;
12use crate::Statsig;
13use crate::StatsigUser;
14
15use chrono::Utc;
16use serde::de::DeserializeOwned;
17use serde::{Deserialize, Serialize};
18use serde_json::{from_value, Value};
19use std::collections::HashMap;
20use std::sync::Weak;
21
22#[derive(Default, Clone)]
23#[cfg(feature = "ffi-support")]
24pub struct BulkEvaluationOptions {
25    pub feature_gate_filter: Option<Vec<String>>,
26    pub dynamic_config_filter: Option<Vec<String>>,
27    pub experiment_filter: Option<Vec<String>>,
28    pub layer_filter: Option<Vec<String>>,
29    pub include_local_override: bool,
30}
31
32#[derive(Default, Clone)]
33#[cfg(feature = "ffi-support")]
34pub struct ResolvedBulkEvaluationOptions {
35    pub feature_gates: Vec<String>,
36    pub dynamic_configs: Vec<String>,
37    pub experiments: Vec<String>,
38    pub layers: Vec<String>,
39    pub include_local_override: bool,
40}
41
42#[derive(Serialize, Deserialize, Clone, Default)]
43#[cfg(feature = "ffi-support")]
44pub struct BulkEvaluationResponse {
45    pub feature_gates: HashMap<String, BulkFeatureGateEvaluation>,
46    pub dynamic_configs: HashMap<String, BulkDynamicConfigEvaluation>,
47    pub experiments: HashMap<String, BulkExperimentEvaluation>,
48    pub layer_configs: HashMap<String, BulkLayerEvaluation>,
49}
50
51#[derive(Serialize, Deserialize, Clone)]
52#[cfg(feature = "ffi-support")]
53pub struct BulkEvaluationCommonFields {
54    #[serde(rename = "ruleID")]
55    pub rule_id: InternedString,
56    #[serde(rename = "idType")]
57    pub id_type: Option<InternedString>,
58    pub details: EvaluationDetails,
59    #[serde(rename = "exposureToken")]
60    pub exposure_token: Option<String>,
61}
62
63#[derive(Serialize, Deserialize, Clone)]
64#[cfg(feature = "ffi-support")]
65pub struct BulkFeatureGateEvaluation {
66    pub value: bool,
67    #[serde(flatten)]
68    pub common: BulkEvaluationCommonFields,
69}
70
71#[derive(Serialize, Deserialize, Clone)]
72#[cfg(feature = "ffi-support")]
73pub struct BulkDynamicConfigEvaluation {
74    pub value: HashMap<String, Value>,
75    #[serde(flatten)]
76    pub common: BulkEvaluationCommonFields,
77}
78
79#[derive(Serialize, Deserialize, Clone)]
80#[cfg(feature = "ffi-support")]
81pub struct BulkExperimentEvaluation {
82    pub value: HashMap<String, Value>,
83    #[serde(rename = "groupName")]
84    pub group_name: Option<String>,
85    #[serde(flatten)]
86    pub common: BulkEvaluationCommonFields,
87}
88
89#[derive(Serialize, Deserialize, Clone)]
90#[cfg(feature = "ffi-support")]
91pub struct BulkLayerEvaluation {
92    pub value: HashMap<String, Value>,
93    #[serde(rename = "groupName")]
94    pub group_name: Option<String>,
95    #[serde(rename = "allocatedExperimentName")]
96    pub allocated_experiment_name: Option<String>,
97    #[serde(flatten)]
98    pub common: BulkEvaluationCommonFields,
99}
100
101#[derive(Serialize, Deserialize, Clone)]
102pub struct FeatureGate {
103    pub name: String,
104    pub value: bool,
105    pub rule_id: String,
106    pub id_type: String,
107    pub details: EvaluationDetails,
108
109    pub(crate) __evaluation: Option<GateEvaluation>,
110}
111
112#[derive(Serialize, Deserialize, Clone)]
113pub struct DynamicConfig {
114    pub name: String,
115    pub value: HashMap<String, Value>,
116    pub rule_id: String,
117    pub id_type: String,
118    pub details: EvaluationDetails,
119
120    pub __evaluation: Option<DynamicConfigEvaluation>,
121}
122
123impl DynamicConfig {
124    #[must_use]
125    pub fn get_opt<T: DeserializeOwned>(&self, param_name: &str) -> Option<T> {
126        match self.value.get(param_name) {
127            Some(value) => from_value(value.clone()).ok(),
128            None => None,
129        }
130    }
131
132    pub fn get_typed_opt(&self, param_name: &str, fallback: Option<Value>) -> Option<Value> {
133        extract_matching_type(&self.value, param_name, &fallback).or(fallback)
134    }
135}
136
137#[derive(Serialize, Deserialize, Clone)]
138pub struct Experiment {
139    pub name: String,
140    pub value: HashMap<String, Value>,
141    pub rule_id: String,
142    pub id_type: String,
143    pub group_name: Option<String>,
144    pub details: EvaluationDetails,
145    pub is_experiment_active: bool,
146
147    pub __evaluation: Option<ExperimentEvaluation>,
148}
149
150impl Experiment {
151    #[must_use]
152    pub fn get_opt<T: DeserializeOwned>(&self, param_name: &str) -> Option<T> {
153        match self.value.get(param_name) {
154            Some(value) => from_value(value.clone()).ok(),
155            None => None,
156        }
157    }
158
159    pub fn get_typed_opt(&self, param_name: &str, fallback: Option<Value>) -> Option<Value> {
160        extract_matching_type(&self.value, param_name, &fallback).or(fallback)
161    }
162}
163
164#[derive(Serialize, Deserialize, Clone)]
165pub struct Layer {
166    pub name: String,
167    pub rule_id: String,
168    pub id_type: String,
169
170    pub group_name: Option<String>,
171    pub details: EvaluationDetails,
172    pub allocated_experiment_name: Option<String>,
173    pub is_experiment_active: bool,
174
175    pub __parameter_rule_ids: Option<HashMap<InternedString, InternedString>>,
176    pub __evaluation: Option<LayerEvaluation>,
177    pub __value: HashMap<String, Value>,
178    pub __user: StatsigUserLoggable,
179    pub __disable_exposure: bool,
180
181    pub __version: Option<u32>, // todo: rm when Java/PHP layer exposures are not a JSON round trip
182
183    #[serde(skip_serializing_if = "Option::is_none")]
184    pub __exposure_info: Option<ExtraExposureInfo>,
185
186    #[serde(skip_serializing, skip_deserializing)]
187    pub __event_logger_ptr: Option<Weak<EventLogger>>,
188}
189
190impl Layer {
191    pub fn get_opt<T: DeserializeOwned>(&self, param_name: &str) -> Option<T> {
192        let value = self.__value.get(param_name)?.clone();
193
194        match from_value(value.clone()) {
195            Ok(value) => {
196                self.log_param_exposure(param_name);
197                Some(value)
198            }
199            Err(_) => None,
200        }
201    }
202
203    pub fn get_typed_opt(&self, param_name: &str, fallback: Option<Value>) -> Option<Value> {
204        match extract_matching_type(&self.__value, param_name, &fallback) {
205            Some(value) => {
206                self.log_param_exposure(param_name);
207                Some(value)
208            }
209            None => fallback,
210        }
211    }
212
213    pub fn get_raw_value(&self, param_name: &str) -> Option<Value> {
214        match self.__value.get(param_name) {
215            Some(value) => {
216                self.log_param_exposure(param_name);
217                Some(value.clone())
218            }
219            None => None,
220        }
221    }
222
223    fn log_param_exposure(&self, param_name: &str) -> Option<()> {
224        let logger = self.__event_logger_ptr.as_ref()?.upgrade()?;
225
226        if self.__disable_exposure {
227            logger.increment_non_exposure_checks(&self.name);
228            return None;
229        }
230
231        logger.enqueue(EnqueueLayerParamExpoOp::LayerRef(
232            Utc::now().timestamp_millis() as u64,
233            self,
234            param_name,
235            ExposureTrigger::Auto,
236        ));
237
238        None
239    }
240}
241
242macro_rules! impl_common_get_methods {
243    ($struct_name:ident) => {
244        impl $struct_name {
245            pub fn get<T: DeserializeOwned>(&self, param_name: &str, fallback: T) -> T {
246                self.get_opt(param_name).unwrap_or_else(|| fallback)
247            }
248
249            #[must_use]
250            pub fn get_bool(&self, param_name: &str, fallback: bool) -> bool {
251                self.get(param_name, fallback)
252            }
253
254            #[must_use]
255            pub fn get_f64(&self, param_name: &str, fallback: f64) -> f64 {
256                self.get(param_name, fallback)
257            }
258
259            #[must_use]
260            pub fn get_i64(&self, param_name: &str, fallback: i64) -> i64 {
261                self.get(param_name, fallback)
262            }
263
264            #[must_use]
265            pub fn get_string(&self, param_name: &str, fallback: String) -> String {
266                self.get(param_name, fallback)
267            }
268
269            #[must_use]
270            pub fn get_array(&self, param_name: &str, fallback: Vec<Value>) -> Vec<Value> {
271                self.get(param_name, fallback)
272            }
273
274            #[must_use]
275            pub fn get_object(
276                &self,
277                param_name: &str,
278                fallback: HashMap<String, Value>,
279            ) -> HashMap<String, Value> {
280                self.get(param_name, fallback)
281            }
282        }
283    };
284}
285
286#[derive(Serialize, Clone)]
287pub struct ParameterStore<'a> {
288    pub name: String,
289    pub details: EvaluationDetails,
290    pub parameters: HashMap<String, Parameter>,
291    pub options: ParameterStoreEvaluationOptions,
292
293    #[serde(skip_serializing, skip_deserializing)]
294    pub _statsig_ref: &'a Statsig,
295}
296
297impl ParameterStore<'_> {
298    pub fn get_opt<T: DeserializeOwned>(&self, user: &StatsigUser, param_name: &str) -> Option<T> {
299        let param = self.parameters.get(param_name)?;
300        match param {
301            Parameter::StaticValue(static_value) => from_value(static_value.value.clone()).ok(),
302            Parameter::Gate(gate) => {
303                let res = self._statsig_ref.check_gate_with_options(
304                    user,
305                    &gate.gate_name,
306                    self.options.into(),
307                );
308                let val = match res {
309                    true => gate.pass_value.clone(),
310                    false => gate.fail_value.clone(),
311                };
312                from_value(val).ok()
313            }
314            Parameter::DynamicConfig(dynamic_config) => {
315                let res = self._statsig_ref.get_dynamic_config_with_options(
316                    user,
317                    &dynamic_config.config_name,
318                    self.options.into(),
319                );
320                res.get_opt(&dynamic_config.param_name)?
321            }
322            Parameter::Experiment(experiment) => {
323                let res = self._statsig_ref.get_experiment_with_options(
324                    user,
325                    &experiment.experiment_name,
326                    self.options.into(),
327                );
328                res.get_opt(&experiment.param_name)?
329            }
330            Parameter::Layer(layer) => {
331                let res = self._statsig_ref.get_layer_with_options(
332                    user,
333                    &layer.layer_name,
334                    self.options.into(),
335                );
336                res.get_opt(&layer.param_name)?
337            }
338        }
339    }
340
341    pub fn get<T: DeserializeOwned>(&self, user: &StatsigUser, param_name: &str, fallback: T) -> T {
342        self.get_opt(user, param_name).unwrap_or(fallback)
343    }
344
345    pub fn get_json_value(
346        &self,
347        user: &StatsigUser,
348        param_name: &str,
349        fallback: Option<Value>,
350    ) -> Value {
351        match fallback {
352            None | Some(Value::Null) => self
353                .get_opt::<Value>(user, param_name)
354                .unwrap_or(Value::Null),
355            Some(Value::Bool(boolean)) => self.get_bool(user, param_name, boolean).into(),
356            Some(Value::Number(number)) => self.get(user, param_name, number).into(),
357            Some(Value::String(string)) => self.get_string(user, param_name, string).into(),
358            Some(Value::Array(vec)) => self.get_array(user, param_name, vec).into(),
359            Some(Value::Object(map)) => self
360                .get_object(user, param_name, map.into_iter().collect())
361                .into_iter()
362                .collect(),
363        }
364    }
365
366    pub fn get_bool(&self, user: &StatsigUser, param_name: &str, fallback: bool) -> bool {
367        self.get(user, param_name, fallback)
368    }
369
370    pub fn get_f64(&self, user: &StatsigUser, param_name: &str, fallback: f64) -> f64 {
371        self.get(user, param_name, fallback)
372    }
373
374    pub fn get_i64(&self, user: &StatsigUser, param_name: &str, fallback: i64) -> i64 {
375        self.get(user, param_name, fallback)
376    }
377
378    pub fn get_string(&self, user: &StatsigUser, param_name: &str, fallback: String) -> String {
379        self.get(user, param_name, fallback)
380    }
381
382    pub fn get_array(
383        &self,
384        user: &StatsigUser,
385        param_name: &str,
386        fallback: Vec<Value>,
387    ) -> Vec<Value> {
388        self.get(user, param_name, fallback)
389    }
390
391    pub fn get_object(
392        &self,
393        user: &StatsigUser,
394        param_name: &str,
395        fallback: HashMap<String, Value>,
396    ) -> HashMap<String, Value> {
397        self.get(user, param_name, fallback)
398    }
399}
400
401impl_common_get_methods!(DynamicConfig);
402impl_common_get_methods!(Experiment);
403impl_common_get_methods!(Layer);
404
405pub enum OverrideAdapterType {
406    LocalOverride,
407}
408
409fn extract_matching_type(
410    value: &HashMap<String, Value>,
411    param_name: &str,
412    fallback: &Option<Value>,
413) -> Option<Value> {
414    let found = value.get(param_name)?;
415    match (fallback, found) {
416        (Some(Value::Bool(_)), Value::Bool(_)) => Some(found.clone()),
417        (Some(Value::Number(_)), Value::Number(_)) => Some(found.clone()),
418        (Some(Value::String(_)), Value::String(_)) => Some(found.clone()),
419        (Some(Value::Array(_)), Value::Array(_)) => Some(found.clone()),
420        (Some(Value::Object(_)), Value::Object(_)) => Some(found.clone()),
421        (Some(Value::Null), Value::Null) => Some(found.clone()),
422        (None, value) => Some(value.clone()),
423        _ => None,
424    }
425}
statsig_rust/statsig_types.rs

statsig_rust/
statsig_types.rs
