statsig-rust 0.19.1

Statsig Rust SDK for usage in multi-user server environments.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

mod utils;

use std::{sync::Arc, time::Duration};

use statsig_rust::{Statsig, StatsigOptions, StatsigUser};
use tokio::time;
use utils::{
    helpers::load_contents,
    mock_scrapi::{Endpoint, EndpointStub, Method, MockScrapi},
};

use crate::utils::mock_scrapi::StubData;

// Context see this pr: https://github.com/statsig-io/private-statsig-server-core/pull/1006
// Test will hang if there is a deadlock happen

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_get_experiment() {
    let statsig = setup_and_init_statsig().await;
    let user = StatsigUser::with_user_id("a_user_id");

    let task = tokio::spawn(async move {
        for _ in 1..100000 {
            statsig.get_experiment(&user, "test_experiment_with_targeting");
        }
    });

    if let Err(_e) = time::timeout(Duration::from_secs(10), task).await {
        panic!("Timeout on get experiment, potential deadlock!!");
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_check_gate() {
    let statsig = setup_and_init_statsig().await;
    let user = StatsigUser::with_user_id("a_user_id");

    let task = tokio::spawn(async move {
        for _ in 1..10000 {
            statsig.get_feature_gate(&user, "test_experiment_with_targeting");
        }
    });

    if let Err(_e) = time::timeout(Duration::from_secs(10), task).await {
        panic!("Timeout on get gate, potential deadlock");
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_get_layer() {
    let statsig = setup_and_init_statsig().await;
    let user = StatsigUser::with_user_id("a_user_id");

    let task = tokio::spawn(async move {
        for _ in 1..10000 {
            statsig.get_layer(&user, "test_experiment_with_targeting");
        }
    });

    if let Err(_e) = time::timeout(Duration::from_secs(10), task).await {
        panic!("Timeout on get layer, potential deadlock");
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_gcir() {
    let statsig = setup_and_init_statsig().await;
    let user = StatsigUser::with_user_id("a_user_id");

    let task = tokio::spawn(async move {
        for _ in 1..100 {
            statsig.get_client_init_response(&user);
        }
    });

    if let Err(_e) = time::timeout(Duration::from_secs(10), task).await {
        panic!("Timeout on gcir, potential deadlock");
    }
}

async fn setup_and_init_statsig() -> Statsig {
    let scrapi = setup_scrapi().await;
    let options = Arc::new(
        StatsigOptions::builder()
            .specs_url(Some(scrapi.url_for_endpoint(Endpoint::DownloadConfigSpecs)))
            .specs_sync_interval_ms(Some(30))
            .build(),
    );
    let statsig = Statsig::new("secret", Some(options));
    statsig.initialize().await.unwrap();
    statsig
}

async fn setup_scrapi() -> MockScrapi {
    let mock_scrapi: MockScrapi = MockScrapi::new().await;
    let dcs = load_contents("eval_proj_dcs.json");

    mock_scrapi
        .stub(EndpointStub {
            method: Method::GET,
            response: StubData::String(dcs),
            ..EndpointStub::with_endpoint(Endpoint::DownloadConfigSpecs)
        })
        .await;

    mock_scrapi
}