MEDIUM: counters: return aggregate extra counters in ->fill_stats()

Now thanks to new macro EXTRA_COUNTERS_AGGR() we can iterate over all
thread groups storages when returning the data for a given metric. This
remains convenient and mostly transparent. The caller continues to pass
the pointer to the metric in the first group, and offsets are calculated
for all other groups and data summed. For now all groups except the
first one contain only zeroes but reported values are nevertheless
correct.

diff --git a/include/haproxy/counters.h b/include/haproxy/counters.h
index 26d2ebe5322aa8746bb9c096165ba29b85674cd4..1c4d7f1c94c4e19e49b87e786d089d30a3af8a11 100644 (file)
--- a/include/haproxy/counters.h
+++ b/include/haproxy/counters.h
@@ -174,4 +174,25 @@ void counters_be_shared_drop(struct be_counters_shared *counters);
                }                                                      \
        } while (0)
 
+/* aggregate all values of <metricp> over the thread groups handled by
+ * <counters>. <metricp> MUST correspond to an entry of the first tgrp of
+ * <counters>. The number of groups and the step are found in <counters>. The
+ * type of the return value is the same as <metricp>, and must be a scalar so
+ * that values are summed before being returned.
+ */
+#define EXTRA_COUNTERS_AGGR(counters, metricp)                         \
+       ({                                                             \
+               typeof(counters) _ctr = (counters);                    \
+               typeof(metricp) *valp, _ret = 0;                       \
+               if (_ctr) {                                            \
+                       size_t ofs = (char *)&metricp - _ctr->datap[0]; \
+                       uint tgrp;                                     \
+                       for (tgrp = 0; tgrp < _ctr->nbtgrp; tgrp++) {  \
+                               valp = (typeof(valp))(_ctr->datap[tgrp * (counters)->tgrp_step] + ofs); \
+                               _ret += HA_ATOMIC_LOAD(valp);          \
+                       }                                              \
+               }                                                      \
+               _ret;                                                  \
+       })
+
 #endif /* _HAPROXY_COUNTERS_H */

diff --git a/src/h3_stats.c b/src/h3_stats.c
index 16453f25dc46e144c6725f453bd2f611c18ca3d5..c35639bbd1adb141185ad1dfa2ee229cf1fa6c94 100644 (file)
--- a/src/h3_stats.c
+++ b/src/h3_stats.c
@@ -146,89 +146,89 @@ static int h3_fill_stats(struct stats_module *mod, struct extra_counters *ctr,
                switch (current_field) {
                /* h3 frame type counters */
                case H3_ST_DATA:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_data);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_data));
                        break;
                case H3_ST_HEADERS:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_headers);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_headers));
                        break;
                case H3_ST_CANCEL_PUSH:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_cancel_push);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_cancel_push));
                        break;
                case H3_ST_PUSH_PROMISE:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_push_promise);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_push_promise));
                        break;
                case H3_ST_MAX_PUSH_ID:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_max_push_id);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_max_push_id));
                        break;
                case H3_ST_GOAWAY:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_goaway);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_goaway));
                        break;
                case H3_ST_SETTINGS:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_settings);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_settings));
                        break;
 
                /* h3 error counters */
                case H3_ST_H3_NO_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_no_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_no_error));
                        break;
                case H3_ST_H3_GENERAL_PROTOCOL_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_general_protocol_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_general_protocol_error));
                        break;
                case H3_ST_H3_INTERNAL_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_internal_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_internal_error));
                        break;
                case H3_ST_H3_STREAM_CREATION_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_stream_creation_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_stream_creation_error));
                        break;
                case H3_ST_H3_CLOSED_CRITICAL_STREAM:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_closed_critical_stream);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_closed_critical_stream));
                        break;
                case H3_ST_H3_FRAME_UNEXPECTED:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_frame_unexpected);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_frame_unexpected));
                        break;
                case H3_ST_H3_FRAME_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_frame_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_frame_error));
                        break;
                case H3_ST_H3_EXCESSIVE_LOAD:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_excessive_load);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_excessive_load));
                        break;
                case H3_ST_H3_ID_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_id_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_id_error));
                        break;
                case H3_ST_H3_SETTINGS_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_settings_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_settings_error));
                        break;
                case H3_ST_H3_MISSING_SETTINGS:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_missing_settings);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_missing_settings));
                        break;
                case H3_ST_H3_REQUEST_REJECTED:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_request_rejected);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_request_rejected));
                        break;
                case H3_ST_H3_REQUEST_CANCELLED:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_request_cancelled);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_request_cancelled));
                        break;
                case H3_ST_H3_REQUEST_INCOMPLETE:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_request_incomplete);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_request_incomplete));
                        break;
                case H3_ST_H3_MESSAGE_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_message_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_message_error));
                        break;
                case H3_ST_H3_CONNECT_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_connect_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_connect_error));
                        break;
                case H3_ST_H3_VERSION_FALLBACK:
