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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
|
#include <haproxy/quic_frame-t.h>
#include <haproxy/quic_stats-t.h>
#include <haproxy/stats.h>
static struct stat_col quic_stats[] = {
[QUIC_ST_RXBUF_FULL] = { .name = "quic_rxbuf_full",
.desc = "Total number of cancelled reception due to full receiver buffer" },
[QUIC_ST_DROPPED_PACKET] = { .name = "quic_dropped_pkt",
.desc = "Total number of dropped packets" },
[QUIC_ST_DROPPED_PACKET_BUFOVERRUN] = { .name = "quic_dropped_pkt_bufoverrun",
.desc = "Total number of dropped packets because of buffer overrun" },
[QUIC_ST_DROPPED_PARSING] = { .name = "quic_dropped_parsing_pkt",
.desc = "Total number of dropped packets upon parsing error" },
[QUIC_ST_SOCKET_FULL] = { .name = "quic_socket_full",
.desc = "Total number of EAGAIN error on sendto() calls" },
[QUIC_ST_SENDTO_ERR] = { .name = "quic_sendto_err",
.desc = "Total number of error on sendto() calls, EAGAIN excepted" },
[QUIC_ST_SENDTO_ERR_UNKNWN] = { .name = "quic_sendto_err_unknwn",
.desc = "Total number of error on sendto() calls not explicitly listed" },
[QUIC_ST_SENT_PACKET] = { .name = "quic_sent_pkt",
.desc = "Total number of sent packets" },
[QUIC_ST_LOST_PACKET] = { .name = "quic_lost_pkt",
.desc = "Total number of lost sent packets" },
[QUIC_ST_TOO_SHORT_INITIAL_DGRAM] = { .name = "quic_too_short_dgram",
.desc = "Total number of too short dgrams with Initial packets" },
[QUIC_ST_RETRY_SENT] = { .name = "quic_retry_sent",
.desc = "Total number of Retry sent" },
[QUIC_ST_RETRY_VALIDATED] = { .name = "quic_retry_validated",
.desc = "Total number of validated Retry tokens" },
[QUIC_ST_RETRY_ERRORS] = { .name = "quic_retry_error",
.desc = "Total number of Retry tokens errors" },
[QUIC_ST_HALF_OPEN_CONN] = { .name = "quic_half_open_conn",
.desc = "Total number of half open connections" },
[QUIC_ST_HDSHK_FAIL] = { .name = "quic_hdshk_fail",
.desc = "Total number of handshake failures" },
[QUIC_ST_STATELESS_RESET_SENT] = { .name = "quic_stless_rst_sent",
.desc = "Total number of stateless reset packet sent" },
/* Special events of interest */
[QUIC_ST_CONN_MIGRATION_DONE] = { .name = "quic_conn_migration_done",
.desc = "Total number of connection migration proceeded" },
/* Transport errors */
[QUIC_ST_TRANSP_ERR_NO_ERROR] = { .name = "quic_transp_err_no_error",
.desc = "Total number of NO_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_INTERNAL_ERROR] = { .name = "quic_transp_err_internal_error",
.desc = "Total number of INTERNAL_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_CONNECTION_REFUSED] = { .name = "quic_transp_err_connection_refused",
.desc = "Total number of CONNECTION_REFUSED errors received" },
[QUIC_ST_TRANSP_ERR_FLOW_CONTROL_ERROR] = { .name = "quic_transp_err_flow_control_error",
.desc = "Total number of FLOW_CONTROL_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_STREAM_LIMIT_ERROR] = { .name = "quic_transp_err_stream_limit_error",
.desc = "Total number of STREAM_LIMIT_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_STREAM_STATE_ERROR] = { .name = "quic_transp_err_stream_state_error",
.desc = "Total number of STREAM_STATE_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_FINAL_SIZE_ERROR] = { .name = "quic_transp_err_final_size_error",
.desc = "Total number of FINAL_SIZE_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_FRAME_ENCODING_ERROR] = { .name = "quic_transp_err_frame_encoding_error",
.desc = "Total number of FRAME_ENCODING_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_TRANSPORT_PARAMETER_ERROR] = { .name = "quic_transp_err_transport_parameter_error",
.desc = "Total number of TRANSPORT_PARAMETER_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_CONNECTION_ID_LIMIT_ERROR] = { .name = "quic_transp_err_connection_id_limit",
.desc = "Total number of CONNECTION_ID_LIMIT_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_PROTOCOL_VIOLATION] = { .name = "quic_transp_err_protocol_violation_error",
.desc = "Total number of PROTOCOL_VIOLATION errors received" },
[QUIC_ST_TRANSP_ERR_INVALID_TOKEN] = { .name = "quic_transp_err_invalid_token",
.desc = "Total number of INVALID_TOKEN errors received" },
[QUIC_ST_TRANSP_ERR_APPLICATION_ERROR] = { .name = "quic_transp_err_application_error",
.desc = "Total number of APPLICATION_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_CRYPTO_BUFFER_EXCEEDED] = { .name = "quic_transp_err_crypto_buffer_exceeded",
.desc = "Total number of CRYPTO_BUFFER_EXCEEDED errors received" },
[QUIC_ST_TRANSP_ERR_KEY_UPDATE_ERROR] = { .name = "quic_transp_err_key_update_error",
.desc = "Total number of KEY_UPDATE_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_AEAD_LIMIT_REACHED] = { .name = "quic_transp_err_aead_limit_reached",
.desc = "Total number of AEAD_LIMIT_REACHED errors received" },
[QUIC_ST_TRANSP_ERR_NO_VIABLE_PATH] = { .name = "quic_transp_err_no_viable_path",
.desc = "Total number of NO_VIABLE_PATH errors received" },
[QUIC_ST_TRANSP_ERR_CRYPTO_ERROR] = { .name = "quic_transp_err_crypto_error",
.desc = "Total number of CRYPTO_ERROR errors received" },
[QUIC_ST_TRANSP_ERR_UNKNOWN_ERROR] = { .name = "quic_transp_err_unknown_error",
.desc = "Total number of UNKNOWN_ERROR errors received" },
/* Streams related counters */
[QUIC_ST_DATA_BLOCKED] = { .name = "quic_data_blocked",
.desc = "Total number of received DATA_BLOCKED frames" },
[QUIC_ST_STREAM_DATA_BLOCKED] = { .name = "quic_stream_data_blocked",
.desc = "Total number of received STREAM_DATA_BLOCKED frames" },
[QUIC_ST_STREAMS_BLOCKED_BIDI] = { .name = "quic_streams_blocked_bidi",
.desc = "Total number of received STREAMS_BLOCKED_BIDI frames" },
[QUIC_ST_STREAMS_BLOCKED_UNI] = { .name = "quic_streams_blocked_uni",
.desc = "Total number of received STREAMS_BLOCKED_UNI frames" },
};
struct quic_counters quic_counters;
static int quic_fill_stats(void *data, struct field *stats, unsigned int *selected_field)
{
struct quic_counters *counters = data;
unsigned int current_field = (selected_field != NULL ? *selected_field : 0);
for (; current_field < QUIC_STATS_COUNT; current_field++) {
struct field metric = { 0 };
switch (current_field) {
case QUIC_ST_RXBUF_FULL:
metric = mkf_u64(FN_COUNTER, counters->rxbuf_full);
break;
case QUIC_ST_DROPPED_PACKET:
metric = mkf_u64(FN_COUNTER, counters->dropped_pkt);
break;
case QUIC_ST_DROPPED_PACKET_BUFOVERRUN:
metric = mkf_u64(FN_COUNTER, counters->dropped_pkt_bufoverrun);
break;
case QUIC_ST_DROPPED_PARSING:
metric = mkf_u64(FN_COUNTER, counters->dropped_parsing);
break;
case QUIC_ST_SOCKET_FULL:
metric = mkf_u64(FN_COUNTER, counters->socket_full);
break;
case QUIC_ST_SENDTO_ERR:
metric = mkf_u64(FN_COUNTER, counters->sendto_err);
break;
case QUIC_ST_SENDTO_ERR_UNKNWN:
metric = mkf_u64(FN_COUNTER, counters->sendto_err_unknown);
break;
case QUIC_ST_SENT_PACKET:
metric = mkf_u64(FN_COUNTER, counters->sent_pkt);
break;
case QUIC_ST_LOST_PACKET:
metric = mkf_u64(FN_COUNTER, counters->lost_pkt);
break;
case QUIC_ST_TOO_SHORT_INITIAL_DGRAM:
metric = mkf_u64(FN_COUNTER, counters->too_short_initial_dgram);
break;
case QUIC_ST_RETRY_SENT:
metric = mkf_u64(FN_COUNTER, counters->retry_sent);
break;
case QUIC_ST_RETRY_VALIDATED:
metric = mkf_u64(FN_COUNTER, counters->retry_validated);
break;
case QUIC_ST_RETRY_ERRORS:
metric = mkf_u64(FN_COUNTER, counters->retry_error);
break;
case QUIC_ST_HALF_OPEN_CONN:
metric = mkf_u64(FN_GAUGE, counters->half_open_conn);
break;
case QUIC_ST_HDSHK_FAIL:
metric = mkf_u64(FN_COUNTER, counters->hdshk_fail);
break;
case QUIC_ST_STATELESS_RESET_SENT:
metric = mkf_u64(FN_COUNTER, counters->stateless_reset_sent);
break;
/* Special events of interest */
case QUIC_ST_CONN_MIGRATION_DONE:
metric = mkf_u64(FN_COUNTER, counters->conn_migration_done);
break;
/* Transport errors */
case QUIC_ST_TRANSP_ERR_NO_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_no_error);
break;
case QUIC_ST_TRANSP_ERR_INTERNAL_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_internal_error);
break;
case QUIC_ST_TRANSP_ERR_CONNECTION_REFUSED:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_connection_refused);
break;
case QUIC_ST_TRANSP_ERR_FLOW_CONTROL_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_flow_control_error);
break;
case QUIC_ST_TRANSP_ERR_STREAM_LIMIT_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_stream_limit_error);
break;
case QUIC_ST_TRANSP_ERR_STREAM_STATE_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_stream_state_error);
break;
case QUIC_ST_TRANSP_ERR_FINAL_SIZE_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_final_size_error);
break;
case QUIC_ST_TRANSP_ERR_FRAME_ENCODING_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_frame_encoding_error);
break;
case QUIC_ST_TRANSP_ERR_TRANSPORT_PARAMETER_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_transport_parameter_error);
break;
case QUIC_ST_TRANSP_ERR_CONNECTION_ID_LIMIT_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_connection_id_limit);
break;
case QUIC_ST_TRANSP_ERR_PROTOCOL_VIOLATION:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_protocol_violation);
break;
case QUIC_ST_TRANSP_ERR_INVALID_TOKEN:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_invalid_token);
break;
case QUIC_ST_TRANSP_ERR_APPLICATION_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_application_error);
break;
case QUIC_ST_TRANSP_ERR_CRYPTO_BUFFER_EXCEEDED:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_crypto_buffer_exceeded);
break;
case QUIC_ST_TRANSP_ERR_KEY_UPDATE_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_key_update_error);
break;
case QUIC_ST_TRANSP_ERR_AEAD_LIMIT_REACHED:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_aead_limit_reached);
break;
case QUIC_ST_TRANSP_ERR_NO_VIABLE_PATH:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_no_viable_path);
break;
case QUIC_ST_TRANSP_ERR_CRYPTO_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_crypto_error);
break;
case QUIC_ST_TRANSP_ERR_UNKNOWN_ERROR:
metric = mkf_u64(FN_COUNTER, counters->quic_transp_err_unknown_error);
break;
/* Streams related counters */
case QUIC_ST_DATA_BLOCKED:
metric = mkf_u64(FN_COUNTER, counters->data_blocked);
break;
case QUIC_ST_STREAM_DATA_BLOCKED:
metric = mkf_u64(FN_COUNTER, counters->stream_data_blocked);
break;
case QUIC_ST_STREAMS_BLOCKED_BIDI:
metric = mkf_u64(FN_COUNTER, counters->streams_blocked_bidi);
break;
case QUIC_ST_STREAMS_BLOCKED_UNI:
metric = mkf_u64(FN_COUNTER, counters->streams_blocked_uni);
break;
default:
/* not used for frontends. If a specific metric
* is requested, return an error. Otherwise continue.
*/
if (selected_field != NULL)
return 0;
continue;
}
stats[current_field] = metric;
if (selected_field != NULL)
break;
}
return 1;
}
struct stats_module quic_stats_module = {
.name = "quic",
.fill_stats = quic_fill_stats,
.stats = quic_stats,
.stats_count = QUIC_STATS_COUNT,
.counters = &quic_counters,
.counters_size = sizeof(quic_counters),
.domain_flags = MK_STATS_PROXY_DOMAIN(STATS_PX_CAP_FE),
.clearable = 1,
};
INITCALL1(STG_REGISTER, stats_register_module, &quic_stats_module);
void quic_stats_transp_err_count_inc(struct quic_counters *ctrs, int error_code)
{
switch (error_code) {
case QC_ERR_NO_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_no_error);
break;
case QC_ERR_INTERNAL_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_internal_error);
break;
case QC_ERR_CONNECTION_REFUSED:
HA_ATOMIC_INC(&ctrs->quic_transp_err_connection_refused);
break;
case QC_ERR_FLOW_CONTROL_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_flow_control_error);
break;
case QC_ERR_STREAM_LIMIT_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_stream_limit_error);
break;
case QC_ERR_STREAM_STATE_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_stream_state_error);
break;
case QC_ERR_FINAL_SIZE_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_final_size_error);
break;
case QC_ERR_FRAME_ENCODING_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_frame_encoding_error);
break;
case QC_ERR_TRANSPORT_PARAMETER_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_transport_parameter_error);
break;
case QC_ERR_CONNECTION_ID_LIMIT_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_connection_id_limit);
break;
case QC_ERR_PROTOCOL_VIOLATION:
HA_ATOMIC_INC(&ctrs->quic_transp_err_protocol_violation);
break;
case QC_ERR_INVALID_TOKEN:
HA_ATOMIC_INC(&ctrs->quic_transp_err_invalid_token);
break;
case QC_ERR_APPLICATION_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_application_error);
break;
case QC_ERR_CRYPTO_BUFFER_EXCEEDED:
HA_ATOMIC_INC(&ctrs->quic_transp_err_crypto_buffer_exceeded);
break;
case QC_ERR_KEY_UPDATE_ERROR:
HA_ATOMIC_INC(&ctrs->quic_transp_err_key_update_error);
break;
case QC_ERR_AEAD_LIMIT_REACHED:
HA_ATOMIC_INC(&ctrs->quic_transp_err_aead_limit_reached);
break;
case QC_ERR_NO_VIABLE_PATH:
HA_ATOMIC_INC(&ctrs->quic_transp_err_no_viable_path);
break;
default:
if (error_code >= 0x100 && error_code <= 0x1ff)
HA_ATOMIC_INC(&ctrs->quic_transp_err_crypto_error);
else
HA_ATOMIC_INC(&ctrs->quic_transp_err_unknown_error);
}
}
|
