sigstat 0.0.3-beta.2

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

use std::fmt::{Display, Formatter};

#[derive(Debug, Clone)]
pub enum StatsigErr {
    CustomError(String),

    LockFailure(String),

    UnstartedAdapter(String),

    NetworkError(String),

    SerializationError(String),

    GzipError(String),

    ZstdError(String),

    JsonParseError(String, String),

    FileError(String),

    ThreadFailure(String),

    StackOverflowError,

    // DataStore
    DataStoreFailure(String),
    DataStoreSkipPoll,

    ObservabilityClientFailure(String),

    // ID Lists Adapter
    IdListsAdapterFailedToInsertIdList,

    GrpcError(String),

    ShutdownTimeout,

    // Task Scheduler
    ScheduleFailure(String),
    ShutdownFailure,
}

impl Display for StatsigErr {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            StatsigErr::CustomError(msg) => write!(f, "{}", msg),

            StatsigErr::LockFailure(msg) => write!(f, "Failed to acquire lock: {}", msg),

            StatsigErr::UnstartedAdapter(msg) => write!(f, "Adapter not started: {}", msg),

            StatsigErr::NetworkError(msg) => write!(f, "Network error: {}", msg),

            StatsigErr::SerializationError(msg) => write!(f, "Serialization error: {}", msg),

            StatsigErr::GzipError(msg) => write!(f, "Gzip error: {}", msg),

            StatsigErr::ZstdError(msg) => write!(f, "Zstd error: {}", msg),

            StatsigErr::JsonParseError(type_name, err_msg) => {
                write!(f, "Failed to parse {} - {}", type_name, err_msg)
            }

            StatsigErr::FileError(msg) => write!(f, "File write error: {}", msg),

            StatsigErr::ThreadFailure(msg) => write!(f, "Thread failure: {}", msg),

            StatsigErr::StackOverflowError => write!(f, "Statsig Evaluation Depth Exceeded"),

            // ID Lists
            StatsigErr::IdListsAdapterFailedToInsertIdList => {
                write!(f, "Failed to insert new Id List")
            }

            StatsigErr::GrpcError(e) => write!(f, "{}", e),

            StatsigErr::ShutdownTimeout => write!(f, "Shutdown timed out"),

            StatsigErr::ScheduleFailure(e) => write!(f, "Failed to schedule task: {}", e),

            StatsigErr::ShutdownFailure => write!(f, "Failed to shutdown task scheduler"),
            StatsigErr::DataStoreFailure(message) => write!(f, "DataStore Error: {}", message),
            StatsigErr::DataStoreSkipPoll => write!(f, "DataStore stops polling"),
            StatsigErr::ObservabilityClientFailure(message) => {
                write!(f, "ObservabilityClient Error: {}", message)
            }
        }
    }
}