use crate::event::{
self, api,
metrics::aggregate::{
info::{self, Str},
AsVariant, BoolRecorder, Info, Metric, NominalRecorder, Recorder, Registry, Units,
},
};
use alloc::{boxed::Box, vec::Vec};
mod id {
#[allow(non_camel_case_types)]
#[allow(clippy::upper_case_acronyms)]
enum InfoId {
APPLICATION_PROTOCOL_INFORMATION,
SERVER_NAME_INFORMATION,
KEY_EXCHANGE_GROUP,
PACKET_SKIPPED,
PACKET_SENT,
PACKET_SENT__KIND,
PACKET_SENT__BYTES__TOTAL,
PACKET_SENT__BYTES,
PACKET_SENT__TRANSMISSION_MODE,
PACKET_RECEIVED,
PACKET_RECEIVED__KIND,
PACKET_RECEIVED__BYTES__TOTAL,
PACKET_RECEIVED__BYTES,
ACTIVE_PATH_UPDATED,
PATH_CREATED,
FRAME_SENT,
FRAME_SENT__PACKET,
FRAME_SENT__FRAME,
FRAME_RECEIVED,
FRAME_RECEIVED__PACKET,
FRAME_RECEIVED__FRAME,
CONNECTION_CLOSE_FRAME_RECEIVED,
CONNECTION_CLOSE_FRAME_RECEIVED__PACKET,
PACKET_LOST,
PACKET_LOST__KIND,
PACKET_LOST__BYTES__TOTAL,
PACKET_LOST__BYTES,
PACKET_LOST__IS_MTU_PROBE,
RECOVERY_METRICS,
RECOVERY_METRICS__MIN_RTT,
RECOVERY_METRICS__SMOOTHED_RTT,
RECOVERY_METRICS__LATEST_RTT,
RECOVERY_METRICS__RTT_VARIANCE,
RECOVERY_METRICS__MAX_ACK_DELAY,
RECOVERY_METRICS__PTO_COUNT,
RECOVERY_METRICS__CONGESTION_WINDOW,
RECOVERY_METRICS__BYTES_IN_FLIGHT,
RECOVERY_METRICS__CONGESTION_LIMITED,
CONGESTION,
CONGESTION__SOURCE,
RX_ACK_RANGE_DROPPED,
ACK_RANGE_RECEIVED,
ACK_RANGE_RECEIVED__PACKET,
ACK_RANGE_SENT,
ACK_RANGE_SENT__PACKET,
PACKET_DROPPED,
PACKET_DROPPED__REASON,
KEY_UPDATE,
KEY_UPDATE__KEY_TYPE,
KEY_UPDATE__CIPHER_SUITE,
KEY_SPACE_DISCARDED,
KEY_SPACE_DISCARDED__INITIAL__LATENCY,
KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY,
KEY_SPACE_DISCARDED__ONE_RTT__LATENCY,
KEY_SPACE_DISCARDED__SPACE,
CONNECTION_STARTED,
DUPLICATE_PACKET,
DUPLICATE_PACKET__KIND,
DUPLICATE_PACKET__ERROR,
TRANSPORT_PARAMETERS_RECEIVED,
TRANSPORT_PARAMETERS_RECEIVED__LATENCY,
DATAGRAM_SENT,
DATAGRAM_SENT__BYTES__TOTAL,
DATAGRAM_SENT__BYTES,
DATAGRAM_SENT__GSO_OFFSET,
DATAGRAM_RECEIVED,
DATAGRAM_RECEIVED__BYTES__TOTAL,
DATAGRAM_RECEIVED__BYTES,
DATAGRAM_DROPPED,
DATAGRAM_DROPPED__BYTES__TOTAL,
DATAGRAM_DROPPED__BYTES,
DATAGRAM_DROPPED__REASON,
HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED,
CONNECTION_ID_UPDATED,
ECN_STATE_CHANGED,
ECN_STATE_CHANGED__STATE,
CONNECTION_MIGRATION_DENIED,
CONNECTION_MIGRATION_DENIED__REASON,
HANDSHAKE_STATUS_UPDATED,
HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY,
HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY,
HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY,
HANDSHAKE_STATUS_UPDATED__STATUS,
TLS_EXPORTER_READY,
TLS_HANDSHAKE_FAILED,
PATH_CHALLENGE_UPDATED,
PATH_CHALLENGE_UPDATED__STATUS,
TLS_CLIENT_HELLO,
TLS_CLIENT_HELLO__LATENCY,
TLS_SERVER_HELLO,
TLS_SERVER_HELLO__LATENCY,
RX_STREAM_PROGRESS,
RX_STREAM_PROGRESS__BYTES__TOTAL,
RX_STREAM_PROGRESS__BYTES,
TX_STREAM_PROGRESS,
TX_STREAM_PROGRESS__BYTES__TOTAL,
TX_STREAM_PROGRESS__BYTES,
KEEP_ALIVE_TIMER_EXPIRED,
MTU_UPDATED,
MTU_UPDATED__MTU,
MTU_UPDATED__CAUSE,
MTU_UPDATED__SEARCH_COMPLETE,
MTU_PROBING_COMPLETE_RECEIVED,
MTU_PROBING_COMPLETE_RECEIVED__PACKET,
MTU_PROBING_COMPLETE_RECEIVED__MTU,
SLOW_START_EXITED,
SLOW_START_EXITED__CAUSE,
SLOW_START_EXITED__LATENCY,
SLOW_START_EXITED__CONGESTION_WINDOW,
DELIVERY_RATE_SAMPLED,
PACING_RATE_UPDATED,
PACING_RATE_UPDATED__BYTES_PER_SECOND,
PACING_RATE_UPDATED__BURST_SIZE,
PACING_RATE_UPDATED__PACING_GAIN,
BBR_STATE_CHANGED,
BBR_STATE_CHANGED__STATE,
DC_STATE_CHANGED,
DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY,
DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY,
DC_STATE_CHANGED__PATH_SECRETS__LATENCY,
DC_STATE_CHANGED__COMPLETE__LATENCY,
DC_STATE_CHANGED__STATE,
DC_PATH_CREATED,
CONNECTION_CLOSED,
CONNECTION_CLOSED__LATENCY,
CONNECTION_CLOSED__ERROR,
VERSION_INFORMATION,
ENDPOINT_PACKET_SENT,
ENDPOINT_PACKET_RECEIVED,
ENDPOINT_DATAGRAM_SENT,
ENDPOINT_DATAGRAM_SENT__BYTES,
ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL,
ENDPOINT_DATAGRAM_SENT__GSO_OFFSET,
ENDPOINT_DATAGRAM_RECEIVED,
ENDPOINT_DATAGRAM_RECEIVED__BYTES,
ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL,
ENDPOINT_DATAGRAM_DROPPED,
ENDPOINT_DATAGRAM_DROPPED__BYTES,
ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL,
ENDPOINT_DATAGRAM_DROPPED__REASON,
ENDPOINT_CONNECTION_ATTEMPT_FAILED,
ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR,
ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED,
PLATFORM_TX,
PLATFORM_TX__PACKETS__TOTAL,
PLATFORM_TX__PACKETS,
PLATFORM_TX__SYSCALLS__TOTAL,
PLATFORM_TX__SYSCALLS,
PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL,
PLATFORM_TX__SYSCALLS__BLOCKED,
PLATFORM_TX__ERRORS__TOTAL,
PLATFORM_TX__ERRORS,
PLATFORM_TX__ERRORS__DROPPED__TOTAL,
PLATFORM_TX__ERRORS__DROPPED,
PLATFORM_TX_ERROR,
PLATFORM_RX,
PLATFORM_RX__PACKETS__TOTAL,
PLATFORM_RX__PACKETS,
PLATFORM_RX__SYSCALLS__TOTAL,
PLATFORM_RX__SYSCALLS,
PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL,
PLATFORM_RX__SYSCALLS__BLOCKED,
PLATFORM_RX__ERRORS__TOTAL,
PLATFORM_RX__ERRORS,
PLATFORM_RX__ERRORS__DROPPED__TOTAL,
PLATFORM_RX__ERRORS__DROPPED,
PLATFORM_RX_ERROR,
PLATFORM_FEATURE_CONFIGURED,
PLATFORM_RX_SOCKET_STATS,
PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL,
PLATFORM_EVENT_LOOP_WAKEUP,
PLATFORM_EVENT_LOOP_SLEEP,
PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION,
PLATFORM_EVENT_LOOP_STARTED,
}
pub const APPLICATION_PROTOCOL_INFORMATION: usize =
InfoId::APPLICATION_PROTOCOL_INFORMATION as usize;
pub const SERVER_NAME_INFORMATION: usize = InfoId::SERVER_NAME_INFORMATION as usize;
pub const KEY_EXCHANGE_GROUP: usize = InfoId::KEY_EXCHANGE_GROUP as usize;
pub const PACKET_SKIPPED: usize = InfoId::PACKET_SKIPPED as usize;
pub const PACKET_SENT: usize = InfoId::PACKET_SENT as usize;
pub const PACKET_SENT__KIND: usize = InfoId::PACKET_SENT__KIND as usize;
pub const PACKET_SENT__BYTES__TOTAL: usize = InfoId::PACKET_SENT__BYTES__TOTAL as usize;
pub const PACKET_SENT__BYTES: usize = InfoId::PACKET_SENT__BYTES as usize;
pub const PACKET_SENT__TRANSMISSION_MODE: usize =
InfoId::PACKET_SENT__TRANSMISSION_MODE as usize;
pub const PACKET_RECEIVED: usize = InfoId::PACKET_RECEIVED as usize;
pub const PACKET_RECEIVED__KIND: usize = InfoId::PACKET_RECEIVED__KIND as usize;
pub const PACKET_RECEIVED__BYTES__TOTAL: usize = InfoId::PACKET_RECEIVED__BYTES__TOTAL as usize;
pub const PACKET_RECEIVED__BYTES: usize = InfoId::PACKET_RECEIVED__BYTES as usize;
pub const ACTIVE_PATH_UPDATED: usize = InfoId::ACTIVE_PATH_UPDATED as usize;
pub const PATH_CREATED: usize = InfoId::PATH_CREATED as usize;
pub const FRAME_SENT: usize = InfoId::FRAME_SENT as usize;
pub const FRAME_SENT__PACKET: usize = InfoId::FRAME_SENT__PACKET as usize;
pub const FRAME_SENT__FRAME: usize = InfoId::FRAME_SENT__FRAME as usize;
pub const FRAME_RECEIVED: usize = InfoId::FRAME_RECEIVED as usize;
pub const FRAME_RECEIVED__PACKET: usize = InfoId::FRAME_RECEIVED__PACKET as usize;
pub const FRAME_RECEIVED__FRAME: usize = InfoId::FRAME_RECEIVED__FRAME as usize;
pub const CONNECTION_CLOSE_FRAME_RECEIVED: usize =
InfoId::CONNECTION_CLOSE_FRAME_RECEIVED as usize;
pub const CONNECTION_CLOSE_FRAME_RECEIVED__PACKET: usize =
InfoId::CONNECTION_CLOSE_FRAME_RECEIVED__PACKET as usize;
pub const PACKET_LOST: usize = InfoId::PACKET_LOST as usize;
pub const PACKET_LOST__KIND: usize = InfoId::PACKET_LOST__KIND as usize;
pub const PACKET_LOST__BYTES__TOTAL: usize = InfoId::PACKET_LOST__BYTES__TOTAL as usize;
pub const PACKET_LOST__BYTES: usize = InfoId::PACKET_LOST__BYTES as usize;
pub const PACKET_LOST__IS_MTU_PROBE: usize = InfoId::PACKET_LOST__IS_MTU_PROBE as usize;
pub const RECOVERY_METRICS: usize = InfoId::RECOVERY_METRICS as usize;
pub const RECOVERY_METRICS__MIN_RTT: usize = InfoId::RECOVERY_METRICS__MIN_RTT as usize;
pub const RECOVERY_METRICS__SMOOTHED_RTT: usize =
InfoId::RECOVERY_METRICS__SMOOTHED_RTT as usize;
pub const RECOVERY_METRICS__LATEST_RTT: usize = InfoId::RECOVERY_METRICS__LATEST_RTT as usize;
pub const RECOVERY_METRICS__RTT_VARIANCE: usize =
InfoId::RECOVERY_METRICS__RTT_VARIANCE as usize;
pub const RECOVERY_METRICS__MAX_ACK_DELAY: usize =
InfoId::RECOVERY_METRICS__MAX_ACK_DELAY as usize;
pub const RECOVERY_METRICS__PTO_COUNT: usize = InfoId::RECOVERY_METRICS__PTO_COUNT as usize;
pub const RECOVERY_METRICS__CONGESTION_WINDOW: usize =
InfoId::RECOVERY_METRICS__CONGESTION_WINDOW as usize;
pub const RECOVERY_METRICS__BYTES_IN_FLIGHT: usize =
InfoId::RECOVERY_METRICS__BYTES_IN_FLIGHT as usize;
pub const RECOVERY_METRICS__CONGESTION_LIMITED: usize =
InfoId::RECOVERY_METRICS__CONGESTION_LIMITED as usize;
pub const CONGESTION: usize = InfoId::CONGESTION as usize;
pub const CONGESTION__SOURCE: usize = InfoId::CONGESTION__SOURCE as usize;
pub const RX_ACK_RANGE_DROPPED: usize = InfoId::RX_ACK_RANGE_DROPPED as usize;
pub const ACK_RANGE_RECEIVED: usize = InfoId::ACK_RANGE_RECEIVED as usize;
pub const ACK_RANGE_RECEIVED__PACKET: usize = InfoId::ACK_RANGE_RECEIVED__PACKET as usize;
pub const ACK_RANGE_SENT: usize = InfoId::ACK_RANGE_SENT as usize;
pub const ACK_RANGE_SENT__PACKET: usize = InfoId::ACK_RANGE_SENT__PACKET as usize;
pub const PACKET_DROPPED: usize = InfoId::PACKET_DROPPED as usize;
pub const PACKET_DROPPED__REASON: usize = InfoId::PACKET_DROPPED__REASON as usize;
pub const KEY_UPDATE: usize = InfoId::KEY_UPDATE as usize;
pub const KEY_UPDATE__KEY_TYPE: usize = InfoId::KEY_UPDATE__KEY_TYPE as usize;
pub const KEY_UPDATE__CIPHER_SUITE: usize = InfoId::KEY_UPDATE__CIPHER_SUITE as usize;
pub const KEY_SPACE_DISCARDED: usize = InfoId::KEY_SPACE_DISCARDED as usize;
pub const KEY_SPACE_DISCARDED__INITIAL__LATENCY: usize =
InfoId::KEY_SPACE_DISCARDED__INITIAL__LATENCY as usize;
pub const KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY: usize =
InfoId::KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY as usize;
pub const KEY_SPACE_DISCARDED__ONE_RTT__LATENCY: usize =
InfoId::KEY_SPACE_DISCARDED__ONE_RTT__LATENCY as usize;
pub const KEY_SPACE_DISCARDED__SPACE: usize = InfoId::KEY_SPACE_DISCARDED__SPACE as usize;
pub const CONNECTION_STARTED: usize = InfoId::CONNECTION_STARTED as usize;
pub const DUPLICATE_PACKET: usize = InfoId::DUPLICATE_PACKET as usize;
pub const DUPLICATE_PACKET__KIND: usize = InfoId::DUPLICATE_PACKET__KIND as usize;
pub const DUPLICATE_PACKET__ERROR: usize = InfoId::DUPLICATE_PACKET__ERROR as usize;
pub const TRANSPORT_PARAMETERS_RECEIVED: usize = InfoId::TRANSPORT_PARAMETERS_RECEIVED as usize;
pub const TRANSPORT_PARAMETERS_RECEIVED__LATENCY: usize =
InfoId::TRANSPORT_PARAMETERS_RECEIVED__LATENCY as usize;
pub const DATAGRAM_SENT: usize = InfoId::DATAGRAM_SENT as usize;
pub const DATAGRAM_SENT__BYTES__TOTAL: usize = InfoId::DATAGRAM_SENT__BYTES__TOTAL as usize;
pub const DATAGRAM_SENT__BYTES: usize = InfoId::DATAGRAM_SENT__BYTES as usize;
pub const DATAGRAM_SENT__GSO_OFFSET: usize = InfoId::DATAGRAM_SENT__GSO_OFFSET as usize;
pub const DATAGRAM_RECEIVED: usize = InfoId::DATAGRAM_RECEIVED as usize;
pub const DATAGRAM_RECEIVED__BYTES__TOTAL: usize =
InfoId::DATAGRAM_RECEIVED__BYTES__TOTAL as usize;
pub const DATAGRAM_RECEIVED__BYTES: usize = InfoId::DATAGRAM_RECEIVED__BYTES as usize;
pub const DATAGRAM_DROPPED: usize = InfoId::DATAGRAM_DROPPED as usize;
pub const DATAGRAM_DROPPED__BYTES__TOTAL: usize =
InfoId::DATAGRAM_DROPPED__BYTES__TOTAL as usize;
pub const DATAGRAM_DROPPED__BYTES: usize = InfoId::DATAGRAM_DROPPED__BYTES as usize;
pub const DATAGRAM_DROPPED__REASON: usize = InfoId::DATAGRAM_DROPPED__REASON as usize;
pub const HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED: usize =
InfoId::HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED as usize;
pub const CONNECTION_ID_UPDATED: usize = InfoId::CONNECTION_ID_UPDATED as usize;
pub const ECN_STATE_CHANGED: usize = InfoId::ECN_STATE_CHANGED as usize;
pub const ECN_STATE_CHANGED__STATE: usize = InfoId::ECN_STATE_CHANGED__STATE as usize;
pub const CONNECTION_MIGRATION_DENIED: usize = InfoId::CONNECTION_MIGRATION_DENIED as usize;
pub const CONNECTION_MIGRATION_DENIED__REASON: usize =
InfoId::CONNECTION_MIGRATION_DENIED__REASON as usize;
pub const HANDSHAKE_STATUS_UPDATED: usize = InfoId::HANDSHAKE_STATUS_UPDATED as usize;
pub const HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY: usize =
InfoId::HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY as usize;
pub const HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY: usize =
InfoId::HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY as usize;
pub const HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY: usize =
InfoId::HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY as usize;
pub const HANDSHAKE_STATUS_UPDATED__STATUS: usize =
InfoId::HANDSHAKE_STATUS_UPDATED__STATUS as usize;
pub const TLS_EXPORTER_READY: usize = InfoId::TLS_EXPORTER_READY as usize;
pub const TLS_HANDSHAKE_FAILED: usize = InfoId::TLS_HANDSHAKE_FAILED as usize;
pub const PATH_CHALLENGE_UPDATED: usize = InfoId::PATH_CHALLENGE_UPDATED as usize;
pub const PATH_CHALLENGE_UPDATED__STATUS: usize =
InfoId::PATH_CHALLENGE_UPDATED__STATUS as usize;
pub const TLS_CLIENT_HELLO: usize = InfoId::TLS_CLIENT_HELLO as usize;
pub const TLS_CLIENT_HELLO__LATENCY: usize = InfoId::TLS_CLIENT_HELLO__LATENCY as usize;
pub const TLS_SERVER_HELLO: usize = InfoId::TLS_SERVER_HELLO as usize;
pub const TLS_SERVER_HELLO__LATENCY: usize = InfoId::TLS_SERVER_HELLO__LATENCY as usize;
pub const RX_STREAM_PROGRESS: usize = InfoId::RX_STREAM_PROGRESS as usize;
pub const RX_STREAM_PROGRESS__BYTES__TOTAL: usize =
InfoId::RX_STREAM_PROGRESS__BYTES__TOTAL as usize;
pub const RX_STREAM_PROGRESS__BYTES: usize = InfoId::RX_STREAM_PROGRESS__BYTES as usize;
pub const TX_STREAM_PROGRESS: usize = InfoId::TX_STREAM_PROGRESS as usize;
pub const TX_STREAM_PROGRESS__BYTES__TOTAL: usize =
InfoId::TX_STREAM_PROGRESS__BYTES__TOTAL as usize;
pub const TX_STREAM_PROGRESS__BYTES: usize = InfoId::TX_STREAM_PROGRESS__BYTES as usize;
pub const KEEP_ALIVE_TIMER_EXPIRED: usize = InfoId::KEEP_ALIVE_TIMER_EXPIRED as usize;
pub const MTU_UPDATED: usize = InfoId::MTU_UPDATED as usize;
pub const MTU_UPDATED__MTU: usize = InfoId::MTU_UPDATED__MTU as usize;
pub const MTU_UPDATED__CAUSE: usize = InfoId::MTU_UPDATED__CAUSE as usize;
pub const MTU_UPDATED__SEARCH_COMPLETE: usize = InfoId::MTU_UPDATED__SEARCH_COMPLETE as usize;
pub const MTU_PROBING_COMPLETE_RECEIVED: usize = InfoId::MTU_PROBING_COMPLETE_RECEIVED as usize;
pub const MTU_PROBING_COMPLETE_RECEIVED__PACKET: usize =
InfoId::MTU_PROBING_COMPLETE_RECEIVED__PACKET as usize;
pub const MTU_PROBING_COMPLETE_RECEIVED__MTU: usize =
InfoId::MTU_PROBING_COMPLETE_RECEIVED__MTU as usize;
pub const SLOW_START_EXITED: usize = InfoId::SLOW_START_EXITED as usize;
pub const SLOW_START_EXITED__CAUSE: usize = InfoId::SLOW_START_EXITED__CAUSE as usize;
pub const SLOW_START_EXITED__LATENCY: usize = InfoId::SLOW_START_EXITED__LATENCY as usize;
pub const SLOW_START_EXITED__CONGESTION_WINDOW: usize =
InfoId::SLOW_START_EXITED__CONGESTION_WINDOW as usize;
pub const DELIVERY_RATE_SAMPLED: usize = InfoId::DELIVERY_RATE_SAMPLED as usize;
pub const PACING_RATE_UPDATED: usize = InfoId::PACING_RATE_UPDATED as usize;
pub const PACING_RATE_UPDATED__BYTES_PER_SECOND: usize =
InfoId::PACING_RATE_UPDATED__BYTES_PER_SECOND as usize;
pub const PACING_RATE_UPDATED__BURST_SIZE: usize =
InfoId::PACING_RATE_UPDATED__BURST_SIZE as usize;
pub const PACING_RATE_UPDATED__PACING_GAIN: usize =
InfoId::PACING_RATE_UPDATED__PACING_GAIN as usize;
pub const BBR_STATE_CHANGED: usize = InfoId::BBR_STATE_CHANGED as usize;
pub const BBR_STATE_CHANGED__STATE: usize = InfoId::BBR_STATE_CHANGED__STATE as usize;
pub const DC_STATE_CHANGED: usize = InfoId::DC_STATE_CHANGED as usize;
pub const DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY: usize =
InfoId::DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY as usize;
pub const DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY: usize =
InfoId::DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY as usize;
pub const DC_STATE_CHANGED__PATH_SECRETS__LATENCY: usize =
InfoId::DC_STATE_CHANGED__PATH_SECRETS__LATENCY as usize;
pub const DC_STATE_CHANGED__COMPLETE__LATENCY: usize =
InfoId::DC_STATE_CHANGED__COMPLETE__LATENCY as usize;
pub const DC_STATE_CHANGED__STATE: usize = InfoId::DC_STATE_CHANGED__STATE as usize;
pub const DC_PATH_CREATED: usize = InfoId::DC_PATH_CREATED as usize;
pub const CONNECTION_CLOSED: usize = InfoId::CONNECTION_CLOSED as usize;
pub const CONNECTION_CLOSED__LATENCY: usize = InfoId::CONNECTION_CLOSED__LATENCY as usize;
pub const CONNECTION_CLOSED__ERROR: usize = InfoId::CONNECTION_CLOSED__ERROR as usize;
pub const VERSION_INFORMATION: usize = InfoId::VERSION_INFORMATION as usize;
pub const ENDPOINT_PACKET_SENT: usize = InfoId::ENDPOINT_PACKET_SENT as usize;
pub const ENDPOINT_PACKET_RECEIVED: usize = InfoId::ENDPOINT_PACKET_RECEIVED as usize;
pub const ENDPOINT_DATAGRAM_SENT: usize = InfoId::ENDPOINT_DATAGRAM_SENT as usize;
pub const ENDPOINT_DATAGRAM_SENT__BYTES: usize = InfoId::ENDPOINT_DATAGRAM_SENT__BYTES as usize;
pub const ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL: usize =
InfoId::ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL as usize;
pub const ENDPOINT_DATAGRAM_SENT__GSO_OFFSET: usize =
InfoId::ENDPOINT_DATAGRAM_SENT__GSO_OFFSET as usize;
pub const ENDPOINT_DATAGRAM_RECEIVED: usize = InfoId::ENDPOINT_DATAGRAM_RECEIVED as usize;
pub const ENDPOINT_DATAGRAM_RECEIVED__BYTES: usize =
InfoId::ENDPOINT_DATAGRAM_RECEIVED__BYTES as usize;
pub const ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL: usize =
InfoId::ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL as usize;
pub const ENDPOINT_DATAGRAM_DROPPED: usize = InfoId::ENDPOINT_DATAGRAM_DROPPED as usize;
pub const ENDPOINT_DATAGRAM_DROPPED__BYTES: usize =
InfoId::ENDPOINT_DATAGRAM_DROPPED__BYTES as usize;
pub const ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL: usize =
InfoId::ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL as usize;
pub const ENDPOINT_DATAGRAM_DROPPED__REASON: usize =
InfoId::ENDPOINT_DATAGRAM_DROPPED__REASON as usize;
pub const ENDPOINT_CONNECTION_ATTEMPT_FAILED: usize =
InfoId::ENDPOINT_CONNECTION_ATTEMPT_FAILED as usize;
pub const ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR: usize =
InfoId::ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR as usize;
pub const ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED: usize =
InfoId::ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED as usize;
pub const PLATFORM_TX: usize = InfoId::PLATFORM_TX as usize;
pub const PLATFORM_TX__PACKETS__TOTAL: usize = InfoId::PLATFORM_TX__PACKETS__TOTAL as usize;
pub const PLATFORM_TX__PACKETS: usize = InfoId::PLATFORM_TX__PACKETS as usize;
pub const PLATFORM_TX__SYSCALLS__TOTAL: usize = InfoId::PLATFORM_TX__SYSCALLS__TOTAL as usize;
pub const PLATFORM_TX__SYSCALLS: usize = InfoId::PLATFORM_TX__SYSCALLS as usize;
pub const PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL: usize =
InfoId::PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL as usize;
pub const PLATFORM_TX__SYSCALLS__BLOCKED: usize =
InfoId::PLATFORM_TX__SYSCALLS__BLOCKED as usize;
pub const PLATFORM_TX__ERRORS__TOTAL: usize = InfoId::PLATFORM_TX__ERRORS__TOTAL as usize;
pub const PLATFORM_TX__ERRORS: usize = InfoId::PLATFORM_TX__ERRORS as usize;
pub const PLATFORM_TX__ERRORS__DROPPED__TOTAL: usize =
InfoId::PLATFORM_TX__ERRORS__DROPPED__TOTAL as usize;
pub const PLATFORM_TX__ERRORS__DROPPED: usize = InfoId::PLATFORM_TX__ERRORS__DROPPED as usize;
pub const PLATFORM_TX_ERROR: usize = InfoId::PLATFORM_TX_ERROR as usize;
pub const PLATFORM_RX: usize = InfoId::PLATFORM_RX as usize;
pub const PLATFORM_RX__PACKETS__TOTAL: usize = InfoId::PLATFORM_RX__PACKETS__TOTAL as usize;
pub const PLATFORM_RX__PACKETS: usize = InfoId::PLATFORM_RX__PACKETS as usize;
pub const PLATFORM_RX__SYSCALLS__TOTAL: usize = InfoId::PLATFORM_RX__SYSCALLS__TOTAL as usize;
pub const PLATFORM_RX__SYSCALLS: usize = InfoId::PLATFORM_RX__SYSCALLS as usize;
pub const PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL: usize =
InfoId::PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL as usize;
pub const PLATFORM_RX__SYSCALLS__BLOCKED: usize =
InfoId::PLATFORM_RX__SYSCALLS__BLOCKED as usize;
pub const PLATFORM_RX__ERRORS__TOTAL: usize = InfoId::PLATFORM_RX__ERRORS__TOTAL as usize;
pub const PLATFORM_RX__ERRORS: usize = InfoId::PLATFORM_RX__ERRORS as usize;
pub const PLATFORM_RX__ERRORS__DROPPED__TOTAL: usize =
InfoId::PLATFORM_RX__ERRORS__DROPPED__TOTAL as usize;
pub const PLATFORM_RX__ERRORS__DROPPED: usize = InfoId::PLATFORM_RX__ERRORS__DROPPED as usize;
pub const PLATFORM_RX_ERROR: usize = InfoId::PLATFORM_RX_ERROR as usize;
pub const PLATFORM_FEATURE_CONFIGURED: usize = InfoId::PLATFORM_FEATURE_CONFIGURED as usize;
pub const PLATFORM_RX_SOCKET_STATS: usize = InfoId::PLATFORM_RX_SOCKET_STATS as usize;
pub const PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL: usize =
InfoId::PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL as usize;
pub const PLATFORM_EVENT_LOOP_WAKEUP: usize = InfoId::PLATFORM_EVENT_LOOP_WAKEUP as usize;
pub const PLATFORM_EVENT_LOOP_SLEEP: usize = InfoId::PLATFORM_EVENT_LOOP_SLEEP as usize;
pub const PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION: usize =
InfoId::PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION as usize;
pub const PLATFORM_EVENT_LOOP_STARTED: usize = InfoId::PLATFORM_EVENT_LOOP_STARTED as usize;
#[allow(non_camel_case_types)]
#[allow(clippy::upper_case_acronyms)]
enum Counters {
COUNTERS_APPLICATION_PROTOCOL_INFORMATION,
COUNTERS_SERVER_NAME_INFORMATION,
COUNTERS_KEY_EXCHANGE_GROUP,
COUNTERS_PACKET_SKIPPED,
COUNTERS_PACKET_SENT,
COUNTERS_PACKET_SENT__BYTES__TOTAL,
COUNTERS_PACKET_RECEIVED,
COUNTERS_PACKET_RECEIVED__BYTES__TOTAL,
COUNTERS_ACTIVE_PATH_UPDATED,
COUNTERS_PATH_CREATED,
COUNTERS_FRAME_SENT,
COUNTERS_FRAME_RECEIVED,
COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED,
COUNTERS_PACKET_LOST,
COUNTERS_PACKET_LOST__BYTES__TOTAL,
COUNTERS_RECOVERY_METRICS,
COUNTERS_CONGESTION,
COUNTERS_RX_ACK_RANGE_DROPPED,
COUNTERS_ACK_RANGE_RECEIVED,
COUNTERS_ACK_RANGE_SENT,
COUNTERS_PACKET_DROPPED,
COUNTERS_KEY_UPDATE,
COUNTERS_KEY_SPACE_DISCARDED,
COUNTERS_CONNECTION_STARTED,
COUNTERS_DUPLICATE_PACKET,
COUNTERS_TRANSPORT_PARAMETERS_RECEIVED,
COUNTERS_DATAGRAM_SENT,
COUNTERS_DATAGRAM_SENT__BYTES__TOTAL,
COUNTERS_DATAGRAM_RECEIVED,
COUNTERS_DATAGRAM_RECEIVED__BYTES__TOTAL,
COUNTERS_DATAGRAM_DROPPED,
COUNTERS_DATAGRAM_DROPPED__BYTES__TOTAL,
COUNTERS_HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED,
COUNTERS_CONNECTION_ID_UPDATED,
COUNTERS_ECN_STATE_CHANGED,
COUNTERS_CONNECTION_MIGRATION_DENIED,
COUNTERS_HANDSHAKE_STATUS_UPDATED,
COUNTERS_TLS_EXPORTER_READY,
COUNTERS_TLS_HANDSHAKE_FAILED,
COUNTERS_PATH_CHALLENGE_UPDATED,
COUNTERS_TLS_CLIENT_HELLO,
COUNTERS_TLS_SERVER_HELLO,
COUNTERS_RX_STREAM_PROGRESS,
COUNTERS_RX_STREAM_PROGRESS__BYTES__TOTAL,
COUNTERS_TX_STREAM_PROGRESS,
COUNTERS_TX_STREAM_PROGRESS__BYTES__TOTAL,
COUNTERS_KEEP_ALIVE_TIMER_EXPIRED,
COUNTERS_MTU_UPDATED,
COUNTERS_MTU_PROBING_COMPLETE_RECEIVED,
COUNTERS_SLOW_START_EXITED,
COUNTERS_DELIVERY_RATE_SAMPLED,
COUNTERS_PACING_RATE_UPDATED,
COUNTERS_BBR_STATE_CHANGED,
COUNTERS_DC_STATE_CHANGED,
COUNTERS_DC_PATH_CREATED,
COUNTERS_CONNECTION_CLOSED,
COUNTERS_VERSION_INFORMATION,
COUNTERS_ENDPOINT_PACKET_SENT,
COUNTERS_ENDPOINT_PACKET_RECEIVED,
COUNTERS_ENDPOINT_DATAGRAM_SENT,
COUNTERS_ENDPOINT_DATAGRAM_RECEIVED,
COUNTERS_ENDPOINT_DATAGRAM_DROPPED,
COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED,
COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED,
COUNTERS_PLATFORM_TX,
COUNTERS_PLATFORM_TX__PACKETS__TOTAL,
COUNTERS_PLATFORM_TX__SYSCALLS__TOTAL,
COUNTERS_PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL,
COUNTERS_PLATFORM_TX__ERRORS__TOTAL,
COUNTERS_PLATFORM_TX__ERRORS__DROPPED__TOTAL,
COUNTERS_PLATFORM_TX_ERROR,
COUNTERS_PLATFORM_RX,
COUNTERS_PLATFORM_RX__PACKETS__TOTAL,
COUNTERS_PLATFORM_RX__SYSCALLS__TOTAL,
COUNTERS_PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL,
COUNTERS_PLATFORM_RX__ERRORS__TOTAL,
COUNTERS_PLATFORM_RX__ERRORS__DROPPED__TOTAL,
COUNTERS_PLATFORM_RX_ERROR,
COUNTERS_PLATFORM_FEATURE_CONFIGURED,
COUNTERS_PLATFORM_RX_SOCKET_STATS,
COUNTERS_PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL,
COUNTERS_PLATFORM_EVENT_LOOP_WAKEUP,
COUNTERS_PLATFORM_EVENT_LOOP_SLEEP,
COUNTERS_PLATFORM_EVENT_LOOP_STARTED,
}
pub const COUNTERS_APPLICATION_PROTOCOL_INFORMATION: usize =
Counters::COUNTERS_APPLICATION_PROTOCOL_INFORMATION as usize;
pub const COUNTERS_SERVER_NAME_INFORMATION: usize =
Counters::COUNTERS_SERVER_NAME_INFORMATION as usize;
pub const COUNTERS_KEY_EXCHANGE_GROUP: usize = Counters::COUNTERS_KEY_EXCHANGE_GROUP as usize;
pub const COUNTERS_PACKET_SKIPPED: usize = Counters::COUNTERS_PACKET_SKIPPED as usize;
pub const COUNTERS_PACKET_SENT: usize = Counters::COUNTERS_PACKET_SENT as usize;
pub const COUNTERS_PACKET_SENT__BYTES__TOTAL: usize =
Counters::COUNTERS_PACKET_SENT__BYTES__TOTAL as usize;
pub const COUNTERS_PACKET_RECEIVED: usize = Counters::COUNTERS_PACKET_RECEIVED as usize;
pub const COUNTERS_PACKET_RECEIVED__BYTES__TOTAL: usize =
Counters::COUNTERS_PACKET_RECEIVED__BYTES__TOTAL as usize;
pub const COUNTERS_ACTIVE_PATH_UPDATED: usize = Counters::COUNTERS_ACTIVE_PATH_UPDATED as usize;
pub const COUNTERS_PATH_CREATED: usize = Counters::COUNTERS_PATH_CREATED as usize;
pub const COUNTERS_FRAME_SENT: usize = Counters::COUNTERS_FRAME_SENT as usize;
pub const COUNTERS_FRAME_RECEIVED: usize = Counters::COUNTERS_FRAME_RECEIVED as usize;
pub const COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED: usize =
Counters::COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED as usize;
pub const COUNTERS_PACKET_LOST: usize = Counters::COUNTERS_PACKET_LOST as usize;
pub const COUNTERS_PACKET_LOST__BYTES__TOTAL: usize =
Counters::COUNTERS_PACKET_LOST__BYTES__TOTAL as usize;
pub const COUNTERS_RECOVERY_METRICS: usize = Counters::COUNTERS_RECOVERY_METRICS as usize;
pub const COUNTERS_CONGESTION: usize = Counters::COUNTERS_CONGESTION as usize;
pub const COUNTERS_RX_ACK_RANGE_DROPPED: usize =
Counters::COUNTERS_RX_ACK_RANGE_DROPPED as usize;
pub const COUNTERS_ACK_RANGE_RECEIVED: usize = Counters::COUNTERS_ACK_RANGE_RECEIVED as usize;
pub const COUNTERS_ACK_RANGE_SENT: usize = Counters::COUNTERS_ACK_RANGE_SENT as usize;
pub const COUNTERS_PACKET_DROPPED: usize = Counters::COUNTERS_PACKET_DROPPED as usize;
pub const COUNTERS_KEY_UPDATE: usize = Counters::COUNTERS_KEY_UPDATE as usize;
pub const COUNTERS_KEY_SPACE_DISCARDED: usize = Counters::COUNTERS_KEY_SPACE_DISCARDED as usize;
pub const COUNTERS_CONNECTION_STARTED: usize = Counters::COUNTERS_CONNECTION_STARTED as usize;
pub const COUNTERS_DUPLICATE_PACKET: usize = Counters::COUNTERS_DUPLICATE_PACKET as usize;
pub const COUNTERS_TRANSPORT_PARAMETERS_RECEIVED: usize =
Counters::COUNTERS_TRANSPORT_PARAMETERS_RECEIVED as usize;
pub const COUNTERS_DATAGRAM_SENT: usize = Counters::COUNTERS_DATAGRAM_SENT as usize;
pub const COUNTERS_DATAGRAM_SENT__BYTES__TOTAL: usize =
Counters::COUNTERS_DATAGRAM_SENT__BYTES__TOTAL as usize;
pub const COUNTERS_DATAGRAM_RECEIVED: usize = Counters::COUNTERS_DATAGRAM_RECEIVED as usize;
pub const COUNTERS_DATAGRAM_RECEIVED__BYTES__TOTAL: usize =
Counters::COUNTERS_DATAGRAM_RECEIVED__BYTES__TOTAL as usize;
pub const COUNTERS_DATAGRAM_DROPPED: usize = Counters::COUNTERS_DATAGRAM_DROPPED as usize;
pub const COUNTERS_DATAGRAM_DROPPED__BYTES__TOTAL: usize =
Counters::COUNTERS_DATAGRAM_DROPPED__BYTES__TOTAL as usize;
pub const COUNTERS_HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED: usize =
Counters::COUNTERS_HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED as usize;
pub const COUNTERS_CONNECTION_ID_UPDATED: usize =
Counters::COUNTERS_CONNECTION_ID_UPDATED as usize;
pub const COUNTERS_ECN_STATE_CHANGED: usize = Counters::COUNTERS_ECN_STATE_CHANGED as usize;
pub const COUNTERS_CONNECTION_MIGRATION_DENIED: usize =
Counters::COUNTERS_CONNECTION_MIGRATION_DENIED as usize;
pub const COUNTERS_HANDSHAKE_STATUS_UPDATED: usize =
Counters::COUNTERS_HANDSHAKE_STATUS_UPDATED as usize;
pub const COUNTERS_TLS_EXPORTER_READY: usize = Counters::COUNTERS_TLS_EXPORTER_READY as usize;
pub const COUNTERS_TLS_HANDSHAKE_FAILED: usize =
Counters::COUNTERS_TLS_HANDSHAKE_FAILED as usize;
pub const COUNTERS_PATH_CHALLENGE_UPDATED: usize =
Counters::COUNTERS_PATH_CHALLENGE_UPDATED as usize;
pub const COUNTERS_TLS_CLIENT_HELLO: usize = Counters::COUNTERS_TLS_CLIENT_HELLO as usize;
pub const COUNTERS_TLS_SERVER_HELLO: usize = Counters::COUNTERS_TLS_SERVER_HELLO as usize;
pub const COUNTERS_RX_STREAM_PROGRESS: usize = Counters::COUNTERS_RX_STREAM_PROGRESS as usize;
pub const COUNTERS_RX_STREAM_PROGRESS__BYTES__TOTAL: usize =
Counters::COUNTERS_RX_STREAM_PROGRESS__BYTES__TOTAL as usize;
pub const COUNTERS_TX_STREAM_PROGRESS: usize = Counters::COUNTERS_TX_STREAM_PROGRESS as usize;
pub const COUNTERS_TX_STREAM_PROGRESS__BYTES__TOTAL: usize =
Counters::COUNTERS_TX_STREAM_PROGRESS__BYTES__TOTAL as usize;
pub const COUNTERS_KEEP_ALIVE_TIMER_EXPIRED: usize =
Counters::COUNTERS_KEEP_ALIVE_TIMER_EXPIRED as usize;
pub const COUNTERS_MTU_UPDATED: usize = Counters::COUNTERS_MTU_UPDATED as usize;
pub const COUNTERS_MTU_PROBING_COMPLETE_RECEIVED: usize =
Counters::COUNTERS_MTU_PROBING_COMPLETE_RECEIVED as usize;
pub const COUNTERS_SLOW_START_EXITED: usize = Counters::COUNTERS_SLOW_START_EXITED as usize;
pub const COUNTERS_DELIVERY_RATE_SAMPLED: usize =
Counters::COUNTERS_DELIVERY_RATE_SAMPLED as usize;
pub const COUNTERS_PACING_RATE_UPDATED: usize = Counters::COUNTERS_PACING_RATE_UPDATED as usize;
pub const COUNTERS_BBR_STATE_CHANGED: usize = Counters::COUNTERS_BBR_STATE_CHANGED as usize;
pub const COUNTERS_DC_STATE_CHANGED: usize = Counters::COUNTERS_DC_STATE_CHANGED as usize;
pub const COUNTERS_DC_PATH_CREATED: usize = Counters::COUNTERS_DC_PATH_CREATED as usize;
pub const COUNTERS_CONNECTION_CLOSED: usize = Counters::COUNTERS_CONNECTION_CLOSED as usize;
pub const COUNTERS_VERSION_INFORMATION: usize = Counters::COUNTERS_VERSION_INFORMATION as usize;
pub const COUNTERS_ENDPOINT_PACKET_SENT: usize =
Counters::COUNTERS_ENDPOINT_PACKET_SENT as usize;
pub const COUNTERS_ENDPOINT_PACKET_RECEIVED: usize =
Counters::COUNTERS_ENDPOINT_PACKET_RECEIVED as usize;
pub const COUNTERS_ENDPOINT_DATAGRAM_SENT: usize =
Counters::COUNTERS_ENDPOINT_DATAGRAM_SENT as usize;
pub const COUNTERS_ENDPOINT_DATAGRAM_RECEIVED: usize =
Counters::COUNTERS_ENDPOINT_DATAGRAM_RECEIVED as usize;
pub const COUNTERS_ENDPOINT_DATAGRAM_DROPPED: usize =
Counters::COUNTERS_ENDPOINT_DATAGRAM_DROPPED as usize;
pub const COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED: usize =
Counters::COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED as usize;
pub const COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED: usize =
Counters::COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED as usize;
pub const COUNTERS_PLATFORM_TX: usize = Counters::COUNTERS_PLATFORM_TX as usize;
pub const COUNTERS_PLATFORM_TX__PACKETS__TOTAL: usize =
Counters::COUNTERS_PLATFORM_TX__PACKETS__TOTAL as usize;
pub const COUNTERS_PLATFORM_TX__SYSCALLS__TOTAL: usize =
Counters::COUNTERS_PLATFORM_TX__SYSCALLS__TOTAL as usize;
pub const COUNTERS_PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL: usize =
Counters::COUNTERS_PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL as usize;
pub const COUNTERS_PLATFORM_TX__ERRORS__TOTAL: usize =
Counters::COUNTERS_PLATFORM_TX__ERRORS__TOTAL as usize;
pub const COUNTERS_PLATFORM_TX__ERRORS__DROPPED__TOTAL: usize =
Counters::COUNTERS_PLATFORM_TX__ERRORS__DROPPED__TOTAL as usize;
pub const COUNTERS_PLATFORM_TX_ERROR: usize = Counters::COUNTERS_PLATFORM_TX_ERROR as usize;
pub const COUNTERS_PLATFORM_RX: usize = Counters::COUNTERS_PLATFORM_RX as usize;
pub const COUNTERS_PLATFORM_RX__PACKETS__TOTAL: usize =
Counters::COUNTERS_PLATFORM_RX__PACKETS__TOTAL as usize;
pub const COUNTERS_PLATFORM_RX__SYSCALLS__TOTAL: usize =
Counters::COUNTERS_PLATFORM_RX__SYSCALLS__TOTAL as usize;
pub const COUNTERS_PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL: usize =
Counters::COUNTERS_PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL as usize;
pub const COUNTERS_PLATFORM_RX__ERRORS__TOTAL: usize =
Counters::COUNTERS_PLATFORM_RX__ERRORS__TOTAL as usize;
pub const COUNTERS_PLATFORM_RX__ERRORS__DROPPED__TOTAL: usize =
Counters::COUNTERS_PLATFORM_RX__ERRORS__DROPPED__TOTAL as usize;
pub const COUNTERS_PLATFORM_RX_ERROR: usize = Counters::COUNTERS_PLATFORM_RX_ERROR as usize;
pub const COUNTERS_PLATFORM_FEATURE_CONFIGURED: usize =
Counters::COUNTERS_PLATFORM_FEATURE_CONFIGURED as usize;
pub const COUNTERS_PLATFORM_RX_SOCKET_STATS: usize =
Counters::COUNTERS_PLATFORM_RX_SOCKET_STATS as usize;
pub const COUNTERS_PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL: usize =
Counters::COUNTERS_PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL as usize;
pub const COUNTERS_PLATFORM_EVENT_LOOP_WAKEUP: usize =
Counters::COUNTERS_PLATFORM_EVENT_LOOP_WAKEUP as usize;
pub const COUNTERS_PLATFORM_EVENT_LOOP_SLEEP: usize =
Counters::COUNTERS_PLATFORM_EVENT_LOOP_SLEEP as usize;
pub const COUNTERS_PLATFORM_EVENT_LOOP_STARTED: usize =
Counters::COUNTERS_PLATFORM_EVENT_LOOP_STARTED as usize;
#[allow(non_camel_case_types)]
#[allow(clippy::upper_case_acronyms)]
enum BoolCounters {
BOOL_COUNTERS_PACKET_LOST__IS_MTU_PROBE,
BOOL_COUNTERS_RECOVERY_METRICS__CONGESTION_LIMITED,
BOOL_COUNTERS_MTU_UPDATED__SEARCH_COMPLETE,
}
pub const BOOL_COUNTERS_PACKET_LOST__IS_MTU_PROBE: usize =
BoolCounters::BOOL_COUNTERS_PACKET_LOST__IS_MTU_PROBE as usize;
pub const BOOL_COUNTERS_RECOVERY_METRICS__CONGESTION_LIMITED: usize =
BoolCounters::BOOL_COUNTERS_RECOVERY_METRICS__CONGESTION_LIMITED as usize;
pub const BOOL_COUNTERS_MTU_UPDATED__SEARCH_COMPLETE: usize =
BoolCounters::BOOL_COUNTERS_MTU_UPDATED__SEARCH_COMPLETE as usize;
#[allow(non_camel_case_types)]
#[allow(clippy::upper_case_acronyms)]
enum NominalCounters {
NOMINAL_COUNTERS_PACKET_SENT__KIND,
NOMINAL_COUNTERS_PACKET_SENT__TRANSMISSION_MODE,
NOMINAL_COUNTERS_PACKET_RECEIVED__KIND,
NOMINAL_COUNTERS_FRAME_SENT__PACKET,
NOMINAL_COUNTERS_FRAME_SENT__FRAME,
NOMINAL_COUNTERS_FRAME_RECEIVED__PACKET,
NOMINAL_COUNTERS_FRAME_RECEIVED__FRAME,
NOMINAL_COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED__PACKET,
NOMINAL_COUNTERS_PACKET_LOST__KIND,
NOMINAL_COUNTERS_CONGESTION__SOURCE,
NOMINAL_COUNTERS_ACK_RANGE_RECEIVED__PACKET,
NOMINAL_COUNTERS_ACK_RANGE_SENT__PACKET,
NOMINAL_COUNTERS_PACKET_DROPPED__REASON,
NOMINAL_COUNTERS_KEY_UPDATE__KEY_TYPE,
NOMINAL_COUNTERS_KEY_UPDATE__CIPHER_SUITE,
NOMINAL_COUNTERS_KEY_SPACE_DISCARDED__SPACE,
NOMINAL_COUNTERS_DUPLICATE_PACKET__KIND,
NOMINAL_COUNTERS_DUPLICATE_PACKET__ERROR,
NOMINAL_COUNTERS_DATAGRAM_DROPPED__REASON,
NOMINAL_COUNTERS_ECN_STATE_CHANGED__STATE,
NOMINAL_COUNTERS_CONNECTION_MIGRATION_DENIED__REASON,
NOMINAL_COUNTERS_HANDSHAKE_STATUS_UPDATED__STATUS,
NOMINAL_COUNTERS_PATH_CHALLENGE_UPDATED__STATUS,
NOMINAL_COUNTERS_MTU_UPDATED__CAUSE,
NOMINAL_COUNTERS_MTU_PROBING_COMPLETE_RECEIVED__PACKET,
NOMINAL_COUNTERS_SLOW_START_EXITED__CAUSE,
NOMINAL_COUNTERS_BBR_STATE_CHANGED__STATE,
NOMINAL_COUNTERS_DC_STATE_CHANGED__STATE,
NOMINAL_COUNTERS_CONNECTION_CLOSED__ERROR,
NOMINAL_COUNTERS_ENDPOINT_DATAGRAM_DROPPED__REASON,
NOMINAL_COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR,
}
pub const NOMINAL_COUNTERS_PACKET_SENT__KIND: usize =
NominalCounters::NOMINAL_COUNTERS_PACKET_SENT__KIND as usize;
pub const NOMINAL_COUNTERS_PACKET_SENT__TRANSMISSION_MODE: usize =
NominalCounters::NOMINAL_COUNTERS_PACKET_SENT__TRANSMISSION_MODE as usize;
pub const NOMINAL_COUNTERS_PACKET_RECEIVED__KIND: usize =
NominalCounters::NOMINAL_COUNTERS_PACKET_RECEIVED__KIND as usize;
pub const NOMINAL_COUNTERS_FRAME_SENT__PACKET: usize =
NominalCounters::NOMINAL_COUNTERS_FRAME_SENT__PACKET as usize;
pub const NOMINAL_COUNTERS_FRAME_SENT__FRAME: usize =
NominalCounters::NOMINAL_COUNTERS_FRAME_SENT__FRAME as usize;
pub const NOMINAL_COUNTERS_FRAME_RECEIVED__PACKET: usize =
NominalCounters::NOMINAL_COUNTERS_FRAME_RECEIVED__PACKET as usize;
pub const NOMINAL_COUNTERS_FRAME_RECEIVED__FRAME: usize =
NominalCounters::NOMINAL_COUNTERS_FRAME_RECEIVED__FRAME as usize;
pub const NOMINAL_COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED__PACKET: usize =
NominalCounters::NOMINAL_COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED__PACKET as usize;
pub const NOMINAL_COUNTERS_PACKET_LOST__KIND: usize =
NominalCounters::NOMINAL_COUNTERS_PACKET_LOST__KIND as usize;
pub const NOMINAL_COUNTERS_CONGESTION__SOURCE: usize =
NominalCounters::NOMINAL_COUNTERS_CONGESTION__SOURCE as usize;
pub const NOMINAL_COUNTERS_ACK_RANGE_RECEIVED__PACKET: usize =
NominalCounters::NOMINAL_COUNTERS_ACK_RANGE_RECEIVED__PACKET as usize;
pub const NOMINAL_COUNTERS_ACK_RANGE_SENT__PACKET: usize =
NominalCounters::NOMINAL_COUNTERS_ACK_RANGE_SENT__PACKET as usize;
pub const NOMINAL_COUNTERS_PACKET_DROPPED__REASON: usize =
NominalCounters::NOMINAL_COUNTERS_PACKET_DROPPED__REASON as usize;
pub const NOMINAL_COUNTERS_KEY_UPDATE__KEY_TYPE: usize =
NominalCounters::NOMINAL_COUNTERS_KEY_UPDATE__KEY_TYPE as usize;
pub const NOMINAL_COUNTERS_KEY_UPDATE__CIPHER_SUITE: usize =
NominalCounters::NOMINAL_COUNTERS_KEY_UPDATE__CIPHER_SUITE as usize;
pub const NOMINAL_COUNTERS_KEY_SPACE_DISCARDED__SPACE: usize =
NominalCounters::NOMINAL_COUNTERS_KEY_SPACE_DISCARDED__SPACE as usize;
pub const NOMINAL_COUNTERS_DUPLICATE_PACKET__KIND: usize =
NominalCounters::NOMINAL_COUNTERS_DUPLICATE_PACKET__KIND as usize;
pub const NOMINAL_COUNTERS_DUPLICATE_PACKET__ERROR: usize =
NominalCounters::NOMINAL_COUNTERS_DUPLICATE_PACKET__ERROR as usize;
pub const NOMINAL_COUNTERS_DATAGRAM_DROPPED__REASON: usize =
NominalCounters::NOMINAL_COUNTERS_DATAGRAM_DROPPED__REASON as usize;
pub const NOMINAL_COUNTERS_ECN_STATE_CHANGED__STATE: usize =
NominalCounters::NOMINAL_COUNTERS_ECN_STATE_CHANGED__STATE as usize;
pub const NOMINAL_COUNTERS_CONNECTION_MIGRATION_DENIED__REASON: usize =
NominalCounters::NOMINAL_COUNTERS_CONNECTION_MIGRATION_DENIED__REASON as usize;
pub const NOMINAL_COUNTERS_HANDSHAKE_STATUS_UPDATED__STATUS: usize =
NominalCounters::NOMINAL_COUNTERS_HANDSHAKE_STATUS_UPDATED__STATUS as usize;
pub const NOMINAL_COUNTERS_PATH_CHALLENGE_UPDATED__STATUS: usize =
NominalCounters::NOMINAL_COUNTERS_PATH_CHALLENGE_UPDATED__STATUS as usize;
pub const NOMINAL_COUNTERS_MTU_UPDATED__CAUSE: usize =
NominalCounters::NOMINAL_COUNTERS_MTU_UPDATED__CAUSE as usize;
pub const NOMINAL_COUNTERS_MTU_PROBING_COMPLETE_RECEIVED__PACKET: usize =
NominalCounters::NOMINAL_COUNTERS_MTU_PROBING_COMPLETE_RECEIVED__PACKET as usize;
pub const NOMINAL_COUNTERS_SLOW_START_EXITED__CAUSE: usize =
NominalCounters::NOMINAL_COUNTERS_SLOW_START_EXITED__CAUSE as usize;
pub const NOMINAL_COUNTERS_BBR_STATE_CHANGED__STATE: usize =
NominalCounters::NOMINAL_COUNTERS_BBR_STATE_CHANGED__STATE as usize;
pub const NOMINAL_COUNTERS_DC_STATE_CHANGED__STATE: usize =
NominalCounters::NOMINAL_COUNTERS_DC_STATE_CHANGED__STATE as usize;
pub const NOMINAL_COUNTERS_CONNECTION_CLOSED__ERROR: usize =
NominalCounters::NOMINAL_COUNTERS_CONNECTION_CLOSED__ERROR as usize;
pub const NOMINAL_COUNTERS_ENDPOINT_DATAGRAM_DROPPED__REASON: usize =
NominalCounters::NOMINAL_COUNTERS_ENDPOINT_DATAGRAM_DROPPED__REASON as usize;
pub const NOMINAL_COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR: usize =
NominalCounters::NOMINAL_COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR as usize;
#[allow(non_camel_case_types)]
#[allow(clippy::upper_case_acronyms)]
enum Measures {
MEASURES_PACKET_SENT__BYTES,
MEASURES_PACKET_RECEIVED__BYTES,
MEASURES_PACKET_LOST__BYTES,
MEASURES_RECOVERY_METRICS__MIN_RTT,
MEASURES_RECOVERY_METRICS__SMOOTHED_RTT,
MEASURES_RECOVERY_METRICS__LATEST_RTT,
MEASURES_RECOVERY_METRICS__RTT_VARIANCE,
MEASURES_RECOVERY_METRICS__MAX_ACK_DELAY,
MEASURES_RECOVERY_METRICS__PTO_COUNT,
MEASURES_RECOVERY_METRICS__CONGESTION_WINDOW,
MEASURES_RECOVERY_METRICS__BYTES_IN_FLIGHT,
MEASURES_DATAGRAM_SENT__BYTES,
MEASURES_DATAGRAM_SENT__GSO_OFFSET,
MEASURES_DATAGRAM_RECEIVED__BYTES,
MEASURES_DATAGRAM_DROPPED__BYTES,
MEASURES_RX_STREAM_PROGRESS__BYTES,
MEASURES_TX_STREAM_PROGRESS__BYTES,
MEASURES_MTU_UPDATED__MTU,
MEASURES_MTU_PROBING_COMPLETE_RECEIVED__MTU,
MEASURES_SLOW_START_EXITED__CONGESTION_WINDOW,
MEASURES_PACING_RATE_UPDATED__BYTES_PER_SECOND,
MEASURES_PACING_RATE_UPDATED__BURST_SIZE,
MEASURES_PACING_RATE_UPDATED__PACING_GAIN,
MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES,
MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL,
MEASURES_ENDPOINT_DATAGRAM_SENT__GSO_OFFSET,
MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES,
MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL,
MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES,
MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL,
MEASURES_PLATFORM_TX__PACKETS,
MEASURES_PLATFORM_TX__SYSCALLS,
MEASURES_PLATFORM_TX__SYSCALLS__BLOCKED,
MEASURES_PLATFORM_TX__ERRORS,
MEASURES_PLATFORM_TX__ERRORS__DROPPED,
MEASURES_PLATFORM_RX__PACKETS,
MEASURES_PLATFORM_RX__SYSCALLS,
MEASURES_PLATFORM_RX__SYSCALLS__BLOCKED,
MEASURES_PLATFORM_RX__ERRORS,
MEASURES_PLATFORM_RX__ERRORS__DROPPED,
}
pub const MEASURES_PACKET_SENT__BYTES: usize = Measures::MEASURES_PACKET_SENT__BYTES as usize;
pub const MEASURES_PACKET_RECEIVED__BYTES: usize =
Measures::MEASURES_PACKET_RECEIVED__BYTES as usize;
pub const MEASURES_PACKET_LOST__BYTES: usize = Measures::MEASURES_PACKET_LOST__BYTES as usize;
pub const MEASURES_RECOVERY_METRICS__MIN_RTT: usize =
Measures::MEASURES_RECOVERY_METRICS__MIN_RTT as usize;
pub const MEASURES_RECOVERY_METRICS__SMOOTHED_RTT: usize =
Measures::MEASURES_RECOVERY_METRICS__SMOOTHED_RTT as usize;
pub const MEASURES_RECOVERY_METRICS__LATEST_RTT: usize =
Measures::MEASURES_RECOVERY_METRICS__LATEST_RTT as usize;
pub const MEASURES_RECOVERY_METRICS__RTT_VARIANCE: usize =
Measures::MEASURES_RECOVERY_METRICS__RTT_VARIANCE as usize;
pub const MEASURES_RECOVERY_METRICS__MAX_ACK_DELAY: usize =
Measures::MEASURES_RECOVERY_METRICS__MAX_ACK_DELAY as usize;
pub const MEASURES_RECOVERY_METRICS__PTO_COUNT: usize =
Measures::MEASURES_RECOVERY_METRICS__PTO_COUNT as usize;
pub const MEASURES_RECOVERY_METRICS__CONGESTION_WINDOW: usize =
Measures::MEASURES_RECOVERY_METRICS__CONGESTION_WINDOW as usize;
pub const MEASURES_RECOVERY_METRICS__BYTES_IN_FLIGHT: usize =
Measures::MEASURES_RECOVERY_METRICS__BYTES_IN_FLIGHT as usize;
pub const MEASURES_DATAGRAM_SENT__BYTES: usize =
Measures::MEASURES_DATAGRAM_SENT__BYTES as usize;
pub const MEASURES_DATAGRAM_SENT__GSO_OFFSET: usize =
Measures::MEASURES_DATAGRAM_SENT__GSO_OFFSET as usize;
pub const MEASURES_DATAGRAM_RECEIVED__BYTES: usize =
Measures::MEASURES_DATAGRAM_RECEIVED__BYTES as usize;
pub const MEASURES_DATAGRAM_DROPPED__BYTES: usize =
Measures::MEASURES_DATAGRAM_DROPPED__BYTES as usize;
pub const MEASURES_RX_STREAM_PROGRESS__BYTES: usize =
Measures::MEASURES_RX_STREAM_PROGRESS__BYTES as usize;
pub const MEASURES_TX_STREAM_PROGRESS__BYTES: usize =
Measures::MEASURES_TX_STREAM_PROGRESS__BYTES as usize;
pub const MEASURES_MTU_UPDATED__MTU: usize = Measures::MEASURES_MTU_UPDATED__MTU as usize;
pub const MEASURES_MTU_PROBING_COMPLETE_RECEIVED__MTU: usize =
Measures::MEASURES_MTU_PROBING_COMPLETE_RECEIVED__MTU as usize;
pub const MEASURES_SLOW_START_EXITED__CONGESTION_WINDOW: usize =
Measures::MEASURES_SLOW_START_EXITED__CONGESTION_WINDOW as usize;
pub const MEASURES_PACING_RATE_UPDATED__BYTES_PER_SECOND: usize =
Measures::MEASURES_PACING_RATE_UPDATED__BYTES_PER_SECOND as usize;
pub const MEASURES_PACING_RATE_UPDATED__BURST_SIZE: usize =
Measures::MEASURES_PACING_RATE_UPDATED__BURST_SIZE as usize;
pub const MEASURES_PACING_RATE_UPDATED__PACING_GAIN: usize =
Measures::MEASURES_PACING_RATE_UPDATED__PACING_GAIN as usize;
pub const MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES: usize =
Measures::MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES as usize;
pub const MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL: usize =
Measures::MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL as usize;
pub const MEASURES_ENDPOINT_DATAGRAM_SENT__GSO_OFFSET: usize =
Measures::MEASURES_ENDPOINT_DATAGRAM_SENT__GSO_OFFSET as usize;
pub const MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES: usize =
Measures::MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES as usize;
pub const MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL: usize =
Measures::MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL as usize;
pub const MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES: usize =
Measures::MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES as usize;
pub const MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL: usize =
Measures::MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL as usize;
pub const MEASURES_PLATFORM_TX__PACKETS: usize =
Measures::MEASURES_PLATFORM_TX__PACKETS as usize;
pub const MEASURES_PLATFORM_TX__SYSCALLS: usize =
Measures::MEASURES_PLATFORM_TX__SYSCALLS as usize;
pub const MEASURES_PLATFORM_TX__SYSCALLS__BLOCKED: usize =
Measures::MEASURES_PLATFORM_TX__SYSCALLS__BLOCKED as usize;
pub const MEASURES_PLATFORM_TX__ERRORS: usize = Measures::MEASURES_PLATFORM_TX__ERRORS as usize;
pub const MEASURES_PLATFORM_TX__ERRORS__DROPPED: usize =
Measures::MEASURES_PLATFORM_TX__ERRORS__DROPPED as usize;
pub const MEASURES_PLATFORM_RX__PACKETS: usize =
Measures::MEASURES_PLATFORM_RX__PACKETS as usize;
pub const MEASURES_PLATFORM_RX__SYSCALLS: usize =
Measures::MEASURES_PLATFORM_RX__SYSCALLS as usize;
pub const MEASURES_PLATFORM_RX__SYSCALLS__BLOCKED: usize =
Measures::MEASURES_PLATFORM_RX__SYSCALLS__BLOCKED as usize;
pub const MEASURES_PLATFORM_RX__ERRORS: usize = Measures::MEASURES_PLATFORM_RX__ERRORS as usize;
pub const MEASURES_PLATFORM_RX__ERRORS__DROPPED: usize =
Measures::MEASURES_PLATFORM_RX__ERRORS__DROPPED as usize;
#[allow(non_camel_case_types)]
#[allow(clippy::upper_case_acronyms)]
enum Timers {
TIMERS_KEY_SPACE_DISCARDED__INITIAL__LATENCY,
TIMERS_KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY,
TIMERS_KEY_SPACE_DISCARDED__ONE_RTT__LATENCY,
TIMERS_TRANSPORT_PARAMETERS_RECEIVED__LATENCY,
TIMERS_HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY,
TIMERS_HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY,
TIMERS_HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY,
TIMERS_TLS_CLIENT_HELLO__LATENCY,
TIMERS_TLS_SERVER_HELLO__LATENCY,
TIMERS_DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY,
TIMERS_DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY,
TIMERS_DC_STATE_CHANGED__PATH_SECRETS__LATENCY,
TIMERS_DC_STATE_CHANGED__COMPLETE__LATENCY,
TIMERS_CONNECTION_CLOSED__LATENCY,
TIMERS_PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION,
}
pub const TIMERS_KEY_SPACE_DISCARDED__INITIAL__LATENCY: usize =
Timers::TIMERS_KEY_SPACE_DISCARDED__INITIAL__LATENCY as usize;
pub const TIMERS_KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY: usize =
Timers::TIMERS_KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY as usize;
pub const TIMERS_KEY_SPACE_DISCARDED__ONE_RTT__LATENCY: usize =
Timers::TIMERS_KEY_SPACE_DISCARDED__ONE_RTT__LATENCY as usize;
pub const TIMERS_TRANSPORT_PARAMETERS_RECEIVED__LATENCY: usize =
Timers::TIMERS_TRANSPORT_PARAMETERS_RECEIVED__LATENCY as usize;
pub const TIMERS_HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY: usize =
Timers::TIMERS_HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY as usize;
pub const TIMERS_HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY: usize =
Timers::TIMERS_HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY as usize;
pub const TIMERS_HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY: usize =
Timers::TIMERS_HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY as usize;
pub const TIMERS_TLS_CLIENT_HELLO__LATENCY: usize =
Timers::TIMERS_TLS_CLIENT_HELLO__LATENCY as usize;
pub const TIMERS_TLS_SERVER_HELLO__LATENCY: usize =
Timers::TIMERS_TLS_SERVER_HELLO__LATENCY as usize;
pub const TIMERS_DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY: usize =
Timers::TIMERS_DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY as usize;
pub const TIMERS_DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY: usize =
Timers::TIMERS_DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY as usize;
pub const TIMERS_DC_STATE_CHANGED__PATH_SECRETS__LATENCY: usize =
Timers::TIMERS_DC_STATE_CHANGED__PATH_SECRETS__LATENCY as usize;
pub const TIMERS_DC_STATE_CHANGED__COMPLETE__LATENCY: usize =
Timers::TIMERS_DC_STATE_CHANGED__COMPLETE__LATENCY as usize;
pub const TIMERS_CONNECTION_CLOSED__LATENCY: usize =
Timers::TIMERS_CONNECTION_CLOSED__LATENCY as usize;
pub const TIMERS_PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION: usize =
Timers::TIMERS_PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION as usize;
#[allow(non_camel_case_types)]
#[allow(clippy::upper_case_acronyms)]
enum NominalTimers {
NOMINAL_TIMERS_SLOW_START_EXITED__LATENCY,
}
pub const NOMINAL_TIMERS_SLOW_START_EXITED__LATENCY: usize =
NominalTimers::NOMINAL_TIMERS_SLOW_START_EXITED__LATENCY as usize;
}
static INFO: &[Info; 174usize] = &[
info::Builder {
id: id::APPLICATION_PROTOCOL_INFORMATION,
name: Str::new("application_protocol_information\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::SERVER_NAME_INFORMATION,
name: Str::new("server_name_information\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::KEY_EXCHANGE_GROUP,
name: Str::new("key_exchange_group\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_SKIPPED,
name: Str::new("packet_skipped\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_SENT,
name: Str::new("packet_sent\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_SENT__KIND,
name: Str::new("packet_sent.kind\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_SENT__BYTES__TOTAL,
name: Str::new("packet_sent.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::PACKET_SENT__BYTES,
name: Str::new("packet_sent.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::PACKET_SENT__TRANSMISSION_MODE,
name: Str::new("packet_sent.transmission_mode\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_RECEIVED,
name: Str::new("packet_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_RECEIVED__KIND,
name: Str::new("packet_received.kind\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_RECEIVED__BYTES__TOTAL,
name: Str::new("packet_received.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::PACKET_RECEIVED__BYTES,
name: Str::new("packet_received.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::ACTIVE_PATH_UPDATED,
name: Str::new("active_path_updated\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PATH_CREATED,
name: Str::new("path_created\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::FRAME_SENT,
name: Str::new("frame_sent\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::FRAME_SENT__PACKET,
name: Str::new("frame_sent.packet\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::FRAME_SENT__FRAME,
name: Str::new("frame_sent.frame\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::FRAME_RECEIVED,
name: Str::new("frame_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::FRAME_RECEIVED__PACKET,
name: Str::new("frame_received.packet\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::FRAME_RECEIVED__FRAME,
name: Str::new("frame_received.frame\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_CLOSE_FRAME_RECEIVED,
name: Str::new("connection_close_frame_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_CLOSE_FRAME_RECEIVED__PACKET,
name: Str::new("connection_close_frame_received.packet\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_LOST,
name: Str::new("packet_lost\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_LOST__KIND,
name: Str::new("packet_lost.kind\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_LOST__BYTES__TOTAL,
name: Str::new("packet_lost.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::PACKET_LOST__BYTES,
name: Str::new("packet_lost.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::PACKET_LOST__IS_MTU_PROBE,
name: Str::new("packet_lost.is_mtu_probe\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS,
name: Str::new("recovery_metrics\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__MIN_RTT,
name: Str::new("recovery_metrics.min_rtt\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__SMOOTHED_RTT,
name: Str::new("recovery_metrics.smoothed_rtt\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__LATEST_RTT,
name: Str::new("recovery_metrics.latest_rtt\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__RTT_VARIANCE,
name: Str::new("recovery_metrics.rtt_variance\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__MAX_ACK_DELAY,
name: Str::new("recovery_metrics.max_ack_delay\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__PTO_COUNT,
name: Str::new("recovery_metrics.pto_count\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__CONGESTION_WINDOW,
name: Str::new("recovery_metrics.congestion_window\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__BYTES_IN_FLIGHT,
name: Str::new("recovery_metrics.bytes_in_flight\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RECOVERY_METRICS__CONGESTION_LIMITED,
name: Str::new("recovery_metrics.congestion_limited\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONGESTION,
name: Str::new("congestion\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONGESTION__SOURCE,
name: Str::new("congestion.source\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::RX_ACK_RANGE_DROPPED,
name: Str::new("rx_ack_range_dropped\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ACK_RANGE_RECEIVED,
name: Str::new("ack_range_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ACK_RANGE_RECEIVED__PACKET,
name: Str::new("ack_range_received.packet\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ACK_RANGE_SENT,
name: Str::new("ack_range_sent\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ACK_RANGE_SENT__PACKET,
name: Str::new("ack_range_sent.packet\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_DROPPED,
name: Str::new("packet_dropped\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACKET_DROPPED__REASON,
name: Str::new("packet_dropped.reason\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::KEY_UPDATE,
name: Str::new("key_update\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::KEY_UPDATE__KEY_TYPE,
name: Str::new("key_update.key_type\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::KEY_UPDATE__CIPHER_SUITE,
name: Str::new("key_update.cipher_suite\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::KEY_SPACE_DISCARDED,
name: Str::new("key_space_discarded\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::KEY_SPACE_DISCARDED__INITIAL__LATENCY,
name: Str::new("key_space_discarded.initial.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY,
name: Str::new("key_space_discarded.handshake.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::KEY_SPACE_DISCARDED__ONE_RTT__LATENCY,
name: Str::new("key_space_discarded.one_rtt.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::KEY_SPACE_DISCARDED__SPACE,
name: Str::new("key_space_discarded.space\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_STARTED,
name: Str::new("connection_started\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DUPLICATE_PACKET,
name: Str::new("duplicate_packet\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DUPLICATE_PACKET__KIND,
name: Str::new("duplicate_packet.kind\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DUPLICATE_PACKET__ERROR,
name: Str::new("duplicate_packet.error\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TRANSPORT_PARAMETERS_RECEIVED,
name: Str::new("transport_parameters_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TRANSPORT_PARAMETERS_RECEIVED__LATENCY,
name: Str::new("transport_parameters_received.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::DATAGRAM_SENT,
name: Str::new("datagram_sent\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DATAGRAM_SENT__BYTES__TOTAL,
name: Str::new("datagram_sent.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::DATAGRAM_SENT__BYTES,
name: Str::new("datagram_sent.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::DATAGRAM_SENT__GSO_OFFSET,
name: Str::new("datagram_sent.gso_offset\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DATAGRAM_RECEIVED,
name: Str::new("datagram_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DATAGRAM_RECEIVED__BYTES__TOTAL,
name: Str::new("datagram_received.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::DATAGRAM_RECEIVED__BYTES,
name: Str::new("datagram_received.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::DATAGRAM_DROPPED,
name: Str::new("datagram_dropped\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DATAGRAM_DROPPED__BYTES__TOTAL,
name: Str::new("datagram_dropped.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::DATAGRAM_DROPPED__BYTES,
name: Str::new("datagram_dropped.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::DATAGRAM_DROPPED__REASON,
name: Str::new("datagram_dropped.reason\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED,
name: Str::new("handshake_remote_address_change_observed\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_ID_UPDATED,
name: Str::new("connection_id_updated\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ECN_STATE_CHANGED,
name: Str::new("ecn_state_changed\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ECN_STATE_CHANGED__STATE,
name: Str::new("ecn_state_changed.state\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_MIGRATION_DENIED,
name: Str::new("connection_migration_denied\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_MIGRATION_DENIED__REASON,
name: Str::new("connection_migration_denied.reason\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::HANDSHAKE_STATUS_UPDATED,
name: Str::new("handshake_status_updated\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY,
name: Str::new("handshake_status_updated.complete.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY,
name: Str::new("handshake_status_updated.confirmed.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY,
name: Str::new("handshake_status_updated.handshake_done_acked.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::HANDSHAKE_STATUS_UPDATED__STATUS,
name: Str::new("handshake_status_updated.status\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TLS_EXPORTER_READY,
name: Str::new("tls_exporter_ready\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TLS_HANDSHAKE_FAILED,
name: Str::new("tls_handshake_failed\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PATH_CHALLENGE_UPDATED,
name: Str::new("path_challenge_updated\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PATH_CHALLENGE_UPDATED__STATUS,
name: Str::new("path_challenge_updated.status\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TLS_CLIENT_HELLO,
name: Str::new("tls_client_hello\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TLS_CLIENT_HELLO__LATENCY,
name: Str::new("tls_client_hello.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::TLS_SERVER_HELLO,
name: Str::new("tls_server_hello\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TLS_SERVER_HELLO__LATENCY,
name: Str::new("tls_server_hello.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::RX_STREAM_PROGRESS,
name: Str::new("rx_stream_progress\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::RX_STREAM_PROGRESS__BYTES__TOTAL,
name: Str::new("rx_stream_progress.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::RX_STREAM_PROGRESS__BYTES,
name: Str::new("rx_stream_progress.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::TX_STREAM_PROGRESS,
name: Str::new("tx_stream_progress\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::TX_STREAM_PROGRESS__BYTES__TOTAL,
name: Str::new("tx_stream_progress.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::TX_STREAM_PROGRESS__BYTES,
name: Str::new("tx_stream_progress.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::KEEP_ALIVE_TIMER_EXPIRED,
name: Str::new("keep_alive_timer_expired\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::MTU_UPDATED,
name: Str::new("mtu_updated\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::MTU_UPDATED__MTU,
name: Str::new("mtu_updated.mtu\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::MTU_UPDATED__CAUSE,
name: Str::new("mtu_updated.cause\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::MTU_UPDATED__SEARCH_COMPLETE,
name: Str::new("mtu_updated.search_complete\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::MTU_PROBING_COMPLETE_RECEIVED,
name: Str::new("mtu_probing_complete_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::MTU_PROBING_COMPLETE_RECEIVED__PACKET,
name: Str::new("mtu_probing_complete_received.packet\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::MTU_PROBING_COMPLETE_RECEIVED__MTU,
name: Str::new("mtu_probing_complete_received.mtu\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::SLOW_START_EXITED,
name: Str::new("slow_start_exited\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::SLOW_START_EXITED__CAUSE,
name: Str::new("slow_start_exited.cause\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::SLOW_START_EXITED__LATENCY,
name: Str::new("slow_start_exited.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::SLOW_START_EXITED__CONGESTION_WINDOW,
name: Str::new("slow_start_exited.congestion_window\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::DELIVERY_RATE_SAMPLED,
name: Str::new("delivery_rate_sampled\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACING_RATE_UPDATED,
name: Str::new("pacing_rate_updated\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PACING_RATE_UPDATED__BYTES_PER_SECOND,
name: Str::new("pacing_rate_updated.bytes_per_second\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::PACING_RATE_UPDATED__BURST_SIZE,
name: Str::new("pacing_rate_updated.burst_size\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::PACING_RATE_UPDATED__PACING_GAIN,
name: Str::new("pacing_rate_updated.pacing_gain\0"),
units: Units::Float,
}
.build(),
info::Builder {
id: id::BBR_STATE_CHANGED,
name: Str::new("bbr_state_changed\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::BBR_STATE_CHANGED__STATE,
name: Str::new("bbr_state_changed.state\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DC_STATE_CHANGED,
name: Str::new("dc_state_changed\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY,
name: Str::new("dc_state_changed.version_negotiated.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY,
name: Str::new("dc_state_changed.no_version_negotiated.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::DC_STATE_CHANGED__PATH_SECRETS__LATENCY,
name: Str::new("dc_state_changed.path_secrets.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::DC_STATE_CHANGED__COMPLETE__LATENCY,
name: Str::new("dc_state_changed.complete.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::DC_STATE_CHANGED__STATE,
name: Str::new("dc_state_changed.state\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::DC_PATH_CREATED,
name: Str::new("dc_path_created\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_CLOSED,
name: Str::new("connection_closed\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::CONNECTION_CLOSED__LATENCY,
name: Str::new("connection_closed.latency\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::CONNECTION_CLOSED__ERROR,
name: Str::new("connection_closed.error\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::VERSION_INFORMATION,
name: Str::new("version_information\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_PACKET_SENT,
name: Str::new("endpoint_packet_sent\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_PACKET_RECEIVED,
name: Str::new("endpoint_packet_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_SENT,
name: Str::new("endpoint_datagram_sent\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_SENT__BYTES,
name: Str::new("endpoint_datagram_sent.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL,
name: Str::new("endpoint_datagram_sent.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_SENT__GSO_OFFSET,
name: Str::new("endpoint_datagram_sent.gso_offset\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_RECEIVED,
name: Str::new("endpoint_datagram_received\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_RECEIVED__BYTES,
name: Str::new("endpoint_datagram_received.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL,
name: Str::new("endpoint_datagram_received.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_DROPPED,
name: Str::new("endpoint_datagram_dropped\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_DROPPED__BYTES,
name: Str::new("endpoint_datagram_dropped.bytes\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL,
name: Str::new("endpoint_datagram_dropped.bytes.total\0"),
units: Units::Bytes,
}
.build(),
info::Builder {
id: id::ENDPOINT_DATAGRAM_DROPPED__REASON,
name: Str::new("endpoint_datagram_dropped.reason\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_CONNECTION_ATTEMPT_FAILED,
name: Str::new("endpoint_connection_attempt_failed\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR,
name: Str::new("endpoint_connection_attempt_failed.error\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED,
name: Str::new("endpoint_connection_attempt_deduplicated\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX,
name: Str::new("platform_tx\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__PACKETS__TOTAL,
name: Str::new("platform_tx.packets.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__PACKETS,
name: Str::new("platform_tx.packets\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__SYSCALLS__TOTAL,
name: Str::new("platform_tx.syscalls.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__SYSCALLS,
name: Str::new("platform_tx.syscalls\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL,
name: Str::new("platform_tx.syscalls.blocked.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__SYSCALLS__BLOCKED,
name: Str::new("platform_tx.syscalls.blocked\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__ERRORS__TOTAL,
name: Str::new("platform_tx.errors.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__ERRORS,
name: Str::new("platform_tx.errors\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__ERRORS__DROPPED__TOTAL,
name: Str::new("platform_tx.errors.dropped.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX__ERRORS__DROPPED,
name: Str::new("platform_tx.errors.dropped\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_TX_ERROR,
name: Str::new("platform_tx_error\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX,
name: Str::new("platform_rx\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__PACKETS__TOTAL,
name: Str::new("platform_rx.packets.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__PACKETS,
name: Str::new("platform_rx.packets\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__SYSCALLS__TOTAL,
name: Str::new("platform_rx.syscalls.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__SYSCALLS,
name: Str::new("platform_rx.syscalls\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL,
name: Str::new("platform_rx.syscalls.blocked.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__SYSCALLS__BLOCKED,
name: Str::new("platform_rx.syscalls.blocked\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__ERRORS__TOTAL,
name: Str::new("platform_rx.errors.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__ERRORS,
name: Str::new("platform_rx.errors\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__ERRORS__DROPPED__TOTAL,
name: Str::new("platform_rx.errors.dropped.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX__ERRORS__DROPPED,
name: Str::new("platform_rx.errors.dropped\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX_ERROR,
name: Str::new("platform_rx_error\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_FEATURE_CONFIGURED,
name: Str::new("platform_feature_configured\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX_SOCKET_STATS,
name: Str::new("platform_rx_socket_stats\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL,
name: Str::new("platform_rx_socket_stats.packets.total\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_EVENT_LOOP_WAKEUP,
name: Str::new("platform_event_loop_wakeup\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_EVENT_LOOP_SLEEP,
name: Str::new("platform_event_loop_sleep\0"),
units: Units::None,
}
.build(),
info::Builder {
id: id::PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION,
name: Str::new("platform_event_loop_sleep.processing_duration\0"),
units: Units::Duration,
}
.build(),
info::Builder {
id: id::PLATFORM_EVENT_LOOP_STARTED,
name: Str::new("platform_event_loop_started\0"),
units: Units::None,
}
.build(),
];
#[derive(Debug)]
#[allow(dead_code)]
pub struct ConnectionContext {
start_time: crate::event::Timestamp,
}
pub struct Subscriber<R: Registry> {
#[allow(dead_code)]
counters: Box<[R::Counter; 84usize]>,
#[allow(dead_code)]
bool_counters: Box<[R::BoolCounter; 3usize]>,
#[allow(dead_code)]
nominal_counters: Box<[R::NominalCounter]>,
#[allow(dead_code)]
nominal_counter_offsets: Box<[usize; 31usize]>,
#[allow(dead_code)]
measures: Box<[R::Measure; 40usize]>,
#[allow(dead_code)]
gauges: Box<[R::Gauge; 0usize]>,
#[allow(dead_code)]
timers: Box<[R::Timer; 15usize]>,
#[allow(dead_code)]
nominal_timers: Box<[R::NominalTimer]>,
#[allow(dead_code)]
nominal_timer_offsets: Box<[usize; 1usize]>,
#[allow(dead_code)]
registry: R,
}
impl<R: Registry + Default> Default for Subscriber<R> {
fn default() -> Self {
Self::new(R::default())
}
}
impl<R: Registry> Subscriber<R> {
#[doc = r" Creates a new subscriber with the given registry"]
#[doc = r""]
#[doc = r" # Note"]
#[doc = r""]
#[doc = r" All of the recorders are registered on initialization and cached for the lifetime"]
#[doc = r" of the subscriber."]
#[allow(unused_mut)]
#[inline]
pub fn new(registry: R) -> Self {
let mut counters = Vec::with_capacity(84usize);
let mut bool_counters = Vec::with_capacity(3usize);
let mut nominal_counters = Vec::with_capacity(31usize);
let mut nominal_counter_offsets = Vec::with_capacity(31usize);
let mut measures = Vec::with_capacity(40usize);
let mut gauges = Vec::with_capacity(0usize);
let mut timers = Vec::with_capacity(15usize);
let mut nominal_timers = Vec::with_capacity(1usize);
let mut nominal_timer_offsets = Vec::with_capacity(1usize);
counters.push(registry.register_counter(&INFO[id::APPLICATION_PROTOCOL_INFORMATION]));
counters.push(registry.register_counter(&INFO[id::SERVER_NAME_INFORMATION]));
counters.push(registry.register_counter(&INFO[id::KEY_EXCHANGE_GROUP]));
counters.push(registry.register_counter(&INFO[id::PACKET_SKIPPED]));
counters.push(registry.register_counter(&INFO[id::PACKET_SENT]));
counters.push(registry.register_counter(&INFO[id::PACKET_SENT__BYTES__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PACKET_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::PACKET_RECEIVED__BYTES__TOTAL]));
counters.push(registry.register_counter(&INFO[id::ACTIVE_PATH_UPDATED]));
counters.push(registry.register_counter(&INFO[id::PATH_CREATED]));
counters.push(registry.register_counter(&INFO[id::FRAME_SENT]));
counters.push(registry.register_counter(&INFO[id::FRAME_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::CONNECTION_CLOSE_FRAME_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::PACKET_LOST]));
counters.push(registry.register_counter(&INFO[id::PACKET_LOST__BYTES__TOTAL]));
counters.push(registry.register_counter(&INFO[id::RECOVERY_METRICS]));
counters.push(registry.register_counter(&INFO[id::CONGESTION]));
counters.push(registry.register_counter(&INFO[id::RX_ACK_RANGE_DROPPED]));
counters.push(registry.register_counter(&INFO[id::ACK_RANGE_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::ACK_RANGE_SENT]));
counters.push(registry.register_counter(&INFO[id::PACKET_DROPPED]));
counters.push(registry.register_counter(&INFO[id::KEY_UPDATE]));
counters.push(registry.register_counter(&INFO[id::KEY_SPACE_DISCARDED]));
counters.push(registry.register_counter(&INFO[id::CONNECTION_STARTED]));
counters.push(registry.register_counter(&INFO[id::DUPLICATE_PACKET]));
counters.push(registry.register_counter(&INFO[id::TRANSPORT_PARAMETERS_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::DATAGRAM_SENT]));
counters.push(registry.register_counter(&INFO[id::DATAGRAM_SENT__BYTES__TOTAL]));
counters.push(registry.register_counter(&INFO[id::DATAGRAM_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::DATAGRAM_RECEIVED__BYTES__TOTAL]));
counters.push(registry.register_counter(&INFO[id::DATAGRAM_DROPPED]));
counters.push(registry.register_counter(&INFO[id::DATAGRAM_DROPPED__BYTES__TOTAL]));
counters
.push(registry.register_counter(&INFO[id::HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED]));
counters.push(registry.register_counter(&INFO[id::CONNECTION_ID_UPDATED]));
counters.push(registry.register_counter(&INFO[id::ECN_STATE_CHANGED]));
counters.push(registry.register_counter(&INFO[id::CONNECTION_MIGRATION_DENIED]));
counters.push(registry.register_counter(&INFO[id::HANDSHAKE_STATUS_UPDATED]));
counters.push(registry.register_counter(&INFO[id::TLS_EXPORTER_READY]));
counters.push(registry.register_counter(&INFO[id::TLS_HANDSHAKE_FAILED]));
counters.push(registry.register_counter(&INFO[id::PATH_CHALLENGE_UPDATED]));
counters.push(registry.register_counter(&INFO[id::TLS_CLIENT_HELLO]));
counters.push(registry.register_counter(&INFO[id::TLS_SERVER_HELLO]));
counters.push(registry.register_counter(&INFO[id::RX_STREAM_PROGRESS]));
counters.push(registry.register_counter(&INFO[id::RX_STREAM_PROGRESS__BYTES__TOTAL]));
counters.push(registry.register_counter(&INFO[id::TX_STREAM_PROGRESS]));
counters.push(registry.register_counter(&INFO[id::TX_STREAM_PROGRESS__BYTES__TOTAL]));
counters.push(registry.register_counter(&INFO[id::KEEP_ALIVE_TIMER_EXPIRED]));
counters.push(registry.register_counter(&INFO[id::MTU_UPDATED]));
counters.push(registry.register_counter(&INFO[id::MTU_PROBING_COMPLETE_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::SLOW_START_EXITED]));
counters.push(registry.register_counter(&INFO[id::DELIVERY_RATE_SAMPLED]));
counters.push(registry.register_counter(&INFO[id::PACING_RATE_UPDATED]));
counters.push(registry.register_counter(&INFO[id::BBR_STATE_CHANGED]));
counters.push(registry.register_counter(&INFO[id::DC_STATE_CHANGED]));
counters.push(registry.register_counter(&INFO[id::DC_PATH_CREATED]));
counters.push(registry.register_counter(&INFO[id::CONNECTION_CLOSED]));
counters.push(registry.register_counter(&INFO[id::VERSION_INFORMATION]));
counters.push(registry.register_counter(&INFO[id::ENDPOINT_PACKET_SENT]));
counters.push(registry.register_counter(&INFO[id::ENDPOINT_PACKET_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::ENDPOINT_DATAGRAM_SENT]));
counters.push(registry.register_counter(&INFO[id::ENDPOINT_DATAGRAM_RECEIVED]));
counters.push(registry.register_counter(&INFO[id::ENDPOINT_DATAGRAM_DROPPED]));
counters.push(registry.register_counter(&INFO[id::ENDPOINT_CONNECTION_ATTEMPT_FAILED]));
counters
.push(registry.register_counter(&INFO[id::ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_TX]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_TX__PACKETS__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_TX__SYSCALLS__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_TX__ERRORS__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_TX__ERRORS__DROPPED__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_TX_ERROR]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX__PACKETS__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX__SYSCALLS__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX__ERRORS__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX__ERRORS__DROPPED__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX_ERROR]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_FEATURE_CONFIGURED]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_RX_SOCKET_STATS]));
counters
.push(registry.register_counter(&INFO[id::PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_EVENT_LOOP_WAKEUP]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_EVENT_LOOP_SLEEP]));
counters.push(registry.register_counter(&INFO[id::PLATFORM_EVENT_LOOP_STARTED]));
bool_counters.push(registry.register_bool_counter(&INFO[id::PACKET_LOST__IS_MTU_PROBE]));
bool_counters
.push(registry.register_bool_counter(&INFO[id::RECOVERY_METRICS__CONGESTION_LIMITED]));
bool_counters.push(registry.register_bool_counter(&INFO[id::MTU_UPDATED__SEARCH_COMPLETE]));
{
#[allow(unused_imports)]
use api::*;
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(&INFO[id::PACKET_SENT__KIND], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <TransmissionMode as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::PACKET_SENT__TRANSMISSION_MODE],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::PACKET_RECEIVED__KIND], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(&INFO[id::FRAME_SENT__PACKET], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <Frame as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(&INFO[id::FRAME_SENT__FRAME], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::FRAME_RECEIVED__PACKET], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <Frame as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::FRAME_RECEIVED__FRAME], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::CONNECTION_CLOSE_FRAME_RECEIVED__PACKET],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(&INFO[id::PACKET_LOST__KIND], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <CongestionSource as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(&INFO[id::CONGESTION__SOURCE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(
&INFO[id::ACK_RANGE_RECEIVED__PACKET],
variant,
),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::ACK_RANGE_SENT__PACKET], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketDropReason as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::PACKET_DROPPED__REASON], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <KeyType as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(&INFO[id::KEY_UPDATE__KEY_TYPE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <CipherSuite as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::KEY_UPDATE__CIPHER_SUITE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <KeySpace as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(
&INFO[id::KEY_SPACE_DISCARDED__SPACE],
variant,
),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::DUPLICATE_PACKET__KIND], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <DuplicatePacketError as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::DUPLICATE_PACKET__ERROR], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <DatagramDropReason as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::DATAGRAM_DROPPED__REASON], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <EcnState as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::ECN_STATE_CHANGED__STATE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <MigrationDenyReason as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::CONNECTION_MIGRATION_DENIED__REASON],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <HandshakeStatus as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::HANDSHAKE_STATUS_UPDATED__STATUS],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PathChallengeStatus as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::PATH_CHALLENGE_UPDATED__STATUS],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <MtuUpdatedCause as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry.register_nominal_counter(&INFO[id::MTU_UPDATED__CAUSE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <PacketHeader as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::MTU_PROBING_COMPLETE_RECEIVED__PACKET],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <SlowStartExitCause as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::SLOW_START_EXITED__CAUSE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <BbrState as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::BBR_STATE_CHANGED__STATE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <DcState as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::DC_STATE_CHANGED__STATE], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <crate::connection::Error as AsVariant>::VARIANTS.iter() {
nominal_counters.push(
registry
.register_nominal_counter(&INFO[id::CONNECTION_CLOSED__ERROR], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <DatagramDropReason as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::ENDPOINT_DATAGRAM_DROPPED__REASON],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
{
let offset = nominal_counters.len();
let mut count = 0;
for variant in <crate::connection::Error as AsVariant>::VARIANTS.iter() {
nominal_counters.push(registry.register_nominal_counter(
&INFO[id::ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR],
variant,
));
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_counter_offsets.push(offset);
}
}
measures.push(registry.register_measure(&INFO[id::PACKET_SENT__BYTES]));
measures.push(registry.register_measure(&INFO[id::PACKET_RECEIVED__BYTES]));
measures.push(registry.register_measure(&INFO[id::PACKET_LOST__BYTES]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__MIN_RTT]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__SMOOTHED_RTT]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__LATEST_RTT]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__RTT_VARIANCE]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__MAX_ACK_DELAY]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__PTO_COUNT]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__CONGESTION_WINDOW]));
measures.push(registry.register_measure(&INFO[id::RECOVERY_METRICS__BYTES_IN_FLIGHT]));
measures.push(registry.register_measure(&INFO[id::DATAGRAM_SENT__BYTES]));
measures.push(registry.register_measure(&INFO[id::DATAGRAM_SENT__GSO_OFFSET]));
measures.push(registry.register_measure(&INFO[id::DATAGRAM_RECEIVED__BYTES]));
measures.push(registry.register_measure(&INFO[id::DATAGRAM_DROPPED__BYTES]));
measures.push(registry.register_measure(&INFO[id::RX_STREAM_PROGRESS__BYTES]));
measures.push(registry.register_measure(&INFO[id::TX_STREAM_PROGRESS__BYTES]));
measures.push(registry.register_measure(&INFO[id::MTU_UPDATED__MTU]));
measures.push(registry.register_measure(&INFO[id::MTU_PROBING_COMPLETE_RECEIVED__MTU]));
measures.push(registry.register_measure(&INFO[id::SLOW_START_EXITED__CONGESTION_WINDOW]));
measures.push(registry.register_measure(&INFO[id::PACING_RATE_UPDATED__BYTES_PER_SECOND]));
measures.push(registry.register_measure(&INFO[id::PACING_RATE_UPDATED__BURST_SIZE]));
measures.push(registry.register_measure(&INFO[id::PACING_RATE_UPDATED__PACING_GAIN]));
measures.push(registry.register_measure(&INFO[id::ENDPOINT_DATAGRAM_SENT__BYTES]));
measures.push(registry.register_measure(&INFO[id::ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL]));
measures.push(registry.register_measure(&INFO[id::ENDPOINT_DATAGRAM_SENT__GSO_OFFSET]));
measures.push(registry.register_measure(&INFO[id::ENDPOINT_DATAGRAM_RECEIVED__BYTES]));
measures
.push(registry.register_measure(&INFO[id::ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL]));
measures.push(registry.register_measure(&INFO[id::ENDPOINT_DATAGRAM_DROPPED__BYTES]));
measures
.push(registry.register_measure(&INFO[id::ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_TX__PACKETS]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_TX__SYSCALLS]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_TX__SYSCALLS__BLOCKED]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_TX__ERRORS]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_TX__ERRORS__DROPPED]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_RX__PACKETS]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_RX__SYSCALLS]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_RX__SYSCALLS__BLOCKED]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_RX__ERRORS]));
measures.push(registry.register_measure(&INFO[id::PLATFORM_RX__ERRORS__DROPPED]));
timers.push(registry.register_timer(&INFO[id::KEY_SPACE_DISCARDED__INITIAL__LATENCY]));
timers.push(registry.register_timer(&INFO[id::KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY]));
timers.push(registry.register_timer(&INFO[id::KEY_SPACE_DISCARDED__ONE_RTT__LATENCY]));
timers.push(registry.register_timer(&INFO[id::TRANSPORT_PARAMETERS_RECEIVED__LATENCY]));
timers
.push(registry.register_timer(&INFO[id::HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY]));
timers
.push(registry.register_timer(&INFO[id::HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY]));
timers
.push(registry.register_timer(
&INFO[id::HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY],
));
timers.push(registry.register_timer(&INFO[id::TLS_CLIENT_HELLO__LATENCY]));
timers.push(registry.register_timer(&INFO[id::TLS_SERVER_HELLO__LATENCY]));
timers.push(
registry.register_timer(&INFO[id::DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY]),
);
timers.push(
registry.register_timer(&INFO[id::DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY]),
);
timers.push(registry.register_timer(&INFO[id::DC_STATE_CHANGED__PATH_SECRETS__LATENCY]));
timers.push(registry.register_timer(&INFO[id::DC_STATE_CHANGED__COMPLETE__LATENCY]));
timers.push(registry.register_timer(&INFO[id::CONNECTION_CLOSED__LATENCY]));
timers.push(
registry.register_timer(&INFO[id::PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION]),
);
{
#[allow(unused_imports)]
use api::*;
{
let offset = nominal_timers.len();
let mut count = 0;
for variant in <SlowStartExitCause as AsVariant>::VARIANTS.iter() {
nominal_timers.push(
registry
.register_nominal_timer(&INFO[id::SLOW_START_EXITED__LATENCY], variant),
);
count += 1;
}
debug_assert_ne!(count, 0, "field type needs at least one variant");
nominal_timer_offsets.push(offset);
}
}
Self {
counters: counters
.try_into()
.unwrap_or_else(|_| panic!("invalid len")),
bool_counters: bool_counters
.try_into()
.unwrap_or_else(|_| panic!("invalid len")),
nominal_counters: nominal_counters.into(),
nominal_counter_offsets: nominal_counter_offsets
.try_into()
.unwrap_or_else(|_| panic!("invalid len")),
measures: measures
.try_into()
.unwrap_or_else(|_| panic!("invalid len")),
gauges: gauges.try_into().unwrap_or_else(|_| panic!("invalid len")),
timers: timers.try_into().unwrap_or_else(|_| panic!("invalid len")),
nominal_timers: nominal_timers.into(),
nominal_timer_offsets: nominal_timer_offsets
.try_into()
.unwrap_or_else(|_| panic!("invalid len")),
registry,
}
}
#[doc = r" Returns all of the registered counters"]
#[inline]
pub fn counters(&self) -> impl Iterator<Item = (&'static Info, &R::Counter)> + '_ {
self.counters
.iter()
.enumerate()
.map(|(idx, entry)| match idx {
id::COUNTERS_APPLICATION_PROTOCOL_INFORMATION => {
(&INFO[id::APPLICATION_PROTOCOL_INFORMATION], entry)
}
id::COUNTERS_SERVER_NAME_INFORMATION => (&INFO[id::SERVER_NAME_INFORMATION], entry),
id::COUNTERS_KEY_EXCHANGE_GROUP => (&INFO[id::KEY_EXCHANGE_GROUP], entry),
id::COUNTERS_PACKET_SKIPPED => (&INFO[id::PACKET_SKIPPED], entry),
id::COUNTERS_PACKET_SENT => (&INFO[id::PACKET_SENT], entry),
id::COUNTERS_PACKET_SENT__BYTES__TOTAL => {
(&INFO[id::PACKET_SENT__BYTES__TOTAL], entry)
}
id::COUNTERS_PACKET_RECEIVED => (&INFO[id::PACKET_RECEIVED], entry),
id::COUNTERS_PACKET_RECEIVED__BYTES__TOTAL => {
(&INFO[id::PACKET_RECEIVED__BYTES__TOTAL], entry)
}
id::COUNTERS_ACTIVE_PATH_UPDATED => (&INFO[id::ACTIVE_PATH_UPDATED], entry),
id::COUNTERS_PATH_CREATED => (&INFO[id::PATH_CREATED], entry),
id::COUNTERS_FRAME_SENT => (&INFO[id::FRAME_SENT], entry),
id::COUNTERS_FRAME_RECEIVED => (&INFO[id::FRAME_RECEIVED], entry),
id::COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED => {
(&INFO[id::CONNECTION_CLOSE_FRAME_RECEIVED], entry)
}
id::COUNTERS_PACKET_LOST => (&INFO[id::PACKET_LOST], entry),
id::COUNTERS_PACKET_LOST__BYTES__TOTAL => {
(&INFO[id::PACKET_LOST__BYTES__TOTAL], entry)
}
id::COUNTERS_RECOVERY_METRICS => (&INFO[id::RECOVERY_METRICS], entry),
id::COUNTERS_CONGESTION => (&INFO[id::CONGESTION], entry),
id::COUNTERS_RX_ACK_RANGE_DROPPED => (&INFO[id::RX_ACK_RANGE_DROPPED], entry),
id::COUNTERS_ACK_RANGE_RECEIVED => (&INFO[id::ACK_RANGE_RECEIVED], entry),
id::COUNTERS_ACK_RANGE_SENT => (&INFO[id::ACK_RANGE_SENT], entry),
id::COUNTERS_PACKET_DROPPED => (&INFO[id::PACKET_DROPPED], entry),
id::COUNTERS_KEY_UPDATE => (&INFO[id::KEY_UPDATE], entry),
id::COUNTERS_KEY_SPACE_DISCARDED => (&INFO[id::KEY_SPACE_DISCARDED], entry),
id::COUNTERS_CONNECTION_STARTED => (&INFO[id::CONNECTION_STARTED], entry),
id::COUNTERS_DUPLICATE_PACKET => (&INFO[id::DUPLICATE_PACKET], entry),
id::COUNTERS_TRANSPORT_PARAMETERS_RECEIVED => {
(&INFO[id::TRANSPORT_PARAMETERS_RECEIVED], entry)
}
id::COUNTERS_DATAGRAM_SENT => (&INFO[id::DATAGRAM_SENT], entry),
id::COUNTERS_DATAGRAM_SENT__BYTES__TOTAL => {
(&INFO[id::DATAGRAM_SENT__BYTES__TOTAL], entry)
}
id::COUNTERS_DATAGRAM_RECEIVED => (&INFO[id::DATAGRAM_RECEIVED], entry),
id::COUNTERS_DATAGRAM_RECEIVED__BYTES__TOTAL => {
(&INFO[id::DATAGRAM_RECEIVED__BYTES__TOTAL], entry)
}
id::COUNTERS_DATAGRAM_DROPPED => (&INFO[id::DATAGRAM_DROPPED], entry),
id::COUNTERS_DATAGRAM_DROPPED__BYTES__TOTAL => {
(&INFO[id::DATAGRAM_DROPPED__BYTES__TOTAL], entry)
}
id::COUNTERS_HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED => {
(&INFO[id::HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED], entry)
}
id::COUNTERS_CONNECTION_ID_UPDATED => (&INFO[id::CONNECTION_ID_UPDATED], entry),
id::COUNTERS_ECN_STATE_CHANGED => (&INFO[id::ECN_STATE_CHANGED], entry),
id::COUNTERS_CONNECTION_MIGRATION_DENIED => {
(&INFO[id::CONNECTION_MIGRATION_DENIED], entry)
}
id::COUNTERS_HANDSHAKE_STATUS_UPDATED => {
(&INFO[id::HANDSHAKE_STATUS_UPDATED], entry)
}
id::COUNTERS_TLS_EXPORTER_READY => (&INFO[id::TLS_EXPORTER_READY], entry),
id::COUNTERS_TLS_HANDSHAKE_FAILED => (&INFO[id::TLS_HANDSHAKE_FAILED], entry),
id::COUNTERS_PATH_CHALLENGE_UPDATED => (&INFO[id::PATH_CHALLENGE_UPDATED], entry),
id::COUNTERS_TLS_CLIENT_HELLO => (&INFO[id::TLS_CLIENT_HELLO], entry),
id::COUNTERS_TLS_SERVER_HELLO => (&INFO[id::TLS_SERVER_HELLO], entry),
id::COUNTERS_RX_STREAM_PROGRESS => (&INFO[id::RX_STREAM_PROGRESS], entry),
id::COUNTERS_RX_STREAM_PROGRESS__BYTES__TOTAL => {
(&INFO[id::RX_STREAM_PROGRESS__BYTES__TOTAL], entry)
}
id::COUNTERS_TX_STREAM_PROGRESS => (&INFO[id::TX_STREAM_PROGRESS], entry),
id::COUNTERS_TX_STREAM_PROGRESS__BYTES__TOTAL => {
(&INFO[id::TX_STREAM_PROGRESS__BYTES__TOTAL], entry)
}
id::COUNTERS_KEEP_ALIVE_TIMER_EXPIRED => {
(&INFO[id::KEEP_ALIVE_TIMER_EXPIRED], entry)
}
id::COUNTERS_MTU_UPDATED => (&INFO[id::MTU_UPDATED], entry),
id::COUNTERS_MTU_PROBING_COMPLETE_RECEIVED => {
(&INFO[id::MTU_PROBING_COMPLETE_RECEIVED], entry)
}
id::COUNTERS_SLOW_START_EXITED => (&INFO[id::SLOW_START_EXITED], entry),
id::COUNTERS_DELIVERY_RATE_SAMPLED => (&INFO[id::DELIVERY_RATE_SAMPLED], entry),
id::COUNTERS_PACING_RATE_UPDATED => (&INFO[id::PACING_RATE_UPDATED], entry),
id::COUNTERS_BBR_STATE_CHANGED => (&INFO[id::BBR_STATE_CHANGED], entry),
id::COUNTERS_DC_STATE_CHANGED => (&INFO[id::DC_STATE_CHANGED], entry),
id::COUNTERS_DC_PATH_CREATED => (&INFO[id::DC_PATH_CREATED], entry),
id::COUNTERS_CONNECTION_CLOSED => (&INFO[id::CONNECTION_CLOSED], entry),
id::COUNTERS_VERSION_INFORMATION => (&INFO[id::VERSION_INFORMATION], entry),
id::COUNTERS_ENDPOINT_PACKET_SENT => (&INFO[id::ENDPOINT_PACKET_SENT], entry),
id::COUNTERS_ENDPOINT_PACKET_RECEIVED => {
(&INFO[id::ENDPOINT_PACKET_RECEIVED], entry)
}
id::COUNTERS_ENDPOINT_DATAGRAM_SENT => (&INFO[id::ENDPOINT_DATAGRAM_SENT], entry),
id::COUNTERS_ENDPOINT_DATAGRAM_RECEIVED => {
(&INFO[id::ENDPOINT_DATAGRAM_RECEIVED], entry)
}
id::COUNTERS_ENDPOINT_DATAGRAM_DROPPED => {
(&INFO[id::ENDPOINT_DATAGRAM_DROPPED], entry)
}
id::COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED => {
(&INFO[id::ENDPOINT_CONNECTION_ATTEMPT_FAILED], entry)
}
id::COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED => {
(&INFO[id::ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED], entry)
}
id::COUNTERS_PLATFORM_TX => (&INFO[id::PLATFORM_TX], entry),
id::COUNTERS_PLATFORM_TX__PACKETS__TOTAL => {
(&INFO[id::PLATFORM_TX__PACKETS__TOTAL], entry)
}
id::COUNTERS_PLATFORM_TX__SYSCALLS__TOTAL => {
(&INFO[id::PLATFORM_TX__SYSCALLS__TOTAL], entry)
}
id::COUNTERS_PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL => {
(&INFO[id::PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL], entry)
}
id::COUNTERS_PLATFORM_TX__ERRORS__TOTAL => {
(&INFO[id::PLATFORM_TX__ERRORS__TOTAL], entry)
}
id::COUNTERS_PLATFORM_TX__ERRORS__DROPPED__TOTAL => {
(&INFO[id::PLATFORM_TX__ERRORS__DROPPED__TOTAL], entry)
}
id::COUNTERS_PLATFORM_TX_ERROR => (&INFO[id::PLATFORM_TX_ERROR], entry),
id::COUNTERS_PLATFORM_RX => (&INFO[id::PLATFORM_RX], entry),
id::COUNTERS_PLATFORM_RX__PACKETS__TOTAL => {
(&INFO[id::PLATFORM_RX__PACKETS__TOTAL], entry)
}
id::COUNTERS_PLATFORM_RX__SYSCALLS__TOTAL => {
(&INFO[id::PLATFORM_RX__SYSCALLS__TOTAL], entry)
}
id::COUNTERS_PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL => {
(&INFO[id::PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL], entry)
}
id::COUNTERS_PLATFORM_RX__ERRORS__TOTAL => {
(&INFO[id::PLATFORM_RX__ERRORS__TOTAL], entry)
}
id::COUNTERS_PLATFORM_RX__ERRORS__DROPPED__TOTAL => {
(&INFO[id::PLATFORM_RX__ERRORS__DROPPED__TOTAL], entry)
}
id::COUNTERS_PLATFORM_RX_ERROR => (&INFO[id::PLATFORM_RX_ERROR], entry),
id::COUNTERS_PLATFORM_FEATURE_CONFIGURED => {
(&INFO[id::PLATFORM_FEATURE_CONFIGURED], entry)
}
id::COUNTERS_PLATFORM_RX_SOCKET_STATS => {
(&INFO[id::PLATFORM_RX_SOCKET_STATS], entry)
}
id::COUNTERS_PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL => {
(&INFO[id::PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL], entry)
}
id::COUNTERS_PLATFORM_EVENT_LOOP_WAKEUP => {
(&INFO[id::PLATFORM_EVENT_LOOP_WAKEUP], entry)
}
id::COUNTERS_PLATFORM_EVENT_LOOP_SLEEP => {
(&INFO[id::PLATFORM_EVENT_LOOP_SLEEP], entry)
}
id::COUNTERS_PLATFORM_EVENT_LOOP_STARTED => {
(&INFO[id::PLATFORM_EVENT_LOOP_STARTED], entry)
}
_ => unsafe { core::hint::unreachable_unchecked() },
})
}
#[allow(dead_code)]
#[inline(always)]
fn count<T: Metric>(&self, info: usize, id: usize, value: T) {
let info = &INFO[info];
let counter = &self.counters[id];
counter.record(info, value);
}
#[doc = r" Returns all of the registered bool counters"]
#[inline]
pub fn bool_counters(&self) -> impl Iterator<Item = (&'static Info, &R::BoolCounter)> + '_ {
self.bool_counters
.iter()
.enumerate()
.map(|(idx, entry)| match idx {
id::BOOL_COUNTERS_PACKET_LOST__IS_MTU_PROBE => {
(&INFO[id::PACKET_LOST__IS_MTU_PROBE], entry)
}
id::BOOL_COUNTERS_RECOVERY_METRICS__CONGESTION_LIMITED => {
(&INFO[id::RECOVERY_METRICS__CONGESTION_LIMITED], entry)
}
id::BOOL_COUNTERS_MTU_UPDATED__SEARCH_COMPLETE => {
(&INFO[id::MTU_UPDATED__SEARCH_COMPLETE], entry)
}
_ => unsafe { core::hint::unreachable_unchecked() },
})
}
#[allow(dead_code)]
#[inline(always)]
fn count_bool(&self, info: usize, id: usize, value: bool) {
let info = &INFO[info];
let counter = &self.bool_counters[id];
counter.record(info, value);
}
#[doc = r" Returns all of the registered nominal counters"]
#[inline]
pub fn nominal_counters(
&self,
) -> impl Iterator<Item = (&'static Info, &[R::NominalCounter], &[info::Variant])> + '_ {
#[allow(unused_imports)]
use api::*;
self.nominal_counter_offsets
.iter()
.enumerate()
.map(|(idx, entry)| match idx {
id::NOMINAL_COUNTERS_PACKET_SENT__KIND => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::PACKET_SENT__KIND], entries, variants)
}
id::NOMINAL_COUNTERS_PACKET_SENT__TRANSMISSION_MODE => {
let offset = *entry;
let variants = <TransmissionMode as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::PACKET_SENT__TRANSMISSION_MODE], entries, variants)
}
id::NOMINAL_COUNTERS_PACKET_RECEIVED__KIND => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::PACKET_RECEIVED__KIND], entries, variants)
}
id::NOMINAL_COUNTERS_FRAME_SENT__PACKET => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::FRAME_SENT__PACKET], entries, variants)
}
id::NOMINAL_COUNTERS_FRAME_SENT__FRAME => {
let offset = *entry;
let variants = <Frame as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::FRAME_SENT__FRAME], entries, variants)
}
id::NOMINAL_COUNTERS_FRAME_RECEIVED__PACKET => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::FRAME_RECEIVED__PACKET], entries, variants)
}
id::NOMINAL_COUNTERS_FRAME_RECEIVED__FRAME => {
let offset = *entry;
let variants = <Frame as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::FRAME_RECEIVED__FRAME], entries, variants)
}
id::NOMINAL_COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED__PACKET => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(
&INFO[id::CONNECTION_CLOSE_FRAME_RECEIVED__PACKET],
entries,
variants,
)
}
id::NOMINAL_COUNTERS_PACKET_LOST__KIND => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::PACKET_LOST__KIND], entries, variants)
}
id::NOMINAL_COUNTERS_CONGESTION__SOURCE => {
let offset = *entry;
let variants = <CongestionSource as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::CONGESTION__SOURCE], entries, variants)
}
id::NOMINAL_COUNTERS_ACK_RANGE_RECEIVED__PACKET => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::ACK_RANGE_RECEIVED__PACKET], entries, variants)
}
id::NOMINAL_COUNTERS_ACK_RANGE_SENT__PACKET => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::ACK_RANGE_SENT__PACKET], entries, variants)
}
id::NOMINAL_COUNTERS_PACKET_DROPPED__REASON => {
let offset = *entry;
let variants = <PacketDropReason as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::PACKET_DROPPED__REASON], entries, variants)
}
id::NOMINAL_COUNTERS_KEY_UPDATE__KEY_TYPE => {
let offset = *entry;
let variants = <KeyType as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::KEY_UPDATE__KEY_TYPE], entries, variants)
}
id::NOMINAL_COUNTERS_KEY_UPDATE__CIPHER_SUITE => {
let offset = *entry;
let variants = <CipherSuite as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::KEY_UPDATE__CIPHER_SUITE], entries, variants)
}
id::NOMINAL_COUNTERS_KEY_SPACE_DISCARDED__SPACE => {
let offset = *entry;
let variants = <KeySpace as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::KEY_SPACE_DISCARDED__SPACE], entries, variants)
}
id::NOMINAL_COUNTERS_DUPLICATE_PACKET__KIND => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::DUPLICATE_PACKET__KIND], entries, variants)
}
id::NOMINAL_COUNTERS_DUPLICATE_PACKET__ERROR => {
let offset = *entry;
let variants = <DuplicatePacketError as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::DUPLICATE_PACKET__ERROR], entries, variants)
}
id::NOMINAL_COUNTERS_DATAGRAM_DROPPED__REASON => {
let offset = *entry;
let variants = <DatagramDropReason as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::DATAGRAM_DROPPED__REASON], entries, variants)
}
id::NOMINAL_COUNTERS_ECN_STATE_CHANGED__STATE => {
let offset = *entry;
let variants = <EcnState as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::ECN_STATE_CHANGED__STATE], entries, variants)
}
id::NOMINAL_COUNTERS_CONNECTION_MIGRATION_DENIED__REASON => {
let offset = *entry;
let variants = <MigrationDenyReason as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(
&INFO[id::CONNECTION_MIGRATION_DENIED__REASON],
entries,
variants,
)
}
id::NOMINAL_COUNTERS_HANDSHAKE_STATUS_UPDATED__STATUS => {
let offset = *entry;
let variants = <HandshakeStatus as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(
&INFO[id::HANDSHAKE_STATUS_UPDATED__STATUS],
entries,
variants,
)
}
id::NOMINAL_COUNTERS_PATH_CHALLENGE_UPDATED__STATUS => {
let offset = *entry;
let variants = <PathChallengeStatus as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::PATH_CHALLENGE_UPDATED__STATUS], entries, variants)
}
id::NOMINAL_COUNTERS_MTU_UPDATED__CAUSE => {
let offset = *entry;
let variants = <MtuUpdatedCause as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::MTU_UPDATED__CAUSE], entries, variants)
}
id::NOMINAL_COUNTERS_MTU_PROBING_COMPLETE_RECEIVED__PACKET => {
let offset = *entry;
let variants = <PacketHeader as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(
&INFO[id::MTU_PROBING_COMPLETE_RECEIVED__PACKET],
entries,
variants,
)
}
id::NOMINAL_COUNTERS_SLOW_START_EXITED__CAUSE => {
let offset = *entry;
let variants = <SlowStartExitCause as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::SLOW_START_EXITED__CAUSE], entries, variants)
}
id::NOMINAL_COUNTERS_BBR_STATE_CHANGED__STATE => {
let offset = *entry;
let variants = <BbrState as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::BBR_STATE_CHANGED__STATE], entries, variants)
}
id::NOMINAL_COUNTERS_DC_STATE_CHANGED__STATE => {
let offset = *entry;
let variants = <DcState as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::DC_STATE_CHANGED__STATE], entries, variants)
}
id::NOMINAL_COUNTERS_CONNECTION_CLOSED__ERROR => {
let offset = *entry;
let variants = <crate::connection::Error as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(&INFO[id::CONNECTION_CLOSED__ERROR], entries, variants)
}
id::NOMINAL_COUNTERS_ENDPOINT_DATAGRAM_DROPPED__REASON => {
let offset = *entry;
let variants = <DatagramDropReason as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(
&INFO[id::ENDPOINT_DATAGRAM_DROPPED__REASON],
entries,
variants,
)
}
id::NOMINAL_COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR => {
let offset = *entry;
let variants = <crate::connection::Error as AsVariant>::VARIANTS;
let entries = &self.nominal_counters[offset..offset + variants.len()];
(
&INFO[id::ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR],
entries,
variants,
)
}
_ => unsafe { core::hint::unreachable_unchecked() },
})
}
#[allow(dead_code)]
#[inline(always)]
fn count_nominal<T: AsVariant>(&self, info: usize, id: usize, value: &T) {
let info = &INFO[info];
let idx = self.nominal_counter_offsets[id] + value.variant_idx();
let counter = &self.nominal_counters[idx];
counter.record(info, value.as_variant(), 1usize);
}
#[doc = r" Returns all of the registered measures"]
#[inline]
pub fn measures(&self) -> impl Iterator<Item = (&'static Info, &R::Measure)> + '_ {
self.measures
.iter()
.enumerate()
.map(|(idx, entry)| match idx {
id::MEASURES_PACKET_SENT__BYTES => (&INFO[id::PACKET_SENT__BYTES], entry),
id::MEASURES_PACKET_RECEIVED__BYTES => (&INFO[id::PACKET_RECEIVED__BYTES], entry),
id::MEASURES_PACKET_LOST__BYTES => (&INFO[id::PACKET_LOST__BYTES], entry),
id::MEASURES_RECOVERY_METRICS__MIN_RTT => {
(&INFO[id::RECOVERY_METRICS__MIN_RTT], entry)
}
id::MEASURES_RECOVERY_METRICS__SMOOTHED_RTT => {
(&INFO[id::RECOVERY_METRICS__SMOOTHED_RTT], entry)
}
id::MEASURES_RECOVERY_METRICS__LATEST_RTT => {
(&INFO[id::RECOVERY_METRICS__LATEST_RTT], entry)
}
id::MEASURES_RECOVERY_METRICS__RTT_VARIANCE => {
(&INFO[id::RECOVERY_METRICS__RTT_VARIANCE], entry)
}
id::MEASURES_RECOVERY_METRICS__MAX_ACK_DELAY => {
(&INFO[id::RECOVERY_METRICS__MAX_ACK_DELAY], entry)
}
id::MEASURES_RECOVERY_METRICS__PTO_COUNT => {
(&INFO[id::RECOVERY_METRICS__PTO_COUNT], entry)
}
id::MEASURES_RECOVERY_METRICS__CONGESTION_WINDOW => {
(&INFO[id::RECOVERY_METRICS__CONGESTION_WINDOW], entry)
}
id::MEASURES_RECOVERY_METRICS__BYTES_IN_FLIGHT => {
(&INFO[id::RECOVERY_METRICS__BYTES_IN_FLIGHT], entry)
}
id::MEASURES_DATAGRAM_SENT__BYTES => (&INFO[id::DATAGRAM_SENT__BYTES], entry),
id::MEASURES_DATAGRAM_SENT__GSO_OFFSET => {
(&INFO[id::DATAGRAM_SENT__GSO_OFFSET], entry)
}
id::MEASURES_DATAGRAM_RECEIVED__BYTES => {
(&INFO[id::DATAGRAM_RECEIVED__BYTES], entry)
}
id::MEASURES_DATAGRAM_DROPPED__BYTES => (&INFO[id::DATAGRAM_DROPPED__BYTES], entry),
id::MEASURES_RX_STREAM_PROGRESS__BYTES => {
(&INFO[id::RX_STREAM_PROGRESS__BYTES], entry)
}
id::MEASURES_TX_STREAM_PROGRESS__BYTES => {
(&INFO[id::TX_STREAM_PROGRESS__BYTES], entry)
}
id::MEASURES_MTU_UPDATED__MTU => (&INFO[id::MTU_UPDATED__MTU], entry),
id::MEASURES_MTU_PROBING_COMPLETE_RECEIVED__MTU => {
(&INFO[id::MTU_PROBING_COMPLETE_RECEIVED__MTU], entry)
}
id::MEASURES_SLOW_START_EXITED__CONGESTION_WINDOW => {
(&INFO[id::SLOW_START_EXITED__CONGESTION_WINDOW], entry)
}
id::MEASURES_PACING_RATE_UPDATED__BYTES_PER_SECOND => {
(&INFO[id::PACING_RATE_UPDATED__BYTES_PER_SECOND], entry)
}
id::MEASURES_PACING_RATE_UPDATED__BURST_SIZE => {
(&INFO[id::PACING_RATE_UPDATED__BURST_SIZE], entry)
}
id::MEASURES_PACING_RATE_UPDATED__PACING_GAIN => {
(&INFO[id::PACING_RATE_UPDATED__PACING_GAIN], entry)
}
id::MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES => {
(&INFO[id::ENDPOINT_DATAGRAM_SENT__BYTES], entry)
}
id::MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL => {
(&INFO[id::ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL], entry)
}
id::MEASURES_ENDPOINT_DATAGRAM_SENT__GSO_OFFSET => {
(&INFO[id::ENDPOINT_DATAGRAM_SENT__GSO_OFFSET], entry)
}
id::MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES => {
(&INFO[id::ENDPOINT_DATAGRAM_RECEIVED__BYTES], entry)
}
id::MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL => {
(&INFO[id::ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL], entry)
}
id::MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES => {
(&INFO[id::ENDPOINT_DATAGRAM_DROPPED__BYTES], entry)
}
id::MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL => {
(&INFO[id::ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL], entry)
}
id::MEASURES_PLATFORM_TX__PACKETS => (&INFO[id::PLATFORM_TX__PACKETS], entry),
id::MEASURES_PLATFORM_TX__SYSCALLS => (&INFO[id::PLATFORM_TX__SYSCALLS], entry),
id::MEASURES_PLATFORM_TX__SYSCALLS__BLOCKED => {
(&INFO[id::PLATFORM_TX__SYSCALLS__BLOCKED], entry)
}
id::MEASURES_PLATFORM_TX__ERRORS => (&INFO[id::PLATFORM_TX__ERRORS], entry),
id::MEASURES_PLATFORM_TX__ERRORS__DROPPED => {
(&INFO[id::PLATFORM_TX__ERRORS__DROPPED], entry)
}
id::MEASURES_PLATFORM_RX__PACKETS => (&INFO[id::PLATFORM_RX__PACKETS], entry),
id::MEASURES_PLATFORM_RX__SYSCALLS => (&INFO[id::PLATFORM_RX__SYSCALLS], entry),
id::MEASURES_PLATFORM_RX__SYSCALLS__BLOCKED => {
(&INFO[id::PLATFORM_RX__SYSCALLS__BLOCKED], entry)
}
id::MEASURES_PLATFORM_RX__ERRORS => (&INFO[id::PLATFORM_RX__ERRORS], entry),
id::MEASURES_PLATFORM_RX__ERRORS__DROPPED => {
(&INFO[id::PLATFORM_RX__ERRORS__DROPPED], entry)
}
_ => unsafe { core::hint::unreachable_unchecked() },
})
}
#[allow(dead_code)]
#[inline(always)]
fn measure<T: Metric>(&self, info: usize, id: usize, value: T) {
let info = &INFO[info];
let measure = &self.measures[id];
measure.record(info, value);
}
#[doc = r" Returns all of the registered gauges"]
#[inline]
pub fn gauges(&self) -> impl Iterator<Item = (&'static Info, &R::Gauge)> + '_ {
core::iter::empty()
}
#[allow(dead_code)]
#[inline(always)]
fn gauge<T: Metric>(&self, info: usize, id: usize, value: T) {
let info = &INFO[info];
let gauge = &self.gauges[id];
gauge.record(info, value);
}
#[doc = r" Returns all of the registered timers"]
#[inline]
pub fn timers(&self) -> impl Iterator<Item = (&'static Info, &R::Timer)> + '_ {
self.timers
.iter()
.enumerate()
.map(|(idx, entry)| match idx {
id::TIMERS_KEY_SPACE_DISCARDED__INITIAL__LATENCY => {
(&INFO[id::KEY_SPACE_DISCARDED__INITIAL__LATENCY], entry)
}
id::TIMERS_KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY => {
(&INFO[id::KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY], entry)
}
id::TIMERS_KEY_SPACE_DISCARDED__ONE_RTT__LATENCY => {
(&INFO[id::KEY_SPACE_DISCARDED__ONE_RTT__LATENCY], entry)
}
id::TIMERS_TRANSPORT_PARAMETERS_RECEIVED__LATENCY => {
(&INFO[id::TRANSPORT_PARAMETERS_RECEIVED__LATENCY], entry)
}
id::TIMERS_HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY => (
&INFO[id::HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY],
entry,
),
id::TIMERS_HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY => (
&INFO[id::HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY],
entry,
),
id::TIMERS_HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY => (
&INFO[id::HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY],
entry,
),
id::TIMERS_TLS_CLIENT_HELLO__LATENCY => {
(&INFO[id::TLS_CLIENT_HELLO__LATENCY], entry)
}
id::TIMERS_TLS_SERVER_HELLO__LATENCY => {
(&INFO[id::TLS_SERVER_HELLO__LATENCY], entry)
}
id::TIMERS_DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY => (
&INFO[id::DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY],
entry,
),
id::TIMERS_DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY => (
&INFO[id::DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY],
entry,
),
id::TIMERS_DC_STATE_CHANGED__PATH_SECRETS__LATENCY => {
(&INFO[id::DC_STATE_CHANGED__PATH_SECRETS__LATENCY], entry)
}
id::TIMERS_DC_STATE_CHANGED__COMPLETE__LATENCY => {
(&INFO[id::DC_STATE_CHANGED__COMPLETE__LATENCY], entry)
}
id::TIMERS_CONNECTION_CLOSED__LATENCY => {
(&INFO[id::CONNECTION_CLOSED__LATENCY], entry)
}
id::TIMERS_PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION => (
&INFO[id::PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION],
entry,
),
_ => unsafe { core::hint::unreachable_unchecked() },
})
}
#[allow(dead_code)]
#[inline(always)]
fn time(&self, info: usize, id: usize, value: core::time::Duration) {
let info = &INFO[info];
let timer = &self.timers[id];
timer.record(info, value);
}
#[allow(dead_code)]
#[inline(always)]
fn time_nominal<T: AsVariant>(
&self,
info: usize,
id: usize,
value: &T,
duration: core::time::Duration,
) {
let info = &INFO[info];
let idx = self.nominal_timer_offsets[id] + value.variant_idx();
let counter = &self.nominal_timers[idx];
counter.record(info, value.as_variant(), duration);
}
}
impl<R: Registry> event::Subscriber for Subscriber<R> {
type ConnectionContext = ConnectionContext;
fn create_connection_context(
&mut self,
meta: &api::ConnectionMeta,
_info: &api::ConnectionInfo,
) -> Self::ConnectionContext {
Self::ConnectionContext {
start_time: meta.timestamp,
}
}
#[inline]
fn on_application_protocol_information(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ApplicationProtocolInformation,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::APPLICATION_PROTOCOL_INFORMATION,
id::COUNTERS_APPLICATION_PROTOCOL_INFORMATION,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_server_name_information(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ServerNameInformation,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::SERVER_NAME_INFORMATION,
id::COUNTERS_SERVER_NAME_INFORMATION,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_key_exchange_group(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::KeyExchangeGroup,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::KEY_EXCHANGE_GROUP,
id::COUNTERS_KEY_EXCHANGE_GROUP,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_packet_skipped(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PacketSkipped,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::PACKET_SKIPPED, id::COUNTERS_PACKET_SKIPPED, 1usize);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_packet_sent(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PacketSent,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::PACKET_SENT, id::COUNTERS_PACKET_SENT, 1usize);
self.count_nominal(
id::PACKET_SENT__KIND,
id::NOMINAL_COUNTERS_PACKET_SENT__KIND,
&event.packet_header,
);
self.count(
id::PACKET_SENT__BYTES__TOTAL,
id::COUNTERS_PACKET_SENT__BYTES__TOTAL,
event.packet_len,
);
self.measure(
id::PACKET_SENT__BYTES,
id::MEASURES_PACKET_SENT__BYTES,
event.packet_len,
);
self.count_nominal(
id::PACKET_SENT__TRANSMISSION_MODE,
id::NOMINAL_COUNTERS_PACKET_SENT__TRANSMISSION_MODE,
&event.transmission_mode,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_packet_received(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PacketReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::PACKET_RECEIVED, id::COUNTERS_PACKET_RECEIVED, 1usize);
self.count_nominal(
id::PACKET_RECEIVED__KIND,
id::NOMINAL_COUNTERS_PACKET_RECEIVED__KIND,
&event.packet_header,
);
self.count(
id::PACKET_RECEIVED__BYTES__TOTAL,
id::COUNTERS_PACKET_RECEIVED__BYTES__TOTAL,
event.packet_len,
);
self.measure(
id::PACKET_RECEIVED__BYTES,
id::MEASURES_PACKET_RECEIVED__BYTES,
event.packet_len,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_active_path_updated(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ActivePathUpdated,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ACTIVE_PATH_UPDATED,
id::COUNTERS_ACTIVE_PATH_UPDATED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_created(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PathCreated,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::PATH_CREATED, id::COUNTERS_PATH_CREATED, 1usize);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_frame_sent(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::FrameSent,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::FRAME_SENT, id::COUNTERS_FRAME_SENT, 1usize);
self.count_nominal(
id::FRAME_SENT__PACKET,
id::NOMINAL_COUNTERS_FRAME_SENT__PACKET,
&event.packet_header,
);
self.count_nominal(
id::FRAME_SENT__FRAME,
id::NOMINAL_COUNTERS_FRAME_SENT__FRAME,
&event.frame,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_frame_received(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::FrameReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::FRAME_RECEIVED, id::COUNTERS_FRAME_RECEIVED, 1usize);
self.count_nominal(
id::FRAME_RECEIVED__PACKET,
id::NOMINAL_COUNTERS_FRAME_RECEIVED__PACKET,
&event.packet_header,
);
self.count_nominal(
id::FRAME_RECEIVED__FRAME,
id::NOMINAL_COUNTERS_FRAME_RECEIVED__FRAME,
&event.frame,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_connection_close_frame_received(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionCloseFrameReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::CONNECTION_CLOSE_FRAME_RECEIVED,
id::COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED,
1usize,
);
self.count_nominal(
id::CONNECTION_CLOSE_FRAME_RECEIVED__PACKET,
id::NOMINAL_COUNTERS_CONNECTION_CLOSE_FRAME_RECEIVED__PACKET,
&event.packet_header,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_packet_lost(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PacketLost,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::PACKET_LOST, id::COUNTERS_PACKET_LOST, 1usize);
self.count_nominal(
id::PACKET_LOST__KIND,
id::NOMINAL_COUNTERS_PACKET_LOST__KIND,
&event.packet_header,
);
self.count(
id::PACKET_LOST__BYTES__TOTAL,
id::COUNTERS_PACKET_LOST__BYTES__TOTAL,
event.bytes_lost,
);
self.measure(
id::PACKET_LOST__BYTES,
id::MEASURES_PACKET_LOST__BYTES,
event.bytes_lost,
);
self.count_bool(
id::PACKET_LOST__IS_MTU_PROBE,
id::BOOL_COUNTERS_PACKET_LOST__IS_MTU_PROBE,
event.is_mtu_probe,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_recovery_metrics(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::RecoveryMetrics,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::RECOVERY_METRICS, id::COUNTERS_RECOVERY_METRICS, 1usize);
self.measure(
id::RECOVERY_METRICS__MIN_RTT,
id::MEASURES_RECOVERY_METRICS__MIN_RTT,
event.min_rtt,
);
self.measure(
id::RECOVERY_METRICS__SMOOTHED_RTT,
id::MEASURES_RECOVERY_METRICS__SMOOTHED_RTT,
event.smoothed_rtt,
);
self.measure(
id::RECOVERY_METRICS__LATEST_RTT,
id::MEASURES_RECOVERY_METRICS__LATEST_RTT,
event.latest_rtt,
);
self.measure(
id::RECOVERY_METRICS__RTT_VARIANCE,
id::MEASURES_RECOVERY_METRICS__RTT_VARIANCE,
event.rtt_variance,
);
self.measure(
id::RECOVERY_METRICS__MAX_ACK_DELAY,
id::MEASURES_RECOVERY_METRICS__MAX_ACK_DELAY,
event.max_ack_delay,
);
self.measure(
id::RECOVERY_METRICS__PTO_COUNT,
id::MEASURES_RECOVERY_METRICS__PTO_COUNT,
event.pto_count,
);
self.measure(
id::RECOVERY_METRICS__CONGESTION_WINDOW,
id::MEASURES_RECOVERY_METRICS__CONGESTION_WINDOW,
event.congestion_window,
);
self.measure(
id::RECOVERY_METRICS__BYTES_IN_FLIGHT,
id::MEASURES_RECOVERY_METRICS__BYTES_IN_FLIGHT,
event.bytes_in_flight,
);
self.count_bool(
id::RECOVERY_METRICS__CONGESTION_LIMITED,
id::BOOL_COUNTERS_RECOVERY_METRICS__CONGESTION_LIMITED,
event.congestion_limited,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_congestion(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::Congestion,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::CONGESTION, id::COUNTERS_CONGESTION, 1usize);
self.count_nominal(
id::CONGESTION__SOURCE,
id::NOMINAL_COUNTERS_CONGESTION__SOURCE,
&event.source,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_rx_ack_range_dropped(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::RxAckRangeDropped,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::RX_ACK_RANGE_DROPPED,
id::COUNTERS_RX_ACK_RANGE_DROPPED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_ack_range_received(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::AckRangeReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ACK_RANGE_RECEIVED,
id::COUNTERS_ACK_RANGE_RECEIVED,
1usize,
);
self.count_nominal(
id::ACK_RANGE_RECEIVED__PACKET,
id::NOMINAL_COUNTERS_ACK_RANGE_RECEIVED__PACKET,
&event.packet_header,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_ack_range_sent(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::AckRangeSent,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::ACK_RANGE_SENT, id::COUNTERS_ACK_RANGE_SENT, 1usize);
self.count_nominal(
id::ACK_RANGE_SENT__PACKET,
id::NOMINAL_COUNTERS_ACK_RANGE_SENT__PACKET,
&event.packet_header,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_packet_dropped(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PacketDropped,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::PACKET_DROPPED, id::COUNTERS_PACKET_DROPPED, 1usize);
self.count_nominal(
id::PACKET_DROPPED__REASON,
id::NOMINAL_COUNTERS_PACKET_DROPPED__REASON,
&event.reason,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_key_update(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::KeyUpdate,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::KEY_UPDATE, id::COUNTERS_KEY_UPDATE, 1usize);
self.count_nominal(
id::KEY_UPDATE__KEY_TYPE,
id::NOMINAL_COUNTERS_KEY_UPDATE__KEY_TYPE,
&event.key_type,
);
self.count_nominal(
id::KEY_UPDATE__CIPHER_SUITE,
id::NOMINAL_COUNTERS_KEY_UPDATE__CIPHER_SUITE,
&event.cipher_suite,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_key_space_discarded(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::KeySpaceDiscarded,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::KEY_SPACE_DISCARDED,
id::COUNTERS_KEY_SPACE_DISCARDED,
1usize,
);
{
fn check(evt: &api::KeySpaceDiscarded) -> bool {
matches!(evt.space, KeySpace::Initial { .. })
}
if check(event) {
self.time(
id::KEY_SPACE_DISCARDED__INITIAL__LATENCY,
id::TIMERS_KEY_SPACE_DISCARDED__INITIAL__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
{
fn check(evt: &api::KeySpaceDiscarded) -> bool {
matches!(evt.space, KeySpace::Handshake { .. })
}
if check(event) {
self.time(
id::KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY,
id::TIMERS_KEY_SPACE_DISCARDED__HANDSHAKE__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
{
fn check(evt: &api::KeySpaceDiscarded) -> bool {
matches!(evt.space, KeySpace::OneRtt { .. })
}
if check(event) {
self.time(
id::KEY_SPACE_DISCARDED__ONE_RTT__LATENCY,
id::TIMERS_KEY_SPACE_DISCARDED__ONE_RTT__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
self.count_nominal(
id::KEY_SPACE_DISCARDED__SPACE,
id::NOMINAL_COUNTERS_KEY_SPACE_DISCARDED__SPACE,
&event.space,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_connection_started(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionStarted,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::CONNECTION_STARTED,
id::COUNTERS_CONNECTION_STARTED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_duplicate_packet(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::DuplicatePacket,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::DUPLICATE_PACKET, id::COUNTERS_DUPLICATE_PACKET, 1usize);
self.count_nominal(
id::DUPLICATE_PACKET__KIND,
id::NOMINAL_COUNTERS_DUPLICATE_PACKET__KIND,
&event.packet_header,
);
self.count_nominal(
id::DUPLICATE_PACKET__ERROR,
id::NOMINAL_COUNTERS_DUPLICATE_PACKET__ERROR,
&event.error,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_transport_parameters_received(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::TransportParametersReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::TRANSPORT_PARAMETERS_RECEIVED,
id::COUNTERS_TRANSPORT_PARAMETERS_RECEIVED,
1usize,
);
self.time(
id::TRANSPORT_PARAMETERS_RECEIVED__LATENCY,
id::TIMERS_TRANSPORT_PARAMETERS_RECEIVED__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_datagram_sent(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::DatagramSent,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::DATAGRAM_SENT, id::COUNTERS_DATAGRAM_SENT, 1usize);
self.count(
id::DATAGRAM_SENT__BYTES__TOTAL,
id::COUNTERS_DATAGRAM_SENT__BYTES__TOTAL,
event.len,
);
self.measure(
id::DATAGRAM_SENT__BYTES,
id::MEASURES_DATAGRAM_SENT__BYTES,
event.len,
);
self.measure(
id::DATAGRAM_SENT__GSO_OFFSET,
id::MEASURES_DATAGRAM_SENT__GSO_OFFSET,
event.gso_offset,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_datagram_received(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::DatagramReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::DATAGRAM_RECEIVED,
id::COUNTERS_DATAGRAM_RECEIVED,
1usize,
);
self.count(
id::DATAGRAM_RECEIVED__BYTES__TOTAL,
id::COUNTERS_DATAGRAM_RECEIVED__BYTES__TOTAL,
event.len,
);
self.measure(
id::DATAGRAM_RECEIVED__BYTES,
id::MEASURES_DATAGRAM_RECEIVED__BYTES,
event.len,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_datagram_dropped(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::DatagramDropped,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::DATAGRAM_DROPPED, id::COUNTERS_DATAGRAM_DROPPED, 1usize);
self.count(
id::DATAGRAM_DROPPED__BYTES__TOTAL,
id::COUNTERS_DATAGRAM_DROPPED__BYTES__TOTAL,
event.len,
);
self.measure(
id::DATAGRAM_DROPPED__BYTES,
id::MEASURES_DATAGRAM_DROPPED__BYTES,
event.len,
);
self.count_nominal(
id::DATAGRAM_DROPPED__REASON,
id::NOMINAL_COUNTERS_DATAGRAM_DROPPED__REASON,
&event.reason,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_handshake_remote_address_change_observed(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::HandshakeRemoteAddressChangeObserved,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED,
id::COUNTERS_HANDSHAKE_REMOTE_ADDRESS_CHANGE_OBSERVED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_connection_id_updated(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionIdUpdated,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::CONNECTION_ID_UPDATED,
id::COUNTERS_CONNECTION_ID_UPDATED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_ecn_state_changed(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::EcnStateChanged,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ECN_STATE_CHANGED,
id::COUNTERS_ECN_STATE_CHANGED,
1usize,
);
self.count_nominal(
id::ECN_STATE_CHANGED__STATE,
id::NOMINAL_COUNTERS_ECN_STATE_CHANGED__STATE,
&event.state,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_connection_migration_denied(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionMigrationDenied,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::CONNECTION_MIGRATION_DENIED,
id::COUNTERS_CONNECTION_MIGRATION_DENIED,
1usize,
);
self.count_nominal(
id::CONNECTION_MIGRATION_DENIED__REASON,
id::NOMINAL_COUNTERS_CONNECTION_MIGRATION_DENIED__REASON,
&event.reason,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_handshake_status_updated(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::HandshakeStatusUpdated,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::HANDSHAKE_STATUS_UPDATED,
id::COUNTERS_HANDSHAKE_STATUS_UPDATED,
1usize,
);
{
fn check(evt: &api::HandshakeStatusUpdated) -> bool {
matches!(evt.status, HandshakeStatus::Complete { .. })
}
if check(event) {
self.time(
id::HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY,
id::TIMERS_HANDSHAKE_STATUS_UPDATED__COMPLETE__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
{
fn check(evt: &api::HandshakeStatusUpdated) -> bool {
matches!(evt.status, HandshakeStatus::Confirmed { .. })
}
if check(event) {
self.time(
id::HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY,
id::TIMERS_HANDSHAKE_STATUS_UPDATED__CONFIRMED__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
{
fn check(evt: &api::HandshakeStatusUpdated) -> bool {
matches!(evt.status, HandshakeStatus::HandshakeDoneAcked { .. })
}
if check(event) {
self.time(
id::HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY,
id::TIMERS_HANDSHAKE_STATUS_UPDATED__HANDSHAKE_DONE_ACKED__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
self.count_nominal(
id::HANDSHAKE_STATUS_UPDATED__STATUS,
id::NOMINAL_COUNTERS_HANDSHAKE_STATUS_UPDATED__STATUS,
&event.status,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_tls_exporter_ready(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::TlsExporterReady,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::TLS_EXPORTER_READY,
id::COUNTERS_TLS_EXPORTER_READY,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_tls_handshake_failed(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::TlsHandshakeFailed,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::TLS_HANDSHAKE_FAILED,
id::COUNTERS_TLS_HANDSHAKE_FAILED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_challenge_updated(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PathChallengeUpdated,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PATH_CHALLENGE_UPDATED,
id::COUNTERS_PATH_CHALLENGE_UPDATED,
1usize,
);
self.count_nominal(
id::PATH_CHALLENGE_UPDATED__STATUS,
id::NOMINAL_COUNTERS_PATH_CHALLENGE_UPDATED__STATUS,
&event.path_challenge_status,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_tls_client_hello(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::TlsClientHello,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::TLS_CLIENT_HELLO, id::COUNTERS_TLS_CLIENT_HELLO, 1usize);
self.time(
id::TLS_CLIENT_HELLO__LATENCY,
id::TIMERS_TLS_CLIENT_HELLO__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_tls_server_hello(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::TlsServerHello,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::TLS_SERVER_HELLO, id::COUNTERS_TLS_SERVER_HELLO, 1usize);
self.time(
id::TLS_SERVER_HELLO__LATENCY,
id::TIMERS_TLS_SERVER_HELLO__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_rx_stream_progress(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::RxStreamProgress,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::RX_STREAM_PROGRESS,
id::COUNTERS_RX_STREAM_PROGRESS,
1usize,
);
self.count(
id::RX_STREAM_PROGRESS__BYTES__TOTAL,
id::COUNTERS_RX_STREAM_PROGRESS__BYTES__TOTAL,
event.bytes,
);
self.measure(
id::RX_STREAM_PROGRESS__BYTES,
id::MEASURES_RX_STREAM_PROGRESS__BYTES,
event.bytes,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_tx_stream_progress(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::TxStreamProgress,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::TX_STREAM_PROGRESS,
id::COUNTERS_TX_STREAM_PROGRESS,
1usize,
);
self.count(
id::TX_STREAM_PROGRESS__BYTES__TOTAL,
id::COUNTERS_TX_STREAM_PROGRESS__BYTES__TOTAL,
event.bytes,
);
self.measure(
id::TX_STREAM_PROGRESS__BYTES,
id::MEASURES_TX_STREAM_PROGRESS__BYTES,
event.bytes,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_keep_alive_timer_expired(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::KeepAliveTimerExpired,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::KEEP_ALIVE_TIMER_EXPIRED,
id::COUNTERS_KEEP_ALIVE_TIMER_EXPIRED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_mtu_updated(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::MtuUpdated,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::MTU_UPDATED, id::COUNTERS_MTU_UPDATED, 1usize);
self.measure(
id::MTU_UPDATED__MTU,
id::MEASURES_MTU_UPDATED__MTU,
event.mtu,
);
self.count_nominal(
id::MTU_UPDATED__CAUSE,
id::NOMINAL_COUNTERS_MTU_UPDATED__CAUSE,
&event.cause,
);
self.count_bool(
id::MTU_UPDATED__SEARCH_COMPLETE,
id::BOOL_COUNTERS_MTU_UPDATED__SEARCH_COMPLETE,
event.search_complete,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_mtu_probing_complete_received(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::MtuProbingCompleteReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::MTU_PROBING_COMPLETE_RECEIVED,
id::COUNTERS_MTU_PROBING_COMPLETE_RECEIVED,
1usize,
);
self.count_nominal(
id::MTU_PROBING_COMPLETE_RECEIVED__PACKET,
id::NOMINAL_COUNTERS_MTU_PROBING_COMPLETE_RECEIVED__PACKET,
&event.packet_header,
);
self.measure(
id::MTU_PROBING_COMPLETE_RECEIVED__MTU,
id::MEASURES_MTU_PROBING_COMPLETE_RECEIVED__MTU,
event.mtu,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_slow_start_exited(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::SlowStartExited,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::SLOW_START_EXITED,
id::COUNTERS_SLOW_START_EXITED,
1usize,
);
self.count_nominal(
id::SLOW_START_EXITED__CAUSE,
id::NOMINAL_COUNTERS_SLOW_START_EXITED__CAUSE,
&event.cause,
);
self.time_nominal(
id::SLOW_START_EXITED__LATENCY,
id::NOMINAL_TIMERS_SLOW_START_EXITED__LATENCY,
&event.cause,
meta.timestamp.saturating_duration_since(context.start_time),
);
self.measure(
id::SLOW_START_EXITED__CONGESTION_WINDOW,
id::MEASURES_SLOW_START_EXITED__CONGESTION_WINDOW,
event.congestion_window,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_delivery_rate_sampled(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::DeliveryRateSampled,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::DELIVERY_RATE_SAMPLED,
id::COUNTERS_DELIVERY_RATE_SAMPLED,
1usize,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_pacing_rate_updated(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::PacingRateUpdated,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PACING_RATE_UPDATED,
id::COUNTERS_PACING_RATE_UPDATED,
1usize,
);
self.measure(
id::PACING_RATE_UPDATED__BYTES_PER_SECOND,
id::MEASURES_PACING_RATE_UPDATED__BYTES_PER_SECOND,
event.bytes_per_second,
);
self.measure(
id::PACING_RATE_UPDATED__BURST_SIZE,
id::MEASURES_PACING_RATE_UPDATED__BURST_SIZE,
event.burst_size,
);
self.measure(
id::PACING_RATE_UPDATED__PACING_GAIN,
id::MEASURES_PACING_RATE_UPDATED__PACING_GAIN,
event.pacing_gain,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_bbr_state_changed(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::BbrStateChanged,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::BBR_STATE_CHANGED,
id::COUNTERS_BBR_STATE_CHANGED,
1usize,
);
self.count_nominal(
id::BBR_STATE_CHANGED__STATE,
id::NOMINAL_COUNTERS_BBR_STATE_CHANGED__STATE,
&event.state,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_dc_state_changed(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::DcStateChanged,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::DC_STATE_CHANGED, id::COUNTERS_DC_STATE_CHANGED, 1usize);
{
fn check(evt: &api::DcStateChanged) -> bool {
matches!(evt.state, DcState::VersionNegotiated { .. })
}
if check(event) {
self.time(
id::DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY,
id::TIMERS_DC_STATE_CHANGED__VERSION_NEGOTIATED__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
{
fn check(evt: &api::DcStateChanged) -> bool {
matches!(evt.state, DcState::VersionNegotiated { .. })
}
if check(event) {
self.time(
id::DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY,
id::TIMERS_DC_STATE_CHANGED__NO_VERSION_NEGOTIATED__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
{
fn check(evt: &api::DcStateChanged) -> bool {
matches!(evt.state, DcState::PathSecretsReady { .. })
}
if check(event) {
self.time(
id::DC_STATE_CHANGED__PATH_SECRETS__LATENCY,
id::TIMERS_DC_STATE_CHANGED__PATH_SECRETS__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
{
fn check(evt: &api::DcStateChanged) -> bool {
matches!(evt.state, DcState::Complete { .. })
}
if check(event) {
self.time(
id::DC_STATE_CHANGED__COMPLETE__LATENCY,
id::TIMERS_DC_STATE_CHANGED__COMPLETE__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
}
}
self.count_nominal(
id::DC_STATE_CHANGED__STATE,
id::NOMINAL_COUNTERS_DC_STATE_CHANGED__STATE,
&event.state,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_dc_path_created(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::DcPathCreated,
) {
#[allow(unused_imports)]
use api::*;
self.count(id::DC_PATH_CREATED, id::COUNTERS_DC_PATH_CREATED, 1usize);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_connection_closed(
&mut self,
context: &mut Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionClosed,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::CONNECTION_CLOSED,
id::COUNTERS_CONNECTION_CLOSED,
1usize,
);
self.time(
id::CONNECTION_CLOSED__LATENCY,
id::TIMERS_CONNECTION_CLOSED__LATENCY,
meta.timestamp.saturating_duration_since(context.start_time),
);
self.count_nominal(
id::CONNECTION_CLOSED__ERROR,
id::NOMINAL_COUNTERS_CONNECTION_CLOSED__ERROR,
&event.error,
);
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_version_information(
&mut self,
meta: &api::EndpointMeta,
event: &api::VersionInformation,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::VERSION_INFORMATION,
id::COUNTERS_VERSION_INFORMATION,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_endpoint_packet_sent(
&mut self,
meta: &api::EndpointMeta,
event: &api::EndpointPacketSent,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ENDPOINT_PACKET_SENT,
id::COUNTERS_ENDPOINT_PACKET_SENT,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_endpoint_packet_received(
&mut self,
meta: &api::EndpointMeta,
event: &api::EndpointPacketReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ENDPOINT_PACKET_RECEIVED,
id::COUNTERS_ENDPOINT_PACKET_RECEIVED,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_endpoint_datagram_sent(
&mut self,
meta: &api::EndpointMeta,
event: &api::EndpointDatagramSent,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ENDPOINT_DATAGRAM_SENT,
id::COUNTERS_ENDPOINT_DATAGRAM_SENT,
1usize,
);
self.measure(
id::ENDPOINT_DATAGRAM_SENT__BYTES,
id::MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES,
event.len,
);
self.measure(
id::ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL,
id::MEASURES_ENDPOINT_DATAGRAM_SENT__BYTES__TOTAL,
event.len,
);
self.measure(
id::ENDPOINT_DATAGRAM_SENT__GSO_OFFSET,
id::MEASURES_ENDPOINT_DATAGRAM_SENT__GSO_OFFSET,
event.gso_offset,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_endpoint_datagram_received(
&mut self,
meta: &api::EndpointMeta,
event: &api::EndpointDatagramReceived,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ENDPOINT_DATAGRAM_RECEIVED,
id::COUNTERS_ENDPOINT_DATAGRAM_RECEIVED,
1usize,
);
self.measure(
id::ENDPOINT_DATAGRAM_RECEIVED__BYTES,
id::MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES,
event.len,
);
self.measure(
id::ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL,
id::MEASURES_ENDPOINT_DATAGRAM_RECEIVED__BYTES__TOTAL,
event.len,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_endpoint_datagram_dropped(
&mut self,
meta: &api::EndpointMeta,
event: &api::EndpointDatagramDropped,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ENDPOINT_DATAGRAM_DROPPED,
id::COUNTERS_ENDPOINT_DATAGRAM_DROPPED,
1usize,
);
self.measure(
id::ENDPOINT_DATAGRAM_DROPPED__BYTES,
id::MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES,
event.len,
);
self.measure(
id::ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL,
id::MEASURES_ENDPOINT_DATAGRAM_DROPPED__BYTES__TOTAL,
event.len,
);
self.count_nominal(
id::ENDPOINT_DATAGRAM_DROPPED__REASON,
id::NOMINAL_COUNTERS_ENDPOINT_DATAGRAM_DROPPED__REASON,
&event.reason,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_endpoint_connection_attempt_failed(
&mut self,
meta: &api::EndpointMeta,
event: &api::EndpointConnectionAttemptFailed,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ENDPOINT_CONNECTION_ATTEMPT_FAILED,
id::COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED,
1usize,
);
self.count_nominal(
id::ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR,
id::NOMINAL_COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_FAILED__ERROR,
&event.error,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_endpoint_connection_attempt_deduplicated(
&mut self,
meta: &api::EndpointMeta,
event: &api::EndpointConnectionAttemptDeduplicated,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED,
id::COUNTERS_ENDPOINT_CONNECTION_ATTEMPT_DEDUPLICATED,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_tx(&mut self, meta: &api::EndpointMeta, event: &api::PlatformTx) {
#[allow(unused_imports)]
use api::*;
self.count(id::PLATFORM_TX, id::COUNTERS_PLATFORM_TX, 1usize);
self.count(
id::PLATFORM_TX__PACKETS__TOTAL,
id::COUNTERS_PLATFORM_TX__PACKETS__TOTAL,
event.count,
);
self.measure(
id::PLATFORM_TX__PACKETS,
id::MEASURES_PLATFORM_TX__PACKETS,
event.count,
);
self.count(
id::PLATFORM_TX__SYSCALLS__TOTAL,
id::COUNTERS_PLATFORM_TX__SYSCALLS__TOTAL,
event.syscalls,
);
self.measure(
id::PLATFORM_TX__SYSCALLS,
id::MEASURES_PLATFORM_TX__SYSCALLS,
event.syscalls,
);
self.count(
id::PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL,
id::COUNTERS_PLATFORM_TX__SYSCALLS__BLOCKED__TOTAL,
event.blocked_syscalls,
);
self.measure(
id::PLATFORM_TX__SYSCALLS__BLOCKED,
id::MEASURES_PLATFORM_TX__SYSCALLS__BLOCKED,
event.blocked_syscalls,
);
self.count(
id::PLATFORM_TX__ERRORS__TOTAL,
id::COUNTERS_PLATFORM_TX__ERRORS__TOTAL,
event.total_errors,
);
self.measure(
id::PLATFORM_TX__ERRORS,
id::MEASURES_PLATFORM_TX__ERRORS,
event.total_errors,
);
self.count(
id::PLATFORM_TX__ERRORS__DROPPED__TOTAL,
id::COUNTERS_PLATFORM_TX__ERRORS__DROPPED__TOTAL,
event.dropped_errors,
);
self.measure(
id::PLATFORM_TX__ERRORS__DROPPED,
id::MEASURES_PLATFORM_TX__ERRORS__DROPPED,
event.dropped_errors,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_tx_error(&mut self, meta: &api::EndpointMeta, event: &api::PlatformTxError) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PLATFORM_TX_ERROR,
id::COUNTERS_PLATFORM_TX_ERROR,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_rx(&mut self, meta: &api::EndpointMeta, event: &api::PlatformRx) {
#[allow(unused_imports)]
use api::*;
self.count(id::PLATFORM_RX, id::COUNTERS_PLATFORM_RX, 1usize);
self.count(
id::PLATFORM_RX__PACKETS__TOTAL,
id::COUNTERS_PLATFORM_RX__PACKETS__TOTAL,
event.count,
);
self.measure(
id::PLATFORM_RX__PACKETS,
id::MEASURES_PLATFORM_RX__PACKETS,
event.count,
);
self.count(
id::PLATFORM_RX__SYSCALLS__TOTAL,
id::COUNTERS_PLATFORM_RX__SYSCALLS__TOTAL,
event.syscalls,
);
self.measure(
id::PLATFORM_RX__SYSCALLS,
id::MEASURES_PLATFORM_RX__SYSCALLS,
event.syscalls,
);
self.count(
id::PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL,
id::COUNTERS_PLATFORM_RX__SYSCALLS__BLOCKED__TOTAL,
event.blocked_syscalls,
);
self.measure(
id::PLATFORM_RX__SYSCALLS__BLOCKED,
id::MEASURES_PLATFORM_RX__SYSCALLS__BLOCKED,
event.blocked_syscalls,
);
self.count(
id::PLATFORM_RX__ERRORS__TOTAL,
id::COUNTERS_PLATFORM_RX__ERRORS__TOTAL,
event.total_errors,
);
self.measure(
id::PLATFORM_RX__ERRORS,
id::MEASURES_PLATFORM_RX__ERRORS,
event.total_errors,
);
self.count(
id::PLATFORM_RX__ERRORS__DROPPED__TOTAL,
id::COUNTERS_PLATFORM_RX__ERRORS__DROPPED__TOTAL,
event.dropped_errors,
);
self.measure(
id::PLATFORM_RX__ERRORS__DROPPED,
id::MEASURES_PLATFORM_RX__ERRORS__DROPPED,
event.dropped_errors,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_rx_error(&mut self, meta: &api::EndpointMeta, event: &api::PlatformRxError) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PLATFORM_RX_ERROR,
id::COUNTERS_PLATFORM_RX_ERROR,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_feature_configured(
&mut self,
meta: &api::EndpointMeta,
event: &api::PlatformFeatureConfigured,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PLATFORM_FEATURE_CONFIGURED,
id::COUNTERS_PLATFORM_FEATURE_CONFIGURED,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_rx_socket_stats(
&mut self,
meta: &api::EndpointMeta,
event: &api::PlatformRxSocketStats,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PLATFORM_RX_SOCKET_STATS,
id::COUNTERS_PLATFORM_RX_SOCKET_STATS,
1usize,
);
self.count(
id::PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL,
id::COUNTERS_PLATFORM_RX_SOCKET_STATS__PACKETS__TOTAL,
event.count,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_event_loop_wakeup(
&mut self,
meta: &api::EndpointMeta,
event: &api::PlatformEventLoopWakeup,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PLATFORM_EVENT_LOOP_WAKEUP,
id::COUNTERS_PLATFORM_EVENT_LOOP_WAKEUP,
1usize,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_event_loop_sleep(
&mut self,
meta: &api::EndpointMeta,
event: &api::PlatformEventLoopSleep,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PLATFORM_EVENT_LOOP_SLEEP,
id::COUNTERS_PLATFORM_EVENT_LOOP_SLEEP,
1usize,
);
self.time(
id::PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION,
id::TIMERS_PLATFORM_EVENT_LOOP_SLEEP__PROCESSING_DURATION,
event.processing_duration,
);
let _ = event;
let _ = meta;
}
#[inline]
fn on_platform_event_loop_started(
&mut self,
meta: &api::EndpointMeta,
event: &api::PlatformEventLoopStarted,
) {
#[allow(unused_imports)]
use api::*;
self.count(
id::PLATFORM_EVENT_LOOP_STARTED,
id::COUNTERS_PLATFORM_EVENT_LOOP_STARTED,
1usize,
);
let _ = event;
let _ = meta;
}
}