ably 0.2.0

Ably client library SDK
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

use serde::Deserialize;

/// Ably Application statistics retrieved from [REST stats endpoint].
///
/// [REST stats endpoint]: https://docs.ably.io/rest-api/#stats
#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Stats {
    pub interval_id: String,
    pub unit: Unit,

    pub all: Option<MessageTypes>,
    pub inbound: Option<MessageTraffic>,
    pub outbound: Option<MessageTraffic>,
    pub persisted: Option<MessageTypes>,

    pub connections: Option<ConnectionTypes>,
    pub channels: Option<ResourceCount>,

    pub api_requests: Option<RequestCount>,
    pub token_requests: Option<RequestCount>,

    pub push: Option<Push>,

    pub xchg_producer: Option<XchgMessages>,
    pub xchg_consumer: Option<XchgMessages>,

    pub peak_rates: Option<Rates>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Unit {
    Minute,
    Hour,
    Day,
    Month,
}

impl Default for Unit {
    fn default() -> Self {
        Unit::Minute
    }
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct MessageCount {
    pub count: f64,
    pub data: f64,
    pub failed: f64,
    pub refused: f64,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ResourceCount {
    pub peak: f64,
    pub min: f64,
    pub mean: f64,
    pub opened: f64,
    pub failed: f64,
    pub refused: f64,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct RequestCount {
    pub failed: f64,
    pub refused: f64,
    pub succeeded: f64,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct MessageTypes {
    pub all: MessageCount,
    pub messages: MessageCount,
    pub presence: MessageCount,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ConnectionTypes {
    pub all: ResourceCount,
    pub plain: ResourceCount,
    pub tls: ResourceCount,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct MessageTraffic {
    pub all: MessageTypes,
    pub realtime: MessageTypes,
    pub rest: MessageTypes,
    pub webhook: MessageTypes,
    pub push: MessageTypes,
    pub external_queue: MessageTypes,
    pub shared_queue: MessageTypes,
    pub http_event: MessageTypes,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Push {
    pub messages: f64,
    pub notifications: PushNotifications,
    pub direct_publishes: f64,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PushNotifications {
    pub invalid: f64,
    pub attempted: PushTransportCount,
    pub successful: PushTransportCount,
    pub failed: PushNotificationFailures,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PushTransportCount {
    pub total: f64,
    pub gcm: f64,
    pub fcm: f64,
    pub apns: f64,
    pub web: f64,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PushNotificationFailures {
    pub retriable: PushTransportCount,
    pub final_: PushTransportCount,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct XchgMessages {
    pub all: MessageTypes,
    pub producer_paid: MessageDirections,
    pub consumer_paid: MessageDirections,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct MessageDirections {
    pub all: MessageTypes,
    pub inbound: MessageTraffic,
    pub outbound: MessageTraffic,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Rates {
    pub messages: f64,
    pub api_requests: f64,
    pub token_requests: f64,
    pub reactor: ReactorRates,
}

#[derive(Debug, Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ReactorRates {
    pub http_event: f64,
    pub amqp: f64,
}