diff --git a/dc/s2n-quic-dc/events/acceptor.rs b/dc/s2n-quic-dc/events/acceptor.rs index 69dedb8950..67a31d4c42 100644 --- a/dc/s2n-quic-dc/events/acceptor.rs +++ b/dc/s2n-quic-dc/events/acceptor.rs @@ -192,6 +192,31 @@ struct AcceptorTcpIoError<'a> { error: &'a std::io::Error, } +/// Emitted when the TCP stream has been sent over a Unix domain socket +#[event("acceptor:tcp:socket_sent")] +#[subject(endpoint)] +struct AcceptorTcpSocketSent<'a> { + /// The credential ID of the stream + #[snapshot("[HIDDEN]")] + credential_id: &'a [u8], + + /// The ID of the stream + stream_id: u64, + + /// The amount of time the TCP stream spent in the queue before being sent over Unix domain socket + #[timer("sojourn_time")] + sojourn_time: core::time::Duration, + + /// The number of times the Unix domain socket was blocked on send + #[counter("blocked_count_host")] + #[measure("blocked_count_stream")] + blocked_count: usize, + + /// The len of the payload sent over the Unix domain socket + #[measure("len", Bytes)] + payload_len: usize, +} + /// Emitted when a UDP acceptor is started #[event("acceptor:udp:started")] #[subject(endpoint)] diff --git a/dc/s2n-quic-dc/src/event/generated.rs b/dc/s2n-quic-dc/src/event/generated.rs index 943d9beabb..9454a52d82 100644 --- a/dc/s2n-quic-dc/src/event/generated.rs +++ b/dc/s2n-quic-dc/src/event/generated.rs @@ -271,6 +271,36 @@ pub mod api { } #[derive(Clone, Debug)] #[non_exhaustive] + #[doc = " Emitted when the TCP stream has been sent over a Unix domain socket"] + pub struct AcceptorTcpSocketSent<'a> { + #[doc = " The credential ID of the stream"] + pub credential_id: &'a [u8], + #[doc = " The ID of the stream"] + pub stream_id: u64, + #[doc = " The amount of time the TCP stream spent in the queue before being sent over Unix domain socket"] + pub sojourn_time: core::time::Duration, + #[doc = " The number of times the Unix domain socket was blocked on send"] + pub blocked_count: usize, + #[doc = " The len of the payload sent over the Unix domain socket"] + pub payload_len: usize, + } + #[cfg(any(test, feature = "testing"))] + impl<'a> crate::event::snapshot::Fmt for AcceptorTcpSocketSent<'a> { + fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { + let mut fmt = fmt.debug_struct("AcceptorTcpSocketSent"); + fmt.field("credential_id", &"[HIDDEN]"); + fmt.field("stream_id", &self.stream_id); + fmt.field("sojourn_time", &self.sojourn_time); + fmt.field("blocked_count", &self.blocked_count); + fmt.field("payload_len", &self.payload_len); + fmt.finish() + } + } + impl<'a> Event for AcceptorTcpSocketSent<'a> { + const NAME: &'static str = "acceptor:tcp:socket_sent"; + } + #[derive(Clone, Debug)] + #[non_exhaustive] #[doc = " Emitted when a UDP acceptor is started"] pub struct AcceptorUdpStarted<'a> { #[doc = " The id of the acceptor worker"] @@ -2377,6 +2407,22 @@ pub mod tracing { tracing :: event ! (target : "acceptor_tcp_io_error" , parent : parent , tracing :: Level :: DEBUG , { error = tracing :: field :: debug (error) }); } #[inline] + fn on_acceptor_tcp_socket_sent( + &self, + meta: &api::EndpointMeta, + event: &api::AcceptorTcpSocketSent, + ) { + let parent = self.parent(meta); + let api::AcceptorTcpSocketSent { + credential_id, + stream_id, + sojourn_time, + blocked_count, + payload_len, + } = event; + tracing :: event ! (target : "acceptor_tcp_socket_sent" , parent : parent , tracing :: Level :: DEBUG , { credential_id = tracing :: field :: debug (credential_id) , stream_id = tracing :: field :: debug (stream_id) , sojourn_time = tracing :: field :: debug (sojourn_time) , blocked_count = tracing :: field :: debug (blocked_count) , payload_len = tracing :: field :: debug (payload_len) }); + } + #[inline] fn on_acceptor_udp_started( &self, meta: &api::EndpointMeta, @@ -3650,6 +3696,39 @@ pub mod builder { } } #[derive(Clone, Debug)] + #[doc = " Emitted when the TCP stream has been sent over a Unix domain socket"] + pub struct AcceptorTcpSocketSent<'a> { + #[doc = " The credential ID of the stream"] + pub credential_id: &'a [u8], + #[doc = " The ID of the stream"] + pub stream_id: u64, + #[doc = " The amount of time the TCP stream spent in the queue before being sent over Unix domain socket"] + pub sojourn_time: core::time::Duration, + #[doc = " The number of times the Unix domain socket was blocked on send"] + pub blocked_count: usize, + #[doc = " The len of the payload sent over the Unix domain socket"] + pub payload_len: usize, + } + impl<'a> IntoEvent> for AcceptorTcpSocketSent<'a> { + #[inline] + fn into_event(self) -> api::AcceptorTcpSocketSent<'a> { + let AcceptorTcpSocketSent { + credential_id, + stream_id, + sojourn_time, + blocked_count, + payload_len, + } = self; + api::AcceptorTcpSocketSent { + credential_id: credential_id.into_event(), + stream_id: stream_id.into_event(), + sojourn_time: sojourn_time.into_event(), + blocked_count: blocked_count.into_event(), + payload_len: payload_len.into_event(), + } + } + } + #[derive(Clone, Debug)] #[doc = " Emitted when a UDP acceptor is started"] pub struct AcceptorUdpStarted<'a> { #[doc = " The id of the acceptor worker"] @@ -5645,6 +5724,16 @@ mod traits { let _ = meta; let _ = event; } + #[doc = "Called when the `AcceptorTcpSocketSent` event is triggered"] + #[inline] + fn on_acceptor_tcp_socket_sent( + &self, + meta: &api::EndpointMeta, + event: &api::AcceptorTcpSocketSent, + ) { + let _ = meta; + let _ = event; + } #[doc = "Called when the `AcceptorUdpStarted` event is triggered"] #[inline] fn on_acceptor_udp_started( @@ -6567,6 +6656,14 @@ mod traits { self.as_ref().on_acceptor_tcp_io_error(meta, event); } #[inline] + fn on_acceptor_tcp_socket_sent( + &self, + meta: &api::EndpointMeta, + event: &api::AcceptorTcpSocketSent, + ) { + self.as_ref().on_acceptor_tcp_socket_sent(meta, event); + } + #[inline] fn on_acceptor_udp_started( &self, meta: &api::EndpointMeta, @@ -7344,6 +7441,15 @@ mod traits { (self.1).on_acceptor_tcp_io_error(meta, event); } #[inline] + fn on_acceptor_tcp_socket_sent( + &self, + meta: &api::EndpointMeta, + event: &api::AcceptorTcpSocketSent, + ) { + (self.0).on_acceptor_tcp_socket_sent(meta, event); + (self.1).on_acceptor_tcp_socket_sent(meta, event); + } + #[inline] fn on_acceptor_udp_started( &self, meta: &api::EndpointMeta, @@ -8091,6 +8197,8 @@ mod traits { fn on_acceptor_tcp_stream_enqueued(&self, event: builder::AcceptorTcpStreamEnqueued); #[doc = "Publishes a `AcceptorTcpIoError` event to the publisher's subscriber"] fn on_acceptor_tcp_io_error(&self, event: builder::AcceptorTcpIoError); + #[doc = "Publishes a `AcceptorTcpSocketSent` event to the publisher's subscriber"] + fn on_acceptor_tcp_socket_sent(&self, event: builder::AcceptorTcpSocketSent); #[doc = "Publishes a `AcceptorUdpStarted` event to the publisher's subscriber"] fn on_acceptor_udp_started(&self, event: builder::AcceptorUdpStarted); #[doc = "Publishes a `AcceptorUdpDatagramReceived` event to the publisher's subscriber"] @@ -8313,6 +8421,13 @@ mod traits { self.subscriber.on_event(&self.meta, &event); } #[inline] + fn on_acceptor_tcp_socket_sent(&self, event: builder::AcceptorTcpSocketSent) { + let event = event.into_event(); + self.subscriber + .on_acceptor_tcp_socket_sent(&self.meta, &event); + self.subscriber.on_event(&self.meta, &event); + } + #[inline] fn on_acceptor_udp_started(&self, event: builder::AcceptorUdpStarted) { let event = event.into_event(); self.subscriber.on_acceptor_udp_started(&self.meta, &event); @@ -9075,6 +9190,7 @@ pub mod testing { pub acceptor_tcp_packet_dropped: AtomicU64, pub acceptor_tcp_stream_enqueued: AtomicU64, pub acceptor_tcp_io_error: AtomicU64, + pub acceptor_tcp_socket_sent: AtomicU64, pub acceptor_udp_started: AtomicU64, pub acceptor_udp_datagram_received: AtomicU64, pub acceptor_udp_packet_received: AtomicU64, @@ -9159,6 +9275,7 @@ pub mod testing { acceptor_tcp_packet_dropped: AtomicU64::new(0), acceptor_tcp_stream_enqueued: AtomicU64::new(0), acceptor_tcp_io_error: AtomicU64::new(0), + acceptor_tcp_socket_sent: AtomicU64::new(0), acceptor_udp_started: AtomicU64::new(0), acceptor_udp_datagram_received: AtomicU64::new(0), acceptor_udp_packet_received: AtomicU64::new(0), @@ -9331,6 +9448,18 @@ pub mod testing { let out = format!("{meta:?} {event:?}"); self.output.lock().unwrap().push(out); } + fn on_acceptor_tcp_socket_sent( + &self, + meta: &api::EndpointMeta, + event: &api::AcceptorTcpSocketSent, + ) { + self.acceptor_tcp_socket_sent + .fetch_add(1, Ordering::Relaxed); + let meta = crate::event::snapshot::Fmt::to_snapshot(meta); + let event = crate::event::snapshot::Fmt::to_snapshot(event); + let out = format!("{meta:?} {event:?}"); + self.output.lock().unwrap().push(out); + } fn on_acceptor_udp_started( &self, meta: &api::EndpointMeta, @@ -9846,6 +9975,7 @@ pub mod testing { pub acceptor_tcp_packet_dropped: AtomicU64, pub acceptor_tcp_stream_enqueued: AtomicU64, pub acceptor_tcp_io_error: AtomicU64, + pub acceptor_tcp_socket_sent: AtomicU64, pub acceptor_udp_started: AtomicU64, pub acceptor_udp_datagram_received: AtomicU64, pub acceptor_udp_packet_received: AtomicU64, @@ -9962,6 +10092,7 @@ pub mod testing { acceptor_tcp_packet_dropped: AtomicU64::new(0), acceptor_tcp_stream_enqueued: AtomicU64::new(0), acceptor_tcp_io_error: AtomicU64::new(0), + acceptor_tcp_socket_sent: AtomicU64::new(0), acceptor_udp_started: AtomicU64::new(0), acceptor_udp_datagram_received: AtomicU64::new(0), acceptor_udp_packet_received: AtomicU64::new(0), @@ -10166,6 +10297,18 @@ pub mod testing { let out = format!("{meta:?} {event:?}"); self.output.lock().unwrap().push(out); } + fn on_acceptor_tcp_socket_sent( + &self, + meta: &api::EndpointMeta, + event: &api::AcceptorTcpSocketSent, + ) { + self.acceptor_tcp_socket_sent + .fetch_add(1, Ordering::Relaxed); + let meta = crate::event::snapshot::Fmt::to_snapshot(meta); + let event = crate::event::snapshot::Fmt::to_snapshot(event); + let out = format!("{meta:?} {event:?}"); + self.output.lock().unwrap().push(out); + } fn on_acceptor_udp_started( &self, meta: &api::EndpointMeta, @@ -11138,6 +11281,7 @@ pub mod testing { pub acceptor_tcp_packet_dropped: AtomicU64, pub acceptor_tcp_stream_enqueued: AtomicU64, pub acceptor_tcp_io_error: AtomicU64, + pub acceptor_tcp_socket_sent: AtomicU64, pub acceptor_udp_started: AtomicU64, pub acceptor_udp_datagram_received: AtomicU64, pub acceptor_udp_packet_received: AtomicU64, @@ -11244,6 +11388,7 @@ pub mod testing { acceptor_tcp_packet_dropped: AtomicU64::new(0), acceptor_tcp_stream_enqueued: AtomicU64::new(0), acceptor_tcp_io_error: AtomicU64::new(0), + acceptor_tcp_socket_sent: AtomicU64::new(0), acceptor_udp_started: AtomicU64::new(0), acceptor_udp_datagram_received: AtomicU64::new(0), acceptor_udp_packet_received: AtomicU64::new(0), @@ -11407,6 +11552,14 @@ pub mod testing { let out = format!("{event:?}"); self.output.lock().unwrap().push(out); } + fn on_acceptor_tcp_socket_sent(&self, event: builder::AcceptorTcpSocketSent) { + self.acceptor_tcp_socket_sent + .fetch_add(1, Ordering::Relaxed); + let event = event.into_event(); + let event = crate::event::snapshot::Fmt::to_snapshot(&event); + let out = format!("{event:?}"); + self.output.lock().unwrap().push(out); + } fn on_acceptor_udp_started(&self, event: builder::AcceptorUdpStarted) { self.acceptor_udp_started.fetch_add(1, Ordering::Relaxed); let event = event.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 103e90ee87..5df02b06a3 100644 --- a/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs +++ b/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs @@ -13,7 +13,7 @@ use crate::event::{ }, }; use core::sync::atomic::{AtomicU64, Ordering}; -static INFO: &[Info; 284usize] = &[ +static INFO: &[Info; 289usize] = &[ info::Builder { id: 0usize, name: Str::new("acceptor_tcp_started\0"), @@ -190,1530 +190,1560 @@ static INFO: &[Info; 284usize] = &[ .build(), info::Builder { id: 29usize, - name: Str::new("acceptor_udp_started\0"), + name: Str::new("acceptor_tcp_socket_sent\0"), units: Units::None, } .build(), info::Builder { id: 30usize, + name: Str::new("acceptor_tcp_socket_sent.sojourn_time\0"), + units: Units::Duration, + } + .build(), + info::Builder { + id: 31usize, + name: Str::new("acceptor_tcp_socket_sent.blocked_count_host\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 32usize, + name: Str::new("acceptor_tcp_socket_sent.blocked_count_stream\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 33usize, + name: Str::new("acceptor_tcp_socket_sent.len\0"), + units: Units::Bytes, + } + .build(), + info::Builder { + id: 34usize, + name: Str::new("acceptor_udp_started\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 35usize, name: Str::new("acceptor_udp_datagram_received\0"), units: Units::None, } .build(), info::Builder { - id: 31usize, + id: 36usize, name: Str::new("acceptor_udp_datagram_received.len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 32usize, + id: 37usize, name: Str::new("acceptor_udp_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 33usize, + id: 38usize, name: Str::new("acceptor_udp_packet_received.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 34usize, + id: 39usize, name: Str::new("acceptor_udp_packet_received.is_zero_offset\0"), units: Units::None, } .build(), info::Builder { - id: 35usize, + id: 40usize, name: Str::new("acceptor_udp_packet_received.is_retransmission\0"), units: Units::None, } .build(), info::Builder { - id: 36usize, + id: 41usize, name: Str::new("acceptor_udp_packet_received.is_fin\0"), units: Units::None, } .build(), info::Builder { - id: 37usize, + id: 42usize, name: Str::new("acceptor_udp_packet_received.is_fin_known\0"), units: Units::None, } .build(), info::Builder { - id: 38usize, + id: 43usize, name: Str::new("acceptor_udp_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 39usize, + id: 44usize, name: Str::new("acceptor_udp_packet_dropped.reason\0"), units: Units::None, } .build(), info::Builder { - id: 40usize, + id: 45usize, name: Str::new("acceptor_udp_stream_enqueued\0"), units: Units::None, } .build(), info::Builder { - id: 41usize, + id: 46usize, name: Str::new("acceptor_udp_io_error\0"), units: Units::None, } .build(), info::Builder { - id: 42usize, + id: 47usize, name: Str::new("acceptor_stream_pruned\0"), units: Units::None, } .build(), info::Builder { - id: 43usize, + id: 48usize, name: Str::new("acceptor_stream_pruned.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 44usize, + id: 49usize, name: Str::new("acceptor_stream_pruned.reason\0"), units: Units::None, } .build(), info::Builder { - id: 45usize, + id: 50usize, name: Str::new("acceptor_stream_dequeued\0"), units: Units::None, } .build(), info::Builder { - id: 46usize, + id: 51usize, name: Str::new("acceptor_stream_dequeued.sojourn_time\0"), units: Units::Duration, } .build(), info::Builder { - id: 47usize, + id: 52usize, name: Str::new("stream_write_flushed\0"), units: Units::None, } .build(), info::Builder { - id: 48usize, + id: 53usize, name: Str::new("stream_write_flushed.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 49usize, + id: 54usize, name: Str::new("stream_write_flushed.conn\0"), units: Units::None, } .build(), info::Builder { - id: 50usize, + id: 55usize, name: Str::new("stream_write_flushed.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 51usize, + id: 56usize, name: Str::new("stream_write_flushed.committed.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 52usize, + id: 57usize, name: Str::new("stream_write_flushed.committed\0"), units: Units::Bytes, } .build(), info::Builder { - id: 53usize, + id: 58usize, name: Str::new("stream_write_flushed.committed.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 54usize, + id: 59usize, name: Str::new("stream_write_flushed.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 55usize, + id: 60usize, name: Str::new("stream_write_flushed.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 56usize, + id: 61usize, name: Str::new("stream_write_fin_flushed\0"), units: Units::None, } .build(), info::Builder { - id: 57usize, + id: 62usize, name: Str::new("stream_write_fin_flushed.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 58usize, + id: 63usize, name: Str::new("stream_write_fin_flushed.conn\0"), units: Units::None, } .build(), info::Builder { - id: 59usize, + id: 64usize, name: Str::new("stream_write_fin_flushed.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 60usize, + id: 65usize, name: Str::new("stream_write_fin_flushed.committed.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 61usize, + id: 66usize, name: Str::new("stream_write_fin_flushed.committed\0"), units: Units::Bytes, } .build(), info::Builder { - id: 62usize, + id: 67usize, name: Str::new("stream_write_fin_flushed.committed.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 63usize, + id: 68usize, name: Str::new("stream_write_fin_flushed.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 64usize, + id: 69usize, name: Str::new("stream_write_fin_flushed.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 65usize, + id: 70usize, name: Str::new("stream_write_blocked\0"), units: Units::None, } .build(), info::Builder { - id: 66usize, + id: 71usize, name: Str::new("stream_write_blocked.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 67usize, + id: 72usize, name: Str::new("stream_write_blocked.conn\0"), units: Units::None, } .build(), info::Builder { - id: 68usize, + id: 73usize, name: Str::new("stream_write_blocked.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 69usize, + id: 74usize, name: Str::new("stream_write_blocked.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 70usize, + id: 75usize, name: Str::new("stream_write_blocked.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 71usize, + id: 76usize, name: Str::new("stream_write_errored\0"), units: Units::None, } .build(), info::Builder { - id: 72usize, + id: 77usize, name: Str::new("stream_write_errored.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 73usize, + id: 78usize, name: Str::new("stream_write_errored.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 74usize, + id: 79usize, name: Str::new("stream_write_errored.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 75usize, + id: 80usize, name: Str::new("stream_write_errored.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 76usize, + id: 81usize, name: Str::new("stream_write_key_updated\0"), units: Units::None, } .build(), info::Builder { - id: 77usize, + id: 82usize, name: Str::new("stream_write_allocated\0"), units: Units::None, } .build(), info::Builder { - id: 78usize, + id: 83usize, name: Str::new("stream_write_allocated.conn\0"), units: Units::None, } .build(), info::Builder { - id: 79usize, + id: 84usize, name: Str::new("stream_write_allocated.allocated_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 80usize, + id: 85usize, name: Str::new("stream_write_allocated.allocated_len.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 81usize, + id: 86usize, name: Str::new("stream_write_shutdown\0"), units: Units::None, } .build(), info::Builder { - id: 82usize, + id: 87usize, name: Str::new("stream_write_shutdown.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 83usize, + id: 88usize, name: Str::new("stream_write_shutdown.buffer_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 84usize, + id: 89usize, name: Str::new("stream_write_shutdown.background\0"), units: Units::None, } .build(), info::Builder { - id: 85usize, + id: 90usize, name: Str::new("stream_write_socket_flushed\0"), units: Units::None, } .build(), info::Builder { - id: 86usize, + id: 91usize, name: Str::new("stream_write_socket_flushed.conn\0"), units: Units::None, } .build(), info::Builder { - id: 87usize, + id: 92usize, name: Str::new("stream_write_socket_flushed.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 88usize, + id: 93usize, name: Str::new("stream_write_socket_flushed.committed.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 89usize, + id: 94usize, name: Str::new("stream_write_socket_flushed.committed\0"), units: Units::Bytes, } .build(), info::Builder { - id: 90usize, + id: 95usize, name: Str::new("stream_write_socket_flushed.committed.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 91usize, + id: 96usize, name: Str::new("stream_write_socket_blocked\0"), units: Units::None, } .build(), info::Builder { - id: 92usize, + id: 97usize, name: Str::new("stream_write_socket_blocked.conn\0"), units: Units::None, } .build(), info::Builder { - id: 93usize, + id: 98usize, name: Str::new("stream_write_socket_blocked.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 94usize, + id: 99usize, name: Str::new("stream_write_socket_errored\0"), units: Units::None, } .build(), info::Builder { - id: 95usize, + id: 100usize, name: Str::new("stream_write_socket_errored.provided\0"), units: Units::Bytes, } .build(), info::Builder { - id: 96usize, + id: 101usize, name: Str::new("stream_read_flushed\0"), units: Units::None, } .build(), info::Builder { - id: 97usize, + id: 102usize, name: Str::new("stream_read_flushed.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 98usize, + id: 103usize, name: Str::new("stream_read_flushed.conn\0"), units: Units::None, } .build(), info::Builder { - id: 99usize, + id: 104usize, name: Str::new("stream_read_flushed.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 100usize, + id: 105usize, name: Str::new("stream_read_flushed.committed.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 101usize, + id: 106usize, name: Str::new("stream_read_flushed.committed\0"), units: Units::Bytes, } .build(), info::Builder { - id: 102usize, + id: 107usize, name: Str::new("stream_read_flushed.committed.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 103usize, + id: 108usize, name: Str::new("stream_read_flushed.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 104usize, + id: 109usize, name: Str::new("stream_read_flushed.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 105usize, + id: 110usize, name: Str::new("stream_read_fin_flushed\0"), units: Units::None, } .build(), info::Builder { - id: 106usize, + id: 111usize, name: Str::new("stream_read_fin_flushed.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 107usize, + id: 112usize, name: Str::new("stream_read_fin_flushed.conn\0"), units: Units::None, } .build(), info::Builder { - id: 108usize, + id: 113usize, name: Str::new("stream_read_fin_flushed.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 109usize, + id: 114usize, name: Str::new("stream_read_fin_flushed.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 110usize, + id: 115usize, name: Str::new("stream_read_fin_flushed.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 111usize, + id: 116usize, name: Str::new("stream_read_blocked\0"), units: Units::None, } .build(), info::Builder { - id: 112usize, + id: 117usize, name: Str::new("stream_read_blocked.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 113usize, + id: 118usize, name: Str::new("stream_read_blocked.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 114usize, + id: 119usize, name: Str::new("stream_read_blocked.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 115usize, + id: 120usize, name: Str::new("stream_read_blocked.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 116usize, + id: 121usize, name: Str::new("stream_read_errored\0"), units: Units::None, } .build(), info::Builder { - id: 117usize, + id: 122usize, name: Str::new("stream_read_errored.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 118usize, + id: 123usize, name: Str::new("stream_read_errored.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 119usize, + id: 124usize, name: Str::new("stream_read_errored.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 120usize, + id: 125usize, name: Str::new("stream_read_errored.processing_duration.conn\0"), units: Units::Duration, } .build(), info::Builder { - id: 121usize, + id: 126usize, name: Str::new("stream_read_key_updated\0"), units: Units::None, } .build(), info::Builder { - id: 122usize, + id: 127usize, name: Str::new("stream_read_shutdown\0"), units: Units::None, } .build(), info::Builder { - id: 123usize, + id: 128usize, name: Str::new("stream_read_shutdown.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 124usize, + id: 129usize, name: Str::new("stream_read_shutdown.background\0"), units: Units::None, } .build(), info::Builder { - id: 125usize, + id: 130usize, name: Str::new("stream_read_socket_flushed\0"), units: Units::None, } .build(), info::Builder { - id: 126usize, + id: 131usize, name: Str::new("stream_read_socket_flushed.conn\0"), units: Units::None, } .build(), info::Builder { - id: 127usize, + id: 132usize, name: Str::new("stream_read_socket_flushed.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 128usize, + id: 133usize, name: Str::new("stream_read_socket_flushed.committed.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 129usize, + id: 134usize, name: Str::new("stream_read_socket_flushed.committed\0"), units: Units::Bytes, } .build(), info::Builder { - id: 130usize, + id: 135usize, name: Str::new("stream_read_socket_flushed.committed.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 131usize, + id: 136usize, name: Str::new("stream_read_socket_blocked\0"), units: Units::None, } .build(), info::Builder { - id: 132usize, + id: 137usize, name: Str::new("stream_read_socket_blocked.conn\0"), units: Units::None, } .build(), info::Builder { - id: 133usize, + id: 138usize, name: Str::new("stream_read_socket_blocked.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 134usize, + id: 139usize, name: Str::new("stream_read_socket_errored\0"), units: Units::None, } .build(), info::Builder { - id: 135usize, + id: 140usize, name: Str::new("stream_read_socket_errored.capacity\0"), units: Units::Bytes, } .build(), info::Builder { - id: 136usize, + id: 141usize, name: Str::new("stream_decrypt_packet\0"), units: Units::None, } .build(), info::Builder { - id: 137usize, + id: 142usize, name: Str::new("stream_decrypt_packet.decrypted_in_place\0"), units: Units::None, } .build(), info::Builder { - id: 138usize, + id: 143usize, name: Str::new("stream_decrypt_packet.forced_copy\0"), units: Units::Bytes, } .build(), info::Builder { - id: 139usize, + id: 144usize, name: Str::new("stream_decrypt_packet.required_application_buffer\0"), units: Units::Bytes, } .build(), info::Builder { - id: 140usize, + id: 145usize, name: Str::new("stream_tcp_connect\0"), units: Units::None, } .build(), info::Builder { - id: 141usize, + id: 146usize, name: Str::new("stream_tcp_connect.error\0"), units: Units::None, } .build(), info::Builder { - id: 142usize, + id: 147usize, name: Str::new("stream_tcp_connect.tcp_latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 143usize, + id: 148usize, name: Str::new("stream_connect\0"), units: Units::None, } .build(), info::Builder { - id: 144usize, + id: 149usize, name: Str::new("stream_connect.error\0"), units: Units::None, } .build(), info::Builder { - id: 145usize, + id: 150usize, name: Str::new("stream_connect.tcp\0"), units: Units::None, } .build(), info::Builder { - id: 146usize, + id: 151usize, name: Str::new("stream_connect.handshake\0"), units: Units::None, } .build(), info::Builder { - id: 147usize, + id: 152usize, name: Str::new("stream_connect_error\0"), units: Units::None, } .build(), info::Builder { - id: 148usize, + id: 153usize, name: Str::new("stream_connect_error.reason\0"), units: Units::None, } .build(), info::Builder { - id: 149usize, + id: 154usize, name: Str::new("stream_packet_transmitted\0"), units: Units::None, } .build(), info::Builder { - id: 150usize, + id: 155usize, name: Str::new("stream_packet_transmitted.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 151usize, + id: 156usize, name: Str::new("stream_packet_transmitted.payload_len.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 152usize, + id: 157usize, name: Str::new("stream_packet_transmitted.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 153usize, + id: 158usize, name: Str::new("stream_packet_transmitted.payload_len.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 154usize, + id: 159usize, name: Str::new("stream_packet_transmitted.retransmission\0"), units: Units::None, } .build(), info::Builder { - id: 155usize, + id: 160usize, name: Str::new("stream_probe_transmitted\0"), units: Units::None, } .build(), info::Builder { - id: 156usize, + id: 161usize, name: Str::new("stream_probe_transmitted.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 157usize, + id: 162usize, name: Str::new("stream_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 158usize, + id: 163usize, name: Str::new("stream_packet_received.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 159usize, + id: 164usize, name: Str::new("stream_packet_received.payload_len.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 160usize, + id: 165usize, name: Str::new("stream_packet_received.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 161usize, + id: 166usize, name: Str::new("stream_packet_received.payload_len.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 162usize, + id: 167usize, name: Str::new("stream_packet_received.retransmission\0"), units: Units::None, } .build(), info::Builder { - id: 163usize, + id: 168usize, name: Str::new("stream_packet_lost\0"), units: Units::None, } .build(), info::Builder { - id: 164usize, + id: 169usize, name: Str::new("stream_packet_lost.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 165usize, + id: 170usize, name: Str::new("stream_packet_lost.payload_len.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 166usize, + id: 171usize, name: Str::new("stream_packet_lost.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 167usize, + id: 172usize, name: Str::new("stream_packet_lost.payload_len.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 168usize, + id: 173usize, name: Str::new("stream_packet_lost.lifetime\0"), units: Units::Duration, } .build(), info::Builder { - id: 169usize, + id: 174usize, name: Str::new("stream_packet_lost.retransmission\0"), units: Units::None, } .build(), info::Builder { - id: 170usize, + id: 175usize, name: Str::new("stream_packet_acked\0"), units: Units::None, } .build(), info::Builder { - id: 171usize, + id: 176usize, name: Str::new("stream_packet_acked.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 172usize, + id: 177usize, name: Str::new("stream_packet_acked.payload_len.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 173usize, + id: 178usize, name: Str::new("stream_packet_acked.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 174usize, + id: 179usize, name: Str::new("stream_packet_acked.payload_len.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 175usize, + id: 180usize, name: Str::new("stream_packet_acked.lifetime\0"), units: Units::Duration, } .build(), info::Builder { - id: 176usize, + id: 181usize, name: Str::new("stream_packet_acked.retransmission\0"), units: Units::None, } .build(), info::Builder { - id: 177usize, + id: 182usize, name: Str::new("stream_packet_spuriously_retransmitted\0"), units: Units::None, } .build(), info::Builder { - id: 178usize, + id: 183usize, name: Str::new("stream_packet_spuriously_retransmitted.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 179usize, + id: 184usize, name: Str::new("stream_packet_spuriously_retransmitted.payload_len.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 180usize, + id: 185usize, name: Str::new("stream_packet_spuriously_retransmitted.payload_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 181usize, + id: 186usize, name: Str::new("stream_packet_spuriously_retransmitted.payload_len.conn\0"), units: Units::Bytes, } .build(), info::Builder { - id: 182usize, + id: 187usize, name: Str::new("stream_packet_spuriously_retransmitted.retransmission\0"), units: Units::None, } .build(), info::Builder { - id: 183usize, + id: 188usize, name: Str::new("stream_max_data_received\0"), units: Units::None, } .build(), info::Builder { - id: 184usize, + id: 189usize, name: Str::new("stream_max_data_received.increase.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 185usize, + id: 190usize, name: Str::new("stream_max_data_received.increase\0"), units: Units::Bytes, } .build(), info::Builder { - id: 186usize, + id: 191usize, name: Str::new("stream_control_packet_transmitted\0"), units: Units::None, } .build(), info::Builder { - id: 187usize, + id: 192usize, name: Str::new("stream_control_packet_transmitted.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 188usize, + id: 193usize, name: Str::new("stream_control_packet_transmitted.control_data_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 189usize, + id: 194usize, name: Str::new("stream_control_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 190usize, + id: 195usize, name: Str::new("stream_control_packet_received.packet_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 191usize, + id: 196usize, name: Str::new("stream_control_packet_received.control_data_len\0"), units: Units::Bytes, } .build(), info::Builder { - id: 192usize, + id: 197usize, name: Str::new("stream_control_packet_received.authenticated\0"), units: Units::None, } .build(), info::Builder { - id: 193usize, + id: 198usize, name: Str::new("stream_receiver_errored\0"), units: Units::None, } .build(), info::Builder { - id: 194usize, + id: 199usize, name: Str::new("stream_sender_errored\0"), units: Units::None, } .build(), info::Builder { - id: 195usize, + id: 200usize, name: Str::new("connection_closed\0"), units: Units::None, } .build(), info::Builder { - id: 196usize, + id: 201usize, name: Str::new("endpoint_initialized\0"), units: Units::None, } .build(), info::Builder { - id: 197usize, + id: 202usize, name: Str::new("endpoint_initialized.acceptor.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 198usize, + id: 203usize, name: Str::new("endpoint_initialized.handshake.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 199usize, + id: 204usize, name: Str::new("endpoint_initialized.tcp\0"), units: Units::None, } .build(), info::Builder { - id: 200usize, + id: 205usize, name: Str::new("endpoint_initialized.udp\0"), units: Units::None, } .build(), info::Builder { - id: 201usize, + id: 206usize, name: Str::new("path_secret_map_initialized\0"), units: Units::None, } .build(), info::Builder { - id: 202usize, + id: 207usize, name: Str::new("path_secret_map_initialized.capacity\0"), units: Units::None, } .build(), info::Builder { - id: 203usize, + id: 208usize, name: Str::new("path_secret_map_uninitialized\0"), units: Units::None, } .build(), info::Builder { - id: 204usize, + id: 209usize, name: Str::new("path_secret_map_uninitialized.capacity\0"), units: Units::None, } .build(), info::Builder { - id: 205usize, + id: 210usize, name: Str::new("path_secret_map_uninitialized.entries\0"), units: Units::None, } .build(), info::Builder { - id: 206usize, + id: 211usize, name: Str::new("path_secret_map_uninitialized.lifetime\0"), units: Units::Duration, } .build(), info::Builder { - id: 207usize, + id: 212usize, name: Str::new("path_secret_map_background_handshake_requested\0"), units: Units::None, } .build(), info::Builder { - id: 208usize, + id: 213usize, name: Str::new("path_secret_map_background_handshake_requested.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 209usize, + id: 214usize, name: Str::new("path_secret_map_entry_inserted\0"), units: Units::None, } .build(), info::Builder { - id: 210usize, + id: 215usize, name: Str::new("path_secret_map_entry_inserted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 211usize, + id: 216usize, name: Str::new("path_secret_map_entry_ready\0"), units: Units::None, } .build(), info::Builder { - id: 212usize, + id: 217usize, name: Str::new("path_secret_map_entry_ready.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 213usize, + id: 218usize, name: Str::new("path_secret_map_entry_replaced\0"), units: Units::None, } .build(), info::Builder { - id: 214usize, + id: 219usize, name: Str::new("path_secret_map_entry_replaced.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 215usize, + id: 220usize, name: Str::new("path_secret_map_id_entry_evicted\0"), units: Units::None, } .build(), info::Builder { - id: 216usize, + id: 221usize, name: Str::new("path_secret_map_id_entry_evicted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 217usize, + id: 222usize, name: Str::new("path_secret_map_id_entry_evicted.age\0"), units: Units::Duration, } .build(), info::Builder { - id: 218usize, + id: 223usize, name: Str::new("path_secret_map_address_entry_evicted\0"), units: Units::None, } .build(), info::Builder { - id: 219usize, + id: 224usize, name: Str::new("path_secret_map_address_entry_evicted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 220usize, + id: 225usize, name: Str::new("path_secret_map_address_entry_evicted.age\0"), units: Units::Duration, } .build(), info::Builder { - id: 221usize, + id: 226usize, name: Str::new("unknown_path_secret_packet_sent\0"), units: Units::None, } .build(), info::Builder { - id: 222usize, + id: 227usize, name: Str::new("unknown_path_secret_packet_sent.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 223usize, + id: 228usize, name: Str::new("unknown_path_secret_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 224usize, + id: 229usize, name: Str::new("unknown_path_secret_packet_received.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 225usize, + id: 230usize, name: Str::new("unknown_path_secret_packet_accepted\0"), units: Units::None, } .build(), info::Builder { - id: 226usize, + id: 231usize, name: Str::new("unknown_path_secret_packet_accepted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 227usize, + id: 232usize, name: Str::new("unknown_path_secret_packet_rejected\0"), units: Units::None, } .build(), info::Builder { - id: 228usize, + id: 233usize, name: Str::new("unknown_path_secret_packet_rejected.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 229usize, + id: 234usize, name: Str::new("unknown_path_secret_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 230usize, + id: 235usize, name: Str::new("unknown_path_secret_packet_dropped.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 231usize, + id: 236usize, name: Str::new("key_accepted\0"), units: Units::None, } .build(), info::Builder { - id: 232usize, + id: 237usize, name: Str::new("key_accepted.gap\0"), units: Units::None, } .build(), info::Builder { - id: 233usize, + id: 238usize, name: Str::new("key_accepted.forward_shift\0"), units: Units::None, } .build(), info::Builder { - id: 234usize, + id: 239usize, name: Str::new("replay_definitely_detected\0"), units: Units::None, } .build(), info::Builder { - id: 235usize, + id: 240usize, name: Str::new("replay_potentially_detected\0"), units: Units::None, } .build(), info::Builder { - id: 236usize, + id: 241usize, name: Str::new("replay_potentially_detected.gap\0"), units: Units::None, } .build(), info::Builder { - id: 237usize, + id: 242usize, name: Str::new("replay_detected_packet_sent\0"), units: Units::None, } .build(), info::Builder { - id: 238usize, + id: 243usize, name: Str::new("replay_detected_packet_sent.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 239usize, + id: 244usize, name: Str::new("replay_detected_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 240usize, + id: 245usize, name: Str::new("replay_detected_packet_received.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 241usize, + id: 246usize, name: Str::new("replay_detected_packet_accepted\0"), units: Units::None, } .build(), info::Builder { - id: 242usize, + id: 247usize, name: Str::new("replay_detected_packet_accepted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 243usize, + id: 248usize, name: Str::new("replay_detected_packet_rejected\0"), units: Units::None, } .build(), info::Builder { - id: 244usize, + id: 249usize, name: Str::new("replay_detected_packet_rejected.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 245usize, + id: 250usize, name: Str::new("replay_detected_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 246usize, + id: 251usize, name: Str::new("replay_detected_packet_dropped.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 247usize, + id: 252usize, name: Str::new("stale_key_packet_sent\0"), units: Units::None, } .build(), info::Builder { - id: 248usize, + id: 253usize, name: Str::new("stale_key_packet_sent.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 249usize, + id: 254usize, name: Str::new("stale_key_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 250usize, + id: 255usize, name: Str::new("stale_key_packet_received.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 251usize, + id: 256usize, name: Str::new("stale_key_packet_accepted\0"), units: Units::None, } .build(), info::Builder { - id: 252usize, + id: 257usize, name: Str::new("stale_key_packet_accepted.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 253usize, + id: 258usize, name: Str::new("stale_key_packet_rejected\0"), units: Units::None, } .build(), info::Builder { - id: 254usize, + id: 259usize, name: Str::new("stale_key_packet_rejected.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 255usize, + id: 260usize, name: Str::new("stale_key_packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 256usize, + id: 261usize, name: Str::new("stale_key_packet_dropped.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 257usize, + id: 262usize, name: Str::new("path_secret_map_address_cache_accessed\0"), units: Units::None, } .build(), info::Builder { - id: 258usize, + id: 263usize, name: Str::new("path_secret_map_address_cache_accessed.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 259usize, + id: 264usize, name: Str::new("path_secret_map_address_cache_accessed.hit\0"), units: Units::None, } .build(), info::Builder { - id: 260usize, + id: 265usize, name: Str::new("path_secret_map_address_cache_accessed_hit\0"), units: Units::None, } .build(), info::Builder { - id: 261usize, + id: 266usize, name: Str::new("path_secret_map_address_cache_accessed_hit.peer_address.protocol\0"), units: Units::None, } .build(), info::Builder { - id: 262usize, + id: 267usize, name: Str::new("path_secret_map_address_cache_accessed_hit.age\0"), units: Units::Duration, } .build(), info::Builder { - id: 263usize, + id: 268usize, name: Str::new("path_secret_map_id_cache_accessed\0"), units: Units::None, } .build(), info::Builder { - id: 264usize, + id: 269usize, name: Str::new("path_secret_map_id_cache_accessed.hit\0"), units: Units::None, } .build(), info::Builder { - id: 265usize, + id: 270usize, name: Str::new("path_secret_map_id_cache_accessed_hit\0"), units: Units::None, } .build(), info::Builder { - id: 266usize, + id: 271usize, name: Str::new("path_secret_map_id_cache_accessed_hit.age\0"), units: Units::Duration, } .build(), info::Builder { - id: 267usize, + id: 272usize, name: Str::new("path_secret_map_cleaner_cycled\0"), units: Units::None, } .build(), info::Builder { - id: 268usize, + id: 273usize, name: Str::new("path_secret_map_cleaner_cycled.entries.id\0"), units: Units::None, } .build(), info::Builder { - id: 269usize, + id: 274usize, name: Str::new("path_secret_map_cleaner_cycled.entries.id.retired\0"), units: Units::None, } .build(), info::Builder { - id: 270usize, + id: 275usize, name: Str::new("path_secret_map_cleaner_cycled.entries.id.active\0"), units: Units::None, } .build(), info::Builder { - id: 271usize, + id: 276usize, name: Str::new("path_secret_map_cleaner_cycled.entries.id.active.utilization\0"), units: Units::Percent, } .build(), info::Builder { - id: 272usize, + id: 277usize, name: Str::new("path_secret_map_cleaner_cycled.entries.id.utilization\0"), units: Units::Percent, } .build(), info::Builder { - id: 273usize, + id: 278usize, name: Str::new("path_secret_map_cleaner_cycled.entries.id.utilization.initial\0"), units: Units::Percent, } .build(), info::Builder { - id: 274usize, + id: 279usize, name: Str::new("path_secret_map_cleaner_cycled.entries.address\0"), units: Units::None, } .build(), info::Builder { - id: 275usize, + id: 280usize, name: Str::new("path_secret_map_cleaner_cycled.entries.address.active\0"), units: Units::None, } .build(), info::Builder { - id: 276usize, + id: 281usize, name: Str::new("path_secret_map_cleaner_cycled.entries.address.active.utilization\0"), units: Units::Percent, } .build(), info::Builder { - id: 277usize, + id: 282usize, name: Str::new("path_secret_map_cleaner_cycled.entries.address.retired\0"), units: Units::None, } .build(), info::Builder { - id: 278usize, + id: 283usize, name: Str::new("path_secret_map_cleaner_cycled.entries.address.utilization\0"), units: Units::Percent, } .build(), info::Builder { - id: 279usize, + id: 284usize, name: Str::new("path_secret_map_cleaner_cycled.entries.address.utilization.initial\0"), units: Units::Percent, } .build(), info::Builder { - id: 280usize, + id: 285usize, name: Str::new("path_secret_map_cleaner_cycled.handshake_requests\0"), units: Units::None, } .build(), info::Builder { - id: 281usize, + id: 286usize, name: Str::new("path_secret_map_cleaner_cycled.handshake_requests.retired\0"), units: Units::None, } .build(), info::Builder { - id: 282usize, + id: 287usize, name: Str::new("path_secret_map_cleaner_cycled.handshake_lock_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 283usize, + id: 288usize, name: Str::new("path_secret_map_cleaner_cycled.total_duration\0"), units: Units::Duration, } @@ -1723,39 +1753,39 @@ static INFO: &[Info; 284usize] = &[ #[allow(dead_code)] pub struct ConnectionContext { start_time: crate::event::Timestamp, - ctr_12: AtomicU64, - ctr_15: AtomicU64, + ctr_14: AtomicU64, ctr_17: AtomicU64, - ctr_18: AtomicU64, - ctr_21: AtomicU64, + ctr_19: AtomicU64, + ctr_20: AtomicU64, ctr_23: AtomicU64, - ctr_24: AtomicU64, - ctr_27: AtomicU64, - ctr_30: AtomicU64, - ctr_31: AtomicU64, + ctr_25: AtomicU64, + ctr_26: AtomicU64, + ctr_29: AtomicU64, + ctr_32: AtomicU64, ctr_33: AtomicU64, ctr_35: AtomicU64, - ctr_38: AtomicU64, - ctr_39: AtomicU64, - ctr_42: AtomicU64, - ctr_45: AtomicU64, + ctr_37: AtomicU64, + ctr_40: AtomicU64, + ctr_41: AtomicU64, + ctr_44: AtomicU64, ctr_47: AtomicU64, - ctr_48: AtomicU64, - ctr_51: AtomicU64, - ctr_54: AtomicU64, - ctr_57: AtomicU64, - ctr_58: AtomicU64, - ctr_61: AtomicU64, - ctr_62: AtomicU64, - ctr_69: AtomicU64, - ctr_73: AtomicU64, - ctr_76: AtomicU64, - ctr_80: AtomicU64, - ctr_84: AtomicU64, + ctr_49: AtomicU64, + ctr_50: AtomicU64, + ctr_53: AtomicU64, + ctr_56: AtomicU64, + ctr_59: AtomicU64, + ctr_60: AtomicU64, + ctr_63: AtomicU64, + ctr_64: AtomicU64, + ctr_71: AtomicU64, + ctr_75: AtomicU64, + ctr_78: AtomicU64, + ctr_82: AtomicU64, + ctr_86: AtomicU64, } pub struct Subscriber { #[allow(dead_code)] - counters: Box<[R::Counter; 96usize]>, + counters: Box<[R::Counter; 98usize]>, #[allow(dead_code)] bool_counters: Box<[R::BoolCounter; 21usize]>, #[allow(dead_code)] @@ -1763,11 +1793,11 @@ pub struct Subscriber { #[allow(dead_code)] nominal_counter_offsets: Box<[usize; 32usize]>, #[allow(dead_code)] - measures: Box<[R::Measure; 117usize]>, + measures: Box<[R::Measure; 119usize]>, #[allow(dead_code)] gauges: Box<[R::Gauge; 0usize]>, #[allow(dead_code)] - timers: Box<[R::Timer; 18usize]>, + timers: Box<[R::Timer; 19usize]>, #[allow(dead_code)] nominal_timers: Box<[R::NominalTimer]>, #[allow(dead_code)] @@ -1790,13 +1820,13 @@ impl Subscriber { #[allow(unused_mut)] #[inline] pub fn new(registry: R) -> Self { - let mut counters = Vec::with_capacity(96usize); + let mut counters = Vec::with_capacity(98usize); let mut bool_counters = Vec::with_capacity(21usize); let mut nominal_counters = Vec::with_capacity(32usize); let mut nominal_counter_offsets = Vec::with_capacity(32usize); - let mut measures = Vec::with_capacity(117usize); + let mut measures = Vec::with_capacity(119usize); let mut gauges = Vec::with_capacity(0usize); - let mut timers = Vec::with_capacity(18usize); + let mut timers = Vec::with_capacity(19usize); let mut nominal_timers = Vec::with_capacity(0usize); let mut nominal_timer_offsets = Vec::with_capacity(0usize); counters.push(registry.register_counter(&INFO[0usize])); @@ -1810,112 +1840,114 @@ impl Subscriber { counters.push(registry.register_counter(&INFO[25usize])); counters.push(registry.register_counter(&INFO[28usize])); 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[42usize])); + counters.push(registry.register_counter(&INFO[31usize])); + counters.push(registry.register_counter(&INFO[34usize])); + counters.push(registry.register_counter(&INFO[35usize])); + counters.push(registry.register_counter(&INFO[37usize])); + counters.push(registry.register_counter(&INFO[43usize])); counters.push(registry.register_counter(&INFO[45usize])); + counters.push(registry.register_counter(&INFO[46usize])); counters.push(registry.register_counter(&INFO[47usize])); - counters.push(registry.register_counter(&INFO[51usize])); + counters.push(registry.register_counter(&INFO[50usize])); + counters.push(registry.register_counter(&INFO[52usize])); counters.push(registry.register_counter(&INFO[56usize])); - counters.push(registry.register_counter(&INFO[60usize])); + counters.push(registry.register_counter(&INFO[61usize])); counters.push(registry.register_counter(&INFO[65usize])); - counters.push(registry.register_counter(&INFO[71usize])); + counters.push(registry.register_counter(&INFO[70usize])); counters.push(registry.register_counter(&INFO[76usize])); - counters.push(registry.register_counter(&INFO[77usize])); counters.push(registry.register_counter(&INFO[81usize])); - counters.push(registry.register_counter(&INFO[85usize])); - counters.push(registry.register_counter(&INFO[88usize])); - counters.push(registry.register_counter(&INFO[91usize])); - counters.push(registry.register_counter(&INFO[94usize])); + counters.push(registry.register_counter(&INFO[82usize])); + counters.push(registry.register_counter(&INFO[86usize])); + counters.push(registry.register_counter(&INFO[90usize])); + counters.push(registry.register_counter(&INFO[93usize])); counters.push(registry.register_counter(&INFO[96usize])); - counters.push(registry.register_counter(&INFO[100usize])); + counters.push(registry.register_counter(&INFO[99usize])); + counters.push(registry.register_counter(&INFO[101usize])); counters.push(registry.register_counter(&INFO[105usize])); - counters.push(registry.register_counter(&INFO[111usize])); + counters.push(registry.register_counter(&INFO[110usize])); counters.push(registry.register_counter(&INFO[116usize])); counters.push(registry.register_counter(&INFO[121usize])); - counters.push(registry.register_counter(&INFO[122usize])); - counters.push(registry.register_counter(&INFO[125usize])); - counters.push(registry.register_counter(&INFO[128usize])); - counters.push(registry.register_counter(&INFO[131usize])); - counters.push(registry.register_counter(&INFO[134usize])); + counters.push(registry.register_counter(&INFO[126usize])); + counters.push(registry.register_counter(&INFO[127usize])); + counters.push(registry.register_counter(&INFO[130usize])); + counters.push(registry.register_counter(&INFO[133usize])); counters.push(registry.register_counter(&INFO[136usize])); - counters.push(registry.register_counter(&INFO[140usize])); - counters.push(registry.register_counter(&INFO[143usize])); - counters.push(registry.register_counter(&INFO[147usize])); - counters.push(registry.register_counter(&INFO[149usize])); - counters.push(registry.register_counter(&INFO[151usize])); - counters.push(registry.register_counter(&INFO[155usize])); - counters.push(registry.register_counter(&INFO[157usize])); - counters.push(registry.register_counter(&INFO[159usize])); - counters.push(registry.register_counter(&INFO[163usize])); - counters.push(registry.register_counter(&INFO[165usize])); + counters.push(registry.register_counter(&INFO[139usize])); + counters.push(registry.register_counter(&INFO[141usize])); + counters.push(registry.register_counter(&INFO[145usize])); + counters.push(registry.register_counter(&INFO[148usize])); + counters.push(registry.register_counter(&INFO[152usize])); + counters.push(registry.register_counter(&INFO[154usize])); + counters.push(registry.register_counter(&INFO[156usize])); + counters.push(registry.register_counter(&INFO[160usize])); + counters.push(registry.register_counter(&INFO[162usize])); + counters.push(registry.register_counter(&INFO[164usize])); + counters.push(registry.register_counter(&INFO[168usize])); counters.push(registry.register_counter(&INFO[170usize])); - counters.push(registry.register_counter(&INFO[172usize])); + counters.push(registry.register_counter(&INFO[175usize])); counters.push(registry.register_counter(&INFO[177usize])); - counters.push(registry.register_counter(&INFO[179usize])); - counters.push(registry.register_counter(&INFO[183usize])); + counters.push(registry.register_counter(&INFO[182usize])); counters.push(registry.register_counter(&INFO[184usize])); - counters.push(registry.register_counter(&INFO[186usize])); + counters.push(registry.register_counter(&INFO[188usize])); counters.push(registry.register_counter(&INFO[189usize])); - counters.push(registry.register_counter(&INFO[193usize])); + counters.push(registry.register_counter(&INFO[191usize])); counters.push(registry.register_counter(&INFO[194usize])); - counters.push(registry.register_counter(&INFO[195usize])); - counters.push(registry.register_counter(&INFO[196usize])); + counters.push(registry.register_counter(&INFO[198usize])); + counters.push(registry.register_counter(&INFO[199usize])); + counters.push(registry.register_counter(&INFO[200usize])); counters.push(registry.register_counter(&INFO[201usize])); - counters.push(registry.register_counter(&INFO[203usize])); - counters.push(registry.register_counter(&INFO[207usize])); - counters.push(registry.register_counter(&INFO[209usize])); - counters.push(registry.register_counter(&INFO[211usize])); - counters.push(registry.register_counter(&INFO[213usize])); - counters.push(registry.register_counter(&INFO[215usize])); + counters.push(registry.register_counter(&INFO[206usize])); + counters.push(registry.register_counter(&INFO[208usize])); + counters.push(registry.register_counter(&INFO[212usize])); + counters.push(registry.register_counter(&INFO[214usize])); + counters.push(registry.register_counter(&INFO[216usize])); counters.push(registry.register_counter(&INFO[218usize])); - counters.push(registry.register_counter(&INFO[221usize])); + counters.push(registry.register_counter(&INFO[220usize])); counters.push(registry.register_counter(&INFO[223usize])); - counters.push(registry.register_counter(&INFO[225usize])); - counters.push(registry.register_counter(&INFO[227usize])); - counters.push(registry.register_counter(&INFO[229usize])); - counters.push(registry.register_counter(&INFO[231usize])); + counters.push(registry.register_counter(&INFO[226usize])); + counters.push(registry.register_counter(&INFO[228usize])); + counters.push(registry.register_counter(&INFO[230usize])); + counters.push(registry.register_counter(&INFO[232usize])); counters.push(registry.register_counter(&INFO[234usize])); - counters.push(registry.register_counter(&INFO[235usize])); - counters.push(registry.register_counter(&INFO[237usize])); + counters.push(registry.register_counter(&INFO[236usize])); counters.push(registry.register_counter(&INFO[239usize])); - counters.push(registry.register_counter(&INFO[241usize])); - counters.push(registry.register_counter(&INFO[243usize])); - counters.push(registry.register_counter(&INFO[245usize])); - counters.push(registry.register_counter(&INFO[247usize])); - counters.push(registry.register_counter(&INFO[249usize])); - counters.push(registry.register_counter(&INFO[251usize])); - counters.push(registry.register_counter(&INFO[253usize])); - counters.push(registry.register_counter(&INFO[255usize])); - counters.push(registry.register_counter(&INFO[257usize])); + counters.push(registry.register_counter(&INFO[240usize])); + counters.push(registry.register_counter(&INFO[242usize])); + counters.push(registry.register_counter(&INFO[244usize])); + counters.push(registry.register_counter(&INFO[246usize])); + counters.push(registry.register_counter(&INFO[248usize])); + counters.push(registry.register_counter(&INFO[250usize])); + counters.push(registry.register_counter(&INFO[252usize])); + counters.push(registry.register_counter(&INFO[254usize])); + counters.push(registry.register_counter(&INFO[256usize])); + counters.push(registry.register_counter(&INFO[258usize])); counters.push(registry.register_counter(&INFO[260usize])); - counters.push(registry.register_counter(&INFO[263usize])); + counters.push(registry.register_counter(&INFO[262usize])); counters.push(registry.register_counter(&INFO[265usize])); - counters.push(registry.register_counter(&INFO[267usize])); + counters.push(registry.register_counter(&INFO[268usize])); + counters.push(registry.register_counter(&INFO[270usize])); + counters.push(registry.register_counter(&INFO[272usize])); 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[84usize])); - bool_counters.push(registry.register_bool_counter(&INFO[124usize])); - bool_counters.push(registry.register_bool_counter(&INFO[137usize])); - bool_counters.push(registry.register_bool_counter(&INFO[141usize])); - bool_counters.push(registry.register_bool_counter(&INFO[144usize])); - bool_counters.push(registry.register_bool_counter(&INFO[154usize])); - bool_counters.push(registry.register_bool_counter(&INFO[162usize])); - bool_counters.push(registry.register_bool_counter(&INFO[169usize])); - bool_counters.push(registry.register_bool_counter(&INFO[176usize])); - bool_counters.push(registry.register_bool_counter(&INFO[182usize])); - bool_counters.push(registry.register_bool_counter(&INFO[192usize])); - bool_counters.push(registry.register_bool_counter(&INFO[199usize])); - bool_counters.push(registry.register_bool_counter(&INFO[200usize])); - bool_counters.push(registry.register_bool_counter(&INFO[259usize])); + bool_counters.push(registry.register_bool_counter(&INFO[39usize])); + bool_counters.push(registry.register_bool_counter(&INFO[40usize])); + bool_counters.push(registry.register_bool_counter(&INFO[41usize])); + bool_counters.push(registry.register_bool_counter(&INFO[42usize])); + bool_counters.push(registry.register_bool_counter(&INFO[89usize])); + bool_counters.push(registry.register_bool_counter(&INFO[129usize])); + bool_counters.push(registry.register_bool_counter(&INFO[142usize])); + bool_counters.push(registry.register_bool_counter(&INFO[146usize])); + bool_counters.push(registry.register_bool_counter(&INFO[149usize])); + bool_counters.push(registry.register_bool_counter(&INFO[159usize])); + bool_counters.push(registry.register_bool_counter(&INFO[167usize])); + bool_counters.push(registry.register_bool_counter(&INFO[174usize])); + bool_counters.push(registry.register_bool_counter(&INFO[181usize])); + bool_counters.push(registry.register_bool_counter(&INFO[187usize])); + bool_counters.push(registry.register_bool_counter(&INFO[197usize])); + bool_counters.push(registry.register_bool_counter(&INFO[204usize])); + bool_counters.push(registry.register_bool_counter(&INFO[205usize])); bool_counters.push(registry.register_bool_counter(&INFO[264usize])); + bool_counters.push(registry.register_bool_counter(&INFO[269usize])); { #[allow(unused_imports)] use api::*; @@ -1946,7 +1978,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[39usize], variant)); + .push(registry.register_nominal_counter(&INFO[44usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1957,7 +1989,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[44usize], variant)); + .push(registry.register_nominal_counter(&INFO[49usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1968,7 +2000,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[145usize], variant)); + .push(registry.register_nominal_counter(&INFO[150usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1979,7 +2011,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[146usize], variant)); + .push(registry.register_nominal_counter(&INFO[151usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1990,7 +2022,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[148usize], variant)); + .push(registry.register_nominal_counter(&INFO[153usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2001,7 +2033,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[197usize], variant)); + .push(registry.register_nominal_counter(&INFO[202usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2012,7 +2044,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[198usize], variant)); + .push(registry.register_nominal_counter(&INFO[203usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2023,7 +2055,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[208usize], variant)); + .push(registry.register_nominal_counter(&INFO[213usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2034,7 +2066,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[210usize], variant)); + .push(registry.register_nominal_counter(&INFO[215usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2045,7 +2077,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[212usize], variant)); + .push(registry.register_nominal_counter(&INFO[217usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2056,7 +2088,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[214usize], variant)); + .push(registry.register_nominal_counter(&INFO[219usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2067,7 +2099,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[216usize], variant)); + .push(registry.register_nominal_counter(&INFO[221usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2078,7 +2110,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[219usize], variant)); + .push(registry.register_nominal_counter(&INFO[224usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2089,7 +2121,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[222usize], variant)); + .push(registry.register_nominal_counter(&INFO[227usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2100,7 +2132,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[224usize], variant)); + .push(registry.register_nominal_counter(&INFO[229usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2111,7 +2143,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[226usize], variant)); + .push(registry.register_nominal_counter(&INFO[231usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2122,7 +2154,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[228usize], variant)); + .push(registry.register_nominal_counter(&INFO[233usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2133,7 +2165,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[230usize], variant)); + .push(registry.register_nominal_counter(&INFO[235usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2144,7 +2176,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[238usize], variant)); + .push(registry.register_nominal_counter(&INFO[243usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2155,7 +2187,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[240usize], variant)); + .push(registry.register_nominal_counter(&INFO[245usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2166,7 +2198,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[242usize], variant)); + .push(registry.register_nominal_counter(&INFO[247usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2177,7 +2209,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[244usize], variant)); + .push(registry.register_nominal_counter(&INFO[249usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2188,7 +2220,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[246usize], variant)); + .push(registry.register_nominal_counter(&INFO[251usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2199,7 +2231,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[248usize], variant)); + .push(registry.register_nominal_counter(&INFO[253usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2210,7 +2242,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[250usize], variant)); + .push(registry.register_nominal_counter(&INFO[255usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2221,7 +2253,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[252usize], variant)); + .push(registry.register_nominal_counter(&INFO[257usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2232,7 +2264,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[254usize], variant)); + .push(registry.register_nominal_counter(&INFO[259usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2243,7 +2275,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[256usize], variant)); + .push(registry.register_nominal_counter(&INFO[261usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2254,7 +2286,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[258usize], variant)); + .push(registry.register_nominal_counter(&INFO[263usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2265,7 +2297,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[261usize], variant)); + .push(registry.register_nominal_counter(&INFO[266usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -2282,24 +2314,23 @@ impl Subscriber { measures.push(registry.register_measure(&INFO[16usize])); measures.push(registry.register_measure(&INFO[18usize])); measures.push(registry.register_measure(&INFO[27usize])); - measures.push(registry.register_measure(&INFO[31usize])); + measures.push(registry.register_measure(&INFO[32usize])); measures.push(registry.register_measure(&INFO[33usize])); - measures.push(registry.register_measure(&INFO[49usize])); - measures.push(registry.register_measure(&INFO[50usize])); - measures.push(registry.register_measure(&INFO[52usize])); - measures.push(registry.register_measure(&INFO[53usize])); + measures.push(registry.register_measure(&INFO[36usize])); + measures.push(registry.register_measure(&INFO[38usize])); measures.push(registry.register_measure(&INFO[54usize])); 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[61usize])); - measures.push(registry.register_measure(&INFO[62usize])); + measures.push(registry.register_measure(&INFO[60usize])); measures.push(registry.register_measure(&INFO[63usize])); measures.push(registry.register_measure(&INFO[64usize])); + measures.push(registry.register_measure(&INFO[66usize])); measures.push(registry.register_measure(&INFO[67usize])); measures.push(registry.register_measure(&INFO[68usize])); measures.push(registry.register_measure(&INFO[69usize])); - measures.push(registry.register_measure(&INFO[70usize])); + measures.push(registry.register_measure(&INFO[72usize])); measures.push(registry.register_measure(&INFO[73usize])); measures.push(registry.register_measure(&INFO[74usize])); measures.push(registry.register_measure(&INFO[75usize])); @@ -2307,77 +2338,75 @@ impl Subscriber { measures.push(registry.register_measure(&INFO[79usize])); measures.push(registry.register_measure(&INFO[80usize])); measures.push(registry.register_measure(&INFO[83usize])); - measures.push(registry.register_measure(&INFO[86usize])); - measures.push(registry.register_measure(&INFO[87usize])); - measures.push(registry.register_measure(&INFO[89usize])); - measures.push(registry.register_measure(&INFO[90usize])); + measures.push(registry.register_measure(&INFO[84usize])); + measures.push(registry.register_measure(&INFO[85usize])); + measures.push(registry.register_measure(&INFO[88usize])); + measures.push(registry.register_measure(&INFO[91usize])); measures.push(registry.register_measure(&INFO[92usize])); - measures.push(registry.register_measure(&INFO[93usize])); + measures.push(registry.register_measure(&INFO[94usize])); measures.push(registry.register_measure(&INFO[95usize])); + measures.push(registry.register_measure(&INFO[97usize])); measures.push(registry.register_measure(&INFO[98usize])); - measures.push(registry.register_measure(&INFO[99usize])); - measures.push(registry.register_measure(&INFO[101usize])); - measures.push(registry.register_measure(&INFO[102usize])); + measures.push(registry.register_measure(&INFO[100usize])); measures.push(registry.register_measure(&INFO[103usize])); measures.push(registry.register_measure(&INFO[104usize])); + measures.push(registry.register_measure(&INFO[106usize])); measures.push(registry.register_measure(&INFO[107usize])); measures.push(registry.register_measure(&INFO[108usize])); measures.push(registry.register_measure(&INFO[109usize])); - measures.push(registry.register_measure(&INFO[110usize])); + measures.push(registry.register_measure(&INFO[112usize])); measures.push(registry.register_measure(&INFO[113usize])); measures.push(registry.register_measure(&INFO[114usize])); measures.push(registry.register_measure(&INFO[115usize])); measures.push(registry.register_measure(&INFO[118usize])); measures.push(registry.register_measure(&INFO[119usize])); measures.push(registry.register_measure(&INFO[120usize])); - measures.push(registry.register_measure(&INFO[126usize])); - measures.push(registry.register_measure(&INFO[127usize])); - measures.push(registry.register_measure(&INFO[129usize])); - measures.push(registry.register_measure(&INFO[130usize])); + measures.push(registry.register_measure(&INFO[123usize])); + measures.push(registry.register_measure(&INFO[124usize])); + measures.push(registry.register_measure(&INFO[125usize])); + measures.push(registry.register_measure(&INFO[131usize])); measures.push(registry.register_measure(&INFO[132usize])); - measures.push(registry.register_measure(&INFO[133usize])); + measures.push(registry.register_measure(&INFO[134usize])); measures.push(registry.register_measure(&INFO[135usize])); + measures.push(registry.register_measure(&INFO[137usize])); measures.push(registry.register_measure(&INFO[138usize])); - measures.push(registry.register_measure(&INFO[139usize])); - measures.push(registry.register_measure(&INFO[150usize])); - measures.push(registry.register_measure(&INFO[152usize])); - measures.push(registry.register_measure(&INFO[153usize])); - measures.push(registry.register_measure(&INFO[156usize])); + measures.push(registry.register_measure(&INFO[140usize])); + measures.push(registry.register_measure(&INFO[143usize])); + measures.push(registry.register_measure(&INFO[144usize])); + measures.push(registry.register_measure(&INFO[155usize])); + measures.push(registry.register_measure(&INFO[157usize])); measures.push(registry.register_measure(&INFO[158usize])); - measures.push(registry.register_measure(&INFO[160usize])); measures.push(registry.register_measure(&INFO[161usize])); - measures.push(registry.register_measure(&INFO[164usize])); + measures.push(registry.register_measure(&INFO[163usize])); + measures.push(registry.register_measure(&INFO[165usize])); measures.push(registry.register_measure(&INFO[166usize])); - measures.push(registry.register_measure(&INFO[167usize])); - measures.push(registry.register_measure(&INFO[168usize])); + measures.push(registry.register_measure(&INFO[169usize])); measures.push(registry.register_measure(&INFO[171usize])); + measures.push(registry.register_measure(&INFO[172usize])); measures.push(registry.register_measure(&INFO[173usize])); - measures.push(registry.register_measure(&INFO[174usize])); - measures.push(registry.register_measure(&INFO[175usize])); + measures.push(registry.register_measure(&INFO[176usize])); measures.push(registry.register_measure(&INFO[178usize])); + measures.push(registry.register_measure(&INFO[179usize])); measures.push(registry.register_measure(&INFO[180usize])); - measures.push(registry.register_measure(&INFO[181usize])); + measures.push(registry.register_measure(&INFO[183usize])); measures.push(registry.register_measure(&INFO[185usize])); - measures.push(registry.register_measure(&INFO[187usize])); - measures.push(registry.register_measure(&INFO[188usize])); + measures.push(registry.register_measure(&INFO[186usize])); measures.push(registry.register_measure(&INFO[190usize])); - measures.push(registry.register_measure(&INFO[191usize])); - measures.push(registry.register_measure(&INFO[202usize])); - measures.push(registry.register_measure(&INFO[204usize])); - measures.push(registry.register_measure(&INFO[205usize])); - measures.push(registry.register_measure(&INFO[206usize])); - measures.push(registry.register_measure(&INFO[217usize])); - measures.push(registry.register_measure(&INFO[220usize])); - measures.push(registry.register_measure(&INFO[232usize])); - measures.push(registry.register_measure(&INFO[233usize])); - measures.push(registry.register_measure(&INFO[236usize])); - measures.push(registry.register_measure(&INFO[262usize])); - measures.push(registry.register_measure(&INFO[266usize])); - measures.push(registry.register_measure(&INFO[268usize])); - measures.push(registry.register_measure(&INFO[269usize])); - measures.push(registry.register_measure(&INFO[270usize])); + measures.push(registry.register_measure(&INFO[192usize])); + measures.push(registry.register_measure(&INFO[193usize])); + measures.push(registry.register_measure(&INFO[195usize])); + measures.push(registry.register_measure(&INFO[196usize])); + measures.push(registry.register_measure(&INFO[207usize])); + measures.push(registry.register_measure(&INFO[209usize])); + measures.push(registry.register_measure(&INFO[210usize])); + measures.push(registry.register_measure(&INFO[211usize])); + measures.push(registry.register_measure(&INFO[222usize])); + measures.push(registry.register_measure(&INFO[225usize])); + measures.push(registry.register_measure(&INFO[237usize])); + measures.push(registry.register_measure(&INFO[238usize])); + measures.push(registry.register_measure(&INFO[241usize])); + measures.push(registry.register_measure(&INFO[267usize])); measures.push(registry.register_measure(&INFO[271usize])); - measures.push(registry.register_measure(&INFO[272usize])); measures.push(registry.register_measure(&INFO[273usize])); measures.push(registry.register_measure(&INFO[274usize])); measures.push(registry.register_measure(&INFO[275usize])); @@ -2389,24 +2418,30 @@ impl Subscriber { measures.push(registry.register_measure(&INFO[281usize])); measures.push(registry.register_measure(&INFO[282usize])); measures.push(registry.register_measure(&INFO[283usize])); + measures.push(registry.register_measure(&INFO[284usize])); + measures.push(registry.register_measure(&INFO[285usize])); + measures.push(registry.register_measure(&INFO[286usize])); + measures.push(registry.register_measure(&INFO[287usize])); + measures.push(registry.register_measure(&INFO[288usize])); 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])); + timers.push(registry.register_timer(&INFO[30usize])); timers.push(registry.register_timer(&INFO[48usize])); - timers.push(registry.register_timer(&INFO[57usize])); - timers.push(registry.register_timer(&INFO[66usize])); - timers.push(registry.register_timer(&INFO[72usize])); - timers.push(registry.register_timer(&INFO[82usize])); - timers.push(registry.register_timer(&INFO[97usize])); - timers.push(registry.register_timer(&INFO[106usize])); - timers.push(registry.register_timer(&INFO[112usize])); + timers.push(registry.register_timer(&INFO[51usize])); + timers.push(registry.register_timer(&INFO[53usize])); + timers.push(registry.register_timer(&INFO[62usize])); + timers.push(registry.register_timer(&INFO[71usize])); + timers.push(registry.register_timer(&INFO[77usize])); + timers.push(registry.register_timer(&INFO[87usize])); + timers.push(registry.register_timer(&INFO[102usize])); + timers.push(registry.register_timer(&INFO[111usize])); timers.push(registry.register_timer(&INFO[117usize])); - timers.push(registry.register_timer(&INFO[123usize])); - timers.push(registry.register_timer(&INFO[142usize])); + timers.push(registry.register_timer(&INFO[122usize])); + timers.push(registry.register_timer(&INFO[128usize])); + timers.push(registry.register_timer(&INFO[147usize])); { #[allow(unused_imports)] use api::*; @@ -2452,91 +2487,93 @@ impl Subscriber { 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), + 11usize => (&INFO[31usize], entry), + 12usize => (&INFO[34usize], entry), + 13usize => (&INFO[35usize], entry), + 14usize => (&INFO[37usize], entry), + 15usize => (&INFO[43usize], entry), + 16usize => (&INFO[45usize], entry), + 17usize => (&INFO[46usize], entry), 18usize => (&INFO[47usize], entry), - 19usize => (&INFO[51usize], entry), - 20usize => (&INFO[56usize], entry), - 21usize => (&INFO[60usize], entry), - 22usize => (&INFO[65usize], entry), - 23usize => (&INFO[71usize], entry), - 24usize => (&INFO[76usize], entry), - 25usize => (&INFO[77usize], entry), + 19usize => (&INFO[50usize], entry), + 20usize => (&INFO[52usize], entry), + 21usize => (&INFO[56usize], entry), + 22usize => (&INFO[61usize], entry), + 23usize => (&INFO[65usize], entry), + 24usize => (&INFO[70usize], entry), + 25usize => (&INFO[76usize], entry), 26usize => (&INFO[81usize], entry), - 27usize => (&INFO[85usize], entry), - 28usize => (&INFO[88usize], entry), - 29usize => (&INFO[91usize], entry), - 30usize => (&INFO[94usize], entry), + 27usize => (&INFO[82usize], entry), + 28usize => (&INFO[86usize], entry), + 29usize => (&INFO[90usize], entry), + 30usize => (&INFO[93usize], entry), 31usize => (&INFO[96usize], entry), - 32usize => (&INFO[100usize], entry), - 33usize => (&INFO[105usize], entry), - 34usize => (&INFO[111usize], entry), - 35usize => (&INFO[116usize], entry), - 36usize => (&INFO[121usize], entry), - 37usize => (&INFO[122usize], entry), - 38usize => (&INFO[125usize], entry), - 39usize => (&INFO[128usize], entry), - 40usize => (&INFO[131usize], entry), - 41usize => (&INFO[134usize], entry), + 32usize => (&INFO[99usize], entry), + 33usize => (&INFO[101usize], entry), + 34usize => (&INFO[105usize], entry), + 35usize => (&INFO[110usize], entry), + 36usize => (&INFO[116usize], entry), + 37usize => (&INFO[121usize], entry), + 38usize => (&INFO[126usize], entry), + 39usize => (&INFO[127usize], entry), + 40usize => (&INFO[130usize], entry), + 41usize => (&INFO[133usize], entry), 42usize => (&INFO[136usize], entry), - 43usize => (&INFO[140usize], entry), - 44usize => (&INFO[143usize], entry), - 45usize => (&INFO[147usize], entry), - 46usize => (&INFO[149usize], entry), - 47usize => (&INFO[151usize], entry), - 48usize => (&INFO[155usize], entry), - 49usize => (&INFO[157usize], entry), - 50usize => (&INFO[159usize], entry), - 51usize => (&INFO[163usize], entry), - 52usize => (&INFO[165usize], entry), - 53usize => (&INFO[170usize], entry), - 54usize => (&INFO[172usize], entry), - 55usize => (&INFO[177usize], entry), - 56usize => (&INFO[179usize], entry), - 57usize => (&INFO[183usize], entry), + 43usize => (&INFO[139usize], entry), + 44usize => (&INFO[141usize], entry), + 45usize => (&INFO[145usize], entry), + 46usize => (&INFO[148usize], entry), + 47usize => (&INFO[152usize], entry), + 48usize => (&INFO[154usize], entry), + 49usize => (&INFO[156usize], entry), + 50usize => (&INFO[160usize], entry), + 51usize => (&INFO[162usize], entry), + 52usize => (&INFO[164usize], entry), + 53usize => (&INFO[168usize], entry), + 54usize => (&INFO[170usize], entry), + 55usize => (&INFO[175usize], entry), + 56usize => (&INFO[177usize], entry), + 57usize => (&INFO[182usize], entry), 58usize => (&INFO[184usize], entry), - 59usize => (&INFO[186usize], entry), + 59usize => (&INFO[188usize], entry), 60usize => (&INFO[189usize], entry), - 61usize => (&INFO[193usize], entry), + 61usize => (&INFO[191usize], entry), 62usize => (&INFO[194usize], entry), - 63usize => (&INFO[195usize], entry), - 64usize => (&INFO[196usize], entry), - 65usize => (&INFO[201usize], entry), - 66usize => (&INFO[203usize], entry), - 67usize => (&INFO[207usize], entry), - 68usize => (&INFO[209usize], entry), - 69usize => (&INFO[211usize], entry), - 70usize => (&INFO[213usize], entry), - 71usize => (&INFO[215usize], entry), + 63usize => (&INFO[198usize], entry), + 64usize => (&INFO[199usize], entry), + 65usize => (&INFO[200usize], entry), + 66usize => (&INFO[201usize], entry), + 67usize => (&INFO[206usize], entry), + 68usize => (&INFO[208usize], entry), + 69usize => (&INFO[212usize], entry), + 70usize => (&INFO[214usize], entry), + 71usize => (&INFO[216usize], entry), 72usize => (&INFO[218usize], entry), - 73usize => (&INFO[221usize], entry), + 73usize => (&INFO[220usize], entry), 74usize => (&INFO[223usize], entry), - 75usize => (&INFO[225usize], entry), - 76usize => (&INFO[227usize], entry), - 77usize => (&INFO[229usize], entry), - 78usize => (&INFO[231usize], entry), + 75usize => (&INFO[226usize], entry), + 76usize => (&INFO[228usize], entry), + 77usize => (&INFO[230usize], entry), + 78usize => (&INFO[232usize], entry), 79usize => (&INFO[234usize], entry), - 80usize => (&INFO[235usize], entry), - 81usize => (&INFO[237usize], entry), - 82usize => (&INFO[239usize], entry), - 83usize => (&INFO[241usize], entry), - 84usize => (&INFO[243usize], entry), - 85usize => (&INFO[245usize], entry), - 86usize => (&INFO[247usize], entry), - 87usize => (&INFO[249usize], entry), - 88usize => (&INFO[251usize], entry), - 89usize => (&INFO[253usize], entry), - 90usize => (&INFO[255usize], entry), - 91usize => (&INFO[257usize], entry), + 80usize => (&INFO[236usize], entry), + 81usize => (&INFO[239usize], entry), + 82usize => (&INFO[240usize], entry), + 83usize => (&INFO[242usize], entry), + 84usize => (&INFO[244usize], entry), + 85usize => (&INFO[246usize], entry), + 86usize => (&INFO[248usize], entry), + 87usize => (&INFO[250usize], entry), + 88usize => (&INFO[252usize], entry), + 89usize => (&INFO[254usize], entry), + 90usize => (&INFO[256usize], entry), + 91usize => (&INFO[258usize], entry), 92usize => (&INFO[260usize], entry), - 93usize => (&INFO[263usize], entry), + 93usize => (&INFO[262usize], entry), 94usize => (&INFO[265usize], entry), - 95usize => (&INFO[267usize], entry), + 95usize => (&INFO[268usize], entry), + 96usize => (&INFO[270usize], entry), + 97usize => (&INFO[272usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -2556,25 +2593,25 @@ impl Subscriber { .map(|(idx, entry)| match idx { 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[84usize], entry), - 7usize => (&INFO[124usize], entry), - 8usize => (&INFO[137usize], entry), - 9usize => (&INFO[141usize], entry), - 10usize => (&INFO[144usize], entry), - 11usize => (&INFO[154usize], entry), - 12usize => (&INFO[162usize], entry), - 13usize => (&INFO[169usize], entry), - 14usize => (&INFO[176usize], entry), - 15usize => (&INFO[182usize], entry), - 16usize => (&INFO[192usize], entry), - 17usize => (&INFO[199usize], entry), - 18usize => (&INFO[200usize], entry), - 19usize => (&INFO[259usize], entry), - 20usize => (&INFO[264usize], entry), + 2usize => (&INFO[39usize], entry), + 3usize => (&INFO[40usize], entry), + 4usize => (&INFO[41usize], entry), + 5usize => (&INFO[42usize], entry), + 6usize => (&INFO[89usize], entry), + 7usize => (&INFO[129usize], entry), + 8usize => (&INFO[142usize], entry), + 9usize => (&INFO[146usize], entry), + 10usize => (&INFO[149usize], entry), + 11usize => (&INFO[159usize], entry), + 12usize => (&INFO[167usize], entry), + 13usize => (&INFO[174usize], entry), + 14usize => (&INFO[181usize], entry), + 15usize => (&INFO[187usize], entry), + 16usize => (&INFO[197usize], entry), + 17usize => (&INFO[204usize], entry), + 18usize => (&INFO[205usize], entry), + 19usize => (&INFO[264usize], entry), + 20usize => (&INFO[269usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -2612,181 +2649,181 @@ impl Subscriber { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[39usize], entries, variants) + (&INFO[44usize], entries, variants) } 3usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[44usize], entries, variants) + (&INFO[49usize], entries, variants) } 4usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[145usize], entries, variants) + (&INFO[150usize], entries, variants) } 5usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[146usize], entries, variants) + (&INFO[151usize], entries, variants) } 6usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[148usize], entries, variants) + (&INFO[153usize], entries, variants) } 7usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[197usize], entries, variants) + (&INFO[202usize], entries, variants) } 8usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[198usize], entries, variants) + (&INFO[203usize], entries, variants) } 9usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[208usize], entries, variants) + (&INFO[213usize], entries, variants) } 10usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[210usize], entries, variants) + (&INFO[215usize], entries, variants) } 11usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[212usize], entries, variants) + (&INFO[217usize], entries, variants) } 12usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[214usize], entries, variants) + (&INFO[219usize], entries, variants) } 13usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[216usize], entries, variants) + (&INFO[221usize], entries, variants) } 14usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[219usize], entries, variants) + (&INFO[224usize], entries, variants) } 15usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[222usize], entries, variants) + (&INFO[227usize], entries, variants) } 16usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[224usize], entries, variants) + (&INFO[229usize], entries, variants) } 17usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[226usize], entries, variants) + (&INFO[231usize], entries, variants) } 18usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[228usize], entries, variants) + (&INFO[233usize], entries, variants) } 19usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[230usize], entries, variants) + (&INFO[235usize], entries, variants) } 20usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[238usize], entries, variants) + (&INFO[243usize], entries, variants) } 21usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[240usize], entries, variants) + (&INFO[245usize], entries, variants) } 22usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[242usize], entries, variants) + (&INFO[247usize], entries, variants) } 23usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[244usize], entries, variants) + (&INFO[249usize], entries, variants) } 24usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[246usize], entries, variants) + (&INFO[251usize], entries, variants) } 25usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[248usize], entries, variants) + (&INFO[253usize], entries, variants) } 26usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[250usize], entries, variants) + (&INFO[255usize], entries, variants) } 27usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[252usize], entries, variants) + (&INFO[257usize], entries, variants) } 28usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[254usize], entries, variants) + (&INFO[259usize], entries, variants) } 29usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[256usize], entries, variants) + (&INFO[261usize], entries, variants) } 30usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[258usize], entries, variants) + (&INFO[263usize], entries, variants) } 31usize => { let offset = *entry; let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[261usize], entries, variants) + (&INFO[266usize], entries, variants) } _ => unsafe { core::hint::unreachable_unchecked() }, }) @@ -2816,113 +2853,115 @@ impl Subscriber { 7usize => (&INFO[16usize], entry), 8usize => (&INFO[18usize], entry), 9usize => (&INFO[27usize], entry), - 10usize => (&INFO[31usize], entry), + 10usize => (&INFO[32usize], entry), 11usize => (&INFO[33usize], entry), - 12usize => (&INFO[49usize], entry), - 13usize => (&INFO[50usize], entry), - 14usize => (&INFO[52usize], entry), - 15usize => (&INFO[53usize], entry), - 16usize => (&INFO[54usize], entry), - 17usize => (&INFO[55usize], entry), - 18usize => (&INFO[58usize], entry), - 19usize => (&INFO[59usize], entry), - 20usize => (&INFO[61usize], entry), - 21usize => (&INFO[62usize], entry), - 22usize => (&INFO[63usize], entry), - 23usize => (&INFO[64usize], entry), - 24usize => (&INFO[67usize], entry), - 25usize => (&INFO[68usize], entry), - 26usize => (&INFO[69usize], entry), - 27usize => (&INFO[70usize], entry), - 28usize => (&INFO[73usize], entry), - 29usize => (&INFO[74usize], entry), - 30usize => (&INFO[75usize], entry), - 31usize => (&INFO[78usize], entry), - 32usize => (&INFO[79usize], entry), - 33usize => (&INFO[80usize], entry), - 34usize => (&INFO[83usize], entry), - 35usize => (&INFO[86usize], entry), - 36usize => (&INFO[87usize], entry), - 37usize => (&INFO[89usize], entry), - 38usize => (&INFO[90usize], entry), - 39usize => (&INFO[92usize], entry), - 40usize => (&INFO[93usize], entry), - 41usize => (&INFO[95usize], entry), + 12usize => (&INFO[36usize], entry), + 13usize => (&INFO[38usize], entry), + 14usize => (&INFO[54usize], entry), + 15usize => (&INFO[55usize], entry), + 16usize => (&INFO[57usize], entry), + 17usize => (&INFO[58usize], entry), + 18usize => (&INFO[59usize], entry), + 19usize => (&INFO[60usize], entry), + 20usize => (&INFO[63usize], entry), + 21usize => (&INFO[64usize], entry), + 22usize => (&INFO[66usize], entry), + 23usize => (&INFO[67usize], entry), + 24usize => (&INFO[68usize], entry), + 25usize => (&INFO[69usize], entry), + 26usize => (&INFO[72usize], entry), + 27usize => (&INFO[73usize], entry), + 28usize => (&INFO[74usize], entry), + 29usize => (&INFO[75usize], entry), + 30usize => (&INFO[78usize], entry), + 31usize => (&INFO[79usize], entry), + 32usize => (&INFO[80usize], entry), + 33usize => (&INFO[83usize], entry), + 34usize => (&INFO[84usize], entry), + 35usize => (&INFO[85usize], entry), + 36usize => (&INFO[88usize], entry), + 37usize => (&INFO[91usize], entry), + 38usize => (&INFO[92usize], entry), + 39usize => (&INFO[94usize], entry), + 40usize => (&INFO[95usize], entry), + 41usize => (&INFO[97usize], entry), 42usize => (&INFO[98usize], entry), - 43usize => (&INFO[99usize], entry), - 44usize => (&INFO[101usize], entry), - 45usize => (&INFO[102usize], entry), - 46usize => (&INFO[103usize], entry), - 47usize => (&INFO[104usize], entry), - 48usize => (&INFO[107usize], entry), - 49usize => (&INFO[108usize], entry), - 50usize => (&INFO[109usize], entry), - 51usize => (&INFO[110usize], entry), - 52usize => (&INFO[113usize], entry), - 53usize => (&INFO[114usize], entry), - 54usize => (&INFO[115usize], entry), - 55usize => (&INFO[118usize], entry), - 56usize => (&INFO[119usize], entry), - 57usize => (&INFO[120usize], entry), - 58usize => (&INFO[126usize], entry), - 59usize => (&INFO[127usize], entry), - 60usize => (&INFO[129usize], entry), - 61usize => (&INFO[130usize], entry), - 62usize => (&INFO[132usize], entry), - 63usize => (&INFO[133usize], entry), - 64usize => (&INFO[135usize], entry), + 43usize => (&INFO[100usize], entry), + 44usize => (&INFO[103usize], entry), + 45usize => (&INFO[104usize], entry), + 46usize => (&INFO[106usize], entry), + 47usize => (&INFO[107usize], entry), + 48usize => (&INFO[108usize], entry), + 49usize => (&INFO[109usize], entry), + 50usize => (&INFO[112usize], entry), + 51usize => (&INFO[113usize], entry), + 52usize => (&INFO[114usize], entry), + 53usize => (&INFO[115usize], entry), + 54usize => (&INFO[118usize], entry), + 55usize => (&INFO[119usize], entry), + 56usize => (&INFO[120usize], entry), + 57usize => (&INFO[123usize], entry), + 58usize => (&INFO[124usize], entry), + 59usize => (&INFO[125usize], entry), + 60usize => (&INFO[131usize], entry), + 61usize => (&INFO[132usize], entry), + 62usize => (&INFO[134usize], entry), + 63usize => (&INFO[135usize], entry), + 64usize => (&INFO[137usize], entry), 65usize => (&INFO[138usize], entry), - 66usize => (&INFO[139usize], entry), - 67usize => (&INFO[150usize], entry), - 68usize => (&INFO[152usize], entry), - 69usize => (&INFO[153usize], entry), - 70usize => (&INFO[156usize], entry), + 66usize => (&INFO[140usize], entry), + 67usize => (&INFO[143usize], entry), + 68usize => (&INFO[144usize], entry), + 69usize => (&INFO[155usize], entry), + 70usize => (&INFO[157usize], entry), 71usize => (&INFO[158usize], entry), - 72usize => (&INFO[160usize], entry), - 73usize => (&INFO[161usize], entry), - 74usize => (&INFO[164usize], entry), + 72usize => (&INFO[161usize], entry), + 73usize => (&INFO[163usize], entry), + 74usize => (&INFO[165usize], entry), 75usize => (&INFO[166usize], entry), - 76usize => (&INFO[167usize], entry), - 77usize => (&INFO[168usize], entry), - 78usize => (&INFO[171usize], entry), + 76usize => (&INFO[169usize], entry), + 77usize => (&INFO[171usize], entry), + 78usize => (&INFO[172usize], entry), 79usize => (&INFO[173usize], entry), - 80usize => (&INFO[174usize], entry), - 81usize => (&INFO[175usize], entry), - 82usize => (&INFO[178usize], entry), + 80usize => (&INFO[176usize], entry), + 81usize => (&INFO[178usize], entry), + 82usize => (&INFO[179usize], entry), 83usize => (&INFO[180usize], entry), - 84usize => (&INFO[181usize], entry), + 84usize => (&INFO[183usize], entry), 85usize => (&INFO[185usize], entry), - 86usize => (&INFO[187usize], entry), - 87usize => (&INFO[188usize], entry), - 88usize => (&INFO[190usize], entry), - 89usize => (&INFO[191usize], entry), - 90usize => (&INFO[202usize], entry), - 91usize => (&INFO[204usize], entry), - 92usize => (&INFO[205usize], entry), - 93usize => (&INFO[206usize], entry), - 94usize => (&INFO[217usize], entry), - 95usize => (&INFO[220usize], entry), - 96usize => (&INFO[232usize], entry), - 97usize => (&INFO[233usize], entry), - 98usize => (&INFO[236usize], entry), - 99usize => (&INFO[262usize], entry), - 100usize => (&INFO[266usize], entry), - 101usize => (&INFO[268usize], entry), - 102usize => (&INFO[269usize], entry), - 103usize => (&INFO[270usize], entry), - 104usize => (&INFO[271usize], entry), - 105usize => (&INFO[272usize], entry), - 106usize => (&INFO[273usize], entry), - 107usize => (&INFO[274usize], entry), - 108usize => (&INFO[275usize], entry), - 109usize => (&INFO[276usize], entry), - 110usize => (&INFO[277usize], entry), - 111usize => (&INFO[278usize], entry), - 112usize => (&INFO[279usize], entry), - 113usize => (&INFO[280usize], entry), - 114usize => (&INFO[281usize], entry), - 115usize => (&INFO[282usize], entry), - 116usize => (&INFO[283usize], entry), + 86usize => (&INFO[186usize], entry), + 87usize => (&INFO[190usize], entry), + 88usize => (&INFO[192usize], entry), + 89usize => (&INFO[193usize], entry), + 90usize => (&INFO[195usize], entry), + 91usize => (&INFO[196usize], entry), + 92usize => (&INFO[207usize], entry), + 93usize => (&INFO[209usize], entry), + 94usize => (&INFO[210usize], entry), + 95usize => (&INFO[211usize], entry), + 96usize => (&INFO[222usize], entry), + 97usize => (&INFO[225usize], entry), + 98usize => (&INFO[237usize], entry), + 99usize => (&INFO[238usize], entry), + 100usize => (&INFO[241usize], entry), + 101usize => (&INFO[267usize], entry), + 102usize => (&INFO[271usize], entry), + 103usize => (&INFO[273usize], entry), + 104usize => (&INFO[274usize], entry), + 105usize => (&INFO[275usize], entry), + 106usize => (&INFO[276usize], entry), + 107usize => (&INFO[277usize], entry), + 108usize => (&INFO[278usize], entry), + 109usize => (&INFO[279usize], entry), + 110usize => (&INFO[280usize], entry), + 111usize => (&INFO[281usize], entry), + 112usize => (&INFO[282usize], entry), + 113usize => (&INFO[283usize], entry), + 114usize => (&INFO[284usize], entry), + 115usize => (&INFO[285usize], entry), + 116usize => (&INFO[286usize], entry), + 117usize => (&INFO[287usize], entry), + 118usize => (&INFO[288usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -2957,19 +2996,20 @@ impl Subscriber { 2usize => (&INFO[21usize], entry), 3usize => (&INFO[24usize], entry), 4usize => (&INFO[26usize], entry), - 5usize => (&INFO[43usize], entry), - 6usize => (&INFO[46usize], entry), - 7usize => (&INFO[48usize], entry), - 8usize => (&INFO[57usize], entry), - 9usize => (&INFO[66usize], entry), - 10usize => (&INFO[72usize], entry), - 11usize => (&INFO[82usize], entry), - 12usize => (&INFO[97usize], entry), - 13usize => (&INFO[106usize], entry), - 14usize => (&INFO[112usize], entry), + 5usize => (&INFO[30usize], entry), + 6usize => (&INFO[48usize], entry), + 7usize => (&INFO[51usize], entry), + 8usize => (&INFO[53usize], entry), + 9usize => (&INFO[62usize], entry), + 10usize => (&INFO[71usize], entry), + 11usize => (&INFO[77usize], entry), + 12usize => (&INFO[87usize], entry), + 13usize => (&INFO[102usize], entry), + 14usize => (&INFO[111usize], entry), 15usize => (&INFO[117usize], entry), - 16usize => (&INFO[123usize], entry), - 17usize => (&INFO[142usize], entry), + 16usize => (&INFO[122usize], entry), + 17usize => (&INFO[128usize], entry), + 18usize => (&INFO[147usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -3004,35 +3044,35 @@ impl event::Subscriber for Subscriber { ) -> Self::ConnectionContext { Self::ConnectionContext { start_time: meta.timestamp, - ctr_12: AtomicU64::new(0), - ctr_15: AtomicU64::new(0), + ctr_14: AtomicU64::new(0), ctr_17: AtomicU64::new(0), - ctr_18: AtomicU64::new(0), - ctr_21: AtomicU64::new(0), + ctr_19: AtomicU64::new(0), + ctr_20: AtomicU64::new(0), ctr_23: AtomicU64::new(0), - ctr_24: AtomicU64::new(0), - ctr_27: AtomicU64::new(0), - ctr_30: AtomicU64::new(0), - ctr_31: AtomicU64::new(0), + ctr_25: AtomicU64::new(0), + ctr_26: AtomicU64::new(0), + ctr_29: AtomicU64::new(0), + ctr_32: AtomicU64::new(0), ctr_33: AtomicU64::new(0), ctr_35: AtomicU64::new(0), - ctr_38: AtomicU64::new(0), - ctr_39: AtomicU64::new(0), - ctr_42: AtomicU64::new(0), - ctr_45: AtomicU64::new(0), + ctr_37: AtomicU64::new(0), + ctr_40: AtomicU64::new(0), + ctr_41: AtomicU64::new(0), + ctr_44: AtomicU64::new(0), ctr_47: AtomicU64::new(0), - ctr_48: AtomicU64::new(0), - ctr_51: AtomicU64::new(0), - ctr_54: AtomicU64::new(0), - ctr_57: AtomicU64::new(0), - ctr_58: AtomicU64::new(0), - ctr_61: AtomicU64::new(0), - ctr_62: AtomicU64::new(0), - ctr_69: AtomicU64::new(0), - ctr_73: AtomicU64::new(0), - ctr_76: AtomicU64::new(0), - ctr_80: AtomicU64::new(0), - ctr_84: AtomicU64::new(0), + ctr_49: AtomicU64::new(0), + ctr_50: AtomicU64::new(0), + ctr_53: AtomicU64::new(0), + ctr_56: AtomicU64::new(0), + ctr_59: AtomicU64::new(0), + ctr_60: AtomicU64::new(0), + ctr_63: AtomicU64::new(0), + ctr_64: AtomicU64::new(0), + ctr_71: AtomicU64::new(0), + ctr_75: AtomicU64::new(0), + ctr_78: AtomicU64::new(0), + ctr_82: AtomicU64::new(0), + ctr_86: AtomicU64::new(0), } } #[inline] @@ -3167,10 +3207,26 @@ impl event::Subscriber for Subscriber { let _ = meta; } #[inline] - fn on_acceptor_udp_started(&self, meta: &api::EndpointMeta, event: &api::AcceptorUdpStarted) { + fn on_acceptor_tcp_socket_sent( + &self, + meta: &api::EndpointMeta, + event: &api::AcceptorTcpSocketSent, + ) { #[allow(unused_imports)] use api::*; self.count(29usize, 10usize, 1usize); + self.time(30usize, 5usize, event.sojourn_time); + self.count(31usize, 11usize, event.blocked_count); + self.measure(32usize, 10usize, event.blocked_count); + self.measure(33usize, 11usize, event.payload_len); + let _ = event; + let _ = meta; + } + #[inline] + fn on_acceptor_udp_started(&self, meta: &api::EndpointMeta, event: &api::AcceptorUdpStarted) { + #[allow(unused_imports)] + use api::*; + self.count(34usize, 12usize, 1usize); let _ = event; let _ = meta; } @@ -3182,8 +3238,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(30usize, 11usize, 1usize); - self.measure(31usize, 10usize, event.len); + self.count(35usize, 13usize, 1usize); + self.measure(36usize, 12usize, event.len); let _ = event; let _ = meta; } @@ -3195,12 +3251,12 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - 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); + self.count(37usize, 14usize, 1usize); + self.measure(38usize, 13usize, event.payload_len); + self.count_bool(39usize, 2usize, event.is_zero_offset); + self.count_bool(40usize, 3usize, event.is_retransmission); + self.count_bool(41usize, 4usize, event.is_fin); + self.count_bool(42usize, 5usize, event.is_fin_known); let _ = event; let _ = meta; } @@ -3212,8 +3268,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(38usize, 13usize, 1usize); - self.count_nominal(39usize, 2usize, &event.reason); + self.count(43usize, 15usize, 1usize); + self.count_nominal(44usize, 2usize, &event.reason); let _ = event; let _ = meta; } @@ -3225,7 +3281,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(40usize, 14usize, 1usize); + self.count(45usize, 16usize, 1usize); let _ = event; let _ = meta; } @@ -3233,7 +3289,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(41usize, 15usize, 1usize); + self.count(46usize, 17usize, 1usize); let _ = event; let _ = meta; } @@ -3245,9 +3301,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(42usize, 16usize, 1usize); - self.time(43usize, 5usize, event.sojourn_time); - self.count_nominal(44usize, 3usize, &event.reason); + self.count(47usize, 18usize, 1usize); + self.time(48usize, 6usize, event.sojourn_time); + self.count_nominal(49usize, 3usize, &event.reason); let _ = event; let _ = meta; } @@ -3259,8 +3315,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(45usize, 17usize, 1usize); - self.time(46usize, 6usize, event.sojourn_time); + self.count(50usize, 19usize, 1usize); + self.time(51usize, 7usize, event.sojourn_time); let _ = event; let _ = meta; } @@ -3273,22 +3329,22 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(47usize, 18usize, 1usize); + self.count(52usize, 20usize, 1usize); self.time( - 48usize, - 7usize, + 53usize, + 8usize, meta.timestamp.saturating_duration_since(context.start_time), ); - context.ctr_12.fetch_add(1, Ordering::Relaxed); - self.measure(50usize, 13usize, event.provided_len); - self.count(51usize, 19usize, event.committed_len); - self.measure(52usize, 14usize, event.committed_len); + context.ctr_14.fetch_add(1, Ordering::Relaxed); + self.measure(55usize, 15usize, event.provided_len); + self.count(56usize, 21usize, event.committed_len); + self.measure(57usize, 16usize, event.committed_len); context - .ctr_15 + .ctr_17 .fetch_add(event.committed_len.as_u64(), Ordering::Relaxed); - self.measure(54usize, 16usize, event.processing_duration); + self.measure(59usize, 18usize, event.processing_duration); context - .ctr_17 + .ctr_19 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3303,22 +3359,22 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(56usize, 20usize, 1usize); + self.count(61usize, 22usize, 1usize); self.time( - 57usize, - 8usize, + 62usize, + 9usize, meta.timestamp.saturating_duration_since(context.start_time), ); - context.ctr_18.fetch_add(1, Ordering::Relaxed); - self.measure(59usize, 19usize, event.provided_len); - self.count(60usize, 21usize, event.committed_len); - self.measure(61usize, 20usize, event.committed_len); + context.ctr_20.fetch_add(1, Ordering::Relaxed); + self.measure(64usize, 21usize, event.provided_len); + self.count(65usize, 23usize, event.committed_len); + self.measure(66usize, 22usize, event.committed_len); context - .ctr_21 + .ctr_23 .fetch_add(event.committed_len.as_u64(), Ordering::Relaxed); - self.measure(63usize, 22usize, event.processing_duration); + self.measure(68usize, 24usize, event.processing_duration); context - .ctr_23 + .ctr_25 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3333,17 +3389,17 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(65usize, 22usize, 1usize); + self.count(70usize, 24usize, 1usize); self.time( - 66usize, - 9usize, + 71usize, + 10usize, meta.timestamp.saturating_duration_since(context.start_time), ); - context.ctr_24.fetch_add(1, Ordering::Relaxed); - self.measure(68usize, 25usize, event.provided_len); - self.measure(69usize, 26usize, event.processing_duration); + context.ctr_26.fetch_add(1, Ordering::Relaxed); + self.measure(73usize, 27usize, event.provided_len); + self.measure(74usize, 28usize, event.processing_duration); context - .ctr_27 + .ctr_29 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3358,16 +3414,16 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(71usize, 23usize, 1usize); + self.count(76usize, 25usize, 1usize); self.time( - 72usize, - 10usize, + 77usize, + 11usize, meta.timestamp.saturating_duration_since(context.start_time), ); - self.measure(73usize, 28usize, event.provided_len); - self.measure(74usize, 29usize, event.processing_duration); + self.measure(78usize, 30usize, event.provided_len); + self.measure(79usize, 31usize, event.processing_duration); context - .ctr_30 + .ctr_32 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3382,7 +3438,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(76usize, 24usize, 1usize); + self.count(81usize, 26usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -3396,11 +3452,11 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(77usize, 25usize, 1usize); - context.ctr_31.fetch_add(1, Ordering::Relaxed); - self.measure(79usize, 32usize, event.allocated_len); + self.count(82usize, 27usize, 1usize); + context.ctr_33.fetch_add(1, Ordering::Relaxed); + self.measure(84usize, 34usize, event.allocated_len); context - .ctr_33 + .ctr_35 .fetch_add(event.allocated_len.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3415,14 +3471,14 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(81usize, 26usize, 1usize); + self.count(86usize, 28usize, 1usize); self.time( - 82usize, - 11usize, + 87usize, + 12usize, meta.timestamp.saturating_duration_since(context.start_time), ); - self.measure(83usize, 34usize, event.buffer_len); - self.count_bool(84usize, 6usize, event.background); + self.measure(88usize, 36usize, event.buffer_len); + self.count_bool(89usize, 6usize, event.background); let _ = context; let _ = meta; let _ = event; @@ -3436,13 +3492,13 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(85usize, 27usize, 1usize); - context.ctr_35.fetch_add(1, Ordering::Relaxed); - self.measure(87usize, 36usize, event.provided_len); - self.count(88usize, 28usize, event.committed_len); - self.measure(89usize, 37usize, event.committed_len); + self.count(90usize, 29usize, 1usize); + context.ctr_37.fetch_add(1, Ordering::Relaxed); + self.measure(92usize, 38usize, event.provided_len); + self.count(93usize, 30usize, event.committed_len); + self.measure(94usize, 39usize, event.committed_len); context - .ctr_38 + .ctr_40 .fetch_add(event.committed_len.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3457,9 +3513,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(91usize, 29usize, 1usize); - context.ctr_39.fetch_add(1, Ordering::Relaxed); - self.measure(93usize, 40usize, event.provided_len); + self.count(96usize, 31usize, 1usize); + context.ctr_41.fetch_add(1, Ordering::Relaxed); + self.measure(98usize, 42usize, event.provided_len); let _ = context; let _ = meta; let _ = event; @@ -3473,8 +3529,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(94usize, 30usize, 1usize); - self.measure(95usize, 41usize, event.provided_len); + self.count(99usize, 32usize, 1usize); + self.measure(100usize, 43usize, event.provided_len); let _ = context; let _ = meta; let _ = event; @@ -3488,22 +3544,22 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(96usize, 31usize, 1usize); + self.count(101usize, 33usize, 1usize); self.time( - 97usize, - 12usize, + 102usize, + 13usize, meta.timestamp.saturating_duration_since(context.start_time), ); - context.ctr_42.fetch_add(1, Ordering::Relaxed); - self.measure(99usize, 43usize, event.capacity); - self.count(100usize, 32usize, event.committed_len); - self.measure(101usize, 44usize, event.committed_len); + context.ctr_44.fetch_add(1, Ordering::Relaxed); + self.measure(104usize, 45usize, event.capacity); + self.count(105usize, 34usize, event.committed_len); + self.measure(106usize, 46usize, event.committed_len); context - .ctr_45 + .ctr_47 .fetch_add(event.committed_len.as_u64(), Ordering::Relaxed); - self.measure(103usize, 46usize, event.processing_duration); + self.measure(108usize, 48usize, event.processing_duration); context - .ctr_47 + .ctr_49 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3518,17 +3574,17 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(105usize, 33usize, 1usize); + self.count(110usize, 35usize, 1usize); self.time( - 106usize, - 13usize, + 111usize, + 14usize, meta.timestamp.saturating_duration_since(context.start_time), ); - context.ctr_48.fetch_add(1, Ordering::Relaxed); - self.measure(108usize, 49usize, event.capacity); - self.measure(109usize, 50usize, event.processing_duration); + context.ctr_50.fetch_add(1, Ordering::Relaxed); + self.measure(113usize, 51usize, event.capacity); + self.measure(114usize, 52usize, event.processing_duration); context - .ctr_51 + .ctr_53 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3543,16 +3599,16 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(111usize, 34usize, 1usize); + self.count(116usize, 36usize, 1usize); self.time( - 112usize, - 14usize, + 117usize, + 15usize, meta.timestamp.saturating_duration_since(context.start_time), ); - self.measure(113usize, 52usize, event.capacity); - self.measure(114usize, 53usize, event.processing_duration); + self.measure(118usize, 54usize, event.capacity); + self.measure(119usize, 55usize, event.processing_duration); context - .ctr_54 + .ctr_56 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3567,16 +3623,16 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(116usize, 35usize, 1usize); + self.count(121usize, 37usize, 1usize); self.time( - 117usize, - 15usize, + 122usize, + 16usize, meta.timestamp.saturating_duration_since(context.start_time), ); - self.measure(118usize, 55usize, event.capacity); - self.measure(119usize, 56usize, event.processing_duration); + self.measure(123usize, 57usize, event.capacity); + self.measure(124usize, 58usize, event.processing_duration); context - .ctr_57 + .ctr_59 .fetch_add(event.processing_duration.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3591,7 +3647,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(121usize, 36usize, 1usize); + self.count(126usize, 38usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -3605,13 +3661,13 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(122usize, 37usize, 1usize); + self.count(127usize, 39usize, 1usize); self.time( - 123usize, - 16usize, + 128usize, + 17usize, meta.timestamp.saturating_duration_since(context.start_time), ); - self.count_bool(124usize, 7usize, event.background); + self.count_bool(129usize, 7usize, event.background); let _ = context; let _ = meta; let _ = event; @@ -3625,13 +3681,13 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(125usize, 38usize, 1usize); - context.ctr_58.fetch_add(1, Ordering::Relaxed); - self.measure(127usize, 59usize, event.capacity); - self.count(128usize, 39usize, event.committed_len); - self.measure(129usize, 60usize, event.committed_len); + self.count(130usize, 40usize, 1usize); + context.ctr_60.fetch_add(1, Ordering::Relaxed); + self.measure(132usize, 61usize, event.capacity); + self.count(133usize, 41usize, event.committed_len); + self.measure(134usize, 62usize, event.committed_len); context - .ctr_61 + .ctr_63 .fetch_add(event.committed_len.as_u64(), Ordering::Relaxed); let _ = context; let _ = meta; @@ -3646,9 +3702,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(131usize, 40usize, 1usize); - context.ctr_62.fetch_add(1, Ordering::Relaxed); - self.measure(133usize, 63usize, event.capacity); + self.count(136usize, 42usize, 1usize); + context.ctr_64.fetch_add(1, Ordering::Relaxed); + self.measure(138usize, 65usize, event.capacity); let _ = context; let _ = meta; let _ = event; @@ -3662,8 +3718,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(134usize, 41usize, 1usize); - self.measure(135usize, 64usize, event.capacity); + self.count(139usize, 43usize, 1usize); + self.measure(140usize, 66usize, event.capacity); let _ = context; let _ = meta; let _ = event; @@ -3677,10 +3733,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(136usize, 42usize, 1usize); - self.count_bool(137usize, 8usize, event.decrypted_in_place); - self.measure(138usize, 65usize, event.forced_copy); - self.measure(139usize, 66usize, event.required_application_buffer); + self.count(141usize, 44usize, 1usize); + self.count_bool(142usize, 8usize, event.decrypted_in_place); + self.measure(143usize, 67usize, event.forced_copy); + self.measure(144usize, 68usize, event.required_application_buffer); let _ = context; let _ = meta; let _ = event; @@ -3689,9 +3745,9 @@ impl event::Subscriber for Subscriber { fn on_stream_tcp_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTcpConnect) { #[allow(unused_imports)] use api::*; - self.count(140usize, 43usize, 1usize); - self.count_bool(141usize, 9usize, event.error); - self.time(142usize, 17usize, event.latency); + self.count(145usize, 45usize, 1usize); + self.count_bool(146usize, 9usize, event.error); + self.time(147usize, 18usize, event.latency); let _ = event; let _ = meta; } @@ -3699,10 +3755,10 @@ impl event::Subscriber for Subscriber { fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { #[allow(unused_imports)] use api::*; - self.count(143usize, 44usize, 1usize); - self.count_bool(144usize, 10usize, event.error); - self.count_nominal(145usize, 4usize, &event.tcp_success); - self.count_nominal(146usize, 5usize, &event.handshake_success); + self.count(148usize, 46usize, 1usize); + self.count_bool(149usize, 10usize, event.error); + self.count_nominal(150usize, 4usize, &event.tcp_success); + self.count_nominal(151usize, 5usize, &event.handshake_success); let _ = event; let _ = meta; } @@ -3710,8 +3766,8 @@ impl event::Subscriber for Subscriber { fn on_stream_connect_error(&self, meta: &api::EndpointMeta, event: &api::StreamConnectError) { #[allow(unused_imports)] use api::*; - self.count(147usize, 45usize, 1usize); - self.count_nominal(148usize, 6usize, &event.reason); + self.count(152usize, 47usize, 1usize); + self.count_nominal(153usize, 6usize, &event.reason); let _ = event; let _ = meta; } @@ -3724,14 +3780,14 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(149usize, 46usize, 1usize); - self.measure(150usize, 67usize, event.packet_len); - self.count(151usize, 47usize, event.payload_len); - self.measure(152usize, 68usize, event.payload_len); + self.count(154usize, 48usize, 1usize); + self.measure(155usize, 69usize, event.packet_len); + self.count(156usize, 49usize, event.payload_len); + self.measure(157usize, 70usize, event.payload_len); context - .ctr_69 + .ctr_71 .fetch_add(event.payload_len.as_u64(), Ordering::Relaxed); - self.count_bool(154usize, 11usize, event.is_retransmission); + self.count_bool(159usize, 11usize, event.is_retransmission); let _ = context; let _ = meta; let _ = event; @@ -3745,8 +3801,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(155usize, 48usize, 1usize); - self.measure(156usize, 70usize, event.packet_len); + self.count(160usize, 50usize, 1usize); + self.measure(161usize, 72usize, event.packet_len); let _ = context; let _ = meta; let _ = event; @@ -3760,14 +3816,14 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(157usize, 49usize, 1usize); - self.measure(158usize, 71usize, event.packet_len); - self.count(159usize, 50usize, event.payload_len); - self.measure(160usize, 72usize, event.payload_len); + self.count(162usize, 51usize, 1usize); + self.measure(163usize, 73usize, event.packet_len); + self.count(164usize, 52usize, event.payload_len); + self.measure(165usize, 74usize, event.payload_len); context - .ctr_73 + .ctr_75 .fetch_add(event.payload_len.as_u64(), Ordering::Relaxed); - self.count_bool(162usize, 12usize, event.is_retransmission); + self.count_bool(167usize, 12usize, event.is_retransmission); let _ = context; let _ = meta; let _ = event; @@ -3781,15 +3837,15 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(163usize, 51usize, 1usize); - self.measure(164usize, 74usize, event.packet_len); - self.count(165usize, 52usize, event.payload_len); - self.measure(166usize, 75usize, event.payload_len); + self.count(168usize, 53usize, 1usize); + self.measure(169usize, 76usize, event.packet_len); + self.count(170usize, 54usize, event.payload_len); + self.measure(171usize, 77usize, event.payload_len); context - .ctr_76 + .ctr_78 .fetch_add(event.payload_len.as_u64(), Ordering::Relaxed); - self.measure(168usize, 77usize, event.lifetime); - self.count_bool(169usize, 13usize, event.is_retransmission); + self.measure(173usize, 79usize, event.lifetime); + self.count_bool(174usize, 13usize, event.is_retransmission); let _ = context; let _ = meta; let _ = event; @@ -3803,15 +3859,15 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(170usize, 53usize, 1usize); - self.measure(171usize, 78usize, event.packet_len); - self.count(172usize, 54usize, event.payload_len); - self.measure(173usize, 79usize, event.payload_len); + self.count(175usize, 55usize, 1usize); + self.measure(176usize, 80usize, event.packet_len); + self.count(177usize, 56usize, event.payload_len); + self.measure(178usize, 81usize, event.payload_len); context - .ctr_80 + .ctr_82 .fetch_add(event.payload_len.as_u64(), Ordering::Relaxed); - self.measure(175usize, 81usize, event.lifetime); - self.count_bool(176usize, 14usize, event.is_retransmission); + self.measure(180usize, 83usize, event.lifetime); + self.count_bool(181usize, 14usize, event.is_retransmission); let _ = context; let _ = meta; let _ = event; @@ -3825,14 +3881,14 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(177usize, 55usize, 1usize); - self.measure(178usize, 82usize, event.packet_len); - self.count(179usize, 56usize, event.payload_len); - self.measure(180usize, 83usize, event.payload_len); + self.count(182usize, 57usize, 1usize); + self.measure(183usize, 84usize, event.packet_len); + self.count(184usize, 58usize, event.payload_len); + self.measure(185usize, 85usize, event.payload_len); context - .ctr_84 + .ctr_86 .fetch_add(event.payload_len.as_u64(), Ordering::Relaxed); - self.count_bool(182usize, 15usize, event.is_retransmission); + self.count_bool(187usize, 15usize, event.is_retransmission); let _ = context; let _ = meta; let _ = event; @@ -3846,9 +3902,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(183usize, 57usize, 1usize); - self.count(184usize, 58usize, event.increase); - self.measure(185usize, 85usize, event.increase); + self.count(188usize, 59usize, 1usize); + self.count(189usize, 60usize, event.increase); + self.measure(190usize, 87usize, event.increase); let _ = context; let _ = meta; let _ = event; @@ -3862,9 +3918,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(186usize, 59usize, 1usize); - self.measure(187usize, 86usize, event.packet_len); - self.measure(188usize, 87usize, event.control_data_len); + self.count(191usize, 61usize, 1usize); + self.measure(192usize, 88usize, event.packet_len); + self.measure(193usize, 89usize, event.control_data_len); let _ = context; let _ = meta; let _ = event; @@ -3878,10 +3934,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(189usize, 60usize, 1usize); - self.measure(190usize, 88usize, event.packet_len); - self.measure(191usize, 89usize, event.control_data_len); - self.count_bool(192usize, 16usize, event.is_authenticated); + self.count(194usize, 62usize, 1usize); + self.measure(195usize, 90usize, event.packet_len); + self.measure(196usize, 91usize, event.control_data_len); + self.count_bool(197usize, 16usize, event.is_authenticated); let _ = context; let _ = meta; let _ = event; @@ -3895,7 +3951,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(193usize, 61usize, 1usize); + self.count(198usize, 63usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -3909,7 +3965,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(194usize, 62usize, 1usize); + self.count(199usize, 64usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -3923,68 +3979,68 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(195usize, 63usize, 1usize); - self.measure(49usize, 12usize, context.ctr_12.load(Ordering::Relaxed)); - self.measure(53usize, 15usize, context.ctr_15.load(Ordering::Relaxed)); - self.measure( - 55usize, - 17usize, - core::time::Duration::from_micros(context.ctr_17.load(Ordering::Relaxed)), - ); - self.measure(58usize, 18usize, context.ctr_18.load(Ordering::Relaxed)); - self.measure(62usize, 21usize, context.ctr_21.load(Ordering::Relaxed)); + self.count(200usize, 65usize, 1usize); + self.measure(54usize, 14usize, context.ctr_14.load(Ordering::Relaxed)); + self.measure(58usize, 17usize, context.ctr_17.load(Ordering::Relaxed)); self.measure( - 64usize, - 23usize, - core::time::Duration::from_micros(context.ctr_23.load(Ordering::Relaxed)), + 60usize, + 19usize, + core::time::Duration::from_micros(context.ctr_19.load(Ordering::Relaxed)), ); - self.measure(67usize, 24usize, context.ctr_24.load(Ordering::Relaxed)); + self.measure(63usize, 20usize, context.ctr_20.load(Ordering::Relaxed)); + self.measure(67usize, 23usize, context.ctr_23.load(Ordering::Relaxed)); self.measure( - 70usize, - 27usize, - core::time::Duration::from_micros(context.ctr_27.load(Ordering::Relaxed)), + 69usize, + 25usize, + core::time::Duration::from_micros(context.ctr_25.load(Ordering::Relaxed)), ); + self.measure(72usize, 26usize, context.ctr_26.load(Ordering::Relaxed)); self.measure( 75usize, - 30usize, - core::time::Duration::from_micros(context.ctr_30.load(Ordering::Relaxed)), + 29usize, + core::time::Duration::from_micros(context.ctr_29.load(Ordering::Relaxed)), ); - self.measure(78usize, 31usize, context.ctr_31.load(Ordering::Relaxed)); - self.measure(80usize, 33usize, context.ctr_33.load(Ordering::Relaxed)); - self.measure(86usize, 35usize, context.ctr_35.load(Ordering::Relaxed)); - self.measure(90usize, 38usize, context.ctr_38.load(Ordering::Relaxed)); - self.measure(92usize, 39usize, context.ctr_39.load(Ordering::Relaxed)); - self.measure(98usize, 42usize, context.ctr_42.load(Ordering::Relaxed)); - self.measure(102usize, 45usize, context.ctr_45.load(Ordering::Relaxed)); self.measure( - 104usize, - 47usize, - core::time::Duration::from_micros(context.ctr_47.load(Ordering::Relaxed)), + 80usize, + 32usize, + core::time::Duration::from_micros(context.ctr_32.load(Ordering::Relaxed)), ); - self.measure(107usize, 48usize, context.ctr_48.load(Ordering::Relaxed)); + self.measure(83usize, 33usize, context.ctr_33.load(Ordering::Relaxed)); + self.measure(85usize, 35usize, context.ctr_35.load(Ordering::Relaxed)); + self.measure(91usize, 37usize, context.ctr_37.load(Ordering::Relaxed)); + self.measure(95usize, 40usize, context.ctr_40.load(Ordering::Relaxed)); + self.measure(97usize, 41usize, context.ctr_41.load(Ordering::Relaxed)); + self.measure(103usize, 44usize, context.ctr_44.load(Ordering::Relaxed)); + self.measure(107usize, 47usize, context.ctr_47.load(Ordering::Relaxed)); self.measure( - 110usize, - 51usize, - core::time::Duration::from_micros(context.ctr_51.load(Ordering::Relaxed)), + 109usize, + 49usize, + core::time::Duration::from_micros(context.ctr_49.load(Ordering::Relaxed)), ); + self.measure(112usize, 50usize, context.ctr_50.load(Ordering::Relaxed)); self.measure( 115usize, - 54usize, - core::time::Duration::from_micros(context.ctr_54.load(Ordering::Relaxed)), + 53usize, + core::time::Duration::from_micros(context.ctr_53.load(Ordering::Relaxed)), ); self.measure( 120usize, - 57usize, - core::time::Duration::from_micros(context.ctr_57.load(Ordering::Relaxed)), + 56usize, + core::time::Duration::from_micros(context.ctr_56.load(Ordering::Relaxed)), ); - self.measure(126usize, 58usize, context.ctr_58.load(Ordering::Relaxed)); - self.measure(130usize, 61usize, context.ctr_61.load(Ordering::Relaxed)); - self.measure(132usize, 62usize, context.ctr_62.load(Ordering::Relaxed)); - self.measure(153usize, 69usize, context.ctr_69.load(Ordering::Relaxed)); - self.measure(161usize, 73usize, context.ctr_73.load(Ordering::Relaxed)); - self.measure(167usize, 76usize, context.ctr_76.load(Ordering::Relaxed)); - self.measure(174usize, 80usize, context.ctr_80.load(Ordering::Relaxed)); - self.measure(181usize, 84usize, context.ctr_84.load(Ordering::Relaxed)); + self.measure( + 125usize, + 59usize, + core::time::Duration::from_micros(context.ctr_59.load(Ordering::Relaxed)), + ); + self.measure(131usize, 60usize, context.ctr_60.load(Ordering::Relaxed)); + self.measure(135usize, 63usize, context.ctr_63.load(Ordering::Relaxed)); + self.measure(137usize, 64usize, context.ctr_64.load(Ordering::Relaxed)); + self.measure(158usize, 71usize, context.ctr_71.load(Ordering::Relaxed)); + self.measure(166usize, 75usize, context.ctr_75.load(Ordering::Relaxed)); + self.measure(172usize, 78usize, context.ctr_78.load(Ordering::Relaxed)); + self.measure(179usize, 82usize, context.ctr_82.load(Ordering::Relaxed)); + self.measure(186usize, 86usize, context.ctr_86.load(Ordering::Relaxed)); let _ = context; let _ = meta; let _ = event; @@ -3993,11 +4049,11 @@ impl event::Subscriber for Subscriber { fn on_endpoint_initialized(&self, meta: &api::EndpointMeta, event: &api::EndpointInitialized) { #[allow(unused_imports)] use api::*; - self.count(196usize, 64usize, 1usize); - self.count_nominal(197usize, 7usize, &event.acceptor_addr); - self.count_nominal(198usize, 8usize, &event.handshake_addr); - self.count_bool(199usize, 17usize, event.tcp); - self.count_bool(200usize, 18usize, event.udp); + self.count(201usize, 66usize, 1usize); + self.count_nominal(202usize, 7usize, &event.acceptor_addr); + self.count_nominal(203usize, 8usize, &event.handshake_addr); + self.count_bool(204usize, 17usize, event.tcp); + self.count_bool(205usize, 18usize, event.udp); let _ = event; let _ = meta; } @@ -4009,8 +4065,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(201usize, 65usize, 1usize); - self.measure(202usize, 90usize, event.capacity); + self.count(206usize, 67usize, 1usize); + self.measure(207usize, 92usize, event.capacity); let _ = event; let _ = meta; } @@ -4022,10 +4078,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(203usize, 66usize, 1usize); - self.measure(204usize, 91usize, event.capacity); - self.measure(205usize, 92usize, event.entries); - self.measure(206usize, 93usize, event.lifetime); + self.count(208usize, 68usize, 1usize); + self.measure(209usize, 93usize, event.capacity); + self.measure(210usize, 94usize, event.entries); + self.measure(211usize, 95usize, event.lifetime); let _ = event; let _ = meta; } @@ -4037,8 +4093,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(207usize, 67usize, 1usize); - self.count_nominal(208usize, 9usize, &event.peer_address); + self.count(212usize, 69usize, 1usize); + self.count_nominal(213usize, 9usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4050,8 +4106,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(209usize, 68usize, 1usize); - self.count_nominal(210usize, 10usize, &event.peer_address); + self.count(214usize, 70usize, 1usize); + self.count_nominal(215usize, 10usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4063,8 +4119,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(211usize, 69usize, 1usize); - self.count_nominal(212usize, 11usize, &event.peer_address); + self.count(216usize, 71usize, 1usize); + self.count_nominal(217usize, 11usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4076,8 +4132,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(213usize, 70usize, 1usize); - self.count_nominal(214usize, 12usize, &event.peer_address); + self.count(218usize, 72usize, 1usize); + self.count_nominal(219usize, 12usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4089,9 +4145,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(215usize, 71usize, 1usize); - self.count_nominal(216usize, 13usize, &event.peer_address); - self.measure(217usize, 94usize, event.age); + self.count(220usize, 73usize, 1usize); + self.count_nominal(221usize, 13usize, &event.peer_address); + self.measure(222usize, 96usize, event.age); let _ = event; let _ = meta; } @@ -4103,9 +4159,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(218usize, 72usize, 1usize); - self.count_nominal(219usize, 14usize, &event.peer_address); - self.measure(220usize, 95usize, event.age); + self.count(223usize, 74usize, 1usize); + self.count_nominal(224usize, 14usize, &event.peer_address); + self.measure(225usize, 97usize, event.age); let _ = event; let _ = meta; } @@ -4117,8 +4173,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(221usize, 73usize, 1usize); - self.count_nominal(222usize, 15usize, &event.peer_address); + self.count(226usize, 75usize, 1usize); + self.count_nominal(227usize, 15usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4130,8 +4186,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(223usize, 74usize, 1usize); - self.count_nominal(224usize, 16usize, &event.peer_address); + self.count(228usize, 76usize, 1usize); + self.count_nominal(229usize, 16usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4143,8 +4199,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(225usize, 75usize, 1usize); - self.count_nominal(226usize, 17usize, &event.peer_address); + self.count(230usize, 77usize, 1usize); + self.count_nominal(231usize, 17usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4156,8 +4212,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(227usize, 76usize, 1usize); - self.count_nominal(228usize, 18usize, &event.peer_address); + self.count(232usize, 78usize, 1usize); + self.count_nominal(233usize, 18usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4169,8 +4225,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(229usize, 77usize, 1usize); - self.count_nominal(230usize, 19usize, &event.peer_address); + self.count(234usize, 79usize, 1usize); + self.count_nominal(235usize, 19usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4178,9 +4234,9 @@ impl event::Subscriber for Subscriber { fn on_key_accepted(&self, meta: &api::EndpointMeta, event: &api::KeyAccepted) { #[allow(unused_imports)] use api::*; - self.count(231usize, 78usize, 1usize); - self.measure(232usize, 96usize, event.gap); - self.measure(233usize, 97usize, event.forward_shift); + self.count(236usize, 80usize, 1usize); + self.measure(237usize, 98usize, event.gap); + self.measure(238usize, 99usize, event.forward_shift); let _ = event; let _ = meta; } @@ -4192,7 +4248,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(234usize, 79usize, 1usize); + self.count(239usize, 81usize, 1usize); let _ = event; let _ = meta; } @@ -4204,8 +4260,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(235usize, 80usize, 1usize); - self.measure(236usize, 98usize, event.gap); + self.count(240usize, 82usize, 1usize); + self.measure(241usize, 100usize, event.gap); let _ = event; let _ = meta; } @@ -4217,8 +4273,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(237usize, 81usize, 1usize); - self.count_nominal(238usize, 20usize, &event.peer_address); + self.count(242usize, 83usize, 1usize); + self.count_nominal(243usize, 20usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4230,8 +4286,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(239usize, 82usize, 1usize); - self.count_nominal(240usize, 21usize, &event.peer_address); + self.count(244usize, 84usize, 1usize); + self.count_nominal(245usize, 21usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4243,8 +4299,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(241usize, 83usize, 1usize); - self.count_nominal(242usize, 22usize, &event.peer_address); + self.count(246usize, 85usize, 1usize); + self.count_nominal(247usize, 22usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4256,8 +4312,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(243usize, 84usize, 1usize); - self.count_nominal(244usize, 23usize, &event.peer_address); + self.count(248usize, 86usize, 1usize); + self.count_nominal(249usize, 23usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4269,8 +4325,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(245usize, 85usize, 1usize); - self.count_nominal(246usize, 24usize, &event.peer_address); + self.count(250usize, 87usize, 1usize); + self.count_nominal(251usize, 24usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4278,8 +4334,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(247usize, 86usize, 1usize); - self.count_nominal(248usize, 25usize, &event.peer_address); + self.count(252usize, 88usize, 1usize); + self.count_nominal(253usize, 25usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4291,8 +4347,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(249usize, 87usize, 1usize); - self.count_nominal(250usize, 26usize, &event.peer_address); + self.count(254usize, 89usize, 1usize); + self.count_nominal(255usize, 26usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4304,8 +4360,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(251usize, 88usize, 1usize); - self.count_nominal(252usize, 27usize, &event.peer_address); + self.count(256usize, 90usize, 1usize); + self.count_nominal(257usize, 27usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4317,8 +4373,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(253usize, 89usize, 1usize); - self.count_nominal(254usize, 28usize, &event.peer_address); + self.count(258usize, 91usize, 1usize); + self.count_nominal(259usize, 28usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4330,8 +4386,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(255usize, 90usize, 1usize); - self.count_nominal(256usize, 29usize, &event.peer_address); + self.count(260usize, 92usize, 1usize); + self.count_nominal(261usize, 29usize, &event.peer_address); let _ = event; let _ = meta; } @@ -4343,9 +4399,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(257usize, 91usize, 1usize); - self.count_nominal(258usize, 30usize, &event.peer_address); - self.count_bool(259usize, 19usize, event.hit); + self.count(262usize, 93usize, 1usize); + self.count_nominal(263usize, 30usize, &event.peer_address); + self.count_bool(264usize, 19usize, event.hit); let _ = event; let _ = meta; } @@ -4357,9 +4413,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(260usize, 92usize, 1usize); - self.count_nominal(261usize, 31usize, &event.peer_address); - self.measure(262usize, 99usize, event.age); + self.count(265usize, 94usize, 1usize); + self.count_nominal(266usize, 31usize, &event.peer_address); + self.measure(267usize, 101usize, event.age); let _ = event; let _ = meta; } @@ -4371,8 +4427,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(263usize, 93usize, 1usize); - self.count_bool(264usize, 20usize, event.hit); + self.count(268usize, 95usize, 1usize); + self.count_bool(269usize, 20usize, event.hit); let _ = event; let _ = meta; } @@ -4384,8 +4440,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(265usize, 94usize, 1usize); - self.measure(266usize, 100usize, event.age); + self.count(270usize, 96usize, 1usize); + self.measure(271usize, 102usize, event.age); let _ = event; let _ = meta; } @@ -4397,27 +4453,27 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(267usize, 95usize, 1usize); - self.measure(268usize, 101usize, event.id_entries); - self.measure(269usize, 102usize, event.id_entries_retired); - self.measure(270usize, 103usize, event.id_entries_active); - self.measure(271usize, 104usize, event.id_entries_active_utilization); - self.measure(272usize, 105usize, event.id_entries_utilization); - self.measure(273usize, 106usize, event.id_entries_initial_utilization); - self.measure(274usize, 107usize, event.address_entries); - self.measure(275usize, 108usize, event.address_entries_active); - self.measure(276usize, 109usize, event.address_entries_active_utilization); - self.measure(277usize, 110usize, event.address_entries_retired); - self.measure(278usize, 111usize, event.address_entries_utilization); + self.count(272usize, 97usize, 1usize); + self.measure(273usize, 103usize, event.id_entries); + self.measure(274usize, 104usize, event.id_entries_retired); + self.measure(275usize, 105usize, event.id_entries_active); + self.measure(276usize, 106usize, event.id_entries_active_utilization); + self.measure(277usize, 107usize, event.id_entries_utilization); + self.measure(278usize, 108usize, event.id_entries_initial_utilization); + self.measure(279usize, 109usize, event.address_entries); + self.measure(280usize, 110usize, event.address_entries_active); + self.measure(281usize, 111usize, event.address_entries_active_utilization); + self.measure(282usize, 112usize, event.address_entries_retired); + self.measure(283usize, 113usize, event.address_entries_utilization); self.measure( - 279usize, - 112usize, + 284usize, + 114usize, event.address_entries_initial_utilization, ); - self.measure(280usize, 113usize, event.handshake_requests); - self.measure(281usize, 114usize, event.handshake_requests_retired); - self.measure(282usize, 115usize, event.handshake_lock_duration); - self.measure(283usize, 116usize, event.duration); + self.measure(285usize, 115usize, event.handshake_requests); + self.measure(286usize, 116usize, event.handshake_requests_retired); + self.measure(287usize, 117usize, event.handshake_lock_duration); + self.measure(288usize, 118usize, event.duration); 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 e5817d3950..5f617a1bef 100644 --- a/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs +++ b/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs @@ -27,92 +27,94 @@ mod counter { 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(stream_write_flushed), - 51usize => Self(stream_write_flushed__committed__total), - 56usize => Self(stream_write_fin_flushed), - 60usize => Self(stream_write_fin_flushed__committed__total), - 65usize => Self(stream_write_blocked), - 71usize => Self(stream_write_errored), - 76usize => Self(stream_write_key_updated), - 77usize => Self(stream_write_allocated), - 81usize => Self(stream_write_shutdown), - 85usize => Self(stream_write_socket_flushed), - 88usize => Self(stream_write_socket_flushed__committed__total), - 91usize => Self(stream_write_socket_blocked), - 94usize => Self(stream_write_socket_errored), - 96usize => Self(stream_read_flushed), - 100usize => Self(stream_read_flushed__committed__total), - 105usize => Self(stream_read_fin_flushed), - 111usize => Self(stream_read_blocked), - 116usize => Self(stream_read_errored), - 121usize => Self(stream_read_key_updated), - 122usize => Self(stream_read_shutdown), - 125usize => Self(stream_read_socket_flushed), - 128usize => Self(stream_read_socket_flushed__committed__total), - 131usize => Self(stream_read_socket_blocked), - 134usize => Self(stream_read_socket_errored), - 136usize => Self(stream_decrypt_packet), - 140usize => Self(stream_tcp_connect), - 143usize => Self(stream_connect), - 147usize => Self(stream_connect_error), - 149usize => Self(stream_packet_transmitted), - 151usize => Self(stream_packet_transmitted__payload_len__total), - 155usize => Self(stream_probe_transmitted), - 157usize => Self(stream_packet_received), - 159usize => Self(stream_packet_received__payload_len__total), - 163usize => Self(stream_packet_lost), - 165usize => Self(stream_packet_lost__payload_len__total), - 170usize => Self(stream_packet_acked), - 172usize => Self(stream_packet_acked__payload_len__total), - 177usize => Self(stream_packet_spuriously_retransmitted), - 179usize => Self(stream_packet_spuriously_retransmitted__payload_len__total), - 183usize => Self(stream_max_data_received), - 184usize => Self(stream_max_data_received__increase__total), - 186usize => Self(stream_control_packet_transmitted), - 189usize => Self(stream_control_packet_received), - 193usize => Self(stream_receiver_errored), - 194usize => Self(stream_sender_errored), - 195usize => Self(connection_closed), - 196usize => Self(endpoint_initialized), - 201usize => Self(path_secret_map_initialized), - 203usize => Self(path_secret_map_uninitialized), - 207usize => Self(path_secret_map_background_handshake_requested), - 209usize => Self(path_secret_map_entry_inserted), - 211usize => Self(path_secret_map_entry_ready), - 213usize => Self(path_secret_map_entry_replaced), - 215usize => Self(path_secret_map_id_entry_evicted), - 218usize => Self(path_secret_map_address_entry_evicted), - 221usize => Self(unknown_path_secret_packet_sent), - 223usize => Self(unknown_path_secret_packet_received), - 225usize => Self(unknown_path_secret_packet_accepted), - 227usize => Self(unknown_path_secret_packet_rejected), - 229usize => Self(unknown_path_secret_packet_dropped), - 231usize => Self(key_accepted), - 234usize => Self(replay_definitely_detected), - 235usize => Self(replay_potentially_detected), - 237usize => Self(replay_detected_packet_sent), - 239usize => Self(replay_detected_packet_received), - 241usize => Self(replay_detected_packet_accepted), - 243usize => Self(replay_detected_packet_rejected), - 245usize => Self(replay_detected_packet_dropped), - 247usize => Self(stale_key_packet_sent), - 249usize => Self(stale_key_packet_received), - 251usize => Self(stale_key_packet_accepted), - 253usize => Self(stale_key_packet_rejected), - 255usize => Self(stale_key_packet_dropped), - 257usize => Self(path_secret_map_address_cache_accessed), - 260usize => Self(path_secret_map_address_cache_accessed_hit), - 263usize => Self(path_secret_map_id_cache_accessed), - 265usize => Self(path_secret_map_id_cache_accessed_hit), - 267usize => Self(path_secret_map_cleaner_cycled), + 29usize => Self(acceptor_tcp_socket_sent), + 31usize => Self(acceptor_tcp_socket_sent__blocked_count_host), + 34usize => Self(acceptor_udp_started), + 35usize => Self(acceptor_udp_datagram_received), + 37usize => Self(acceptor_udp_packet_received), + 43usize => Self(acceptor_udp_packet_dropped), + 45usize => Self(acceptor_udp_stream_enqueued), + 46usize => Self(acceptor_udp_io_error), + 47usize => Self(acceptor_stream_pruned), + 50usize => Self(acceptor_stream_dequeued), + 52usize => Self(stream_write_flushed), + 56usize => Self(stream_write_flushed__committed__total), + 61usize => Self(stream_write_fin_flushed), + 65usize => Self(stream_write_fin_flushed__committed__total), + 70usize => Self(stream_write_blocked), + 76usize => Self(stream_write_errored), + 81usize => Self(stream_write_key_updated), + 82usize => Self(stream_write_allocated), + 86usize => Self(stream_write_shutdown), + 90usize => Self(stream_write_socket_flushed), + 93usize => Self(stream_write_socket_flushed__committed__total), + 96usize => Self(stream_write_socket_blocked), + 99usize => Self(stream_write_socket_errored), + 101usize => Self(stream_read_flushed), + 105usize => Self(stream_read_flushed__committed__total), + 110usize => Self(stream_read_fin_flushed), + 116usize => Self(stream_read_blocked), + 121usize => Self(stream_read_errored), + 126usize => Self(stream_read_key_updated), + 127usize => Self(stream_read_shutdown), + 130usize => Self(stream_read_socket_flushed), + 133usize => Self(stream_read_socket_flushed__committed__total), + 136usize => Self(stream_read_socket_blocked), + 139usize => Self(stream_read_socket_errored), + 141usize => Self(stream_decrypt_packet), + 145usize => Self(stream_tcp_connect), + 148usize => Self(stream_connect), + 152usize => Self(stream_connect_error), + 154usize => Self(stream_packet_transmitted), + 156usize => Self(stream_packet_transmitted__payload_len__total), + 160usize => Self(stream_probe_transmitted), + 162usize => Self(stream_packet_received), + 164usize => Self(stream_packet_received__payload_len__total), + 168usize => Self(stream_packet_lost), + 170usize => Self(stream_packet_lost__payload_len__total), + 175usize => Self(stream_packet_acked), + 177usize => Self(stream_packet_acked__payload_len__total), + 182usize => Self(stream_packet_spuriously_retransmitted), + 184usize => Self(stream_packet_spuriously_retransmitted__payload_len__total), + 188usize => Self(stream_max_data_received), + 189usize => Self(stream_max_data_received__increase__total), + 191usize => Self(stream_control_packet_transmitted), + 194usize => Self(stream_control_packet_received), + 198usize => Self(stream_receiver_errored), + 199usize => Self(stream_sender_errored), + 200usize => Self(connection_closed), + 201usize => Self(endpoint_initialized), + 206usize => Self(path_secret_map_initialized), + 208usize => Self(path_secret_map_uninitialized), + 212usize => Self(path_secret_map_background_handshake_requested), + 214usize => Self(path_secret_map_entry_inserted), + 216usize => Self(path_secret_map_entry_ready), + 218usize => Self(path_secret_map_entry_replaced), + 220usize => Self(path_secret_map_id_entry_evicted), + 223usize => Self(path_secret_map_address_entry_evicted), + 226usize => Self(unknown_path_secret_packet_sent), + 228usize => Self(unknown_path_secret_packet_received), + 230usize => Self(unknown_path_secret_packet_accepted), + 232usize => Self(unknown_path_secret_packet_rejected), + 234usize => Self(unknown_path_secret_packet_dropped), + 236usize => Self(key_accepted), + 239usize => Self(replay_definitely_detected), + 240usize => Self(replay_potentially_detected), + 242usize => Self(replay_detected_packet_sent), + 244usize => Self(replay_detected_packet_received), + 246usize => Self(replay_detected_packet_accepted), + 248usize => Self(replay_detected_packet_rejected), + 250usize => Self(replay_detected_packet_dropped), + 252usize => Self(stale_key_packet_sent), + 254usize => Self(stale_key_packet_received), + 256usize => Self(stale_key_packet_accepted), + 258usize => Self(stale_key_packet_rejected), + 260usize => Self(stale_key_packet_dropped), + 262usize => Self(path_secret_map_address_cache_accessed), + 265usize => Self(path_secret_map_address_cache_accessed_hit), + 268usize => Self(path_secret_map_id_cache_accessed), + 270usize => Self(path_secret_map_id_cache_accessed_hit), + 272usize => Self(path_secret_map_cleaner_cycled), _ => unreachable!("invalid info: {info:?}"), } } @@ -144,6 +146,10 @@ mod counter { fn acceptor_tcp_stream_enqueued(value: u64); # [link_name = s2n_quic_dc__event__counter__acceptor_tcp_io_error] fn acceptor_tcp_io_error(value: u64); + # [link_name = s2n_quic_dc__event__counter__acceptor_tcp_socket_sent] + fn acceptor_tcp_socket_sent(value: u64); + # [link_name = s2n_quic_dc__event__counter__acceptor_tcp_socket_sent__blocked_count_host] + fn acceptor_tcp_socket_sent__blocked_count_host(value: u64); # [link_name = s2n_quic_dc__event__counter__acceptor_udp_started] fn acceptor_udp_started(value: u64); # [link_name = s2n_quic_dc__event__counter__acceptor_udp_datagram_received] @@ -327,25 +333,25 @@ mod counter { match info.id { 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_retransmission), - 36usize => Self(acceptor_udp_packet_received__is_fin), - 37usize => Self(acceptor_udp_packet_received__is_fin_known), - 84usize => Self(stream_write_shutdown__background), - 124usize => Self(stream_read_shutdown__background), - 137usize => Self(stream_decrypt_packet__decrypted_in_place), - 141usize => Self(stream_tcp_connect__error), - 144usize => Self(stream_connect__error), - 154usize => Self(stream_packet_transmitted__retransmission), - 162usize => Self(stream_packet_received__retransmission), - 169usize => Self(stream_packet_lost__retransmission), - 176usize => Self(stream_packet_acked__retransmission), - 182usize => Self(stream_packet_spuriously_retransmitted__retransmission), - 192usize => Self(stream_control_packet_received__authenticated), - 199usize => Self(endpoint_initialized__tcp), - 200usize => Self(endpoint_initialized__udp), - 259usize => Self(path_secret_map_address_cache_accessed__hit), - 264usize => Self(path_secret_map_id_cache_accessed__hit), + 39usize => Self(acceptor_udp_packet_received__is_zero_offset), + 40usize => Self(acceptor_udp_packet_received__is_retransmission), + 41usize => Self(acceptor_udp_packet_received__is_fin), + 42usize => Self(acceptor_udp_packet_received__is_fin_known), + 89usize => Self(stream_write_shutdown__background), + 129usize => Self(stream_read_shutdown__background), + 142usize => Self(stream_decrypt_packet__decrypted_in_place), + 146usize => Self(stream_tcp_connect__error), + 149usize => Self(stream_connect__error), + 159usize => Self(stream_packet_transmitted__retransmission), + 167usize => Self(stream_packet_received__retransmission), + 174usize => Self(stream_packet_lost__retransmission), + 181usize => Self(stream_packet_acked__retransmission), + 187usize => Self(stream_packet_spuriously_retransmitted__retransmission), + 197usize => Self(stream_control_packet_received__authenticated), + 204usize => Self(endpoint_initialized__tcp), + 205usize => Self(endpoint_initialized__udp), + 264usize => Self(path_secret_map_address_cache_accessed__hit), + 269usize => Self(path_secret_map_id_cache_accessed__hit), _ => unreachable!("invalid info: {info:?}"), } } @@ -412,40 +418,40 @@ mod counter { match info.id { 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), - 145usize => Self(stream_connect__tcp), - 146usize => Self(stream_connect__handshake), - 148usize => Self(stream_connect_error__reason), - 197usize => Self(endpoint_initialized__acceptor__protocol), - 198usize => Self(endpoint_initialized__handshake__protocol), - 208usize => { + 44usize => Self(acceptor_udp_packet_dropped__reason), + 49usize => Self(acceptor_stream_pruned__reason), + 150usize => Self(stream_connect__tcp), + 151usize => Self(stream_connect__handshake), + 153usize => Self(stream_connect_error__reason), + 202usize => Self(endpoint_initialized__acceptor__protocol), + 203usize => Self(endpoint_initialized__handshake__protocol), + 213usize => { Self(path_secret_map_background_handshake_requested__peer_address__protocol) } - 210usize => Self(path_secret_map_entry_inserted__peer_address__protocol), - 212usize => Self(path_secret_map_entry_ready__peer_address__protocol), - 214usize => Self(path_secret_map_entry_replaced__peer_address__protocol), - 216usize => Self(path_secret_map_id_entry_evicted__peer_address__protocol), - 219usize => Self(path_secret_map_address_entry_evicted__peer_address__protocol), - 222usize => Self(unknown_path_secret_packet_sent__peer_address__protocol), - 224usize => Self(unknown_path_secret_packet_received__peer_address__protocol), - 226usize => Self(unknown_path_secret_packet_accepted__peer_address__protocol), - 228usize => Self(unknown_path_secret_packet_rejected__peer_address__protocol), - 230usize => Self(unknown_path_secret_packet_dropped__peer_address__protocol), - 238usize => Self(replay_detected_packet_sent__peer_address__protocol), - 240usize => Self(replay_detected_packet_received__peer_address__protocol), - 242usize => Self(replay_detected_packet_accepted__peer_address__protocol), - 244usize => Self(replay_detected_packet_rejected__peer_address__protocol), - 246usize => Self(replay_detected_packet_dropped__peer_address__protocol), - 248usize => Self(stale_key_packet_sent__peer_address__protocol), - 250usize => Self(stale_key_packet_received__peer_address__protocol), - 252usize => Self(stale_key_packet_accepted__peer_address__protocol), - 254usize => Self(stale_key_packet_rejected__peer_address__protocol), - 256usize => Self(stale_key_packet_dropped__peer_address__protocol), - 258usize => { + 215usize => Self(path_secret_map_entry_inserted__peer_address__protocol), + 217usize => Self(path_secret_map_entry_ready__peer_address__protocol), + 219usize => Self(path_secret_map_entry_replaced__peer_address__protocol), + 221usize => Self(path_secret_map_id_entry_evicted__peer_address__protocol), + 224usize => Self(path_secret_map_address_entry_evicted__peer_address__protocol), + 227usize => Self(unknown_path_secret_packet_sent__peer_address__protocol), + 229usize => Self(unknown_path_secret_packet_received__peer_address__protocol), + 231usize => Self(unknown_path_secret_packet_accepted__peer_address__protocol), + 233usize => Self(unknown_path_secret_packet_rejected__peer_address__protocol), + 235usize => Self(unknown_path_secret_packet_dropped__peer_address__protocol), + 243usize => Self(replay_detected_packet_sent__peer_address__protocol), + 245usize => Self(replay_detected_packet_received__peer_address__protocol), + 247usize => Self(replay_detected_packet_accepted__peer_address__protocol), + 249usize => Self(replay_detected_packet_rejected__peer_address__protocol), + 251usize => Self(replay_detected_packet_dropped__peer_address__protocol), + 253usize => Self(stale_key_packet_sent__peer_address__protocol), + 255usize => Self(stale_key_packet_received__peer_address__protocol), + 257usize => Self(stale_key_packet_accepted__peer_address__protocol), + 259usize => Self(stale_key_packet_rejected__peer_address__protocol), + 261usize => Self(stale_key_packet_dropped__peer_address__protocol), + 263usize => { Self(path_secret_map_address_cache_accessed__peer_address__protocol) } - 261usize => { + 266usize => { Self(path_secret_map_address_cache_accessed_hit__peer_address__protocol) } _ => unreachable!("invalid info: {info:?}"), @@ -666,117 +672,119 @@ mod measure { 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), - 49usize => Self(stream_write_flushed__conn), - 50usize => Self(stream_write_flushed__provided), - 52usize => Self(stream_write_flushed__committed), - 53usize => Self(stream_write_flushed__committed__conn), - 54usize => Self(stream_write_flushed__processing_duration), - 55usize => Self(stream_write_flushed__processing_duration__conn), - 58usize => Self(stream_write_fin_flushed__conn), - 59usize => Self(stream_write_fin_flushed__provided), - 61usize => Self(stream_write_fin_flushed__committed), - 62usize => Self(stream_write_fin_flushed__committed__conn), - 63usize => Self(stream_write_fin_flushed__processing_duration), - 64usize => Self(stream_write_fin_flushed__processing_duration__conn), - 67usize => Self(stream_write_blocked__conn), - 68usize => Self(stream_write_blocked__provided), - 69usize => Self(stream_write_blocked__processing_duration), - 70usize => Self(stream_write_blocked__processing_duration__conn), - 73usize => Self(stream_write_errored__provided), - 74usize => Self(stream_write_errored__processing_duration), - 75usize => Self(stream_write_errored__processing_duration__conn), - 78usize => Self(stream_write_allocated__conn), - 79usize => Self(stream_write_allocated__allocated_len), - 80usize => Self(stream_write_allocated__allocated_len__conn), - 83usize => Self(stream_write_shutdown__buffer_len), - 86usize => Self(stream_write_socket_flushed__conn), - 87usize => Self(stream_write_socket_flushed__provided), - 89usize => Self(stream_write_socket_flushed__committed), - 90usize => Self(stream_write_socket_flushed__committed__conn), - 92usize => Self(stream_write_socket_blocked__conn), - 93usize => Self(stream_write_socket_blocked__provided), - 95usize => Self(stream_write_socket_errored__provided), - 98usize => Self(stream_read_flushed__conn), - 99usize => Self(stream_read_flushed__capacity), - 101usize => Self(stream_read_flushed__committed), - 102usize => Self(stream_read_flushed__committed__conn), - 103usize => Self(stream_read_flushed__processing_duration), - 104usize => Self(stream_read_flushed__processing_duration__conn), - 107usize => Self(stream_read_fin_flushed__conn), - 108usize => Self(stream_read_fin_flushed__capacity), - 109usize => Self(stream_read_fin_flushed__processing_duration), - 110usize => Self(stream_read_fin_flushed__processing_duration__conn), - 113usize => Self(stream_read_blocked__capacity), - 114usize => Self(stream_read_blocked__processing_duration), - 115usize => Self(stream_read_blocked__processing_duration__conn), - 118usize => Self(stream_read_errored__capacity), - 119usize => Self(stream_read_errored__processing_duration), - 120usize => Self(stream_read_errored__processing_duration__conn), - 126usize => Self(stream_read_socket_flushed__conn), - 127usize => Self(stream_read_socket_flushed__capacity), - 129usize => Self(stream_read_socket_flushed__committed), - 130usize => Self(stream_read_socket_flushed__committed__conn), - 132usize => Self(stream_read_socket_blocked__conn), - 133usize => Self(stream_read_socket_blocked__capacity), - 135usize => Self(stream_read_socket_errored__capacity), - 138usize => Self(stream_decrypt_packet__forced_copy), - 139usize => Self(stream_decrypt_packet__required_application_buffer), - 150usize => Self(stream_packet_transmitted__packet_len), - 152usize => Self(stream_packet_transmitted__payload_len), - 153usize => Self(stream_packet_transmitted__payload_len__conn), - 156usize => Self(stream_probe_transmitted__packet_len), - 158usize => Self(stream_packet_received__packet_len), - 160usize => Self(stream_packet_received__payload_len), - 161usize => Self(stream_packet_received__payload_len__conn), - 164usize => Self(stream_packet_lost__packet_len), - 166usize => Self(stream_packet_lost__payload_len), - 167usize => Self(stream_packet_lost__payload_len__conn), - 168usize => Self(stream_packet_lost__lifetime), - 171usize => Self(stream_packet_acked__packet_len), - 173usize => Self(stream_packet_acked__payload_len), - 174usize => Self(stream_packet_acked__payload_len__conn), - 175usize => Self(stream_packet_acked__lifetime), - 178usize => Self(stream_packet_spuriously_retransmitted__packet_len), - 180usize => Self(stream_packet_spuriously_retransmitted__payload_len), - 181usize => Self(stream_packet_spuriously_retransmitted__payload_len__conn), - 185usize => Self(stream_max_data_received__increase), - 187usize => Self(stream_control_packet_transmitted__packet_len), - 188usize => Self(stream_control_packet_transmitted__control_data_len), - 190usize => Self(stream_control_packet_received__packet_len), - 191usize => Self(stream_control_packet_received__control_data_len), - 202usize => Self(path_secret_map_initialized__capacity), - 204usize => Self(path_secret_map_uninitialized__capacity), - 205usize => Self(path_secret_map_uninitialized__entries), - 206usize => Self(path_secret_map_uninitialized__lifetime), - 217usize => Self(path_secret_map_id_entry_evicted__age), - 220usize => Self(path_secret_map_address_entry_evicted__age), - 232usize => Self(key_accepted__gap), - 233usize => Self(key_accepted__forward_shift), - 236usize => Self(replay_potentially_detected__gap), - 262usize => Self(path_secret_map_address_cache_accessed_hit__age), - 266usize => Self(path_secret_map_id_cache_accessed_hit__age), - 268usize => Self(path_secret_map_cleaner_cycled__entries__id), - 269usize => Self(path_secret_map_cleaner_cycled__entries__id__retired), - 270usize => Self(path_secret_map_cleaner_cycled__entries__id__active), - 271usize => Self(path_secret_map_cleaner_cycled__entries__id__active__utilization), - 272usize => Self(path_secret_map_cleaner_cycled__entries__id__utilization), - 273usize => Self(path_secret_map_cleaner_cycled__entries__id__utilization__initial), - 274usize => Self(path_secret_map_cleaner_cycled__entries__address), - 275usize => Self(path_secret_map_cleaner_cycled__entries__address__active), - 276usize => { + 32usize => Self(acceptor_tcp_socket_sent__blocked_count_stream), + 33usize => Self(acceptor_tcp_socket_sent__len), + 36usize => Self(acceptor_udp_datagram_received__len), + 38usize => Self(acceptor_udp_packet_received__payload_len), + 54usize => Self(stream_write_flushed__conn), + 55usize => Self(stream_write_flushed__provided), + 57usize => Self(stream_write_flushed__committed), + 58usize => Self(stream_write_flushed__committed__conn), + 59usize => Self(stream_write_flushed__processing_duration), + 60usize => Self(stream_write_flushed__processing_duration__conn), + 63usize => Self(stream_write_fin_flushed__conn), + 64usize => Self(stream_write_fin_flushed__provided), + 66usize => Self(stream_write_fin_flushed__committed), + 67usize => Self(stream_write_fin_flushed__committed__conn), + 68usize => Self(stream_write_fin_flushed__processing_duration), + 69usize => Self(stream_write_fin_flushed__processing_duration__conn), + 72usize => Self(stream_write_blocked__conn), + 73usize => Self(stream_write_blocked__provided), + 74usize => Self(stream_write_blocked__processing_duration), + 75usize => Self(stream_write_blocked__processing_duration__conn), + 78usize => Self(stream_write_errored__provided), + 79usize => Self(stream_write_errored__processing_duration), + 80usize => Self(stream_write_errored__processing_duration__conn), + 83usize => Self(stream_write_allocated__conn), + 84usize => Self(stream_write_allocated__allocated_len), + 85usize => Self(stream_write_allocated__allocated_len__conn), + 88usize => Self(stream_write_shutdown__buffer_len), + 91usize => Self(stream_write_socket_flushed__conn), + 92usize => Self(stream_write_socket_flushed__provided), + 94usize => Self(stream_write_socket_flushed__committed), + 95usize => Self(stream_write_socket_flushed__committed__conn), + 97usize => Self(stream_write_socket_blocked__conn), + 98usize => Self(stream_write_socket_blocked__provided), + 100usize => Self(stream_write_socket_errored__provided), + 103usize => Self(stream_read_flushed__conn), + 104usize => Self(stream_read_flushed__capacity), + 106usize => Self(stream_read_flushed__committed), + 107usize => Self(stream_read_flushed__committed__conn), + 108usize => Self(stream_read_flushed__processing_duration), + 109usize => Self(stream_read_flushed__processing_duration__conn), + 112usize => Self(stream_read_fin_flushed__conn), + 113usize => Self(stream_read_fin_flushed__capacity), + 114usize => Self(stream_read_fin_flushed__processing_duration), + 115usize => Self(stream_read_fin_flushed__processing_duration__conn), + 118usize => Self(stream_read_blocked__capacity), + 119usize => Self(stream_read_blocked__processing_duration), + 120usize => Self(stream_read_blocked__processing_duration__conn), + 123usize => Self(stream_read_errored__capacity), + 124usize => Self(stream_read_errored__processing_duration), + 125usize => Self(stream_read_errored__processing_duration__conn), + 131usize => Self(stream_read_socket_flushed__conn), + 132usize => Self(stream_read_socket_flushed__capacity), + 134usize => Self(stream_read_socket_flushed__committed), + 135usize => Self(stream_read_socket_flushed__committed__conn), + 137usize => Self(stream_read_socket_blocked__conn), + 138usize => Self(stream_read_socket_blocked__capacity), + 140usize => Self(stream_read_socket_errored__capacity), + 143usize => Self(stream_decrypt_packet__forced_copy), + 144usize => Self(stream_decrypt_packet__required_application_buffer), + 155usize => Self(stream_packet_transmitted__packet_len), + 157usize => Self(stream_packet_transmitted__payload_len), + 158usize => Self(stream_packet_transmitted__payload_len__conn), + 161usize => Self(stream_probe_transmitted__packet_len), + 163usize => Self(stream_packet_received__packet_len), + 165usize => Self(stream_packet_received__payload_len), + 166usize => Self(stream_packet_received__payload_len__conn), + 169usize => Self(stream_packet_lost__packet_len), + 171usize => Self(stream_packet_lost__payload_len), + 172usize => Self(stream_packet_lost__payload_len__conn), + 173usize => Self(stream_packet_lost__lifetime), + 176usize => Self(stream_packet_acked__packet_len), + 178usize => Self(stream_packet_acked__payload_len), + 179usize => Self(stream_packet_acked__payload_len__conn), + 180usize => Self(stream_packet_acked__lifetime), + 183usize => Self(stream_packet_spuriously_retransmitted__packet_len), + 185usize => Self(stream_packet_spuriously_retransmitted__payload_len), + 186usize => Self(stream_packet_spuriously_retransmitted__payload_len__conn), + 190usize => Self(stream_max_data_received__increase), + 192usize => Self(stream_control_packet_transmitted__packet_len), + 193usize => Self(stream_control_packet_transmitted__control_data_len), + 195usize => Self(stream_control_packet_received__packet_len), + 196usize => Self(stream_control_packet_received__control_data_len), + 207usize => Self(path_secret_map_initialized__capacity), + 209usize => Self(path_secret_map_uninitialized__capacity), + 210usize => Self(path_secret_map_uninitialized__entries), + 211usize => Self(path_secret_map_uninitialized__lifetime), + 222usize => Self(path_secret_map_id_entry_evicted__age), + 225usize => Self(path_secret_map_address_entry_evicted__age), + 237usize => Self(key_accepted__gap), + 238usize => Self(key_accepted__forward_shift), + 241usize => Self(replay_potentially_detected__gap), + 267usize => Self(path_secret_map_address_cache_accessed_hit__age), + 271usize => Self(path_secret_map_id_cache_accessed_hit__age), + 273usize => Self(path_secret_map_cleaner_cycled__entries__id), + 274usize => Self(path_secret_map_cleaner_cycled__entries__id__retired), + 275usize => Self(path_secret_map_cleaner_cycled__entries__id__active), + 276usize => Self(path_secret_map_cleaner_cycled__entries__id__active__utilization), + 277usize => Self(path_secret_map_cleaner_cycled__entries__id__utilization), + 278usize => Self(path_secret_map_cleaner_cycled__entries__id__utilization__initial), + 279usize => Self(path_secret_map_cleaner_cycled__entries__address), + 280usize => Self(path_secret_map_cleaner_cycled__entries__address__active), + 281usize => { Self(path_secret_map_cleaner_cycled__entries__address__active__utilization) } - 277usize => Self(path_secret_map_cleaner_cycled__entries__address__retired), - 278usize => Self(path_secret_map_cleaner_cycled__entries__address__utilization), - 279usize => { + 282usize => Self(path_secret_map_cleaner_cycled__entries__address__retired), + 283usize => Self(path_secret_map_cleaner_cycled__entries__address__utilization), + 284usize => { Self(path_secret_map_cleaner_cycled__entries__address__utilization__initial) } - 280usize => Self(path_secret_map_cleaner_cycled__handshake_requests), - 281usize => Self(path_secret_map_cleaner_cycled__handshake_requests__retired), - 282usize => Self(path_secret_map_cleaner_cycled__handshake_lock_duration), - 283usize => Self(path_secret_map_cleaner_cycled__total_duration), + 285usize => Self(path_secret_map_cleaner_cycled__handshake_requests), + 286usize => Self(path_secret_map_cleaner_cycled__handshake_requests__retired), + 287usize => Self(path_secret_map_cleaner_cycled__handshake_lock_duration), + 288usize => Self(path_secret_map_cleaner_cycled__total_duration), _ => unreachable!("invalid info: {info:?}"), } } @@ -808,6 +816,10 @@ mod measure { fn acceptor_tcp_packet_received__payload_len(value: u64); # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_stream_enqueued__blocked_count] fn acceptor_tcp_stream_enqueued__blocked_count(value: u64); + # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_socket_sent__blocked_count_stream] + fn acceptor_tcp_socket_sent__blocked_count_stream(value: u64); + # [link_name = s2n_quic_dc__event__measure__acceptor_tcp_socket_sent__len] + fn acceptor_tcp_socket_sent__len(value: u64); # [link_name = s2n_quic_dc__event__measure__acceptor_udp_datagram_received__len] fn acceptor_udp_datagram_received__len(value: u64); # [link_name = s2n_quic_dc__event__measure__acceptor_udp_packet_received__payload_len] @@ -1054,19 +1066,20 @@ mod timer { 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), - 48usize => Self(stream_write_flushed__latency), - 57usize => Self(stream_write_fin_flushed__latency), - 66usize => Self(stream_write_blocked__latency), - 72usize => Self(stream_write_errored__latency), - 82usize => Self(stream_write_shutdown__latency), - 97usize => Self(stream_read_flushed__latency), - 106usize => Self(stream_read_fin_flushed__latency), - 112usize => Self(stream_read_blocked__latency), - 117usize => Self(stream_read_errored__latency), - 123usize => Self(stream_read_shutdown__latency), - 142usize => Self(stream_tcp_connect__tcp_latency), + 30usize => Self(acceptor_tcp_socket_sent__sojourn_time), + 48usize => Self(acceptor_stream_pruned__sojourn_time), + 51usize => Self(acceptor_stream_dequeued__sojourn_time), + 53usize => Self(stream_write_flushed__latency), + 62usize => Self(stream_write_fin_flushed__latency), + 71usize => Self(stream_write_blocked__latency), + 77usize => Self(stream_write_errored__latency), + 87usize => Self(stream_write_shutdown__latency), + 102usize => Self(stream_read_flushed__latency), + 111usize => Self(stream_read_fin_flushed__latency), + 117usize => Self(stream_read_blocked__latency), + 122usize => Self(stream_read_errored__latency), + 128usize => Self(stream_read_shutdown__latency), + 147usize => Self(stream_tcp_connect__tcp_latency), _ => unreachable!("invalid info: {info:?}"), } } @@ -1090,6 +1103,8 @@ mod timer { fn acceptor_tcp_packet_dropped__sojourn_time(value: core::time::Duration); # [link_name = s2n_quic_dc__event__timer__acceptor_tcp_stream_enqueued__sojourn_time] fn acceptor_tcp_stream_enqueued__sojourn_time(value: core::time::Duration); + # [link_name = s2n_quic_dc__event__timer__acceptor_tcp_socket_sent__sojourn_time] + fn acceptor_tcp_socket_sent__sojourn_time(value: core::time::Duration); # [link_name = s2n_quic_dc__event__timer__acceptor_stream_pruned__sojourn_time] fn acceptor_stream_pruned__sojourn_time(value: core::time::Duration); # [link_name = s2n_quic_dc__event__timer__acceptor_stream_dequeued__sojourn_time] diff --git a/dc/s2n-quic-dc/src/msg/recv.rs b/dc/s2n-quic-dc/src/msg/recv.rs index be692ef0bd..935b59829c 100644 --- a/dc/s2n-quic-dc/src/msg/recv.rs +++ b/dc/s2n-quic-dc/src/msg/recv.rs @@ -44,6 +44,15 @@ impl Message { } } + pub fn new_from_packet(bytes: Vec, addr: std::net::SocketAddr) -> Self { + let buffer = Buffer::from(bytes); + Self { + addr: Addr::new(addr.into()), + buffer, + recv: Default::default(), + } + } + #[inline] pub fn remote_address(&self) -> SocketAddress { self.addr.get() diff --git a/dc/s2n-quic-dc/src/packet/uds/decoder.rs b/dc/s2n-quic-dc/src/packet/uds/decoder.rs index b844deca51..0b8b40fcec 100644 --- a/dc/s2n-quic-dc/src/packet/uds/decoder.rs +++ b/dc/s2n-quic-dc/src/packet/uds/decoder.rs @@ -6,7 +6,7 @@ use crate::{ path::secret::schedule::Ciphersuite, }; use s2n_codec::{DecoderBufferMut, DecoderBufferMutResult, DecoderError}; -use s2n_quic_core::{dc::ApplicationParams, varint::VarInt}; +use s2n_quic_core::{dc::ApplicationParams, time::Timestamp, varint::VarInt}; #[derive(Clone, Debug)] pub struct Packet { @@ -15,6 +15,7 @@ pub struct Packet { export_secret: Vec, application_params_version: u8, application_params: ApplicationParams, + queue_time: Timestamp, payload: Vec, } @@ -44,6 +45,11 @@ impl Packet { &self.application_params } + #[inline] + pub fn queue_time(&self) -> &Timestamp { + &self.queue_time + } + #[inline] pub fn payload(&self) -> &[u8] { &self.payload @@ -75,6 +81,8 @@ impl Packet { let (application_params, buffer) = buffer.decode::()?; + let (queue_time, buffer) = buffer.decode::()?; + let (payload_slice, buffer) = buffer.decode_slice_with_len_prefix::()?; let payload = payload_slice.into_less_safe_slice().to_vec(); @@ -84,6 +92,7 @@ impl Packet { export_secret, application_params_version, application_params, + queue_time, payload, }; @@ -93,6 +102,8 @@ impl Packet { #[cfg(test)] mod tests { + use std::time::Duration; + use crate::{ packet::uds::{ decoder, @@ -101,7 +112,7 @@ mod tests { path::secret::schedule::Ciphersuite, }; use s2n_codec::{DecoderBufferMut, DecoderError, EncoderLenEstimator}; - use s2n_quic_core::dc; + use s2n_quic_core::{dc, time::Timestamp}; #[test] fn test_encode_decode() { @@ -109,6 +120,7 @@ mod tests { let export_secret = b"secret_data"; let application_params = dc::testing::TEST_APPLICATION_PARAMS; let payload = b"payload_with_data"; + let time = unsafe { Timestamp::from_duration(Duration::new(10, 0)) }; // Encode let mut estimator = EncoderLenEstimator::new(usize::MAX); @@ -117,6 +129,7 @@ mod tests { &ciphersuite, export_secret, &application_params, + time, payload, ); let mut buffer = vec![0u8; expected_size]; @@ -126,6 +139,7 @@ mod tests { &ciphersuite, export_secret, &application_params, + time, payload, ); assert_eq!(encoded_size, expected_size); diff --git a/dc/s2n-quic-dc/src/packet/uds/encoder.rs b/dc/s2n-quic-dc/src/packet/uds/encoder.rs index b021c08a92..4239e0cfd2 100644 --- a/dc/s2n-quic-dc/src/packet/uds/encoder.rs +++ b/dc/s2n-quic-dc/src/packet/uds/encoder.rs @@ -3,7 +3,7 @@ use crate::path::secret::schedule::Ciphersuite; use s2n_codec::Encoder; -use s2n_quic_core::{dc::ApplicationParams, varint::VarInt}; +use s2n_quic_core::{dc::ApplicationParams, time::Timestamp, varint::VarInt}; pub const PACKET_VERSION: u8 = 0; pub const APP_PARAMS_VERSION: u8 = 0; @@ -14,6 +14,7 @@ pub fn encode( ciphersuite: &Ciphersuite, export_secret: &[u8], application_params: &ApplicationParams, + queue_time: Timestamp, payload: &[u8], ) -> usize { let start_len = encoder.len(); @@ -29,6 +30,8 @@ pub fn encode( encoder.encode(application_params); + encoder.encode(&queue_time); + encoder.encode_with_len_prefix::(&payload); encoder.len() - start_len diff --git a/dc/s2n-quic-dc/src/path/secret/key.rs b/dc/s2n-quic-dc/src/path/secret/key.rs index 253107fa4c..bc553351d2 100644 --- a/dc/s2n-quic-dc/src/path/secret/key.rs +++ b/dc/s2n-quic-dc/src/path/secret/key.rs @@ -169,7 +169,7 @@ pub mod open { /// Ensures the key has not been used before #[inline] - fn on_decrypt_success(&self, payload: &mut UninitSlice) -> open::Result { + pub fn on_decrypt_success(&self, payload: &mut UninitSlice) -> open::Result { self.dedup.check().map_err(|e| { let payload = unsafe { let ptr = payload.as_mut_ptr() as *mut MaybeUninit; diff --git a/dc/s2n-quic-dc/src/path/secret/map.rs b/dc/s2n-quic-dc/src/path/secret/map.rs index 691ef79714..d8567bf8cb 100644 --- a/dc/s2n-quic-dc/src/path/secret/map.rs +++ b/dc/s2n-quic-dc/src/path/secret/map.rs @@ -5,7 +5,11 @@ use crate::{ credentials::{Credentials, Id}, event, packet::{secret_control as control, Packet}, - path::secret::{open, seal, stateless_reset}, + path::secret::{ + open, + schedule::{Ciphersuite, ExportSecret}, + seal, stateless_reset, + }, stream::TransportFeatures, }; use core::fmt; @@ -170,6 +174,28 @@ impl Map { Some((keys, params)) } + pub fn secret_for_credentials( + &self, + credentials: &Credentials, + queue_id: Option, + features: &TransportFeatures, + control_out: &mut Vec, + ) -> Option<( + ExportSecret, + Ciphersuite, + entry::Bidirectional, + dc::ApplicationParams, + )> { + let entry = self + .store + .pre_authentication(credentials, queue_id, control_out)?; + let params = entry.parameters(); + let keys = entry.bidi_remote(self.clone(), credentials, queue_id, features); // for dedup check + let secret = entry.secret(); + + Some((*secret.export_secret(), *secret.ciphersuite(), keys, params)) + } + /// This can be called from anywhere to ask the map to handle a packet. /// /// For secret control packets, this will process those. diff --git a/dc/s2n-quic-dc/src/path/secret/map/entry.rs b/dc/s2n-quic-dc/src/path/secret/map/entry.rs index 1fd0e5292f..541a5362e9 100644 --- a/dc/s2n-quic-dc/src/path/secret/map/entry.rs +++ b/dc/s2n-quic-dc/src/path/secret/map/entry.rs @@ -156,6 +156,10 @@ impl Entry { self.secret.id() } + pub fn secret(&self) -> &schedule::Secret { + &self.secret + } + pub fn set_accessed_id(&self) { self.accessed.fetch_or(0b10, Ordering::Relaxed); } @@ -340,7 +344,12 @@ pub struct ApplicationPair { } impl ApplicationPair { - fn new(secret: &schedule::Secret, key_id: VarInt, initiator: Initiator, dedup: Dedup) -> Self { + pub fn new( + secret: &schedule::Secret, + key_id: VarInt, + initiator: Initiator, + dedup: Dedup, + ) -> Self { let (sealer, sealer_ku, opener, opener_ku) = secret.application_pair(key_id, initiator); let sealer = seal::Application::new(sealer, sealer_ku); diff --git a/dc/s2n-quic-dc/src/path/secret/schedule.rs b/dc/s2n-quic-dc/src/path/secret/schedule.rs index e174f17dfa..38a2132730 100644 --- a/dc/s2n-quic-dc/src/path/secret/schedule.rs +++ b/dc/s2n-quic-dc/src/path/secret/schedule.rs @@ -186,6 +186,16 @@ impl Secret { &self.id } + #[inline] + pub fn export_secret(&self) -> &ExportSecret { + &self.export_secret + } + + #[inline] + pub fn ciphersuite(&self) -> &Ciphersuite { + &self.ciphersuite + } + #[inline] pub fn application_pair( &self, diff --git a/dc/s2n-quic-dc/src/stream/server.rs b/dc/s2n-quic-dc/src/stream/server.rs index b5d91e42f1..e19a8e9003 100644 --- a/dc/s2n-quic-dc/src/stream/server.rs +++ b/dc/s2n-quic-dc/src/stream/server.rs @@ -12,7 +12,9 @@ use s2n_codec::{DecoderBufferMut, DecoderError}; use s2n_quic_core::varint::VarInt; pub mod accept; +pub mod application; pub mod handshake; +pub mod manager; pub mod stats; pub mod tokio; pub mod udp; diff --git a/dc/s2n-quic-dc/src/stream/server/application.rs b/dc/s2n-quic-dc/src/stream/server/application.rs new file mode 100644 index 0000000000..7ab7cb03f7 --- /dev/null +++ b/dc/s2n-quic-dc/src/stream/server/application.rs @@ -0,0 +1,104 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +use crate::{ + event, + stream::{ + environment::tokio as env, + server::tokio::{common_builder_methods, uds}, + socket, + }, +}; +use s2n_quic_core::ensure; +use std::{ + io, + net::SocketAddr, + path::{Path, PathBuf}, +}; +use tracing::Instrument as _; + +#[derive(Clone)] +pub struct Server { + receiver: uds::Receiver, + span: tracing::Span, +} + +impl Server { + #[inline] + pub fn new(subscriber: S) -> io::Result { + Builder::default().build(subscriber) + } + + pub fn builder() -> Builder { + Builder::default() + } + + #[inline] + pub async fn accept(&self) -> io::Result<(crate::stream::application::Stream, SocketAddr)> { + let stream = if self.span.is_disabled() { + self.receiver.receive_stream().await? + } else { + self.receiver + .receive_stream() + .instrument(self.span.clone()) + .await? + }; + let (stream, _sojourn_time) = stream.accept()?; + let remote_addr = stream.peer_addr()?; + + Ok((stream, remote_addr)) + } +} + +pub struct Builder { + span: Option, + enable_udp: bool, + enable_tcp: bool, + socket_path: Option, +} + +impl Default for Builder { + fn default() -> Self { + Self { + span: None, + enable_udp: true, + enable_tcp: false, + socket_path: None, + } + } +} + +impl Builder { + common_builder_methods!(); + + pub fn with_socket_path(mut self, path: &Path) -> Self { + self.socket_path = Some(path.to_path_buf()); + self + } + + pub fn build(self, subscriber: S) -> io::Result> { + ensure!( + self.enable_udp || self.enable_tcp, + Err(io::Error::new( + io::ErrorKind::InvalidInput, + "at least one acceptor type needs to be enabled" + )) + ); + + let env = env::Builder::new(subscriber).build()?; + + let mut span = self.span.unwrap_or_else(tracing::span::Span::current); + if span.is_none() { + span = tracing::debug_span!("server"); + } + + let path = self.socket_path.ok_or(io::Error::new( + io::ErrorKind::InvalidInput, + "Unix domain socket path is required", + ))?; + let receiver = uds::Receiver::new(&path, &env)?; + let server = Server { receiver, span }; + + Ok(server) + } +} diff --git a/dc/s2n-quic-dc/src/stream/server/manager.rs b/dc/s2n-quic-dc/src/stream/server/manager.rs new file mode 100644 index 0000000000..8a48d91024 --- /dev/null +++ b/dc/s2n-quic-dc/src/stream/server/manager.rs @@ -0,0 +1,386 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +use crate::{ + event, + stream::{ + environment::tokio::{self as env, Environment}, + runtime::tokio as runtime, + server::{ + accept, + tokio::{ + common_builder_methods, manager_builder_methods, tcp, Handshake, DEFAULT_BACKLOG, + MAX_TCP_WORKERS, + }, + }, + socket, + }, +}; +use core::num::{NonZeroU16, NonZeroUsize}; +use s2n_quic_core::ensure; +use std::{ + io, + net::SocketAddr, + path::{Path, PathBuf}, + time::Duration, +}; +use tracing::{trace, Instrument as _}; + +#[derive(Clone)] +pub struct Server { + local_addr: SocketAddr, + handshake: H, + env: Environment, + acceptor_rt: runtime::Shared, +} + +impl Server { + #[inline] + pub fn new(acceptor_addr: SocketAddr, handshake: &H, subscriber: S) -> io::Result { + Builder::default() + .with_address(acceptor_addr) + .build(handshake.clone(), subscriber) + } + + pub fn builder() -> Builder { + Builder::default() + } + + pub fn handshake_state(&self) -> &H { + &self.handshake + } + + /// Should generally only be used for advanced users. + /// + /// This should not be used for spawning heavy-weight work (e.g., request processing), and is + /// generally best used for tiny tasks which intermediate to some other runtime. For example, + /// it can work well for having some small processing to then send into another channel. + pub fn acceptor_rt(&self) -> tokio::runtime::Handle { + (*self.acceptor_rt).clone() + } + + #[inline] + pub fn acceptor_addr(&self) -> io::Result { + Ok(self.local_addr) + } + + #[inline] + pub fn handshake_addr(&self) -> io::Result { + Ok(self.handshake.local_addr()) + } +} + +pub struct Builder { + backlog: Option, + workers: Option, + acceptor_addr: SocketAddr, + span: Option, + enable_udp: bool, + enable_tcp: bool, + accept_flavor: accept::Flavor, + linger: Option, + send_buffer: Option, + recv_buffer: Option, + reuse_addr: Option, + socket_path: Option, +} + +impl Default for Builder { + fn default() -> Self { + Self { + backlog: None, + workers: None, + // FIXME: Don't default to a fixed port? + acceptor_addr: "[::]:4444".parse().unwrap(), + span: None, + enable_udp: true, + enable_tcp: false, + linger: None, + accept_flavor: Default::default(), + send_buffer: None, + recv_buffer: None, + reuse_addr: None, + socket_path: None, + } + } +} + +impl Builder { + common_builder_methods!(); + manager_builder_methods!(); + + pub fn with_socket_path(mut self, path: &Path) -> Self { + self.socket_path = Some(path.to_path_buf()); + self + } + + pub fn build( + self, + handshake: H, + subscriber: S, + ) -> io::Result> { + ensure!( + self.enable_udp || self.enable_tcp, + Err(io::Error::new( + io::ErrorKind::InvalidInput, + "at least one acceptor type needs to be enabled" + )) + ); + + let concurrency: usize = self.workers.unwrap_or_else(|| { + std::thread::available_parallelism() + .unwrap_or_else(|_| 1.try_into().unwrap()) + .into() + }); + + let backlog: usize = self.backlog.map(NonZeroU16::get).unwrap_or(DEFAULT_BACKLOG) as usize; + + let env = env::Builder::new(subscriber).with_threads(concurrency); + + let enable_udp_pool = true; + + if self.enable_udp && enable_udp_pool { + // TODO UDP + } + + let env = env.build()?; + + if self.enable_udp && enable_udp_pool { + // TODO UDP + } + + // TODO is it better to spawn one current_thread runtime per concurrency? + let acceptor_rt: runtime::Shared = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .thread_name("acceptor") + .worker_threads(concurrency) + .build()? + .into(); + + let mut span = self.span.unwrap_or_else(tracing::span::Span::current); + + if span.is_none() { + span = tracing::debug_span!("server"); + } + + let mut server = Server { + local_addr: self.acceptor_addr, + handshake, + env, + acceptor_rt, + }; + + // split the backlog between all of the workers + // this is only used in TCP, so clamp division to maximum TCP worker concurrency + let backlog = backlog + .div_ceil(concurrency.clamp(0, MAX_TCP_WORKERS)) + .max(1); + let path = self.socket_path.ok_or(io::Error::new( + io::ErrorKind::InvalidInput, + "Unix domain socket path is required", + ))?; + + Start { + enable_tcp: self.enable_tcp, + enable_udp: self.enable_udp, + accept_flavor: self.accept_flavor, + linger: self.linger, + backlog, + concurrency, + server: &mut server, + span, + next_id: 0, + send_buffer: self.send_buffer, + recv_buffer: self.recv_buffer, + reuse_addr: self.reuse_addr.unwrap_or(false), + socket_path: path, + } + .start()?; + + Ok(server) + } +} + +struct Start<'a, H: Handshake + Clone, S: event::Subscriber + Clone> { + enable_tcp: bool, + enable_udp: bool, + accept_flavor: accept::Flavor, + backlog: usize, + concurrency: usize, + server: &'a mut Server, + span: tracing::Span, + next_id: usize, + linger: Option, + send_buffer: Option, + recv_buffer: Option, + reuse_addr: bool, + socket_path: PathBuf, +} + +impl Start<'_, H, S> { + #[inline] + fn start(&mut self) -> io::Result<()> { + let _acceptor = self.server.acceptor_rt.enter(); + + // check if we need to find a port for which both types are free + if self.enable_tcp && self.enable_udp && self.server.local_addr.port() == 0 { + // find a port and spawn the initial listeners + self.spawn_initial_wildcard_pair()?; + // spawn the rest of the concurrency + self.spawn_count(self.concurrency - 1, 1)?; + } else { + // otherwise spawn things as normal + self.spawn_count(self.concurrency, 0)?; + } + + debug_assert_ne!( + self.server.local_addr.port(), + 0, + "a port should be selected" + ); + + Ok(()) + } + + #[inline] + fn spawn_initial_wildcard_pair(&mut self) -> io::Result<()> { + debug_assert!(self.enable_tcp); + debug_assert!(self.enable_udp); + debug_assert_eq!(self.server.local_addr.port(), 0); + + // try 10 times before bailing + for iteration in 0..10 { + trace!(wildcard_search_iteration = iteration); + let udp_socket = self.socket_opts(self.server.local_addr).build_udp()?; + let local_addr = udp_socket.local_addr()?; + trace!(candidate = %local_addr); + match self.socket_opts(local_addr).build_tcp_listener() { + Ok(tcp_socket) => { + trace!(selected = %local_addr); + // we found a port that both protocols can use + self.server.local_addr = local_addr; + self.spawn_udp(udp_socket)?; + self.spawn_tcp(tcp_socket)?; + return Ok(()); + } + Err(err) if err.kind() == io::ErrorKind::AddrInUse => { + // try to find another address + continue; + } + // bubble up all other error types + Err(err) => return Err(err), + } + } + + // we couldn't find a free port so return and error + Err(io::ErrorKind::AddrInUse.into()) + } + + #[inline] + fn spawn_count(&mut self, count: usize, already_running: usize) -> io::Result<()> { + for protocol in [socket::Protocol::Udp, socket::Protocol::Tcp] { + match protocol { + socket::Protocol::Udp => ensure!(self.enable_udp, continue), + socket::Protocol::Tcp => ensure!(self.enable_tcp, continue), + _ => continue, + } + + for idx in 0..count { + match protocol { + socket::Protocol::Udp => { + let socket = self.socket_opts(self.server.local_addr).build_udp()?; + self.spawn_udp(socket)?; + } + socket::Protocol::Tcp => { + if idx + already_running >= MAX_TCP_WORKERS { + continue; + } + + let socket = self + .socket_opts(self.server.local_addr) + .build_tcp_listener()?; + self.spawn_tcp(socket)?; + } + _ => continue, + } + } + } + + Ok(()) + } + + #[inline] + fn socket_opts(&self, local_addr: SocketAddr) -> socket::Options { + let mut options = socket::Options::new(local_addr); + + // Explicitly do **not** set the socket backlog to self.backlog. While we split the + // configured backlog amongst our in-process queues as concurrency increases, it doesn't + // make sense to shrink the kernel backlogs -- that just causes packet drops and generally + // bad behavior. + // + // This is especially true for TCP where we don't have workers matching concurrency. + options.send_buffer = self.send_buffer; + options.recv_buffer = self.recv_buffer; + options.reuse_address = self.reuse_addr; + + // if we have more than one thread then we'll need to use reuse port + if self.concurrency > 1 { + // if the application is wanting to bind to a random port then we need to set + // reuse_port after + if local_addr.port() == 0 { + options.reuse_port = socket::ReusePort::AfterBind; + } else { + options.reuse_port = socket::ReusePort::BeforeBind; + } + } + + options + } + + #[inline] + fn spawn_udp(&mut self, _socket: std::net::UdpSocket) -> io::Result<()> { + // TODO UDP + + Ok(()) + } + + #[inline] + fn spawn_tcp(&mut self, socket: std::net::TcpListener) -> io::Result<()> { + // if this is the first socket being spawned then update the local address + if self.server.local_addr.port() == 0 { + self.server.local_addr = socket.local_addr()?; + } + + let socket = tokio::io::unix::AsyncFd::new(socket)?; + let id = self.id(); + + let socket_behavior = tcp::worker::SocketBehavior::new(&self.socket_path); + let acceptor = tcp::Acceptor::new( + id, + socket, + &self.server.env, + self.server.handshake.map(), + self.backlog, + self.accept_flavor, + self.linger, + socket_behavior, + )? + .run(); + + if self.span.is_disabled() { + self.server.acceptor_rt.spawn(acceptor); + } else { + self.server + .acceptor_rt + .spawn(acceptor.instrument(self.span.clone())); + } + + Ok(()) + } + + fn id(&mut self) -> usize { + let id = self.next_id; + self.next_id += 1; + id + } +} diff --git a/dc/s2n-quic-dc/src/stream/server/tokio.rs b/dc/s2n-quic-dc/src/stream/server/tokio.rs index f58b5c5ad9..c3cf9000b8 100644 --- a/dc/s2n-quic-dc/src/stream/server/tokio.rs +++ b/dc/s2n-quic-dc/src/stream/server/tokio.rs @@ -30,10 +30,11 @@ use tracing::{trace, Instrument as _}; // // With UDP there's ~no lock contention for receiving packets on separate UDP sockets, // so we don't clamp concurrency in that case. -const MAX_TCP_WORKERS: usize = 4; +pub const MAX_TCP_WORKERS: usize = 4; pub mod tcp; pub mod udp; +pub mod uds; // This trait is a solution to abstract local_addr and map methods pub trait Handshake: Clone { @@ -112,7 +113,7 @@ impl Server { /// Default to the SOMAXCONN, similar to rust: /// https://github.com/rust-lang/rust/blob/28a58f2fa7f0c46b8fab8237c02471a915924fe5/library/std/src/os/unix/net/listener.rs#L104 -const DEFAULT_BACKLOG: u16 = libc::SOMAXCONN as _; +pub const DEFAULT_BACKLOG: u16 = libc::SOMAXCONN as _; pub struct Builder { backlog: Option, @@ -147,77 +148,87 @@ impl Default for Builder { } } -impl Builder { - pub fn with_address(mut self, addr: SocketAddr) -> Self { - self.acceptor_addr = addr; - self - } +macro_rules! common_builder_methods { + () => { + pub fn with_protocol(mut self, protocol: socket::Protocol) -> Self { + match protocol { + socket::Protocol::Udp => { + self.enable_udp = true; + self.enable_tcp = false + } + socket::Protocol::Tcp => { + self.enable_udp = false; + self.enable_tcp = true; + } + _ => { + self.enable_udp = false; + self.enable_tcp = false; + } + } + self + } - pub fn with_backlog(mut self, backlog: NonZeroU16) -> Self { - self.backlog = Some(backlog); - self - } + pub fn with_udp(mut self, enabled: bool) -> Self { + self.enable_udp = enabled; + self + } - pub fn with_workers(mut self, workers: NonZeroUsize) -> Self { - self.workers = Some(workers.into()); - self - } + pub fn with_tcp(mut self, enabled: bool) -> Self { + self.enable_tcp = enabled; + self + } + }; +} +macro_rules! manager_builder_methods { + () => { + pub fn with_address(mut self, addr: SocketAddr) -> Self { + self.acceptor_addr = addr; + self + } - pub fn with_protocol(mut self, protocol: socket::Protocol) -> Self { - match protocol { - socket::Protocol::Udp => { - self.enable_udp = true; - self.enable_tcp = false - } - socket::Protocol::Tcp => { - self.enable_udp = false; - self.enable_tcp = true; - } - _ => { - self.enable_udp = false; - self.enable_tcp = false; - } + pub fn with_backlog(mut self, backlog: NonZeroU16) -> Self { + self.backlog = Some(backlog); + self } - self - } - pub fn with_udp(mut self, enabled: bool) -> Self { - self.enable_udp = enabled; - self - } + pub fn with_workers(mut self, workers: NonZeroUsize) -> Self { + self.workers = Some(workers.into()); + self + } - pub fn with_tcp(mut self, enabled: bool) -> Self { - self.enable_tcp = enabled; - self - } + pub fn with_linger(mut self, linger: Duration) -> Self { + self.linger = Some(linger); + self + } - pub fn with_linger(mut self, linger: Duration) -> Self { - self.linger = Some(linger); - self - } + pub fn with_send_buffer(mut self, bytes: usize) -> Self { + self.send_buffer = Some(bytes); + self + } - pub fn with_send_buffer(mut self, bytes: usize) -> Self { - self.send_buffer = Some(bytes); - self - } + pub fn with_recv_buffer(mut self, bytes: usize) -> Self { + self.recv_buffer = Some(bytes); + self + } - pub fn with_recv_buffer(mut self, bytes: usize) -> Self { - self.recv_buffer = Some(bytes); - self - } + /// Sets the reuse address option for the OS socket handle. + /// + /// This allows the application to bind to a previously used local address. + /// In TCP, this can be useful when a closed socket is in the `TIME_WAIT` state and the application + /// would like to reuse that address immediately. + /// On Linux packets are routed to the most recently bound socket. + /// + /// See `SO_REUSEADDR` for more information. + pub fn with_reuse_addr(mut self, enabled: bool) -> Self { + self.reuse_addr = Some(enabled); + self + } + }; +} - /// Sets the reuse address option for the OS socket handle. - /// - /// This allows the application to bind to a previously used local address. - /// In TCP, this can be useful when a closed socket is in the `TIME_WAIT` state and the application - /// would like to reuse that address immediately. - /// On Linux packets are routed to the most recently bound socket. - /// - /// See `SO_REUSEADDR` for more information. - pub fn with_reuse_addr(mut self, enabled: bool) -> Self { - self.reuse_addr = Some(enabled); - self - } +impl Builder { + common_builder_methods!(); + manager_builder_methods!(); pub fn build( mut self, @@ -513,17 +524,16 @@ impl Start<'_, H, S> { let socket = tokio::io::unix::AsyncFd::new(socket)?; let id = self.id(); - + let channel_behavior = tcp::worker::DefaultBehavior::new(&self.stream_sender); let acceptor = tcp::Acceptor::new( id, socket, - &self.stream_sender, &self.server.env, self.server.handshake.map(), self.backlog, self.accept_flavor, self.linger, - tcp::worker::DefaultBehavior, + channel_behavior, )? .run(); @@ -544,3 +554,6 @@ impl Start<'_, H, S> { id } } + +pub(crate) use common_builder_methods; +pub(crate) use manager_builder_methods; 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 c3f5428c72..988f4bc102 100644 --- a/dc/s2n-quic-dc/src/stream/server/tokio/tcp.rs +++ b/dc/s2n-quic-dc/src/stream/server/tokio/tcp.rs @@ -27,7 +27,6 @@ where Sub: Subscriber + Clone, B: PollBehavior + Clone, { - sender: accept::Sender, socket: AsyncFd, env: Environment, secrets: secret::Map, @@ -46,7 +45,6 @@ where pub fn new( id: usize, socket: AsyncFd, - sender: &accept::Sender, env: &Environment, secrets: &secret::Map, backlog: usize, @@ -55,7 +53,6 @@ where poll_behavior: B, ) -> std::io::Result { let acceptor = Self { - sender: sender.clone(), socket, env: env.clone(), secrets: secrets.clone(), diff --git a/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs b/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs index 7431218506..3bcdb4ad58 100644 --- a/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs +++ b/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs @@ -5,13 +5,14 @@ use super::{accept, LazyBoundStream}; use crate::{ either::Either, event::{self, EndpointPublisher, IntoEvent}, - msg, + msg, packet, path::secret, stream::{ endpoint, environment::tokio::{self as env, Environment}, recv, server, TransportFeatures, }, + uds, }; use core::{ ops::ControlFlow, @@ -19,13 +20,17 @@ use core::{ task::{self, Poll}, time::Duration, }; -use s2n_codec::DecoderError; +use s2n_codec::{DecoderError, EncoderLenEstimator}; use s2n_quic_core::{ inet::SocketAddress, ready, time::{Clock, Timestamp}, }; -use std::io; +use std::{ + io, + os::fd::AsFd as _, + path::{Path, PathBuf}, +}; use tracing::debug; pub struct Context @@ -33,7 +38,6 @@ where Sub: event::Subscriber + Clone, { recv_buffer: msg::recv::Message, - sender: accept::Sender, env: Environment, secrets: secret::Map, accept_flavor: accept::Flavor, @@ -48,7 +52,6 @@ where pub fn new + Clone>(acceptor: &super::Acceptor) -> Self { Self { recv_buffer: msg::recv::Message::new(u16::MAX), - sender: acceptor.sender.clone(), env: acceptor.env.clone(), secrets: acceptor.secrets.clone(), accept_flavor: acceptor.accept_flavor, @@ -135,6 +138,7 @@ where WorkerState::Init => 0, WorkerState::Buffering { buffer, .. } => buffer.payload_len(), WorkerState::Erroring { .. } => 0, + WorkerState::Sending { .. } => 0, }; publisher.on_acceptor_tcp_stream_replaced(event::builder::AcceptorTcpStreamReplaced { remote_address: &remote_address, @@ -163,7 +167,7 @@ where { // if we don't have a stream then it's a bug in the worker impl - in production just return // `Ready`, which will correct the state - if self.stream.is_none() { + if self.stream.is_none() && !matches!(self.state, WorkerState::Sending { .. }) { debug_assert!( false, "Worker::poll should only be called with an active socket" @@ -204,6 +208,9 @@ where #[inline] fn is_active(&self) -> bool { + if matches!(self.state, WorkerState::Sending { .. }) { + return true; + } let is_active = self.stream.is_some(); if !is_active { debug_assert!(matches!(self.state, WorkerState::Init)); @@ -233,7 +240,6 @@ where Self: Sized; } -#[derive(Debug)] pub enum WorkerState { /// Worker is waiting for a packet Init, @@ -249,6 +255,10 @@ pub enum WorkerState { buffer: Vec, error: io::Error, }, + Sending { + future: Pin> + Send>>, + event_data: SocketEventData, + }, } impl WorkerState { @@ -282,9 +292,26 @@ impl WorkerState { } #[derive(Clone)] -pub struct DefaultBehavior; +pub struct DefaultBehavior +where + Sub: event::Subscriber + Clone, +{ + sender: accept::Sender, +} + +impl DefaultBehavior +where + Sub: event::Subscriber + Clone, +{ + #[inline] + pub fn new(sender: &accept::Sender) -> Self { + Self { + sender: sender.clone(), + } + } +} -impl PollBehavior for DefaultBehavior +impl PollBehavior for DefaultBehavior where Sub: event::Subscriber + Clone, { @@ -335,6 +362,7 @@ where return Err(Some(error)).into(); } + WorkerState::Sending { .. } => unreachable!(), }; // try to read an initial packet from the socket @@ -446,8 +474,8 @@ where } let res = match context.accept_flavor { - accept::Flavor::Fifo => context.sender.send_back(stream_builder), - accept::Flavor::Lifo => context.sender.send_front(stream_builder), + accept::Flavor::Fifo => self.sender.send_back(stream_builder), + accept::Flavor::Lifo => self.sender.send_front(stream_builder), }; return Poll::Ready(Ok(match res { @@ -538,3 +566,262 @@ impl WorkerState { } } } + +#[derive(Clone)] +pub struct SocketEventData { + blocked_count: usize, + payload_len: usize, + credential_id: Vec, + stream_id: u64, + sojourn_time: Duration, +} + +#[derive(Clone)] +pub struct SocketBehavior { + dest_path: PathBuf, +} + +impl SocketBehavior { + #[inline] + pub fn new(dest_path: &Path) -> Self { + Self { + dest_path: dest_path.to_path_buf(), + } + } + + fn poll_send( + mut future: Pin>, + cx: &mut task::Context, + state: &mut WorkerState, + mut event_data: SocketEventData, + publisher: &Pub, + ) -> Poll, Option>> + where + Pub: EndpointPublisher, + F: std::future::Future> + Send + 'static, + { + match future.as_mut().poll(cx) { + Poll::Ready(res) => match res { + Ok(_) => { + publisher.on_acceptor_tcp_socket_sent(event::builder::AcceptorTcpSocketSent { + credential_id: &event_data.credential_id, + stream_id: event_data.stream_id, + payload_len: event_data.payload_len, + blocked_count: event_data.blocked_count, + sojourn_time: event_data.sojourn_time, + }); + Poll::Ready(Ok(ControlFlow::Continue(()))) + } + Err(err) => { + debug!("Error sending message to socket {:?}", err); + Err(Some(err)).into() + } + }, + Poll::Pending => { + event_data.blocked_count += 1; + + *state = WorkerState::Sending { future, event_data }; + Poll::Pending + } + } + } +} + +impl PollBehavior for SocketBehavior +where + Sub: event::Subscriber + Clone, +{ + fn poll( + &self, + state: &mut WorkerState, + cx: &mut task::Context, + context: &mut Context, + stream: &mut Option<(LazyBoundStream, SocketAddress)>, + _subscriber_ctx: &mut Option, + queue_time: Timestamp, + now: Timestamp, + publisher: &Pub, + ) -> Poll, Option>> + where + Pub: EndpointPublisher, + { + let sojourn_time = now.saturating_duration_since(queue_time); + + loop { + // figure out where to put the received bytes + let (recv_buffer, blocked_count) = match state { + // borrow the context's recv buffer initially + WorkerState::Init => (&mut context.recv_buffer, 0), + // we have our own recv buffer to use + WorkerState::Buffering { + buffer, + blocked_count, + } => (buffer, *blocked_count), + // we encountered an error so try and send it back + WorkerState::Erroring { offset, buffer, .. } => { + let (stream, _remote_address) = stream.as_mut().unwrap(); + let len = ready!(Pin::new(stream).poll_write(cx, &buffer[*offset..]))?; + + *offset += len; + + // if we still need to send part of the buffer then loop back around + if *offset < buffer.len() { + continue; + } + + // io::Error doesn't implement clone so we have to take the error to return it + let WorkerState::Erroring { error, .. } = + core::mem::replace(state, WorkerState::Init) + else { + unreachable!() + }; + + return Err(Some(error)).into(); + } + WorkerState::Sending { future, event_data } => match future.as_mut().poll(cx) { + Poll::Ready(res) => match res { + Ok(_) => { + publisher.on_acceptor_tcp_socket_sent( + event::builder::AcceptorTcpSocketSent { + credential_id: &event_data.credential_id, + stream_id: event_data.stream_id, + payload_len: event_data.payload_len, + blocked_count: event_data.blocked_count, + sojourn_time: event_data.sojourn_time, + }, + ); + return Ok(ControlFlow::Continue(())).into(); + } + Err(err) => { + debug!("Error sending message to socket {:?}", err); + return Err(Some(err)).into(); + } + }, + Poll::Pending => { + event_data.blocked_count += 1; + return Poll::Pending; + } + }, + }; + + // try to read an initial packet from the socket + let res = { + let (stream, remote_address) = stream.as_mut().unwrap(); + WorkerState::poll_initial_packet( + cx, + stream, + remote_address, + recv_buffer, + sojourn_time, + publisher, + ) + }; + + let Poll::Ready(res) = res else { + // if we got `Pending` but we don't own the recv buffer then we need to copy it + // into the worker so we can resume where we left off last time + if blocked_count == 0 { + let buffer = recv_buffer.take(); + *state = WorkerState::Buffering { + buffer, + blocked_count, + }; + } + + if let WorkerState::Buffering { blocked_count, .. } = state { + *blocked_count += 1; + } + + return Poll::Pending; + }; + + let initial_packet = res?; + + let (socket, remote_address) = stream.take().unwrap(); + + let recv_buffer = recv_buffer.make_contiguous(); + + let mut secret_control = vec![]; + let credentials = &initial_packet.credentials; + + let map = &context.secrets; + let Some((export_secret, ciphersuite, keys, application_params)) = map + .secret_for_credentials( + credentials, + initial_packet.source_queue_id, + &TransportFeatures::TCP, + &mut secret_control, + ) + else { + let error = io::Error::new( + io::ErrorKind::NotFound, + format!("missing credentials for client: {credentials:?}"), + ); + + if !secret_control.is_empty() { + *stream = Some((socket, remote_address)); + *state = WorkerState::Erroring { + offset: 0, + buffer: secret_control, + error, + }; + continue; + } else { + // Close socket immediately + let _ = socket.set_linger(Some(Duration::ZERO)); + drop(socket); + } + return Err(Some(error)).into(); + }; + + if keys + .application + .opener + .on_decrypt_success(recv_buffer.into()) + .is_err() + { + return Ok(ControlFlow::Continue(())).into(); + }; + + let mut estimator = EncoderLenEstimator::new(usize::MAX); + let size = packet::uds::encoder::encode( + &mut estimator, + &ciphersuite, + &export_secret, + &application_params, + queue_time, + recv_buffer, + ); + let mut buffer = vec![0u8; size]; + let mut encoder = s2n_codec::EncoderBuffer::new(&mut buffer); + packet::uds::encoder::encode( + &mut encoder, + &ciphersuite, + &export_secret, + &application_params, + queue_time, + recv_buffer, + ); + + let sender = uds::sender::Sender::new()?; + let dest_path = self.dest_path.clone(); + let tcp_stream = socket.into_std()?; + + let send_future = Box::pin(async move { + sender + .send_msg(&buffer, &dest_path, tcp_stream.as_fd()) + .await + }); + + let event_data = SocketEventData { + credential_id: credentials.id.to_vec(), + stream_id: credentials.key_id.as_u64(), + payload_len: size, + blocked_count: 0, + sojourn_time, + }; + + return Self::poll_send(send_future, cx, state, event_data, publisher); + } + } +} diff --git a/dc/s2n-quic-dc/src/stream/server/tokio/uds.rs b/dc/s2n-quic-dc/src/stream/server/tokio/uds.rs new file mode 100644 index 0000000000..bbeaf77a2d --- /dev/null +++ b/dc/s2n-quic-dc/src/stream/server/tokio/uds.rs @@ -0,0 +1,207 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +use crate::{ + either::{self, Either}, + event::{self, EndpointPublisher, Subscriber}, + msg::recv::Message, + packet::uds::decoder, + path::secret::{ + map::{ApplicationPair, Bidirectional, Dedup}, + schedule::{ExportSecret, Initiator, Secret}, + stateless_reset, Map, + }, + stream::{ + application::Builder, + endpoint, + environment::{ + tokio::{self as env, Environment}, + Environment as _, + }, + recv::{self, buffer::Channel}, + server::{self, tokio::tcp::LazyBoundStream}, + }, + uds::{self}, +}; +use s2n_codec::DecoderBufferMut; +use s2n_quic_core::{ + endpoint::Type, + event::IntoEvent as _, + inet::SocketAddress, + time::{self, Clock as _}, +}; +use std::{io::ErrorKind, os::fd::OwnedFd, path::Path, time::Duration}; +use tokio::net::TcpStream; + +#[derive(Clone)] +pub struct Receiver +where + Sub: Subscriber + Clone, +{ + receiver: uds::receiver::Receiver, + env: Environment, + map: Map, // placeholder map +} + +impl Receiver +where + Sub: Subscriber + Clone, +{ + pub fn new(socket_path: &Path, env: &Environment) -> std::io::Result { + let receiver = uds::receiver::Receiver::new(socket_path)?; + let sub = env.subscriber(); + let map = Map::new( + stateless_reset::Signer::random(), + 1, + time::NoopClock, + sub.clone(), + ); + Ok(Self { + receiver, + env: env.clone(), + map, + }) + } + + pub async fn receive_stream(&self) -> std::io::Result> { + let now = self.env.clock().get_time(); + + let publisher = self.env.endpoint_publisher_with_time(now); + + let (packet_data, fd) = self.receiver.receive_msg().await?; + + let decoded_packet = self.decode_packet(&packet_data)?; + + let tcp_stream = self.create_tcp_stream_from_fd(fd)?; + + let remote_address = tcp_stream.peer_addr()?; + let mut buffer = + Message::new_from_packet(decoded_packet.payload().to_vec().clone(), remote_address); + + let initial_packet = match server::InitialPacket::peek(&mut buffer, 16) { + Ok(packet) => packet, + Err(err) => { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + format!("Failed to peek initial packet, err: {:?}", err), + )); + } + }; + + let now = self.env.clock().get_time(); + let meta = event::api::ConnectionMeta { + id: 0, // TODO use an actual connection ID + timestamp: now.into_event(), + }; + let info = event::api::ConnectionInfo {}; + let subscriber_ctx = self + .env + .subscriber() + .create_connection_context(&meta, &info); + + let recv_buffer = recv::buffer::Local::new(buffer, None); + let recv_buffer: either::Either<_, Channel> = Either::A(recv_buffer); + let secret_control = vec![]; // this is only used while returning an error from endpoint::accept_stream + + let export_secret: ExportSecret = + decoded_packet.export_secret().try_into().map_err(|e| { + std::io::Error::new( + ErrorKind::InvalidInput, + format!("Error parsing export secret {:?}", e), + ) + })?; + + // create app pair + let key_id = initial_packet.credentials.key_id; + let initiator = Initiator::Remote; + let secret = Secret::new( + decoded_packet.ciphersuite(), + decoded_packet.version_tag().into(), + Type::Server, + &export_secret, + ); + let application = ApplicationPair::new( + &secret, + key_id, + initiator, + // Dedup should be done in manager + Dedup::disabled(), + ); + + let control = None; + let crypto = Bidirectional { + credentials: initial_packet.credentials, + application, + control, + }; + + let local_port = tcp_stream.local_addr()?.port(); + let socket = LazyBoundStream::Tokio(tcp_stream); + let peer = env::tcp::Reregistered { + socket, + peer_addr: remote_address.into(), + local_port, + recv_buffer, + }; + let stream_builder = match endpoint::accept_stream( + now, + &self.env, + peer, + &initial_packet, + &self.map, + subscriber_ctx, + None, + crypto, + decoded_packet.application_params().clone(), + secret_control, + ) { + Ok(stream) => stream, + Err(error) => { + return Err(std::io::Error::new( + ErrorKind::InvalidData, + format!("Failed to accept stream, err: {:?}", error.error), + )); + } + }; + + { + let remote_address: SocketAddress = stream_builder.shared.remote_addr(); + let remote_address = &remote_address; + let creds = stream_builder.shared.credentials(); + let credential_id = &*creds.id; + let stream_id = creds.key_id.as_u64(); + publisher.on_acceptor_tcp_stream_enqueued(event::builder::AcceptorTcpStreamEnqueued { + remote_address, + credential_id, + stream_id, + sojourn_time: Duration::new(0, 0), + blocked_count: 0, + }); + } + Ok(stream_builder) + } + + fn decode_packet(&self, data: &[u8]) -> std::io::Result { + let mut buffer = data.to_vec(); + let decoder_buffer = DecoderBufferMut::new(&mut buffer); + + match decoder::Packet::decode(decoder_buffer) { + Ok((packet, remaining)) => { + if !remaining.is_empty() { + tracing::warn!("Buffer not empty after decoding packet"); + } + Ok(packet) + } + Err(e) => Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + format!("Failed to decode unix packet: {:?}", e), + )), + } + } + + fn create_tcp_stream_from_fd(&self, fd: OwnedFd) -> std::io::Result { + let std_stream = std::net::TcpStream::from(fd); + std_stream.set_nonblocking(true)?; + TcpStream::from_std(std_stream) + } +} diff --git a/dc/s2n-quic-dc/src/stream/testing.rs b/dc/s2n-quic-dc/src/stream/testing.rs index 2e1404d5bc..20d6cff2f8 100644 --- a/dc/s2n-quic-dc/src/stream/testing.rs +++ b/dc/s2n-quic-dc/src/stream/testing.rs @@ -837,17 +837,18 @@ pub mod server { let socket = options.build_tcp_listener().unwrap(); let local_addr = socket.local_addr().unwrap(); let socket = ::tokio::io::unix::AsyncFd::new(socket).unwrap(); + let channel_behavior = + stream_server::tokio::tcp::worker::DefaultBehavior::new(&sender); let acceptor = stream_server::tokio::tcp::Acceptor::new( 0, socket, - &sender, &env, &map, backlog, flavor, linger, - stream_server::tokio::tcp::worker::DefaultBehavior, + channel_behavior, ) .unwrap(); let acceptor = drop_handle_receiver.wrap(acceptor.run()); diff --git a/dc/s2n-quic-dc/src/stream/tests.rs b/dc/s2n-quic-dc/src/stream/tests.rs index 9ac2d3d726..16ae6fb511 100644 --- a/dc/s2n-quic-dc/src/stream/tests.rs +++ b/dc/s2n-quic-dc/src/stream/tests.rs @@ -14,6 +14,7 @@ mod key_update; mod request_response; mod restart; mod rpc; +mod shared_cache; /// Shows an endpoint doesn't need an application tokio runtime to be created #[test] diff --git a/dc/s2n-quic-dc/src/stream/tests/shared_cache.rs b/dc/s2n-quic-dc/src/stream/tests/shared_cache.rs new file mode 100644 index 0000000000..1e27bd5114 --- /dev/null +++ b/dc/s2n-quic-dc/src/stream/tests/shared_cache.rs @@ -0,0 +1,191 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +// use crate::{handshake, stream::Protocol, testing::init_tracing}; +use crate::{ + path::secret::{stateless_reset::Signer, Map}, + psk::{client::Provider as ClientProvider, server::Provider as ServerProvider}, + stream::{ + client::tokio::Client as ClientTokio, server::manager::Server as ServerTokio, Protocol, + }, + testing::{init_tracing, query_event, server_name, NoopSubscriber, TestTlsProvider}, +}; +use s2n_quic_core::time::StdClock; +use std::{ + num::NonZeroUsize, + path::{Path, PathBuf}, + time::Duration, +}; +use tracing::info; + +#[tokio::test] +async fn setup_servers() { + init_tracing(); + + let tls_materials_provider = TestTlsProvider {}; + let test_event_subscriber = NoopSubscriber {}; + let unix_socket_path1 = PathBuf::from("/tmp/shared1.sock"); + let unix_socket_path2 = PathBuf::from("/tmp/shared2.sock"); + + // Create client + let handshake_client = ClientProvider::builder() + .start( + "127.0.0.1:0".parse().unwrap(), + Map::new( + Signer::new(b"default"), + 100, + StdClock::default(), + test_event_subscriber.clone(), + ), + tls_materials_provider.clone(), + test_event_subscriber.clone(), + query_event, + server_name(), + ) + .unwrap(); + + info!("Handshake client: {:?}", handshake_client.local_addr()); + + let stream_client = ClientTokio::::builder() + .with_tcp(true) + .with_default_protocol(Protocol::Tcp) + .build(handshake_client, test_event_subscriber.clone()) + .unwrap(); + + info!("Client created"); + + // Create manager handshake server + let manager_handshake_map = Map::new( + Signer::new(b"default"), + 1, + StdClock::default(), + test_event_subscriber.clone(), + ); + + let handshake_server = ServerProvider::builder() + .start( + "127.0.0.1:0".parse().unwrap(), + tls_materials_provider.clone(), + test_event_subscriber.clone(), + manager_handshake_map, + ) + .await + .unwrap(); + + info!( + "Manager handshake server: {}", + handshake_server.local_addr() + ); + + let handshake_addr = handshake_server.local_addr(); + stream_client + .handshake_with(handshake_addr, server_name()) + .await + .unwrap(); + info!("Handshake completed"); + + info!("Setting up first manager+application servers"); + test_connection( + &unix_socket_path1, + &handshake_server, + test_event_subscriber.clone(), + &stream_client, + ) + .await; + + info!("Setting up second manager+application servers"); + test_connection( + &unix_socket_path2, + &handshake_server, + test_event_subscriber, + &stream_client, + ) + .await; +} + +async fn test_connection( + unix_socket_path: &Path, + handshake_server: &ServerProvider, + test_event_subscriber: NoopSubscriber, + stream_client: &ClientTokio, +) { + let manager_server = ServerTokio::::builder() + .with_address("127.0.0.1:0".parse().unwrap()) + .with_protocol(Protocol::Tcp) + .with_udp(false) + .with_workers(NonZeroUsize::new(1).unwrap()) + .with_socket_path(unix_socket_path) + .build(handshake_server.clone(), test_event_subscriber.clone()) + .unwrap(); + + info!( + "Manager server created at: {:?}", + manager_server.acceptor_addr() + ); + + let app_server = crate::stream::server::application::Server::::builder() + .with_protocol(Protocol::Tcp) + .with_udp(false) + .with_socket_path(unix_socket_path) + .build(test_event_subscriber.clone()) + .unwrap(); + info!("Application server created"); + + info!("All servers setup completed successfully"); + + let handshake_addr = handshake_server.local_addr(); + let acceptor_addr = manager_server.acceptor_addr().unwrap(); + let connection_result = tokio::try_join!( + stream_client.connect(handshake_addr, acceptor_addr, server_name()), + async { + tokio::time::timeout(Duration::from_secs(5), app_server.accept()) + .await + .unwrap() + } + ); + + assert!( + connection_result.is_ok(), + "Connection should be established successfully" + ); + let (mut client_stream, server_result) = connection_result.unwrap(); + let (mut server_stream, _addr) = server_result; + + info!("Connection established successfully between client and application server"); + + let test_message = b"Hello from server!"; + + let data_exchange_result = tokio::try_join!( + async { + let mut buffer = Vec::new(); + let bytes_read = client_stream.read_into(&mut buffer).await?; + info!( + "Client received {} bytes: {}", + bytes_read, + String::from_utf8_lossy(&buffer[..bytes_read]) + ); + assert_eq!( + &buffer[..bytes_read], + test_message, + "Client should receive the correct message" + ); + Ok::<(), Box>(()) + }, + async { + let mut message_slice = &test_message[..]; + let bytes_written = server_stream.write_from(&mut message_slice).await?; + info!( + "Server sent {} bytes: {}", + bytes_written, + String::from_utf8_lossy(test_message) + ); + Ok::<(), Box>(()) + } + ); + + assert!( + data_exchange_result.is_ok(), + "Data exchange should be successful" + ); + info!("Data exchange completed successfully"); +} diff --git a/dc/s2n-quic-dc/src/uds/receiver.rs b/dc/s2n-quic-dc/src/uds/receiver.rs index 28051e9603..dca9de2c79 100644 --- a/dc/s2n-quic-dc/src/uds/receiver.rs +++ b/dc/s2n-quic-dc/src/uds/receiver.rs @@ -14,13 +14,15 @@ use std::{ }, }, path::{Path, PathBuf}, + sync::Arc, }; -use tokio::io::{unix::AsyncFd, Interest}; +use tokio::io::{unix::AsyncFd, Interest, Ready}; const BUFFER_SIZE: usize = u16::MAX as usize; +#[derive(Clone)] pub struct Receiver { - async_fd: AsyncFd, + async_fd: Arc>, socket_path: PathBuf, } @@ -29,7 +31,7 @@ impl Receiver { let socket = UnixDatagram::bind(socket_path)?; socket.set_nonblocking(true)?; - let async_fd = AsyncFd::new(OwnedFd::from(socket))?; + let async_fd = Arc::new(AsyncFd::new(OwnedFd::from(socket))?); Ok(Self { async_fd, @@ -46,7 +48,7 @@ impl Receiver { return Ok(result); } Err(nix::Error::EAGAIN) => { - guard.clear_ready(); + guard.clear_ready_matching(Ready::READABLE); continue; } Err(e) => { diff --git a/dc/s2n-quic-dc/src/uds/sender.rs b/dc/s2n-quic-dc/src/uds/sender.rs index 622bd0c35f..7bbf763ea1 100644 --- a/dc/s2n-quic-dc/src/uds/sender.rs +++ b/dc/s2n-quic-dc/src/uds/sender.rs @@ -9,7 +9,7 @@ use std::{ }, path::Path, }; -use tokio::io::{unix::AsyncFd, Interest}; +use tokio::io::{unix::AsyncFd, Interest, Ready}; pub struct Sender { socket_fd: AsyncFd, @@ -41,13 +41,11 @@ impl Sender { return Ok(()); } Err(nix::Error::EAGAIN) => { - guard.clear_ready(); + guard.clear_ready_matching(Ready::WRITABLE); continue; } Err(e) => { - let err = Err(std::io::Error::from(e)); - println!("{:?}", err); - return err; + return Err(std::io::Error::from(e)); } } } diff --git a/quic/s2n-quic-core/src/time/timestamp.rs b/quic/s2n-quic-core/src/time/timestamp.rs index a7eb5bf34d..2b3849cb5a 100644 --- a/quic/s2n-quic-core/src/time/timestamp.rs +++ b/quic/s2n-quic-core/src/time/timestamp.rs @@ -3,6 +3,8 @@ //! Defines time related datatypes and functions +use s2n_codec::{decoder_value, DecoderError, Encoder, EncoderValue}; + use crate::recovery::K_GRANULARITY; use core::{fmt, num::NonZeroU64, time::Duration}; @@ -186,6 +188,23 @@ impl core::ops::SubAssign for Timestamp { } } +decoder_value!( + impl<'a> Timestamp { + fn decode(buffer: Buffer) -> Result { + let (time, buffer) = buffer.decode::()?; + let time = NonZeroU64::new(time) + .ok_or(DecoderError::InvariantViolation("Timestamp cannot be 0"))?; + Ok((Self(time), buffer)) + } + } +); + +impl EncoderValue for Timestamp { + fn encode(&self, buffer: &mut E) { + buffer.encode(&self.0.get()); + } +} + #[cfg(test)] mod tests { use super::*;