-                       metric = mkf_u64(FN_COUNTER, counters->h3_version_fallback);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->h3_version_fallback));
                        break;
 
                /* QPACK error counters */
                case H3_ST_QPACK_DECOMPRESSION_FAILED:
-                       metric = mkf_u64(FN_COUNTER, counters->qpack_decompression_failed);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->qpack_decompression_failed));
                        break;
                case H3_ST_QPACK_ENCODER_STREAM_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->qpack_encoder_stream_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->qpack_encoder_stream_error));
                        break;
                case H3_ST_QPACK_DECODER_STREAM_ERROR:
-                       metric = mkf_u64(FN_COUNTER, counters->qpack_decoder_stream_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->qpack_decoder_stream_error));
                        break;
                default:
                        /* not used for frontends. If a specific metric

diff --git a/src/mux_h1.c b/src/mux_h1.c
index 94a773c719181873a32492b10256e5e6d1928dc3..22b3daea7f9a55b0faa36245f2c1169152dd572c 100644 (file)
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -288,29 +288,29 @@ static int h1_fill_stats(struct stats_module *mod, struct extra_counters *ctr,
 
                switch (current_field) {
                case H1_ST_OPEN_CONN:
-                       metric = mkf_u64(FN_GAUGE,   counters->open_conns);
+                       metric = mkf_u64(FN_GAUGE,   EXTRA_COUNTERS_AGGR(ctr, counters->open_conns));
                        break;
                case H1_ST_OPEN_STREAM:
-                       metric = mkf_u64(FN_GAUGE,   counters->open_streams);
+                       metric = mkf_u64(FN_GAUGE,   EXTRA_COUNTERS_AGGR(ctr, counters->open_streams));
                        break;
                case H1_ST_TOTAL_CONN:
-                       metric = mkf_u64(FN_COUNTER, counters->total_conns);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->total_conns));
                        break;
                case H1_ST_TOTAL_STREAM:
-                       metric = mkf_u64(FN_COUNTER, counters->total_streams);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->total_streams));
                        break;
                case H1_ST_BYTES_IN:
-                       metric = mkf_u64(FN_COUNTER, counters->bytes_in);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->bytes_in));
                        break;
                case H1_ST_BYTES_OUT:
-                       metric = mkf_u64(FN_COUNTER, counters->bytes_out);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->bytes_out));
                        break;
 #if defined(USE_LINUX_SPLICE)
                case H1_ST_SPLICED_BYTES_IN:
-                       metric = mkf_u64(FN_COUNTER, counters->spliced_bytes_in);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->spliced_bytes_in));
                        break;
                case H1_ST_SPLICED_BYTES_OUT:
-                       metric = mkf_u64(FN_COUNTER, counters->spliced_bytes_out);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->spliced_bytes_out));
                        break;
 #endif
                default:

diff --git a/src/mux_h2.c b/src/mux_h2.c
index 21d6155283fd6c9477666e94241d5b1a08d60ab2..80abac3d855020f2cb80ba8c8ca70fb2bed1a99a 100644 (file)
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -387,43 +387,43 @@ static int h2_fill_stats(struct stats_module *mod, struct extra_counters *ctr,
 
                switch (current_field) {
                case H2_ST_HEADERS_RCVD:
-                       metric = mkf_u64(FN_COUNTER, counters->headers_rcvd);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->headers_rcvd));
                        break;
                case H2_ST_DATA_RCVD:
-                       metric = mkf_u64(FN_COUNTER, counters->data_rcvd);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->data_rcvd));
                        break;
                case H2_ST_SETTINGS_RCVD:
-                       metric = mkf_u64(FN_COUNTER, counters->settings_rcvd);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->settings_rcvd));
                        break;
                case H2_ST_RST_STREAM_RCVD:
-                       metric = mkf_u64(FN_COUNTER, counters->rst_stream_rcvd);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->rst_stream_rcvd));
                        break;
                case H2_ST_GOAWAY_RCVD:
-                       metric = mkf_u64(FN_COUNTER, counters->goaway_rcvd);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->goaway_rcvd));
                        break;
                case H2_ST_CONN_PROTO_ERR:
-                       metric = mkf_u64(FN_COUNTER, counters->conn_proto_err);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->conn_proto_err));
                        break;
                case H2_ST_STRM_PROTO_ERR:
-                       metric = mkf_u64(FN_COUNTER, counters->strm_proto_err);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->strm_proto_err));
                        break;
                case H2_ST_RST_STREAM_RESP:
-                       metric = mkf_u64(FN_COUNTER, counters->rst_stream_resp);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->rst_stream_resp));
                        break;
                case H2_ST_GOAWAY_RESP:
-                       metric = mkf_u64(FN_COUNTER, counters->goaway_resp);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->goaway_resp));
                        break;
                case H2_ST_OPEN_CONN:
-                       metric = mkf_u64(FN_GAUGE,   counters->open_conns);
+                       metric = mkf_u64(FN_GAUGE,   EXTRA_COUNTERS_AGGR(ctr, counters->open_conns));
                        break;
                case H2_ST_OPEN_STREAM:
-                       metric = mkf_u64(FN_GAUGE,   counters->open_streams);
+                       metric = mkf_u64(FN_GAUGE,   EXTRA_COUNTERS_AGGR(ctr, counters->open_streams));
                        break;
                case H2_ST_TOTAL_CONN:
-                       metric = mkf_u64(FN_COUNTER, counters->total_conns);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->total_conns));
                        break;
                case H2_ST_TOTAL_STREAM:
-                       metric = mkf_u64(FN_COUNTER, counters->total_streams);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->total_streams));
                        break;
                default:
                        /* not used for frontends. If a specific metric

diff --git a/src/quic_stats.c b/src/quic_stats.c
index 7e7e1aaee1d952051dc5adc256e0273d686a2c8f..7fade00534a9f90716d649e4b6e63334611dfc19 100644 (file)
--- a/src/quic_stats.c
+++ b/src/quic_stats.c
@@ -108,133 +108,133 @@ static int quic_fill_stats(struct stats_module *mod, struct extra_counters *ctr,
 
                switch (current_field) {
                case QUIC_ST_RXBUF_FULL:
-                       metric = mkf_u64(FN_COUNTER, counters->rxbuf_full);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->rxbuf_full));
                        break;
                case QUIC_ST_DROPPED_PACKET:
-                       metric = mkf_u64(FN_COUNTER, counters->dropped_pkt);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->dropped_pkt));
                        break;
                case QUIC_ST_DROPPED_PACKET_BUFOVERRUN:
-                       metric = mkf_u64(FN_COUNTER, counters->dropped_pkt_bufoverrun);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->dropped_pkt_bufoverrun));
                        break;
                case QUIC_ST_DROPPED_PARSING:
-                       metric = mkf_u64(FN_COUNTER, counters->dropped_parsing);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->dropped_parsing));
                        break;
                case QUIC_ST_SOCKET_FULL:
-                       metric = mkf_u64(FN_COUNTER, counters->socket_full);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->socket_full));
                        break;
                case QUIC_ST_SENDTO_ERR:
-                       metric = mkf_u64(FN_COUNTER, counters->sendto_err);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->sendto_err));
                        break;
                case QUIC_ST_SENDTO_ERR_UNKNWN:
-                       metric = mkf_u64(FN_COUNTER, counters->sendto_err_unknown);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->sendto_err_unknown));
                        break;
                case QUIC_ST_SENT_PACKET:
-                       metric = mkf_u64(FN_COUNTER, counters->sent_pkt);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->sent_pkt));
                        break;
                case QUIC_ST_LOST_PACKET:
-                       metric = mkf_u64(FN_COUNTER, counters->lost_pkt);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->lost_pkt));
                        break;
                case QUIC_ST_TOO_SHORT_INITIAL_DGRAM:
-                       metric = mkf_u64(FN_COUNTER, counters->too_short_initial_dgram);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->too_short_initial_dgram));
                        break;
                case QUIC_ST_RETRY_SENT:
-                       metric = mkf_u64(FN_COUNTER, counters->retry_sent);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->retry_sent));
                        break;
                case QUIC_ST_RETRY_VALIDATED:
-                       metric = mkf_u64(FN_COUNTER, counters->retry_validated);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->retry_validated));
                        break;
                case QUIC_ST_RETRY_ERRORS:
-                       metric = mkf_u64(FN_COUNTER, counters->retry_error);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->retry_error));
                        break;
                case QUIC_ST_HALF_OPEN_CONN:
-                       metric = mkf_u64(FN_GAUGE, counters->half_open_conn);
+                       metric = mkf_u64(FN_GAUGE, EXTRA_COUNTERS_AGGR(ctr, counters->half_open_conn));
                        break;
                case QUIC_ST_HDSHK_FAIL:
-                       metric = mkf_u64(FN_COUNTER, counters->hdshk_fail);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->hdshk_fail));
                        break;
                case QUIC_ST_STATELESS_RESET_SENT:
-                       metric = mkf_u64(FN_COUNTER, counters->stateless_reset_sent);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->stateless_reset_sent));
                        break;
 
                /* Special events of interest */
                case QUIC_ST_CONN_MIGRATION_DONE:
