From 43e8cb7bf1fb353ee40a7b113e6f38296bcf8f30 Mon Sep 17 00:00:00 2001 From: Cameron Bytheway Date: Tue, 19 Nov 2024 10:35:57 -0700 Subject: [PATCH] pr feedback --- dc/s2n-quic-dc/events/acceptor.rs | 20 +- dc/s2n-quic-dc/events/map.rs | 4 +- dc/s2n-quic-dc/src/event/generated.rs | 44 +- .../src/event/generated/metrics/aggregate.rs | 828 ++++++++++-------- .../src/event/generated/metrics/probe.rs | 222 ++--- dc/s2n-quic-dc/src/stream/server.rs | 3 + dc/s2n-quic-dc/src/stream/server/tokio/tcp.rs | 3 + dc/s2n-quic-dc/src/stream/server/tokio/udp.rs | 1 + .../src/event/metrics/aggregate/metric.rs | 2 + quic/s2n-quic-events/src/main.rs | 4 + quic/s2n-quic-events/src/validation.rs | 44 + 11 files changed, 696 insertions(+), 479 deletions(-) create mode 100644 quic/s2n-quic-events/src/validation.rs diff --git a/dc/s2n-quic-dc/events/acceptor.rs b/dc/s2n-quic-dc/events/acceptor.rs index ca7037844..bbe9cdba4 100644 --- a/dc/s2n-quic-dc/events/acceptor.rs +++ b/dc/s2n-quic-dc/events/acceptor.rs @@ -17,13 +17,21 @@ struct AcceptorTcpStarted<'a> { } /// Emitted when a TCP acceptor completes a single iteration of the event loop -#[event("acceptor:tcp:started")] +#[event("acceptor:tcp:loop_iteration_completed")] #[subject(endpoint)] struct AcceptorTcpLoopIterationCompleted { /// The number of streams that are waiting on initial packets #[measure("pending_streams")] pending_streams: usize, + /// The number of slots that are not currently processing a stream + #[measure("slots_idle")] + slots_idle: usize, + + /// The percentage of slots currently processing streams + #[measure("slot_utilization", Percent)] + slot_utilization: f32, + /// The amount of time it took to complete the iteration #[timer("processing_duration")] processing_duration: core::time::Duration, @@ -123,6 +131,10 @@ struct AcceptorTcpPacketReceived<'a> { #[bool_counter("is_fin")] is_fin: bool, + /// If the packet includes the final offset of the stream + #[bool_counter("is_fin_known")] + is_fin_known: bool, + /// The amount of time the TCP stream spent in the queue before receiving /// the initial packet #[timer("sojourn_time")] @@ -138,6 +150,7 @@ struct AcceptorTcpPacketDropped<'a> { remote_address: SocketAddress<'a>, /// The reason the packet was dropped + #[nominal_counter("reason")] reason: AcceptorPacketDropReason, /// The amount of time the TCP stream spent in the queue before receiving @@ -233,6 +246,10 @@ struct AcceptorUdpPacketReceived<'a> { /// If the packet includes the final bytes of the stream #[bool_counter("is_fin")] is_fin: bool, + + /// If the packet includes the final offset of the stream + #[bool_counter("is_fin_known")] + is_fin_known: bool, } /// Emitted when the UDP acceptor received an invalid initial packet @@ -244,6 +261,7 @@ struct AcceptorUdpPacketDropped<'a> { remote_address: SocketAddress<'a>, /// The reason the packet was dropped + #[nominal_counter("reason")] reason: AcceptorPacketDropReason, } diff --git a/dc/s2n-quic-dc/events/map.rs b/dc/s2n-quic-dc/events/map.rs index e0ad67be4..23f95b0c7 100644 --- a/dc/s2n-quic-dc/events/map.rs +++ b/dc/s2n-quic-dc/events/map.rs @@ -32,7 +32,7 @@ struct PathSecretMapBackgroundHandshakeRequested<'a> { peer_address: SocketAddress<'a>, } -#[event("path_secret_map:entry_replaced")] +#[event("path_secret_map:entry_inserted")] #[subject(endpoint)] /// Emitted when the entry is inserted into the path secret map struct PathSecretMapEntryInserted<'a> { @@ -43,7 +43,7 @@ struct PathSecretMapEntryInserted<'a> { credential_id: &'a [u8], } -#[event("path_secret_map:entry_replaced")] +#[event("path_secret_map:entry_ready")] #[subject(endpoint)] /// Emitted when the entry is considered ready for use struct PathSecretMapEntryReady<'a> { diff --git a/dc/s2n-quic-dc/src/event/generated.rs b/dc/s2n-quic-dc/src/event/generated.rs index c89046e4b..6dc4b5e62 100644 --- a/dc/s2n-quic-dc/src/event/generated.rs +++ b/dc/s2n-quic-dc/src/event/generated.rs @@ -44,6 +44,10 @@ pub mod api { pub struct AcceptorTcpLoopIterationCompleted { #[doc = " The number of streams that are waiting on initial packets"] pub pending_streams: usize, + #[doc = " The number of slots that are not currently processing a stream"] + pub slots_idle: usize, + #[doc = " The percentage of slots currently processing streams"] + pub slot_utilization: f32, #[doc = " The amount of time it took to complete the iteration"] pub processing_duration: core::time::Duration, #[doc = " The computed max sojourn time that is allowed for streams"] @@ -57,13 +61,15 @@ pub mod api { fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { let mut fmt = fmt.debug_struct("AcceptorTcpLoopIterationCompleted"); fmt.field("pending_streams", &self.pending_streams); + fmt.field("slots_idle", &self.slots_idle); + fmt.field("slot_utilization", &self.slot_utilization); fmt.field("processing_duration", &self.processing_duration); fmt.field("max_sojourn_time", &self.max_sojourn_time); fmt.finish() } } impl Event for AcceptorTcpLoopIterationCompleted { - const NAME: &'static str = "acceptor:tcp:started"; + const NAME: &'static str = "acceptor:tcp:loop_iteration_completed"; } #[derive(Clone, Debug)] #[non_exhaustive] @@ -166,6 +172,8 @@ pub mod api { pub payload_len: usize, #[doc = " If the packet includes the final bytes of the stream"] pub is_fin: bool, + #[doc = " If the packet includes the final offset of the stream"] + pub is_fin_known: bool, #[doc = " The amount of time the TCP stream spent in the queue before receiving"] #[doc = " the initial packet"] pub sojourn_time: core::time::Duration, @@ -179,6 +187,7 @@ pub mod api { fmt.field("stream_id", &self.stream_id); fmt.field("payload_len", &self.payload_len); fmt.field("is_fin", &self.is_fin); + fmt.field("is_fin_known", &self.is_fin_known); fmt.field("sojourn_time", &self.sojourn_time); fmt.finish() } @@ -319,6 +328,8 @@ pub mod api { pub is_retransmission: bool, #[doc = " If the packet includes the final bytes of the stream"] pub is_fin: bool, + #[doc = " If the packet includes the final offset of the stream"] + pub is_fin_known: bool, } #[cfg(any(test, feature = "testing"))] impl<'a> crate::event::snapshot::Fmt for AcceptorUdpPacketReceived<'a> { @@ -331,6 +342,7 @@ pub mod api { fmt.field("is_zero_offset", &self.is_zero_offset); fmt.field("is_retransmission", &self.is_retransmission); fmt.field("is_fin", &self.is_fin); + fmt.field("is_fin_known", &self.is_fin_known); fmt.finish() } } @@ -736,7 +748,7 @@ pub mod api { } } impl<'a> Event for PathSecretMapEntryInserted<'a> { - const NAME: &'static str = "path_secret_map:entry_replaced"; + const NAME: &'static str = "path_secret_map:entry_inserted"; } #[derive(Clone, Debug)] #[non_exhaustive] @@ -755,7 +767,7 @@ pub mod api { } } impl<'a> Event for PathSecretMapEntryReady<'a> { - const NAME: &'static str = "path_secret_map:entry_replaced"; + const NAME: &'static str = "path_secret_map:entry_ready"; } #[derive(Clone, Debug)] #[non_exhaustive] @@ -1171,10 +1183,12 @@ pub mod tracing { let parent = self.parent(meta); let api::AcceptorTcpLoopIterationCompleted { pending_streams, + slots_idle, + slot_utilization, processing_duration, max_sojourn_time, } = event; - tracing :: event ! (target : "acceptor_tcp_loop_iteration_completed" , parent : parent , tracing :: Level :: DEBUG , pending_streams = tracing :: field :: debug (pending_streams) , processing_duration = tracing :: field :: debug (processing_duration) , max_sojourn_time = tracing :: field :: debug (max_sojourn_time)); + tracing :: event ! (target : "acceptor_tcp_loop_iteration_completed" , parent : parent , tracing :: Level :: DEBUG , pending_streams = tracing :: field :: debug (pending_streams) , slots_idle = tracing :: field :: debug (slots_idle) , slot_utilization = tracing :: field :: debug (slot_utilization) , processing_duration = tracing :: field :: debug (processing_duration) , max_sojourn_time = tracing :: field :: debug (max_sojourn_time)); } #[inline] fn on_acceptor_tcp_fresh_enqueued( @@ -1240,9 +1254,10 @@ pub mod tracing { stream_id, payload_len, is_fin, + is_fin_known, sojourn_time, } = event; - tracing :: event ! (target : "acceptor_tcp_packet_received" , parent : parent , tracing :: Level :: DEBUG , remote_address = tracing :: field :: debug (remote_address) , credential_id = tracing :: field :: debug (credential_id) , stream_id = tracing :: field :: debug (stream_id) , payload_len = tracing :: field :: debug (payload_len) , is_fin = tracing :: field :: debug (is_fin) , sojourn_time = tracing :: field :: debug (sojourn_time)); + tracing :: event ! (target : "acceptor_tcp_packet_received" , parent : parent , tracing :: Level :: DEBUG , remote_address = tracing :: field :: debug (remote_address) , credential_id = tracing :: field :: debug (credential_id) , stream_id = tracing :: field :: debug (stream_id) , payload_len = tracing :: field :: debug (payload_len) , is_fin = tracing :: field :: debug (is_fin) , is_fin_known = tracing :: field :: debug (is_fin_known) , sojourn_time = tracing :: field :: debug (sojourn_time)); } #[inline] fn on_acceptor_tcp_packet_dropped( @@ -1322,8 +1337,9 @@ pub mod tracing { is_zero_offset, is_retransmission, is_fin, + is_fin_known, } = event; - tracing :: event ! (target : "acceptor_udp_packet_received" , parent : parent , tracing :: Level :: DEBUG , remote_address = tracing :: field :: debug (remote_address) , credential_id = tracing :: field :: debug (credential_id) , stream_id = tracing :: field :: debug (stream_id) , payload_len = tracing :: field :: debug (payload_len) , is_zero_offset = tracing :: field :: debug (is_zero_offset) , is_retransmission = tracing :: field :: debug (is_retransmission) , is_fin = tracing :: field :: debug (is_fin)); + tracing :: event ! (target : "acceptor_udp_packet_received" , parent : parent , tracing :: Level :: DEBUG , remote_address = tracing :: field :: debug (remote_address) , credential_id = tracing :: field :: debug (credential_id) , stream_id = tracing :: field :: debug (stream_id) , payload_len = tracing :: field :: debug (payload_len) , is_zero_offset = tracing :: field :: debug (is_zero_offset) , is_retransmission = tracing :: field :: debug (is_retransmission) , is_fin = tracing :: field :: debug (is_fin) , is_fin_known = tracing :: field :: debug (is_fin_known)); } #[inline] fn on_acceptor_udp_packet_dropped( @@ -1765,6 +1781,10 @@ pub mod builder { pub struct AcceptorTcpLoopIterationCompleted { #[doc = " The number of streams that are waiting on initial packets"] pub pending_streams: usize, + #[doc = " The number of slots that are not currently processing a stream"] + pub slots_idle: usize, + #[doc = " The percentage of slots currently processing streams"] + pub slot_utilization: f32, #[doc = " The amount of time it took to complete the iteration"] pub processing_duration: core::time::Duration, #[doc = " The computed max sojourn time that is allowed for streams"] @@ -1778,11 +1798,15 @@ pub mod builder { fn into_event(self) -> api::AcceptorTcpLoopIterationCompleted { let AcceptorTcpLoopIterationCompleted { pending_streams, + slots_idle, + slot_utilization, processing_duration, max_sojourn_time, } = self; api::AcceptorTcpLoopIterationCompleted { pending_streams: pending_streams.into_event(), + slots_idle: slots_idle.into_event(), + slot_utilization: slot_utilization.into_event(), processing_duration: processing_duration.into_event(), max_sojourn_time: max_sojourn_time.into_event(), } @@ -1887,6 +1911,8 @@ pub mod builder { pub payload_len: usize, #[doc = " If the packet includes the final bytes of the stream"] pub is_fin: bool, + #[doc = " If the packet includes the final offset of the stream"] + pub is_fin_known: bool, #[doc = " The amount of time the TCP stream spent in the queue before receiving"] #[doc = " the initial packet"] pub sojourn_time: core::time::Duration, @@ -1900,6 +1926,7 @@ pub mod builder { stream_id, payload_len, is_fin, + is_fin_known, sojourn_time, } = self; api::AcceptorTcpPacketReceived { @@ -1908,6 +1935,7 @@ pub mod builder { stream_id: stream_id.into_event(), payload_len: payload_len.into_event(), is_fin: is_fin.into_event(), + is_fin_known: is_fin_known.into_event(), sojourn_time: sojourn_time.into_event(), } } @@ -2042,6 +2070,8 @@ pub mod builder { pub is_retransmission: bool, #[doc = " If the packet includes the final bytes of the stream"] pub is_fin: bool, + #[doc = " If the packet includes the final offset of the stream"] + pub is_fin_known: bool, } impl<'a> IntoEvent> for AcceptorUdpPacketReceived<'a> { #[inline] @@ -2054,6 +2084,7 @@ pub mod builder { is_zero_offset, is_retransmission, is_fin, + is_fin_known, } = self; api::AcceptorUdpPacketReceived { remote_address: remote_address.into_event(), @@ -2063,6 +2094,7 @@ pub mod builder { is_zero_offset: is_zero_offset.into_event(), is_retransmission: is_retransmission.into_event(), is_fin: is_fin.into_event(), + is_fin_known: is_fin_known.into_event(), } } } diff --git a/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs b/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs index 0bd38f887..1a905d2ac 100644 --- a/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs +++ b/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs @@ -12,7 +12,7 @@ use crate::event::{ AsVariant, BoolRecorder, Info, Metric, NominalRecorder, Recorder, Registry, Units, }, }; -static INFO: &[Info; 101usize] = &[ +static INFO: &[Info; 107usize] = &[ info::Builder { id: 0usize, name: Str::new("acceptor_tcp_started\0"), @@ -33,588 +33,624 @@ static INFO: &[Info; 101usize] = &[ .build(), info::Builder { id: 3usize, + name: Str::new("acceptor_tcp_loop_iteration_completed.slots_idle\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 4usize, + name: Str::new("acceptor_tcp_loop_iteration_completed.slot_utilization\0"), + units: Units::Percent, + } + .build(), + info::Builder { + id: 5usize, name: Str::new("acceptor_tcp_loop_iteration_completed.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 4usize, + id: 6usize, name: Str::new("acceptor_tcp_loop_iteration_completed.max_sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 5usize, + id: 7usize, name: Str::new("acceptor_tcp_fresh_enqueued\0"), units: Units::None, } .build(), info::Builder { - id: 6usize, + id: 8usize, name: Str::new("acceptor_tcp_fresh_batch_completed\0"), units: Units::None, } .build(), info::Builder { - id: 7usize, + id: 9usize, name: Str::new("acceptor_tcp_fresh_batch_completed.enqueued\0"), units: Units::None, } .build(), info::Builder { - id: 8usize, + id: 10usize, name: Str::new("acceptor_tcp_fresh_batch_completed.dropped\0"), units: Units::None, } .build(), info::Builder { - id: 9usize, + id: 11usize, name: Str::new("acceptor_tcp_fresh_batch_completed.errored\0"), units: Units::None, } .build(), info::Builder { - id: 10usize, + id: 12usize, name: Str::new("acceptor_tcp_stream_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 11usize, + id: 13usize, name: Str::new("acceptor_tcp_stream_dropped.reason\0"), units: Units::None, } .build(), info::Builder { - id: 12usize, + id: 14usize, name: Str::new("acceptor_tcp_stream_replaced\0"), units: Units::None, } .build(), info::Builder { - id: 13usize, + id: 15usize, name: Str::new("acceptor_tcp_stream_replaced.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 14usize, + id: 16usize, name: Str::new("acceptor_tcp_stream_replaced.buffer_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 15usize, + id: 17usize, name: Str::new("acceptor_tcp_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 16usize, + id: 18usize, name: Str::new("acceptor_tcp_packet_received.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 17usize, + id: 19usize, name: Str::new("acceptor_tcp_packet_received.is_fin\0"), units: Units::None, } .build(), info::Builder { - id: 18usize, + id: 20usize, + name: Str::new("acceptor_tcp_packet_received.is_fin_known\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 21usize, name: Str::new("acceptor_tcp_packet_received.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 19usize, + id: 22usize, name: Str::new("acceptor_tcp_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 20usize, + id: 23usize, + name: Str::new("acceptor_tcp_packet_dropped.reason\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 24usize, name: Str::new("acceptor_tcp_packet_dropped.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 21usize, + id: 25usize, name: Str::new("acceptor_tcp_stream_enqueued\0"), units: Units::None, } .build(), info::Builder { - id: 22usize, + id: 26usize, name: Str::new("acceptor_tcp_stream_enqueued.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 23usize, + id: 27usize, name: Str::new("acceptor_tcp_stream_enqueued.blocked_count\0"), units: Units::None, } .build(), info::Builder { - id: 24usize, + id: 28usize, name: Str::new("acceptor_tcp_io_error\0"), units: Units::None, } .build(), info::Builder { - id: 25usize, + id: 29usize, name: Str::new("acceptor_udp_started\0"), units: Units::None, } .build(), info::Builder { - id: 26usize, + id: 30usize, name: Str::new("acceptor_udp_datagram_received\0"), units: Units::None, } .build(), info::Builder { - id: 27usize, + id: 31usize, name: Str::new("acceptor_udp_datagram_received.len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 28usize, + id: 32usize, name: Str::new("acceptor_udp_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 29usize, + id: 33usize, name: Str::new("acceptor_udp_packet_received.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 30usize, + id: 34usize, name: Str::new("acceptor_udp_packet_received.is_zero_offset\0"), units: Units::None, } .build(), info::Builder { - id: 31usize, + id: 35usize, name: Str::new("acceptor_udp_packet_received.is_retransmisson\0"), units: Units::None, } .build(), info::Builder { - id: 32usize, + id: 36usize, name: Str::new("acceptor_udp_packet_received.is_fin\0"), units: Units::None, } .build(), info::Builder { - id: 33usize, + id: 37usize, + name: Str::new("acceptor_udp_packet_received.is_fin_known\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 38usize, name: Str::new("acceptor_udp_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 34usize, + id: 39usize, + name: Str::new("acceptor_udp_packet_dropped.reason\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 40usize, name: Str::new("acceptor_udp_stream_enqueued\0"), units: Units::None, } .build(), info::Builder { - id: 35usize, + id: 41usize, name: Str::new("acceptor_udp_io_error\0"), units: Units::None, } .build(), info::Builder { - id: 36usize, + id: 42usize, name: Str::new("acceptor_stream_pruned\0"), units: Units::None, } .build(), info::Builder { - id: 37usize, + id: 43usize, name: Str::new("acceptor_stream_pruned.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 38usize, + id: 44usize, name: Str::new("acceptor_stream_pruned.reason\0"), units: Units::None, } .build(), info::Builder { - id: 39usize, + id: 45usize, name: Str::new("acceptor_stream_dequeued\0"), units: Units::None, } .build(), info::Builder { - id: 40usize, + id: 46usize, name: Str::new("acceptor_stream_dequeued.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 41usize, + id: 47usize, name: Str::new("application_write\0"), units: Units::None, } .build(), info::Builder { - id: 42usize, + id: 48usize, name: Str::new("application_write.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 43usize, + id: 49usize, name: Str::new("application_write.committed.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 44usize, + id: 50usize, name: Str::new("application_write.committed\0"), units: Units::Bytes, } .build(), info::Builder { - id: 45usize, + id: 51usize, name: Str::new("application_read\0"), units: Units::None, } .build(), info::Builder { - id: 46usize, + id: 52usize, name: Str::new("application_read.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 47usize, + id: 53usize, name: Str::new("application_read.committed.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 48usize, + id: 54usize, name: Str::new("application_read.committed\0"), units: Units::Bytes, } .build(), info::Builder { - id: 49usize, + id: 55usize, name: Str::new("endpoint_initialized\0"), units: Units::None, } .build(), info::Builder { - id: 50usize, + id: 56usize, name: Str::new("endpoint_initialized.acceptor.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 51usize, + id: 57usize, name: Str::new("endpoint_initialized.handshake.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 52usize, + id: 58usize, name: Str::new("endpoint_initialized.tcp\0"), units: Units::None, } .build(), info::Builder { - id: 53usize, + id: 59usize, name: Str::new("endpoint_initialized.udp\0"), units: Units::None, } .build(), info::Builder { - id: 54usize, + id: 60usize, name: Str::new("path_secret_map_initialized\0"), units: Units::None, } .build(), info::Builder { - id: 55usize, + id: 61usize, name: Str::new("path_secret_map_initialized.capacity\0"), units: Units::None, } .build(), info::Builder { - id: 56usize, + id: 62usize, name: Str::new("path_secret_map_uninitialized\0"), units: Units::None, } .build(), info::Builder { - id: 57usize, + id: 63usize, name: Str::new("path_secret_map_uninitialized.capacity\0"), units: Units::None, } .build(), info::Builder { - id: 58usize, + id: 64usize, name: Str::new("path_secret_map_uninitialized.entries\0"), units: Units::None, } .build(), info::Builder { - id: 59usize, + id: 65usize, name: Str::new("path_secret_map_uninitialized.lifetime\0"), units: Units::Duration, } .build(), info::Builder { - id: 60usize, + id: 66usize, name: Str::new("path_secret_map_background_handshake_requested\0"), units: Units::None, } .build(), info::Builder { - id: 61usize, + id: 67usize, name: Str::new("path_secret_map_background_handshake_requested.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 62usize, + id: 68usize, name: Str::new("path_secret_map_entry_inserted\0"), units: Units::None, } .build(), info::Builder { - id: 63usize, + id: 69usize, name: Str::new("path_secret_map_entry_inserted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 64usize, + id: 70usize, name: Str::new("path_secret_map_entry_ready\0"), units: Units::None, } .build(), info::Builder { - id: 65usize, + id: 71usize, name: Str::new("path_secret_map_entry_ready.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 66usize, + id: 72usize, name: Str::new("path_secret_map_entry_replaced\0"), units: Units::None, } .build(), info::Builder { - id: 67usize, + id: 73usize, name: Str::new("path_secret_map_entry_replaced.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 68usize, + id: 74usize, name: Str::new("unknown_path_secret_packet_sent\0"), units: Units::None, } .build(), info::Builder { - id: 69usize, + id: 75usize, name: Str::new("unknown_path_secret_packet_sent.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 70usize, + id: 76usize, name: Str::new("unknown_path_secret_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 71usize, + id: 77usize, name: Str::new("unknown_path_secret_packet_received.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 72usize, + id: 78usize, name: Str::new("unknown_path_secret_packet_accepted\0"), units: Units::None, } .build(), info::Builder { - id: 73usize, + id: 79usize, name: Str::new("unknown_path_secret_packet_accepted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 74usize, + id: 80usize, name: Str::new("unknown_path_secret_packet_rejected\0"), units: Units::None, } .build(), info::Builder { - id: 75usize, + id: 81usize, name: Str::new("unknown_path_secret_packet_rejected.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 76usize, + id: 82usize, name: Str::new("unknown_path_secret_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 77usize, + id: 83usize, name: Str::new("unknown_path_secret_packet_dropped.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 78usize, + id: 84usize, name: Str::new("replay_definitely_detected\0"), units: Units::None, } .build(), info::Builder { - id: 79usize, + id: 85usize, name: Str::new("replay_potentially_detected\0"), units: Units::None, } .build(), info::Builder { - id: 80usize, + id: 86usize, name: Str::new("replay_potentially_detected.gap\0"), units: Units::None, } .build(), info::Builder { - id: 81usize, + id: 87usize, name: Str::new("replay_detected_packet_sent\0"), units: Units::None, } .build(), info::Builder { - id: 82usize, + id: 88usize, name: Str::new("replay_detected_packet_sent.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 83usize, + id: 89usize, name: Str::new("replay_detected_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 84usize, + id: 90usize, name: Str::new("replay_detected_packet_received.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 85usize, + id: 91usize, name: Str::new("replay_detected_packet_accepted\0"), units: Units::None, } .build(), info::Builder { - id: 86usize, + id: 92usize, name: Str::new("replay_detected_packet_accepted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 87usize, + id: 93usize, name: Str::new("replay_detected_packet_rejected\0"), units: Units::None, } .build(), info::Builder { - id: 88usize, + id: 94usize, name: Str::new("replay_detected_packet_rejected.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 89usize, + id: 95usize, name: Str::new("replay_detected_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 90usize, + id: 96usize, name: Str::new("replay_detected_packet_dropped.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 91usize, + id: 97usize, name: Str::new("stale_key_packet_sent\0"), units: Units::None, } .build(), info::Builder { - id: 92usize, + id: 98usize, name: Str::new("stale_key_packet_sent.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 93usize, + id: 99usize, name: Str::new("stale_key_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 94usize, + id: 100usize, name: Str::new("stale_key_packet_received.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 95usize, + id: 101usize, name: Str::new("stale_key_packet_accepted\0"), units: Units::None, } .build(), info::Builder { - id: 96usize, + id: 102usize, name: Str::new("stale_key_packet_accepted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 97usize, + id: 103usize, name: Str::new("stale_key_packet_rejected\0"), units: Units::None, } .build(), info::Builder { - id: 98usize, + id: 104usize, name: Str::new("stale_key_packet_rejected.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 99usize, + id: 105usize, name: Str::new("stale_key_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 100usize, + id: 106usize, name: Str::new("stale_key_packet_dropped.peer_address.protocol\0"), units: Units::None, } @@ -629,13 +665,13 @@ pub struct Subscriber { #[allow(dead_code)] counters: Box<[R::Counter; 46usize]>, #[allow(dead_code)] - bool_counters: Box<[R::BoolCounter; 6usize]>, + bool_counters: Box<[R::BoolCounter; 8usize]>, #[allow(dead_code)] nominal_counters: Box<[R::NominalCounter]>, #[allow(dead_code)] - nominal_counter_offsets: Box<[usize; 23usize]>, + nominal_counter_offsets: Box<[usize; 25usize]>, #[allow(dead_code)] - measures: Box<[R::Measure; 19usize]>, + measures: Box<[R::Measure; 21usize]>, #[allow(dead_code)] gauges: Box<[R::Gauge; 0usize]>, #[allow(dead_code)] @@ -663,42 +699,39 @@ impl Subscriber { #[inline] pub fn new(registry: R) -> Self { let mut counters = Vec::with_capacity(46usize); - let mut bool_counters = Vec::with_capacity(6usize); - let mut nominal_counters = Vec::with_capacity(23usize); - let mut nominal_counter_offsets = Vec::with_capacity(23usize); - let mut measures = Vec::with_capacity(19usize); + let mut bool_counters = Vec::with_capacity(8usize); + let mut nominal_counters = Vec::with_capacity(25usize); + let mut nominal_counter_offsets = Vec::with_capacity(25usize); + let mut measures = Vec::with_capacity(21usize); let mut gauges = Vec::with_capacity(0usize); let mut timers = Vec::with_capacity(7usize); let mut nominal_timers = Vec::with_capacity(0usize); let mut nominal_timer_offsets = Vec::with_capacity(0usize); counters.push(registry.register_counter(&INFO[0usize])); counters.push(registry.register_counter(&INFO[1usize])); - counters.push(registry.register_counter(&INFO[5usize])); - counters.push(registry.register_counter(&INFO[6usize])); - counters.push(registry.register_counter(&INFO[10usize])); + counters.push(registry.register_counter(&INFO[7usize])); + counters.push(registry.register_counter(&INFO[8usize])); counters.push(registry.register_counter(&INFO[12usize])); - counters.push(registry.register_counter(&INFO[15usize])); - counters.push(registry.register_counter(&INFO[19usize])); - counters.push(registry.register_counter(&INFO[21usize])); - counters.push(registry.register_counter(&INFO[24usize])); + counters.push(registry.register_counter(&INFO[14usize])); + counters.push(registry.register_counter(&INFO[17usize])); + counters.push(registry.register_counter(&INFO[22usize])); counters.push(registry.register_counter(&INFO[25usize])); - counters.push(registry.register_counter(&INFO[26usize])); counters.push(registry.register_counter(&INFO[28usize])); - counters.push(registry.register_counter(&INFO[33usize])); - counters.push(registry.register_counter(&INFO[34usize])); - counters.push(registry.register_counter(&INFO[35usize])); - counters.push(registry.register_counter(&INFO[36usize])); - counters.push(registry.register_counter(&INFO[39usize])); + counters.push(registry.register_counter(&INFO[29usize])); + counters.push(registry.register_counter(&INFO[30usize])); + counters.push(registry.register_counter(&INFO[32usize])); + counters.push(registry.register_counter(&INFO[38usize])); + counters.push(registry.register_counter(&INFO[40usize])); counters.push(registry.register_counter(&INFO[41usize])); - counters.push(registry.register_counter(&INFO[43usize])); + counters.push(registry.register_counter(&INFO[42usize])); counters.push(registry.register_counter(&INFO[45usize])); counters.push(registry.register_counter(&INFO[47usize])); counters.push(registry.register_counter(&INFO[49usize])); - counters.push(registry.register_counter(&INFO[54usize])); - counters.push(registry.register_counter(&INFO[56usize])); + counters.push(registry.register_counter(&INFO[51usize])); + counters.push(registry.register_counter(&INFO[53usize])); + counters.push(registry.register_counter(&INFO[55usize])); counters.push(registry.register_counter(&INFO[60usize])); counters.push(registry.register_counter(&INFO[62usize])); - counters.push(registry.register_counter(&INFO[64usize])); counters.push(registry.register_counter(&INFO[66usize])); counters.push(registry.register_counter(&INFO[68usize])); counters.push(registry.register_counter(&INFO[70usize])); @@ -706,9 +739,9 @@ impl Subscriber { counters.push(registry.register_counter(&INFO[74usize])); counters.push(registry.register_counter(&INFO[76usize])); counters.push(registry.register_counter(&INFO[78usize])); - counters.push(registry.register_counter(&INFO[79usize])); - counters.push(registry.register_counter(&INFO[81usize])); - counters.push(registry.register_counter(&INFO[83usize])); + counters.push(registry.register_counter(&INFO[80usize])); + counters.push(registry.register_counter(&INFO[82usize])); + counters.push(registry.register_counter(&INFO[84usize])); counters.push(registry.register_counter(&INFO[85usize])); counters.push(registry.register_counter(&INFO[87usize])); counters.push(registry.register_counter(&INFO[89usize])); @@ -717,12 +750,17 @@ impl Subscriber { counters.push(registry.register_counter(&INFO[95usize])); counters.push(registry.register_counter(&INFO[97usize])); counters.push(registry.register_counter(&INFO[99usize])); - bool_counters.push(registry.register_bool_counter(&INFO[17usize])); - bool_counters.push(registry.register_bool_counter(&INFO[30usize])); - bool_counters.push(registry.register_bool_counter(&INFO[31usize])); - bool_counters.push(registry.register_bool_counter(&INFO[32usize])); - bool_counters.push(registry.register_bool_counter(&INFO[52usize])); - bool_counters.push(registry.register_bool_counter(&INFO[53usize])); + counters.push(registry.register_counter(&INFO[101usize])); + counters.push(registry.register_counter(&INFO[103usize])); + counters.push(registry.register_counter(&INFO[105usize])); + bool_counters.push(registry.register_bool_counter(&INFO[19usize])); + bool_counters.push(registry.register_bool_counter(&INFO[20usize])); + bool_counters.push(registry.register_bool_counter(&INFO[34usize])); + bool_counters.push(registry.register_bool_counter(&INFO[35usize])); + bool_counters.push(registry.register_bool_counter(&INFO[36usize])); + bool_counters.push(registry.register_bool_counter(&INFO[37usize])); + bool_counters.push(registry.register_bool_counter(&INFO[58usize])); + bool_counters.push(registry.register_bool_counter(&INFO[59usize])); { #[allow(unused_imports)] use api::*; @@ -731,7 +769,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[11usize], variant)); + .push(registry.register_nominal_counter(&INFO[13usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -740,9 +778,9 @@ impl Subscriber { { let offset = nominal_counters.len(); let mut count = 0; - for variant in ::VARIANTS.iter() { + for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[38usize], variant)); + .push(registry.register_nominal_counter(&INFO[23usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -751,9 +789,9 @@ impl Subscriber { { let offset = nominal_counters.len(); let mut count = 0; - for variant in ::VARIANTS.iter() { + for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[50usize], variant)); + .push(registry.register_nominal_counter(&INFO[39usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -762,20 +800,9 @@ impl Subscriber { { let offset = nominal_counters.len(); let mut count = 0; - for variant in ::VARIANTS.iter() { - nominal_counters - .push(registry.register_nominal_counter(&INFO[51usize], 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 ::VARIANTS.iter() { + for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[61usize], variant)); + .push(registry.register_nominal_counter(&INFO[44usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -786,7 +813,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[63usize], variant)); + .push(registry.register_nominal_counter(&INFO[56usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -797,7 +824,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[65usize], variant)); + .push(registry.register_nominal_counter(&INFO[57usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -874,7 +901,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[82usize], variant)); + .push(registry.register_nominal_counter(&INFO[79usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -885,7 +912,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[84usize], variant)); + .push(registry.register_nominal_counter(&INFO[81usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -896,7 +923,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[86usize], variant)); + .push(registry.register_nominal_counter(&INFO[83usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -979,33 +1006,68 @@ impl Subscriber { 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 ::VARIANTS.iter() { + nominal_counters + .push(registry.register_nominal_counter(&INFO[102usize], 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 ::VARIANTS.iter() { + nominal_counters + .push(registry.register_nominal_counter(&INFO[104usize], 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 ::VARIANTS.iter() { + nominal_counters + .push(registry.register_nominal_counter(&INFO[106usize], 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[2usize])); + measures.push(registry.register_measure(&INFO[3usize])); measures.push(registry.register_measure(&INFO[4usize])); - measures.push(registry.register_measure(&INFO[7usize])); - measures.push(registry.register_measure(&INFO[8usize])); + measures.push(registry.register_measure(&INFO[6usize])); measures.push(registry.register_measure(&INFO[9usize])); - measures.push(registry.register_measure(&INFO[14usize])); + measures.push(registry.register_measure(&INFO[10usize])); + measures.push(registry.register_measure(&INFO[11usize])); measures.push(registry.register_measure(&INFO[16usize])); - measures.push(registry.register_measure(&INFO[23usize])); + measures.push(registry.register_measure(&INFO[18usize])); measures.push(registry.register_measure(&INFO[27usize])); - measures.push(registry.register_measure(&INFO[29usize])); - measures.push(registry.register_measure(&INFO[42usize])); - measures.push(registry.register_measure(&INFO[44usize])); - measures.push(registry.register_measure(&INFO[46usize])); + measures.push(registry.register_measure(&INFO[31usize])); + measures.push(registry.register_measure(&INFO[33usize])); measures.push(registry.register_measure(&INFO[48usize])); - measures.push(registry.register_measure(&INFO[55usize])); - measures.push(registry.register_measure(&INFO[57usize])); - measures.push(registry.register_measure(&INFO[58usize])); - measures.push(registry.register_measure(&INFO[59usize])); - measures.push(registry.register_measure(&INFO[80usize])); - timers.push(registry.register_timer(&INFO[3usize])); - timers.push(registry.register_timer(&INFO[13usize])); - timers.push(registry.register_timer(&INFO[18usize])); - timers.push(registry.register_timer(&INFO[20usize])); - timers.push(registry.register_timer(&INFO[22usize])); - timers.push(registry.register_timer(&INFO[37usize])); - timers.push(registry.register_timer(&INFO[40usize])); + measures.push(registry.register_measure(&INFO[50usize])); + measures.push(registry.register_measure(&INFO[52usize])); + measures.push(registry.register_measure(&INFO[54usize])); + measures.push(registry.register_measure(&INFO[61usize])); + measures.push(registry.register_measure(&INFO[63usize])); + measures.push(registry.register_measure(&INFO[64usize])); + measures.push(registry.register_measure(&INFO[65usize])); + measures.push(registry.register_measure(&INFO[86usize])); + timers.push(registry.register_timer(&INFO[5usize])); + timers.push(registry.register_timer(&INFO[15usize])); + timers.push(registry.register_timer(&INFO[21usize])); + timers.push(registry.register_timer(&INFO[24usize])); + timers.push(registry.register_timer(&INFO[26usize])); + timers.push(registry.register_timer(&INFO[43usize])); + timers.push(registry.register_timer(&INFO[46usize])); { #[allow(unused_imports)] use api::*; @@ -1042,50 +1104,50 @@ impl Subscriber { .map(|(idx, entry)| match idx { 0usize => (&INFO[0usize], entry), 1usize => (&INFO[1usize], entry), - 2usize => (&INFO[5usize], entry), - 3usize => (&INFO[6usize], entry), - 4usize => (&INFO[10usize], entry), - 5usize => (&INFO[12usize], entry), - 6usize => (&INFO[15usize], entry), - 7usize => (&INFO[19usize], entry), - 8usize => (&INFO[21usize], entry), - 9usize => (&INFO[24usize], entry), - 10usize => (&INFO[25usize], entry), - 11usize => (&INFO[26usize], entry), - 12usize => (&INFO[28usize], entry), - 13usize => (&INFO[33usize], entry), - 14usize => (&INFO[34usize], entry), - 15usize => (&INFO[35usize], entry), - 16usize => (&INFO[36usize], entry), - 17usize => (&INFO[39usize], entry), - 18usize => (&INFO[41usize], entry), - 19usize => (&INFO[43usize], entry), - 20usize => (&INFO[45usize], entry), - 21usize => (&INFO[47usize], entry), - 22usize => (&INFO[49usize], entry), - 23usize => (&INFO[54usize], entry), - 24usize => (&INFO[56usize], entry), - 25usize => (&INFO[60usize], entry), - 26usize => (&INFO[62usize], entry), - 27usize => (&INFO[64usize], entry), - 28usize => (&INFO[66usize], entry), - 29usize => (&INFO[68usize], entry), - 30usize => (&INFO[70usize], entry), - 31usize => (&INFO[72usize], entry), - 32usize => (&INFO[74usize], entry), - 33usize => (&INFO[76usize], entry), - 34usize => (&INFO[78usize], entry), - 35usize => (&INFO[79usize], entry), - 36usize => (&INFO[81usize], entry), - 37usize => (&INFO[83usize], entry), - 38usize => (&INFO[85usize], entry), - 39usize => (&INFO[87usize], entry), - 40usize => (&INFO[89usize], entry), - 41usize => (&INFO[91usize], entry), - 42usize => (&INFO[93usize], entry), - 43usize => (&INFO[95usize], entry), - 44usize => (&INFO[97usize], entry), - 45usize => (&INFO[99usize], entry), + 2usize => (&INFO[7usize], entry), + 3usize => (&INFO[8usize], entry), + 4usize => (&INFO[12usize], entry), + 5usize => (&INFO[14usize], entry), + 6usize => (&INFO[17usize], entry), + 7usize => (&INFO[22usize], entry), + 8usize => (&INFO[25usize], entry), + 9usize => (&INFO[28usize], entry), + 10usize => (&INFO[29usize], entry), + 11usize => (&INFO[30usize], entry), + 12usize => (&INFO[32usize], entry), + 13usize => (&INFO[38usize], entry), + 14usize => (&INFO[40usize], entry), + 15usize => (&INFO[41usize], entry), + 16usize => (&INFO[42usize], entry), + 17usize => (&INFO[45usize], entry), + 18usize => (&INFO[47usize], entry), + 19usize => (&INFO[49usize], entry), + 20usize => (&INFO[51usize], entry), + 21usize => (&INFO[53usize], entry), + 22usize => (&INFO[55usize], entry), + 23usize => (&INFO[60usize], entry), + 24usize => (&INFO[62usize], entry), + 25usize => (&INFO[66usize], entry), + 26usize => (&INFO[68usize], entry), + 27usize => (&INFO[70usize], entry), + 28usize => (&INFO[72usize], entry), + 29usize => (&INFO[74usize], entry), + 30usize => (&INFO[76usize], entry), + 31usize => (&INFO[78usize], entry), + 32usize => (&INFO[80usize], entry), + 33usize => (&INFO[82usize], entry), + 34usize => (&INFO[84usize], entry), + 35usize => (&INFO[85usize], entry), + 36usize => (&INFO[87usize], entry), + 37usize => (&INFO[89usize], entry), + 38usize => (&INFO[91usize], entry), + 39usize => (&INFO[93usize], entry), + 40usize => (&INFO[95usize], entry), + 41usize => (&INFO[97usize], entry), + 42usize => (&INFO[99usize], entry), + 43usize => (&INFO[101usize], entry), + 44usize => (&INFO[103usize], entry), + 45usize => (&INFO[105usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1103,12 +1165,14 @@ impl Subscriber { .iter() .enumerate() .map(|(idx, entry)| match idx { - 0usize => (&INFO[17usize], entry), - 1usize => (&INFO[30usize], entry), - 2usize => (&INFO[31usize], entry), - 3usize => (&INFO[32usize], entry), - 4usize => (&INFO[52usize], entry), - 5usize => (&INFO[53usize], entry), + 0usize => (&INFO[19usize], entry), + 1usize => (&INFO[20usize], entry), + 2usize => (&INFO[34usize], entry), + 3usize => (&INFO[35usize], entry), + 4usize => (&INFO[36usize], entry), + 5usize => (&INFO[37usize], entry), + 6usize => (&INFO[58usize], entry), + 7usize => (&INFO[59usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1133,139 +1197,151 @@ impl Subscriber { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[11usize], entries, variants) + (&INFO[13usize], entries, variants) } 1usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[38usize], entries, variants) + (&INFO[23usize], entries, variants) } 2usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[50usize], entries, variants) + (&INFO[39usize], entries, variants) } 3usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[51usize], entries, variants) + (&INFO[44usize], entries, variants) } 4usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[61usize], entries, variants) + (&INFO[56usize], entries, variants) } 5usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[63usize], entries, variants) + (&INFO[57usize], entries, variants) } 6usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[65usize], entries, variants) + (&INFO[67usize], entries, variants) } 7usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[67usize], entries, variants) + (&INFO[69usize], entries, variants) } 8usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[69usize], entries, variants) + (&INFO[71usize], entries, variants) } 9usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[71usize], entries, variants) + (&INFO[73usize], entries, variants) } 10usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[73usize], entries, variants) + (&INFO[75usize], entries, variants) } 11usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[75usize], entries, variants) + (&INFO[77usize], entries, variants) } 12usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[77usize], entries, variants) + (&INFO[79usize], entries, variants) } 13usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[82usize], entries, variants) + (&INFO[81usize], entries, variants) } 14usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[84usize], entries, variants) + (&INFO[83usize], entries, variants) } 15usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[86usize], entries, variants) + (&INFO[88usize], entries, variants) } 16usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[88usize], entries, variants) + (&INFO[90usize], entries, variants) } 17usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[90usize], entries, variants) + (&INFO[92usize], entries, variants) } 18usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[92usize], entries, variants) + (&INFO[94usize], entries, variants) } 19usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[94usize], entries, variants) + (&INFO[96usize], entries, variants) } 20usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[96usize], entries, variants) + (&INFO[98usize], entries, variants) } 21usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[98usize], entries, variants) + (&INFO[100usize], entries, variants) } 22usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[100usize], entries, variants) + (&INFO[102usize], entries, variants) + } + 23usize => { + let offset = *entry; + let variants = ::VARIANTS; + let entries = &self.nominal_counters[offset..offset + variants.len()]; + (&INFO[104usize], entries, variants) + } + 24usize => { + let offset = *entry; + let variants = ::VARIANTS; + let entries = &self.nominal_counters[offset..offset + variants.len()]; + (&INFO[106usize], entries, variants) } _ => unsafe { core::hint::unreachable_unchecked() }, }) @@ -1286,24 +1362,26 @@ impl Subscriber { .enumerate() .map(|(idx, entry)| match idx { 0usize => (&INFO[2usize], entry), - 1usize => (&INFO[4usize], entry), - 2usize => (&INFO[7usize], entry), - 3usize => (&INFO[8usize], entry), + 1usize => (&INFO[3usize], entry), + 2usize => (&INFO[4usize], entry), + 3usize => (&INFO[6usize], entry), 4usize => (&INFO[9usize], entry), - 5usize => (&INFO[14usize], entry), - 6usize => (&INFO[16usize], entry), - 7usize => (&INFO[23usize], entry), - 8usize => (&INFO[27usize], entry), - 9usize => (&INFO[29usize], entry), - 10usize => (&INFO[42usize], entry), - 11usize => (&INFO[44usize], entry), - 12usize => (&INFO[46usize], entry), - 13usize => (&INFO[48usize], entry), - 14usize => (&INFO[55usize], entry), - 15usize => (&INFO[57usize], entry), - 16usize => (&INFO[58usize], entry), - 17usize => (&INFO[59usize], entry), - 18usize => (&INFO[80usize], entry), + 5usize => (&INFO[10usize], entry), + 6usize => (&INFO[11usize], entry), + 7usize => (&INFO[16usize], entry), + 8usize => (&INFO[18usize], entry), + 9usize => (&INFO[27usize], entry), + 10usize => (&INFO[31usize], entry), + 11usize => (&INFO[33usize], entry), + 12usize => (&INFO[48usize], entry), + 13usize => (&INFO[50usize], entry), + 14usize => (&INFO[52usize], entry), + 15usize => (&INFO[54usize], entry), + 16usize => (&INFO[61usize], entry), + 17usize => (&INFO[63usize], entry), + 18usize => (&INFO[64usize], entry), + 19usize => (&INFO[65usize], entry), + 20usize => (&INFO[86usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1333,13 +1411,13 @@ impl Subscriber { .iter() .enumerate() .map(|(idx, entry)| match idx { - 0usize => (&INFO[3usize], entry), - 1usize => (&INFO[13usize], entry), - 2usize => (&INFO[18usize], entry), - 3usize => (&INFO[20usize], entry), - 4usize => (&INFO[22usize], entry), - 5usize => (&INFO[37usize], entry), - 6usize => (&INFO[40usize], entry), + 0usize => (&INFO[5usize], entry), + 1usize => (&INFO[15usize], entry), + 2usize => (&INFO[21usize], entry), + 3usize => (&INFO[24usize], entry), + 4usize => (&INFO[26usize], entry), + 5usize => (&INFO[43usize], entry), + 6usize => (&INFO[46usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1394,8 +1472,10 @@ impl event::Subscriber for Subscriber { use api::*; self.count(1usize, 1usize, 1usize); self.measure(2usize, 0usize, event.pending_streams); - self.time(3usize, 0usize, event.processing_duration); - self.measure(4usize, 1usize, event.max_sojourn_time); + self.measure(3usize, 1usize, event.slots_idle); + self.measure(4usize, 2usize, event.slot_utilization); + self.time(5usize, 0usize, event.processing_duration); + self.measure(6usize, 3usize, event.max_sojourn_time); let _ = event; let _ = meta; } @@ -1407,7 +1487,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(5usize, 2usize, 1usize); + self.count(7usize, 2usize, 1usize); let _ = event; let _ = meta; } @@ -1419,10 +1499,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(6usize, 3usize, 1usize); - self.measure(7usize, 2usize, event.enqueued); - self.measure(8usize, 3usize, event.dropped); - self.measure(9usize, 4usize, event.errored); + self.count(8usize, 3usize, 1usize); + self.measure(9usize, 4usize, event.enqueued); + self.measure(10usize, 5usize, event.dropped); + self.measure(11usize, 6usize, event.errored); let _ = event; let _ = meta; } @@ -1434,8 +1514,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(10usize, 4usize, 1usize); - self.count_nominal(11usize, 0usize, &event.reason); + self.count(12usize, 4usize, 1usize); + self.count_nominal(13usize, 0usize, &event.reason); let _ = event; let _ = meta; } @@ -1447,9 +1527,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(12usize, 5usize, 1usize); - self.time(13usize, 1usize, event.sojourn_time); - self.measure(14usize, 5usize, event.buffer_len); + self.count(14usize, 5usize, 1usize); + self.time(15usize, 1usize, event.sojourn_time); + self.measure(16usize, 7usize, event.buffer_len); let _ = event; let _ = meta; } @@ -1461,10 +1541,11 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(15usize, 6usize, 1usize); - self.measure(16usize, 6usize, event.payload_len); - self.count_bool(17usize, 0usize, event.is_fin); - self.time(18usize, 2usize, event.sojourn_time); + self.count(17usize, 6usize, 1usize); + self.measure(18usize, 8usize, event.payload_len); + self.count_bool(19usize, 0usize, event.is_fin); + self.count_bool(20usize, 1usize, event.is_fin_known); + self.time(21usize, 2usize, event.sojourn_time); let _ = event; let _ = meta; } @@ -1476,8 +1557,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(19usize, 7usize, 1usize); - self.time(20usize, 3usize, event.sojourn_time); + self.count(22usize, 7usize, 1usize); + self.count_nominal(23usize, 1usize, &event.reason); + self.time(24usize, 3usize, event.sojourn_time); let _ = event; let _ = meta; } @@ -1489,9 +1571,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(21usize, 8usize, 1usize); - self.time(22usize, 4usize, event.sojourn_time); - self.measure(23usize, 7usize, event.blocked_count); + self.count(25usize, 8usize, 1usize); + self.time(26usize, 4usize, event.sojourn_time); + self.measure(27usize, 9usize, event.blocked_count); let _ = event; let _ = meta; } @@ -1499,7 +1581,7 @@ impl event::Subscriber for Subscriber { fn on_acceptor_tcp_io_error(&self, meta: &api::EndpointMeta, event: &api::AcceptorTcpIoError) { #[allow(unused_imports)] use api::*; - self.count(24usize, 9usize, 1usize); + self.count(28usize, 9usize, 1usize); let _ = event; let _ = meta; } @@ -1507,7 +1589,7 @@ impl event::Subscriber for Subscriber { fn on_acceptor_udp_started(&self, meta: &api::EndpointMeta, event: &api::AcceptorUdpStarted) { #[allow(unused_imports)] use api::*; - self.count(25usize, 10usize, 1usize); + self.count(29usize, 10usize, 1usize); let _ = event; let _ = meta; } @@ -1519,8 +1601,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(26usize, 11usize, 1usize); - self.measure(27usize, 8usize, event.len); + self.count(30usize, 11usize, 1usize); + self.measure(31usize, 10usize, event.len); let _ = event; let _ = meta; } @@ -1532,11 +1614,12 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(28usize, 12usize, 1usize); - self.measure(29usize, 9usize, event.payload_len); - self.count_bool(30usize, 1usize, event.is_zero_offset); - self.count_bool(31usize, 2usize, event.is_retransmission); - self.count_bool(32usize, 3usize, event.is_fin); + self.count(32usize, 12usize, 1usize); + self.measure(33usize, 11usize, event.payload_len); + self.count_bool(34usize, 2usize, event.is_zero_offset); + self.count_bool(35usize, 3usize, event.is_retransmission); + self.count_bool(36usize, 4usize, event.is_fin); + self.count_bool(37usize, 5usize, event.is_fin_known); let _ = event; let _ = meta; } @@ -1548,7 +1631,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(33usize, 13usize, 1usize); + self.count(38usize, 13usize, 1usize); + self.count_nominal(39usize, 2usize, &event.reason); let _ = event; let _ = meta; } @@ -1560,7 +1644,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(34usize, 14usize, 1usize); + self.count(40usize, 14usize, 1usize); let _ = event; let _ = meta; } @@ -1568,7 +1652,7 @@ impl event::Subscriber for Subscriber { fn on_acceptor_udp_io_error(&self, meta: &api::EndpointMeta, event: &api::AcceptorUdpIoError) { #[allow(unused_imports)] use api::*; - self.count(35usize, 15usize, 1usize); + self.count(41usize, 15usize, 1usize); let _ = event; let _ = meta; } @@ -1580,9 +1664,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(36usize, 16usize, 1usize); - self.time(37usize, 5usize, event.sojourn_time); - self.count_nominal(38usize, 1usize, &event.reason); + self.count(42usize, 16usize, 1usize); + self.time(43usize, 5usize, event.sojourn_time); + self.count_nominal(44usize, 3usize, &event.reason); let _ = event; let _ = meta; } @@ -1594,8 +1678,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(39usize, 17usize, 1usize); - self.time(40usize, 6usize, event.sojourn_time); + self.count(45usize, 17usize, 1usize); + self.time(46usize, 6usize, event.sojourn_time); let _ = event; let _ = meta; } @@ -1608,10 +1692,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(41usize, 18usize, 1usize); - self.measure(42usize, 10usize, event.total_len); - self.count(43usize, 19usize, event.write_len); - self.measure(44usize, 11usize, event.write_len); + self.count(47usize, 18usize, 1usize); + self.measure(48usize, 12usize, event.total_len); + self.count(49usize, 19usize, event.write_len); + self.measure(50usize, 13usize, event.write_len); let _ = context; let _ = meta; let _ = event; @@ -1625,10 +1709,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(45usize, 20usize, 1usize); - self.measure(46usize, 12usize, event.capacity); - self.count(47usize, 21usize, event.read_len); - self.measure(48usize, 13usize, event.read_len); + self.count(51usize, 20usize, 1usize); + self.measure(52usize, 14usize, event.capacity); + self.count(53usize, 21usize, event.read_len); + self.measure(54usize, 15usize, event.read_len); let _ = context; let _ = meta; let _ = event; @@ -1637,11 +1721,11 @@ impl event::Subscriber for Subscriber { fn on_endpoint_initialized(&self, meta: &api::EndpointMeta, event: &api::EndpointInitialized) { #[allow(unused_imports)] use api::*; - self.count(49usize, 22usize, 1usize); - self.count_nominal(50usize, 2usize, &event.acceptor_addr); - self.count_nominal(51usize, 3usize, &event.handshake_addr); - self.count_bool(52usize, 4usize, event.tcp); - self.count_bool(53usize, 5usize, event.udp); + self.count(55usize, 22usize, 1usize); + self.count_nominal(56usize, 4usize, &event.acceptor_addr); + self.count_nominal(57usize, 5usize, &event.handshake_addr); + self.count_bool(58usize, 6usize, event.tcp); + self.count_bool(59usize, 7usize, event.udp); let _ = event; let _ = meta; } @@ -1653,8 +1737,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(54usize, 23usize, 1usize); - self.measure(55usize, 14usize, event.capacity); + self.count(60usize, 23usize, 1usize); + self.measure(61usize, 16usize, event.capacity); let _ = event; let _ = meta; } @@ -1666,10 +1750,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(56usize, 24usize, 1usize); - self.measure(57usize, 15usize, event.capacity); - self.measure(58usize, 16usize, event.entries); - self.measure(59usize, 17usize, event.lifetime); + self.count(62usize, 24usize, 1usize); + self.measure(63usize, 17usize, event.capacity); + self.measure(64usize, 18usize, event.entries); + self.measure(65usize, 19usize, event.lifetime); let _ = event; let _ = meta; } @@ -1681,8 +1765,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(60usize, 25usize, 1usize); - self.count_nominal(61usize, 4usize, &event.peer_address); + self.count(66usize, 25usize, 1usize); + self.count_nominal(67usize, 6usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1694,8 +1778,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(62usize, 26usize, 1usize); - self.count_nominal(63usize, 5usize, &event.peer_address); + self.count(68usize, 26usize, 1usize); + self.count_nominal(69usize, 7usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1707,8 +1791,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(64usize, 27usize, 1usize); - self.count_nominal(65usize, 6usize, &event.peer_address); + self.count(70usize, 27usize, 1usize); + self.count_nominal(71usize, 8usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1720,8 +1804,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(66usize, 28usize, 1usize); - self.count_nominal(67usize, 7usize, &event.peer_address); + self.count(72usize, 28usize, 1usize); + self.count_nominal(73usize, 9usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1733,8 +1817,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(68usize, 29usize, 1usize); - self.count_nominal(69usize, 8usize, &event.peer_address); + self.count(74usize, 29usize, 1usize); + self.count_nominal(75usize, 10usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1746,8 +1830,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(70usize, 30usize, 1usize); - self.count_nominal(71usize, 9usize, &event.peer_address); + self.count(76usize, 30usize, 1usize); + self.count_nominal(77usize, 11usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1759,8 +1843,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(72usize, 31usize, 1usize); - self.count_nominal(73usize, 10usize, &event.peer_address); + self.count(78usize, 31usize, 1usize); + self.count_nominal(79usize, 12usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1772,8 +1856,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(74usize, 32usize, 1usize); - self.count_nominal(75usize, 11usize, &event.peer_address); + self.count(80usize, 32usize, 1usize); + self.count_nominal(81usize, 13usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1785,8 +1869,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(76usize, 33usize, 1usize); - self.count_nominal(77usize, 12usize, &event.peer_address); + self.count(82usize, 33usize, 1usize); + self.count_nominal(83usize, 14usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1798,7 +1882,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(78usize, 34usize, 1usize); + self.count(84usize, 34usize, 1usize); let _ = event; let _ = meta; } @@ -1810,8 +1894,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(79usize, 35usize, 1usize); - self.measure(80usize, 18usize, event.gap); + self.count(85usize, 35usize, 1usize); + self.measure(86usize, 20usize, event.gap); let _ = event; let _ = meta; } @@ -1823,8 +1907,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(81usize, 36usize, 1usize); - self.count_nominal(82usize, 13usize, &event.peer_address); + self.count(87usize, 36usize, 1usize); + self.count_nominal(88usize, 15usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1836,8 +1920,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(83usize, 37usize, 1usize); - self.count_nominal(84usize, 14usize, &event.peer_address); + self.count(89usize, 37usize, 1usize); + self.count_nominal(90usize, 16usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1849,8 +1933,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(85usize, 38usize, 1usize); - self.count_nominal(86usize, 15usize, &event.peer_address); + self.count(91usize, 38usize, 1usize); + self.count_nominal(92usize, 17usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1862,8 +1946,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(87usize, 39usize, 1usize); - self.count_nominal(88usize, 16usize, &event.peer_address); + self.count(93usize, 39usize, 1usize); + self.count_nominal(94usize, 18usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1875,8 +1959,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(89usize, 40usize, 1usize); - self.count_nominal(90usize, 17usize, &event.peer_address); + self.count(95usize, 40usize, 1usize); + self.count_nominal(96usize, 19usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1884,8 +1968,8 @@ impl event::Subscriber for Subscriber { fn on_stale_key_packet_sent(&self, meta: &api::EndpointMeta, event: &api::StaleKeyPacketSent) { #[allow(unused_imports)] use api::*; - self.count(91usize, 41usize, 1usize); - self.count_nominal(92usize, 18usize, &event.peer_address); + self.count(97usize, 41usize, 1usize); + self.count_nominal(98usize, 20usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1897,8 +1981,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(93usize, 42usize, 1usize); - self.count_nominal(94usize, 19usize, &event.peer_address); + self.count(99usize, 42usize, 1usize); + self.count_nominal(100usize, 21usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1910,8 +1994,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(95usize, 43usize, 1usize); - self.count_nominal(96usize, 20usize, &event.peer_address); + self.count(101usize, 43usize, 1usize); + self.count_nominal(102usize, 22usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1923,8 +2007,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(97usize, 44usize, 1usize); - self.count_nominal(98usize, 21usize, &event.peer_address); + self.count(103usize, 44usize, 1usize); + self.count_nominal(104usize, 23usize, &event.peer_address); let _ = event; let _ = meta; } @@ -1936,8 +2020,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(99usize, 45usize, 1usize); - self.count_nominal(100usize, 22usize, &event.peer_address); + self.count(105usize, 45usize, 1usize); + self.count_nominal(106usize, 24usize, &event.peer_address); let _ = event; let _ = meta; } diff --git a/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs b/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs index 4077f2c93..250a52061 100644 --- a/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs +++ b/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs @@ -19,50 +19,50 @@ mod counter { match info.id { 0usize => Self(acceptor_tcp_started), 1usize => Self(acceptor_tcp_loop_iteration_completed), - 5usize => Self(acceptor_tcp_fresh_enqueued), - 6usize => Self(acceptor_tcp_fresh_batch_completed), - 10usize => Self(acceptor_tcp_stream_dropped), - 12usize => Self(acceptor_tcp_stream_replaced), - 15usize => Self(acceptor_tcp_packet_received), - 19usize => Self(acceptor_tcp_packet_dropped), - 21usize => Self(acceptor_tcp_stream_enqueued), - 24usize => Self(acceptor_tcp_io_error), - 25usize => Self(acceptor_udp_started), - 26usize => Self(acceptor_udp_datagram_received), - 28usize => Self(acceptor_udp_packet_received), - 33usize => Self(acceptor_udp_packet_dropped), - 34usize => Self(acceptor_udp_stream_enqueued), - 35usize => Self(acceptor_udp_io_error), - 36usize => Self(acceptor_stream_pruned), - 39usize => Self(acceptor_stream_dequeued), - 41usize => Self(application_write), - 43usize => Self(application_write__committed__total), - 45usize => Self(application_read), - 47usize => Self(application_read__committed__total), - 49usize => Self(endpoint_initialized), - 54usize => Self(path_secret_map_initialized), - 56usize => Self(path_secret_map_uninitialized), - 60usize => Self(path_secret_map_background_handshake_requested), - 62usize => Self(path_secret_map_entry_inserted), - 64usize => Self(path_secret_map_entry_ready), - 66usize => Self(path_secret_map_entry_replaced), - 68usize => Self(unknown_path_secret_packet_sent), - 70usize => Self(unknown_path_secret_packet_received), - 72usize => Self(unknown_path_secret_packet_accepted), - 74usize => Self(unknown_path_secret_packet_rejected), - 76usize => Self(unknown_path_secret_packet_dropped), - 78usize => Self(replay_definitely_detected), - 79usize => Self(replay_potentially_detected), - 81usize => Self(replay_detected_packet_sent), - 83usize => Self(replay_detected_packet_received), - 85usize => Self(replay_detected_packet_accepted), - 87usize => Self(replay_detected_packet_rejected), - 89usize => Self(replay_detected_packet_dropped), - 91usize => Self(stale_key_packet_sent), - 93usize => Self(stale_key_packet_received), - 95usize => Self(stale_key_packet_accepted), - 97usize => Self(stale_key_packet_rejected), - 99usize => Self(stale_key_packet_dropped), + 7usize => Self(acceptor_tcp_fresh_enqueued), + 8usize => Self(acceptor_tcp_fresh_batch_completed), + 12usize => Self(acceptor_tcp_stream_dropped), + 14usize => Self(acceptor_tcp_stream_replaced), + 17usize => Self(acceptor_tcp_packet_received), + 22usize => Self(acceptor_tcp_packet_dropped), + 25usize => Self(acceptor_tcp_stream_enqueued), + 28usize => Self(acceptor_tcp_io_error), + 29usize => Self(acceptor_udp_started), + 30usize => Self(acceptor_udp_datagram_received), + 32usize => Self(acceptor_udp_packet_received), + 38usize => Self(acceptor_udp_packet_dropped), + 40usize => Self(acceptor_udp_stream_enqueued), + 41usize => Self(acceptor_udp_io_error), + 42usize => Self(acceptor_stream_pruned), + 45usize => Self(acceptor_stream_dequeued), + 47usize => Self(application_write), + 49usize => Self(application_write__committed__total), + 51usize => Self(application_read), + 53usize => Self(application_read__committed__total), + 55usize => Self(endpoint_initialized), + 60usize => Self(path_secret_map_initialized), + 62usize => Self(path_secret_map_uninitialized), + 66usize => Self(path_secret_map_background_handshake_requested), + 68usize => Self(path_secret_map_entry_inserted), + 70usize => Self(path_secret_map_entry_ready), + 72usize => Self(path_secret_map_entry_replaced), + 74usize => Self(unknown_path_secret_packet_sent), + 76usize => Self(unknown_path_secret_packet_received), + 78usize => Self(unknown_path_secret_packet_accepted), + 80usize => Self(unknown_path_secret_packet_rejected), + 82usize => Self(unknown_path_secret_packet_dropped), + 84usize => Self(replay_definitely_detected), + 85usize => Self(replay_potentially_detected), + 87usize => Self(replay_detected_packet_sent), + 89usize => Self(replay_detected_packet_received), + 91usize => Self(replay_detected_packet_accepted), + 93usize => Self(replay_detected_packet_rejected), + 95usize => Self(replay_detected_packet_dropped), + 97usize => Self(stale_key_packet_sent), + 99usize => Self(stale_key_packet_received), + 101usize => Self(stale_key_packet_accepted), + 103usize => Self(stale_key_packet_rejected), + 105usize => Self(stale_key_packet_dropped), _ => unreachable!("invalid info: {info:?}"), } } @@ -175,12 +175,14 @@ mod counter { impl Recorder { pub(crate) fn new(info: &'static Info) -> Self { match info.id { - 17usize => Self(acceptor_tcp_packet_received__is_fin), - 30usize => Self(acceptor_udp_packet_received__is_zero_offset), - 31usize => Self(acceptor_udp_packet_received__is_retransmisson), - 32usize => Self(acceptor_udp_packet_received__is_fin), - 52usize => Self(endpoint_initialized__tcp), - 53usize => Self(endpoint_initialized__udp), + 19usize => Self(acceptor_tcp_packet_received__is_fin), + 20usize => Self(acceptor_tcp_packet_received__is_fin_known), + 34usize => Self(acceptor_udp_packet_received__is_zero_offset), + 35usize => Self(acceptor_udp_packet_received__is_retransmisson), + 36usize => Self(acceptor_udp_packet_received__is_fin), + 37usize => Self(acceptor_udp_packet_received__is_fin_known), + 58usize => Self(endpoint_initialized__tcp), + 59usize => Self(endpoint_initialized__udp), _ => unreachable!("invalid info: {info:?}"), } } @@ -194,12 +196,16 @@ mod counter { extern "probe" { # [link_name = s2n_quic_dc__event__counter__bool__acceptor_tcp_packet_received__is_fin] fn acceptor_tcp_packet_received__is_fin(value: bool); + # [link_name = s2n_quic_dc__event__counter__bool__acceptor_tcp_packet_received__is_fin_known] + fn acceptor_tcp_packet_received__is_fin_known(value: bool); # [link_name = s2n_quic_dc__event__counter__bool__acceptor_udp_packet_received__is_zero_offset] fn acceptor_udp_packet_received__is_zero_offset(value: bool); # [link_name = s2n_quic_dc__event__counter__bool__acceptor_udp_packet_received__is_retransmisson] fn acceptor_udp_packet_received__is_retransmisson(value: bool); # [link_name = s2n_quic_dc__event__counter__bool__acceptor_udp_packet_received__is_fin] fn acceptor_udp_packet_received__is_fin(value: bool); + # [link_name = s2n_quic_dc__event__counter__bool__acceptor_udp_packet_received__is_fin_known] + fn acceptor_udp_packet_received__is_fin_known(value: bool); # [link_name = s2n_quic_dc__event__counter__bool__endpoint_initialized__tcp] fn endpoint_initialized__tcp(value: bool); # [link_name = s2n_quic_dc__event__counter__bool__endpoint_initialized__udp] @@ -215,31 +221,33 @@ mod counter { impl Recorder { pub(crate) fn new(info: &'static Info, _variant: &'static info::Variant) -> Self { match info.id { - 11usize => Self(acceptor_tcp_stream_dropped__reason), - 38usize => Self(acceptor_stream_pruned__reason), - 50usize => Self(endpoint_initialized__acceptor__protocol), - 51usize => Self(endpoint_initialized__handshake__protocol), - 61usize => { + 13usize => Self(acceptor_tcp_stream_dropped__reason), + 23usize => Self(acceptor_tcp_packet_dropped__reason), + 39usize => Self(acceptor_udp_packet_dropped__reason), + 44usize => Self(acceptor_stream_pruned__reason), + 56usize => Self(endpoint_initialized__acceptor__protocol), + 57usize => Self(endpoint_initialized__handshake__protocol), + 67usize => { Self(path_secret_map_background_handshake_requested__peer_address__protocol) } - 63usize => Self(path_secret_map_entry_inserted__peer_address__protocol), - 65usize => Self(path_secret_map_entry_ready__peer_address__protocol), - 67usize => Self(path_secret_map_entry_replaced__peer_address__protocol), - 69usize => Self(unknown_path_secret_packet_sent__peer_address__protocol), - 71usize => Self(unknown_path_secret_packet_received__peer_address__protocol), - 73usize => Self(unknown_path_secret_packet_accepted__peer_address__protocol), - 75usize => Self(unknown_path_secret_packet_rejected__peer_address__protocol), - 77usize => Self(unknown_path_secret_packet_dropped__peer_address__protocol), - 82usize => Self(replay_detected_packet_sent__peer_address__protocol), - 84usize => Self(replay_detected_packet_received__peer_address__protocol), - 86usize => Self(replay_detected_packet_accepted__peer_address__protocol), - 88usize => Self(replay_detected_packet_rejected__peer_address__protocol), - 90usize => Self(replay_detected_packet_dropped__peer_address__protocol), - 92usize => Self(stale_key_packet_sent__peer_address__protocol), - 94usize => Self(stale_key_packet_received__peer_address__protocol), - 96usize => Self(stale_key_packet_accepted__peer_address__protocol), - 98usize => Self(stale_key_packet_rejected__peer_address__protocol), - 100usize => Self(stale_key_packet_dropped__peer_address__protocol), + 69usize => Self(path_secret_map_entry_inserted__peer_address__protocol), + 71usize => Self(path_secret_map_entry_ready__peer_address__protocol), + 73usize => Self(path_secret_map_entry_replaced__peer_address__protocol), + 75usize => Self(unknown_path_secret_packet_sent__peer_address__protocol), + 77usize => Self(unknown_path_secret_packet_received__peer_address__protocol), + 79usize => Self(unknown_path_secret_packet_accepted__peer_address__protocol), + 81usize => Self(unknown_path_secret_packet_rejected__peer_address__protocol), + 83usize => Self(unknown_path_secret_packet_dropped__peer_address__protocol), + 88usize => Self(replay_detected_packet_sent__peer_address__protocol), + 90usize => Self(replay_detected_packet_received__peer_address__protocol), + 92usize => Self(replay_detected_packet_accepted__peer_address__protocol), + 94usize => Self(replay_detected_packet_rejected__peer_address__protocol), + 96usize => Self(replay_detected_packet_dropped__peer_address__protocol), + 98usize => Self(stale_key_packet_sent__peer_address__protocol), + 100usize => Self(stale_key_packet_received__peer_address__protocol), + 102usize => Self(stale_key_packet_accepted__peer_address__protocol), + 104usize => Self(stale_key_packet_rejected__peer_address__protocol), + 106usize => Self(stale_key_packet_dropped__peer_address__protocol), _ => unreachable!("invalid info: {info:?}"), } } @@ -262,6 +270,18 @@ mod counter { variant: u64, variant_name: &info::Str, ); + # [link_name = s2n_quic_dc__event__counter__nominal__acceptor_tcp_packet_dropped__reason] + fn acceptor_tcp_packet_dropped__reason( + value: u64, + variant: u64, + variant_name: &info::Str, + ); + # [link_name = s2n_quic_dc__event__counter__nominal__acceptor_udp_packet_dropped__reason] + fn acceptor_udp_packet_dropped__reason( + value: u64, + variant: u64, + variant_name: &info::Str, + ); # [link_name = s2n_quic_dc__event__counter__nominal__acceptor_stream_pruned__reason] fn acceptor_stream_pruned__reason( value: u64, @@ -407,24 +427,26 @@ mod measure { pub(crate) fn new(info: &'static Info) -> Self { match info.id { 2usize => Self(acceptor_tcp_loop_iteration_completed__pending_streams), - 4usize => Self(acceptor_tcp_loop_iteration_completed__max_sojourn_time), - 7usize => Self(acceptor_tcp_fresh_batch_completed__enqueued), - 8usize => Self(acceptor_tcp_fresh_batch_completed__dropped), - 9usize => Self(acceptor_tcp_fresh_batch_completed__errored), - 14usize => Self(acceptor_tcp_stream_replaced__buffer_len), - 16usize => Self(acceptor_tcp_packet_received__payload_len), - 23usize => Self(acceptor_tcp_stream_enqueued__blocked_count), - 27usize => Self(acceptor_udp_datagram_received__len), - 29usize => Self(acceptor_udp_packet_received__payload_len), - 42usize => Self(application_write__provided), - 44usize => Self(application_write__committed), - 46usize => Self(application_read__capacity), - 48usize => Self(application_read__committed), - 55usize => Self(path_secret_map_initialized__capacity), - 57usize => Self(path_secret_map_uninitialized__capacity), - 58usize => Self(path_secret_map_uninitialized__entries), - 59usize => Self(path_secret_map_uninitialized__lifetime), - 80usize => Self(replay_potentially_detected__gap), + 3usize => Self(acceptor_tcp_loop_iteration_completed__slots_idle), + 4usize => Self(acceptor_tcp_loop_iteration_completed__slot_utilization), + 6usize => Self(acceptor_tcp_loop_iteration_completed__max_sojourn_time), + 9usize => Self(acceptor_tcp_fresh_batch_completed__enqueued), + 10usize => Self(acceptor_tcp_fresh_batch_completed__dropped), + 11usize => Self(acceptor_tcp_fresh_batch_completed__errored), + 16usize => Self(acceptor_tcp_stream_replaced__buffer_len), + 18usize => Self(acceptor_tcp_packet_received__payload_len), + 27usize => Self(acceptor_tcp_stream_enqueued__blocked_count), + 31usize => Self(acceptor_udp_datagram_received__len), + 33usize => Self(acceptor_udp_packet_received__payload_len), + 48usize => Self(application_write__provided), + 50usize => Self(application_write__committed), + 52usize => Self(application_read__capacity), + 54usize => Self(application_read__committed), + 61usize => Self(path_secret_map_initialized__capacity), + 63usize => Self(path_secret_map_uninitialized__capacity), + 64usize => Self(path_secret_map_uninitialized__entries), + 65usize => Self(path_secret_map_uninitialized__lifetime), + 86usize => Self(replay_potentially_detected__gap), _ => unreachable!("invalid info: {info:?}"), } } @@ -438,6 +460,10 @@ mod measure { extern "probe" { # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_loop_iteration_completed__pending_streams] fn acceptor_tcp_loop_iteration_completed__pending_streams(value: u64); + # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_loop_iteration_completed__slots_idle] + fn acceptor_tcp_loop_iteration_completed__slots_idle(value: u64); + # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_loop_iteration_completed__slot_utilization] + fn acceptor_tcp_loop_iteration_completed__slot_utilization(value: u64); # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_loop_iteration_completed__max_sojourn_time] fn acceptor_tcp_loop_iteration_completed__max_sojourn_time(value: u64); # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_fresh_batch_completed__enqueued] @@ -501,13 +527,13 @@ mod timer { impl Recorder { pub(crate) fn new(info: &'static Info) -> Self { match info.id { - 3usize => Self(acceptor_tcp_loop_iteration_completed__processing_duration), - 13usize => Self(acceptor_tcp_stream_replaced__sojourn_time), - 18usize => Self(acceptor_tcp_packet_received__sojourn_time), - 20usize => Self(acceptor_tcp_packet_dropped__sojourn_time), - 22usize => Self(acceptor_tcp_stream_enqueued__sojourn_time), - 37usize => Self(acceptor_stream_pruned__sojourn_time), - 40usize => Self(acceptor_stream_dequeued__sojourn_time), + 5usize => Self(acceptor_tcp_loop_iteration_completed__processing_duration), + 15usize => Self(acceptor_tcp_stream_replaced__sojourn_time), + 21usize => Self(acceptor_tcp_packet_received__sojourn_time), + 24usize => Self(acceptor_tcp_packet_dropped__sojourn_time), + 26usize => Self(acceptor_tcp_stream_enqueued__sojourn_time), + 43usize => Self(acceptor_stream_pruned__sojourn_time), + 46usize => Self(acceptor_stream_dequeued__sojourn_time), _ => unreachable!("invalid info: {info:?}"), } } diff --git a/dc/s2n-quic-dc/src/stream/server.rs b/dc/s2n-quic-dc/src/stream/server.rs index c4f4f494f..6fd44c480 100644 --- a/dc/s2n-quic-dc/src/stream/server.rs +++ b/dc/s2n-quic-dc/src/stream/server.rs @@ -19,6 +19,7 @@ pub struct InitialPacket { pub is_zero_offset: bool, pub is_retransmission: bool, pub is_fin: bool, + pub is_fin_known: bool, } impl InitialPacket { @@ -55,6 +56,7 @@ impl<'a> From> for InitialPacket { let is_zero_offset = packet.stream_offset().as_u64() == 0; let is_retransmission = packet.is_retransmission(); let is_fin = packet.is_fin(); + let is_fin_known = packet.final_offset().is_some(); Self { credentials, stream_id, @@ -64,6 +66,7 @@ impl<'a> From> for InitialPacket { payload_len, is_retransmission, is_fin, + is_fin_known, } } } diff --git a/dc/s2n-quic-dc/src/stream/server/tokio/tcp.rs b/dc/s2n-quic-dc/src/stream/server/tokio/tcp.rs index 99409ff64..34bd4b9e3 100644 --- a/dc/s2n-quic-dc/src/stream/server/tokio/tcp.rs +++ b/dc/s2n-quic-dc/src/stream/server/tokio/tcp.rs @@ -111,6 +111,8 @@ where publisher.on_acceptor_tcp_loop_iteration_completed( event::builder::AcceptorTcpLoopIterationCompleted { pending_streams: workers.working.len(), + slots_idle: workers.free.len(), + slot_utilization: workers.working.len() as f32 / workers.workers.len() as f32, processing_duration: self.env.clock().get_time().saturating_duration_since(now), max_sojourn_time: workers.max_sojourn_time(), }, @@ -753,6 +755,7 @@ impl WorkerState { stream_id: packet.stream_id.into_varint().as_u64(), payload_len: packet.payload_len, is_fin: packet.is_fin, + is_fin_known: packet.is_fin_known, sojourn_time, }, ); diff --git a/dc/s2n-quic-dc/src/stream/server/tokio/udp.rs b/dc/s2n-quic-dc/src/stream/server/tokio/udp.rs index ee6eeb1fc..f46bc13b6 100644 --- a/dc/s2n-quic-dc/src/stream/server/tokio/udp.rs +++ b/dc/s2n-quic-dc/src/stream/server/tokio/udp.rs @@ -191,6 +191,7 @@ where is_zero_offset: packet.is_zero_offset, is_retransmission: packet.is_retransmission, is_fin: packet.is_fin, + is_fin_known: packet.is_fin_known, }, ); diff --git a/quic/s2n-quic-core/src/event/metrics/aggregate/metric.rs b/quic/s2n-quic-core/src/event/metrics/aggregate/metric.rs index 18254f66a..14063ddcb 100644 --- a/quic/s2n-quic-core/src/event/metrics/aggregate/metric.rs +++ b/quic/s2n-quic-core/src/event/metrics/aggregate/metric.rs @@ -10,6 +10,7 @@ pub enum Units { None, Bytes, Duration, + Percent, } impl Units { @@ -18,6 +19,7 @@ impl Units { Units::None => Str::new("\0"), Units::Bytes => Str::new("bytes\0"), Units::Duration => Str::new("duration\0"), + Units::Percent => Str::new("percent\0"), } } } diff --git a/quic/s2n-quic-events/src/main.rs b/quic/s2n-quic-events/src/main.rs index 703a2086b..43ec60bc0 100644 --- a/quic/s2n-quic-events/src/main.rs +++ b/quic/s2n-quic-events/src/main.rs @@ -10,6 +10,7 @@ type Result = core::result::Result; mod output; mod output_mode; mod parser; +mod validation; use output::Output; use output_mode::OutputMode; @@ -155,6 +156,9 @@ fn main() -> Result<()> { // make sure events are in a deterministic order files.sort_by(|a, b| a.path.as_os_str().cmp(b.path.as_os_str())); + // validate the events + validation::validate(&files); + let root = std::path::Path::new(event_info.output_path); let _ = std::fs::create_dir_all(root); let root = root.canonicalize()?; diff --git a/quic/s2n-quic-events/src/validation.rs b/quic/s2n-quic-events/src/validation.rs new file mode 100644 index 000000000..9889ddade --- /dev/null +++ b/quic/s2n-quic-events/src/validation.rs @@ -0,0 +1,44 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +use crate::parser::File; +use std::collections::HashSet; + +pub fn validate(files: &[File]) { + let mut endpoint_names = HashSet::new(); + let mut connection_names = HashSet::new(); + let mut errored = false; + + for file in files { + for (subject, name) in file + .structs + .iter() + .map(|v| (&v.attrs.subject, v.attrs.event_name.as_ref())) + { + let Some(name) = name else { + continue; + }; + + let set = if subject.is_connection() { + &mut connection_names + } else { + &mut endpoint_names + }; + + if !set.insert(name.value()) { + let path = file.path.canonicalize().unwrap(); + let path = path.strip_prefix(std::env::current_dir().unwrap()).unwrap(); + eprintln!( + "[{}]: Duplicate event name: {:?}, subject = {subject:?}", + path.display(), + name.value() + ); + errored = true; + } + } + } + + if errored { + panic!("Validation errors"); + } +}