-                       metric = mkf_u64(FN_COUNTER, counters->conn_migration_done);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, 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);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->quic_transp_err_unknown_error));
                        break;
 
                /* Streams related counters */
                case QUIC_ST_DATA_BLOCKED:
-                       metric = mkf_u64(FN_COUNTER, counters->data_blocked);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->data_blocked));
                        break;
                case QUIC_ST_STREAM_DATA_BLOCKED:
-                       metric = mkf_u64(FN_COUNTER, counters->stream_data_blocked);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->stream_data_blocked));
                        break;
                case QUIC_ST_STREAMS_BLOCKED_BIDI:
-                       metric = mkf_u64(FN_COUNTER, counters->streams_blocked_bidi);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->streams_blocked_bidi));
                        break;
                case QUIC_ST_STREAMS_BLOCKED_UNI:
-                       metric = mkf_u64(FN_COUNTER, counters->streams_blocked_uni);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->streams_blocked_uni));
                        break;
                case QUIC_ST_NCBUF_GAP_LIMIT:
-                       metric = mkf_u64(FN_COUNTER, counters->ncbuf_gap_limit);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->ncbuf_gap_limit));
                        break;
                default:
                        /* not used for frontends. If a specific metric

diff --git a/src/ssl_sock.c b/src/ssl_sock.c
index 4fbfcb4dd052a02233d28c9e097ac5240e0dc111..483532bf349b9ea9556b846d3883f4b433969798 100644 (file)
--- a/src/ssl_sock.c
+++ b/src/ssl_sock.c
@@ -210,19 +210,19 @@ static int ssl_fill_stats(struct stats_module *mod, struct extra_counters *ctr,
 
                switch (current_field) {
                case SSL_ST_SESS:
-                       metric = mkf_u64(FN_COUNTER, counters->sess);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->sess));
                        break;
                case SSL_ST_REUSED_SESS:
-                       metric = mkf_u64(FN_COUNTER, counters->reused_sess);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->reused_sess));
                        break;
                case SSL_ST_FAILED_HANDSHAKE:
-                       metric = mkf_u64(FN_COUNTER, counters->failed_handshake);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->failed_handshake));
                        break;
                case SSL_ST_OCSP_STAPLE:
-                       metric = mkf_u64(FN_COUNTER, counters->ocsp_staple);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->ocsp_staple));
                        break;
                case SSL_ST_FAILED_OCSP_STAPLE:
-                       metric = mkf_u64(FN_COUNTER, counters->failed_ocsp_staple);
+                       metric = mkf_u64(FN_COUNTER, EXTRA_COUNTERS_AGGR(ctr, counters->failed_ocsp_staple));
                        break;
 
                default: