From fa2e663660f4995b8b09abc04829e418ba966e77 Mon Sep 17 00:00:00 2001 From: Wesley Rosenblum <55108558+WesleyRosenblum@users.noreply.github.com> Date: Mon, 6 Jan 2025 15:53:50 -0800 Subject: [PATCH] events: add ConnectionCloseFrameReceived event (#2436) * create new ConnectionCloseFrameReceived event * fix typo * add helper method and debug to print reason as UTF-8 * put behind alloc feature * PR feedback * add cfg_attr * trying again * trying again --- quic/s2n-quic-core/events/common.rs | 45 + quic/s2n-quic-core/events/connection.rs | 12 + quic/s2n-quic-core/src/event/generated.rs | 205 ++++ .../src/event/generated/metrics.rs | 17 + .../src/event/generated/metrics/aggregate.rs | 1048 +++++++++-------- .../src/event/generated/metrics/probe.rs | 294 ++--- quic/s2n-quic-core/src/packet/encoding.rs | 2 +- .../src/space/application.rs | 21 +- .../s2n-quic-transport/src/space/handshake.rs | 19 +- quic/s2n-quic-transport/src/space/initial.rs | 19 +- quic/s2n-quic-transport/src/space/mod.rs | 10 +- ...s__dc__dc_handshake_self_test__events.snap | 2 + ...dshake_auth_failure_self_test__events.snap | 5 +- ...lient_not_supported_self_test__events.snap | 2 + ...__dc_mtls_handshake_self_test__events.snap | 2 + ...erver_not_supported_self_test__events.snap | 2 + 16 files changed, 1047 insertions(+), 658 deletions(-) diff --git a/quic/s2n-quic-core/events/common.rs b/quic/s2n-quic-core/events/common.rs index 9b1878135f..7f1c173091 100644 --- a/quic/s2n-quic-core/events/common.rs +++ b/quic/s2n-quic-core/events/common.rs @@ -581,6 +581,51 @@ impl<'a> IntoEvent for &crate::frame::DcStatelessResetTokens<'a> } } +#[derive(Clone)] +struct ConnectionCloseFrame<'a> { + error_code: u64, + frame_type: Option, + reason: Option<&'a [u8]>, +} + +#[cfg(feature = "alloc")] +impl<'a> ConnectionCloseFrame<'a> { + /// Converts the reason to a UTF-8 `str`, including invalid characters + pub fn reason_lossy_utf8(&self) -> Option> { + self.reason + .map(|reason| alloc::string::String::from_utf8_lossy(reason)) + } +} + +impl<'a> IntoEvent> for &crate::frame::ConnectionClose<'a> { + #[inline] + fn into_event(self) -> builder::ConnectionCloseFrame<'a> { + builder::ConnectionCloseFrame { + error_code: self.error_code.as_u64(), + frame_type: self.frame_type.into_event(), + reason: self.reason.into_event(), + } + } +} + +#[cfg(feature = "alloc")] +impl<'a> core::fmt::Debug for ConnectionCloseFrame<'a> { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + f.debug_struct("ConnectionCloseFrame") + .field("error_code", &self.error_code) + .field("frame_type", &self.frame_type) + .field("reason", &self.reason_lossy_utf8()) + .finish() + } +} + +#[cfg(not(feature = "alloc"))] +impl<'a> core::fmt::Debug for ConnectionCloseFrame<'a> { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + write!(f, "{:?}", self) + } +} + enum StreamType { Bidirectional, Unidirectional, diff --git a/quic/s2n-quic-core/events/connection.rs b/quic/s2n-quic-core/events/connection.rs index d8f2644521..cb77e33e4c 100644 --- a/quic/s2n-quic-core/events/connection.rs +++ b/quic/s2n-quic-core/events/connection.rs @@ -87,6 +87,18 @@ struct FrameReceived<'a> { frame: Frame, } +/// A `CONNECTION_CLOSE` frame was received +/// +/// This event includes additional details from the frame, particularly the +/// reason (if provided) the peer closed the connection +#[event("transport:connection_close_frame_received")] +struct ConnectionCloseFrameReceived<'a> { + #[nominal_counter("packet")] + packet_header: PacketHeader, + path: Path<'a>, + frame: ConnectionCloseFrame<'a>, +} + #[event("recovery:packet_lost")] //= https://tools.ietf.org/id/draft-marx-qlog-event-definitions-quic-h3-02#5.4.5 /// Packet was lost diff --git a/quic/s2n-quic-core/src/event/generated.rs b/quic/s2n-quic-core/src/event/generated.rs index a5e3fb458b..bc0d15f37c 100644 --- a/quic/s2n-quic-core/src/event/generated.rs +++ b/quic/s2n-quic-core/src/event/generated.rs @@ -202,6 +202,23 @@ pub mod api { fmt.finish() } } + #[non_exhaustive] + #[derive(Clone)] + pub struct ConnectionCloseFrame<'a> { + pub error_code: u64, + pub frame_type: Option, + pub reason: Option<&'a [u8]>, + } + #[cfg(any(test, feature = "testing"))] + impl<'a> crate::event::snapshot::Fmt for ConnectionCloseFrame<'a> { + fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { + let mut fmt = fmt.debug_struct("ConnectionCloseFrame"); + fmt.field("error_code", &self.error_code); + fmt.field("frame_type", &self.frame_type); + fmt.field("reason", &self.reason); + fmt.finish() + } + } #[derive(Clone, Debug)] #[non_exhaustive] pub struct MtuConfig { @@ -1923,6 +1940,30 @@ pub mod api { } #[derive(Clone, Debug)] #[non_exhaustive] + #[doc = " A `CONNECTION_CLOSE` frame was received"] + #[doc = ""] + #[doc = " This event includes additional details from the frame, particularly the"] + #[doc = " reason (if provided) the peer closed the connection"] + pub struct ConnectionCloseFrameReceived<'a> { + pub packet_header: PacketHeader, + pub path: Path<'a>, + pub frame: ConnectionCloseFrame<'a>, + } + #[cfg(any(test, feature = "testing"))] + impl<'a> crate::event::snapshot::Fmt for ConnectionCloseFrameReceived<'a> { + fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { + let mut fmt = fmt.debug_struct("ConnectionCloseFrameReceived"); + fmt.field("packet_header", &self.packet_header); + fmt.field("path", &self.path); + fmt.field("frame", &self.frame); + fmt.finish() + } + } + impl<'a> Event for ConnectionCloseFrameReceived<'a> { + const NAME: &'static str = "transport:connection_close_frame_received"; + } + #[derive(Clone, Debug)] + #[non_exhaustive] #[doc = " Packet was lost"] pub struct PacketLost<'a> { pub packet_header: PacketHeader, @@ -3353,6 +3394,40 @@ pub mod api { builder::Frame::DcStatelessResetTokens {} } } + #[cfg(feature = "alloc")] + impl<'a> ConnectionCloseFrame<'a> { + #[doc = " Converts the reason to a UTF-8 `str`, including invalid characters"] + pub fn reason_lossy_utf8(&self) -> Option> { + self.reason + .map(|reason| alloc::string::String::from_utf8_lossy(reason)) + } + } + impl<'a> IntoEvent> for &crate::frame::ConnectionClose<'a> { + #[inline] + fn into_event(self) -> builder::ConnectionCloseFrame<'a> { + builder::ConnectionCloseFrame { + error_code: self.error_code.as_u64(), + frame_type: self.frame_type.into_event(), + reason: self.reason.into_event(), + } + } + } + #[cfg(feature = "alloc")] + impl<'a> core::fmt::Debug for ConnectionCloseFrame<'a> { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + f.debug_struct("ConnectionCloseFrame") + .field("error_code", &self.error_code) + .field("frame_type", &self.frame_type) + .field("reason", &self.reason_lossy_utf8()) + .finish() + } + } + #[cfg(not(feature = "alloc"))] + impl<'a> core::fmt::Debug for ConnectionCloseFrame<'a> { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + write!(f, "{:?}", self) + } + } impl IntoEvent for &crate::stream::StreamType { #[inline] fn into_event(self) -> builder::StreamType { @@ -3601,6 +3676,21 @@ pub mod tracing { tracing :: event ! (target : "frame_received" , parent : id , tracing :: Level :: DEBUG , { packet_header = tracing :: field :: debug (packet_header) , path = tracing :: field :: debug (path) , frame = tracing :: field :: debug (frame) }); } #[inline] + fn on_connection_close_frame_received( + &mut self, + context: &mut Self::ConnectionContext, + _meta: &api::ConnectionMeta, + event: &api::ConnectionCloseFrameReceived, + ) { + let id = context.id(); + let api::ConnectionCloseFrameReceived { + packet_header, + path, + frame, + } = event; + tracing :: event ! (target : "connection_close_frame_received" , parent : id , tracing :: Level :: DEBUG , { packet_header = tracing :: field :: debug (packet_header) , path = tracing :: field :: debug (path) , frame = tracing :: field :: debug (frame) }); + } + #[inline] fn on_packet_lost( &mut self, context: &mut Self::ConnectionContext, @@ -4411,6 +4501,27 @@ pub mod builder { } } #[derive(Clone, Debug)] + pub struct ConnectionCloseFrame<'a> { + pub error_code: u64, + pub frame_type: Option, + pub reason: Option<&'a [u8]>, + } + impl<'a> IntoEvent> for ConnectionCloseFrame<'a> { + #[inline] + fn into_event(self) -> api::ConnectionCloseFrame<'a> { + let ConnectionCloseFrame { + error_code, + frame_type, + reason, + } = self; + api::ConnectionCloseFrame { + error_code: error_code.into_event(), + frame_type: frame_type.into_event(), + reason: reason.into_event(), + } + } + } + #[derive(Clone, Debug)] pub struct MtuConfig { pub initial_mtu: u16, pub base_mtu: u16, @@ -5480,6 +5591,31 @@ pub mod builder { } } #[derive(Clone, Debug)] + #[doc = " A `CONNECTION_CLOSE` frame was received"] + #[doc = ""] + #[doc = " This event includes additional details from the frame, particularly the"] + #[doc = " reason (if provided) the peer closed the connection"] + pub struct ConnectionCloseFrameReceived<'a> { + pub packet_header: PacketHeader, + pub path: Path<'a>, + pub frame: ConnectionCloseFrame<'a>, + } + impl<'a> IntoEvent> for ConnectionCloseFrameReceived<'a> { + #[inline] + fn into_event(self) -> api::ConnectionCloseFrameReceived<'a> { + let ConnectionCloseFrameReceived { + packet_header, + path, + frame, + } = self; + api::ConnectionCloseFrameReceived { + packet_header: packet_header.into_event(), + path: path.into_event(), + frame: frame.into_event(), + } + } + } + #[derive(Clone, Debug)] #[doc = " Packet was lost"] pub struct PacketLost<'a> { pub packet_header: PacketHeader, @@ -6699,6 +6835,18 @@ mod traits { let _ = meta; let _ = event; } + #[doc = "Called when the `ConnectionCloseFrameReceived` event is triggered"] + #[inline] + fn on_connection_close_frame_received( + &mut self, + context: &mut Self::ConnectionContext, + meta: &api::ConnectionMeta, + event: &api::ConnectionCloseFrameReceived, + ) { + let _ = context; + let _ = meta; + let _ = event; + } #[doc = "Called when the `PacketLost` event is triggered"] #[inline] fn on_packet_lost( @@ -7432,6 +7580,16 @@ mod traits { (self.1).on_frame_received(&mut context.1, meta, event); } #[inline] + fn on_connection_close_frame_received( + &mut self, + context: &mut Self::ConnectionContext, + meta: &api::ConnectionMeta, + event: &api::ConnectionCloseFrameReceived, + ) { + (self.0).on_connection_close_frame_received(&mut context.0, meta, event); + (self.1).on_connection_close_frame_received(&mut context.1, meta, event); + } + #[inline] fn on_packet_lost( &mut self, context: &mut Self::ConnectionContext, @@ -8121,6 +8279,11 @@ mod traits { fn on_frame_sent(&mut self, event: builder::FrameSent); #[doc = "Publishes a `FrameReceived` event to the publisher's subscriber"] fn on_frame_received(&mut self, event: builder::FrameReceived); + #[doc = "Publishes a `ConnectionCloseFrameReceived` event to the publisher's subscriber"] + fn on_connection_close_frame_received( + &mut self, + event: builder::ConnectionCloseFrameReceived, + ); #[doc = "Publishes a `PacketLost` event to the publisher's subscriber"] fn on_packet_lost(&mut self, event: builder::PacketLost); #[doc = "Publishes a `RecoveryMetrics` event to the publisher's subscriber"] @@ -8310,6 +8473,18 @@ mod traits { self.subscriber.on_event(&self.meta, &event); } #[inline] + fn on_connection_close_frame_received( + &mut self, + event: builder::ConnectionCloseFrameReceived, + ) { + let event = event.into_event(); + self.subscriber + .on_connection_close_frame_received(self.context, &self.meta, &event); + self.subscriber + .on_connection_event(self.context, &self.meta, &event); + self.subscriber.on_event(&self.meta, &event); + } + #[inline] fn on_packet_lost(&mut self, event: builder::PacketLost) { let event = event.into_event(); self.subscriber @@ -8882,6 +9057,7 @@ pub mod testing { pub path_created: u64, pub frame_sent: u64, pub frame_received: u64, + pub connection_close_frame_received: u64, pub packet_lost: u64, pub recovery_metrics: u64, pub congestion: u64, @@ -8971,6 +9147,7 @@ pub mod testing { path_created: 0, frame_sent: 0, frame_received: 0, + connection_close_frame_received: 0, packet_lost: 0, recovery_metrics: 0, congestion: 0, @@ -9157,6 +9334,20 @@ pub mod testing { self.output.push(out); } } + fn on_connection_close_frame_received( + &mut self, + _context: &mut Self::ConnectionContext, + meta: &api::ConnectionMeta, + event: &api::ConnectionCloseFrameReceived, + ) { + self.connection_close_frame_received += 1; + if self.location.is_some() { + 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.push(out); + } + } fn on_packet_lost( &mut self, _context: &mut Self::ConnectionContext, @@ -9797,6 +9988,7 @@ pub mod testing { pub path_created: u64, pub frame_sent: u64, pub frame_received: u64, + pub connection_close_frame_received: u64, pub packet_lost: u64, pub recovery_metrics: u64, pub congestion: u64, @@ -9876,6 +10068,7 @@ pub mod testing { path_created: 0, frame_sent: 0, frame_received: 0, + connection_close_frame_received: 0, packet_lost: 0, recovery_metrics: 0, congestion: 0, @@ -10126,6 +10319,18 @@ pub mod testing { self.output.push(out); } } + fn on_connection_close_frame_received( + &mut self, + event: builder::ConnectionCloseFrameReceived, + ) { + self.connection_close_frame_received += 1; + let event = event.into_event(); + if self.location.is_some() { + let event = crate::event::snapshot::Fmt::to_snapshot(&event); + let out = format!("{event:?}"); + self.output.push(out); + } + } fn on_packet_lost(&mut self, event: builder::PacketLost) { self.packet_lost += 1; let event = event.into_event(); diff --git a/quic/s2n-quic-core/src/event/generated/metrics.rs b/quic/s2n-quic-core/src/event/generated/metrics.rs index 206f0c8d6d..6c04188a69 100644 --- a/quic/s2n-quic-core/src/event/generated/metrics.rs +++ b/quic/s2n-quic-core/src/event/generated/metrics.rs @@ -35,6 +35,7 @@ pub struct Context { path_created: u64, frame_sent: u64, frame_received: u64, + connection_close_frame_received: u64, packet_lost: u64, recovery_metrics: u64, congestion: u64, @@ -91,6 +92,7 @@ where path_created: 0, frame_sent: 0, frame_received: 0, + connection_close_frame_received: 0, packet_lost: 0, recovery_metrics: 0, congestion: 0, @@ -227,6 +229,17 @@ where .on_frame_received(&mut context.recorder, meta, event); } #[inline] + fn on_connection_close_frame_received( + &mut self, + context: &mut Self::ConnectionContext, + meta: &api::ConnectionMeta, + event: &api::ConnectionCloseFrameReceived, + ) { + context.connection_close_frame_received += 1; + self.subscriber + .on_connection_close_frame_received(&mut context.recorder, meta, event); + } + #[inline] fn on_packet_lost( &mut self, context: &mut Self::ConnectionContext, @@ -624,6 +637,10 @@ impl Drop for Context { .increment_counter("frame_sent", self.frame_sent as _); self.recorder .increment_counter("frame_received", self.frame_received as _); + self.recorder.increment_counter( + "connection_close_frame_received", + self.connection_close_frame_received as _, + ); self.recorder .increment_counter("packet_lost", self.packet_lost as _); self.recorder diff --git a/quic/s2n-quic-core/src/event/generated/metrics/aggregate.rs b/quic/s2n-quic-core/src/event/generated/metrics/aggregate.rs index 36f88cae2c..6b3d6a8a09 100644 --- a/quic/s2n-quic-core/src/event/generated/metrics/aggregate.rs +++ b/quic/s2n-quic-core/src/event/generated/metrics/aggregate.rs @@ -13,7 +13,7 @@ use crate::event::{ }, }; use alloc::{boxed::Box, vec::Vec}; -static INFO: &[Info; 159usize] = &[ +static INFO: &[Info; 161usize] = &[ info::Builder { id: 0usize, name: Str::new("application_protocol_information\0"), @@ -118,852 +118,864 @@ static INFO: &[Info; 159usize] = &[ .build(), info::Builder { id: 17usize, - name: Str::new("packet_lost\0"), + name: Str::new("connection_close_frame_received\0"), units: Units::None, } .build(), info::Builder { id: 18usize, - name: Str::new("packet_lost.kind\0"), + name: Str::new("connection_close_frame_received.packet\0"), units: Units::None, } .build(), info::Builder { id: 19usize, + name: Str::new("packet_lost\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 20usize, + name: Str::new("packet_lost.kind\0"), + units: Units::None, + } + .build(), + info::Builder { + id: 21usize, name: Str::new("packet_lost.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 20usize, + id: 22usize, name: Str::new("packet_lost.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 21usize, + id: 23usize, name: Str::new("packet_lost.is_mtu_probe\0"), units: Units::None, } .build(), info::Builder { - id: 22usize, + id: 24usize, name: Str::new("recovery_metrics\0"), units: Units::None, } .build(), info::Builder { - id: 23usize, + id: 25usize, name: Str::new("recovery_metrics.min_rtt\0"), units: Units::Duration, } .build(), info::Builder { - id: 24usize, + id: 26usize, name: Str::new("recovery_metrics.smoothed_rtt\0"), units: Units::Duration, } .build(), info::Builder { - id: 25usize, + id: 27usize, name: Str::new("recovery_metrics.latest_rtt\0"), units: Units::Duration, } .build(), info::Builder { - id: 26usize, + id: 28usize, name: Str::new("recovery_metrics.rtt_variance\0"), units: Units::Duration, } .build(), info::Builder { - id: 27usize, + id: 29usize, name: Str::new("recovery_metrics.max_ack_delay\0"), units: Units::Duration, } .build(), info::Builder { - id: 28usize, + id: 30usize, name: Str::new("recovery_metrics.pto_count\0"), units: Units::None, } .build(), info::Builder { - id: 29usize, + id: 31usize, name: Str::new("recovery_metrics.congestion_window\0"), units: Units::Duration, } .build(), info::Builder { - id: 30usize, + id: 32usize, name: Str::new("recovery_metrics.bytes_in_flight\0"), units: Units::Duration, } .build(), info::Builder { - id: 31usize, + id: 33usize, name: Str::new("recovery_metrics.congestion_limited\0"), units: Units::None, } .build(), info::Builder { - id: 32usize, + id: 34usize, name: Str::new("congestion\0"), units: Units::None, } .build(), info::Builder { - id: 33usize, + id: 35usize, name: Str::new("congestion.source\0"), units: Units::None, } .build(), info::Builder { - id: 34usize, + id: 36usize, name: Str::new("rx_ack_range_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 35usize, + id: 37usize, name: Str::new("ack_range_received\0"), units: Units::None, } .build(), info::Builder { - id: 36usize, + id: 38usize, name: Str::new("ack_range_received.packet\0"), units: Units::None, } .build(), info::Builder { - id: 37usize, + id: 39usize, name: Str::new("ack_range_sent\0"), units: Units::None, } .build(), info::Builder { - id: 38usize, + id: 40usize, name: Str::new("ack_range_sent.packet\0"), units: Units::None, } .build(), info::Builder { - id: 39usize, + id: 41usize, name: Str::new("packet_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 40usize, + id: 42usize, name: Str::new("packet_dropped.reason\0"), units: Units::None, } .build(), info::Builder { - id: 41usize, + id: 43usize, name: Str::new("key_update\0"), units: Units::None, } .build(), info::Builder { - id: 42usize, + id: 44usize, name: Str::new("key_update.key_type\0"), units: Units::None, } .build(), info::Builder { - id: 43usize, + id: 45usize, name: Str::new("key_update.cipher_suite\0"), units: Units::None, } .build(), info::Builder { - id: 44usize, + id: 46usize, name: Str::new("key_space_discarded\0"), units: Units::None, } .build(), info::Builder { - id: 45usize, + id: 47usize, name: Str::new("key_space_discarded.initial.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 46usize, + id: 48usize, name: Str::new("key_space_discarded.handshake.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 47usize, + id: 49usize, name: Str::new("key_space_discarded.one_rtt.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 48usize, + id: 50usize, name: Str::new("key_space_discarded.space\0"), units: Units::None, } .build(), info::Builder { - id: 49usize, + id: 51usize, name: Str::new("connection_started\0"), units: Units::None, } .build(), info::Builder { - id: 50usize, + id: 52usize, name: Str::new("duplicate_packet\0"), units: Units::None, } .build(), info::Builder { - id: 51usize, + id: 53usize, name: Str::new("duplicate_packet.kind\0"), units: Units::None, } .build(), info::Builder { - id: 52usize, + id: 54usize, name: Str::new("duplicate_packet.error\0"), units: Units::None, } .build(), info::Builder { - id: 53usize, + id: 55usize, name: Str::new("transport_parameters_received\0"), units: Units::None, } .build(), info::Builder { - id: 54usize, + id: 56usize, name: Str::new("transport_parameters_received.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 55usize, + id: 57usize, name: Str::new("datagram_sent\0"), units: Units::None, } .build(), info::Builder { - id: 56usize, + id: 58usize, name: Str::new("datagram_sent.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 57usize, + id: 59usize, name: Str::new("datagram_sent.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 58usize, + id: 60usize, name: Str::new("datagram_sent.gso_offset\0"), units: Units::None, } .build(), info::Builder { - id: 59usize, + id: 61usize, name: Str::new("datagram_received\0"), units: Units::None, } .build(), info::Builder { - id: 60usize, + id: 62usize, name: Str::new("datagram_received.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 61usize, + id: 63usize, name: Str::new("datagram_received.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 62usize, + id: 64usize, name: Str::new("datagram_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 63usize, + id: 65usize, name: Str::new("datagram_dropped.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 64usize, + id: 66usize, name: Str::new("datagram_dropped.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 65usize, + id: 67usize, name: Str::new("datagram_dropped.reason\0"), units: Units::None, } .build(), info::Builder { - id: 66usize, + id: 68usize, name: Str::new("connection_id_updated\0"), units: Units::None, } .build(), info::Builder { - id: 67usize, + id: 69usize, name: Str::new("ecn_state_changed\0"), units: Units::None, } .build(), info::Builder { - id: 68usize, + id: 70usize, name: Str::new("ecn_state_changed.state\0"), units: Units::None, } .build(), info::Builder { - id: 69usize, + id: 71usize, name: Str::new("connection_migration_denied\0"), units: Units::None, } .build(), info::Builder { - id: 70usize, + id: 72usize, name: Str::new("connection_migration_denied.reason\0"), units: Units::None, } .build(), info::Builder { - id: 71usize, + id: 73usize, name: Str::new("handshake_status_updated\0"), units: Units::None, } .build(), info::Builder { - id: 72usize, + id: 74usize, name: Str::new("handshake_status_updated.complete.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 73usize, + id: 75usize, name: Str::new("handshake_status_updated.confirmed.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 74usize, + id: 76usize, name: Str::new("handshake_status_updated.handshake_done_acked.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 75usize, + id: 77usize, name: Str::new("handshake_status_updated.status\0"), units: Units::None, } .build(), info::Builder { - id: 76usize, + id: 78usize, name: Str::new("tls_exporter_ready\0"), units: Units::None, } .build(), info::Builder { - id: 77usize, + id: 79usize, name: Str::new("path_challenge_updated\0"), units: Units::None, } .build(), info::Builder { - id: 78usize, + id: 80usize, name: Str::new("path_challenge_updated.status\0"), units: Units::None, } .build(), info::Builder { - id: 79usize, + id: 81usize, name: Str::new("tls_client_hello\0"), units: Units::None, } .build(), info::Builder { - id: 80usize, + id: 82usize, name: Str::new("tls_client_hello.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 81usize, + id: 83usize, name: Str::new("tls_server_hello\0"), units: Units::None, } .build(), info::Builder { - id: 82usize, + id: 84usize, name: Str::new("tls_server_hello.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 83usize, + id: 85usize, name: Str::new("rx_stream_progress\0"), units: Units::None, } .build(), info::Builder { - id: 84usize, + id: 86usize, name: Str::new("rx_stream_progress.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 85usize, + id: 87usize, name: Str::new("rx_stream_progress.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 86usize, + id: 88usize, name: Str::new("tx_stream_progress\0"), units: Units::None, } .build(), info::Builder { - id: 87usize, + id: 89usize, name: Str::new("tx_stream_progress.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 88usize, + id: 90usize, name: Str::new("tx_stream_progress.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 89usize, + id: 91usize, name: Str::new("keep_alive_timer_expired\0"), units: Units::None, } .build(), info::Builder { - id: 90usize, + id: 92usize, name: Str::new("mtu_updated\0"), units: Units::None, } .build(), info::Builder { - id: 91usize, + id: 93usize, name: Str::new("mtu_updated.mtu\0"), units: Units::Bytes, } .build(), info::Builder { - id: 92usize, + id: 94usize, name: Str::new("mtu_updated.cause\0"), units: Units::None, } .build(), info::Builder { - id: 93usize, + id: 95usize, name: Str::new("mtu_updated.search_complete\0"), units: Units::None, } .build(), info::Builder { - id: 94usize, + id: 96usize, name: Str::new("slow_start_exited\0"), units: Units::None, } .build(), info::Builder { - id: 95usize, + id: 97usize, name: Str::new("slow_start_exited.cause\0"), units: Units::None, } .build(), info::Builder { - id: 96usize, + id: 98usize, name: Str::new("slow_start_exited.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 97usize, + id: 99usize, name: Str::new("slow_start_exited.congestion_window\0"), units: Units::Bytes, } .build(), info::Builder { - id: 98usize, + id: 100usize, name: Str::new("delivery_rate_sampled\0"), units: Units::None, } .build(), info::Builder { - id: 99usize, + id: 101usize, name: Str::new("pacing_rate_updated\0"), units: Units::None, } .build(), info::Builder { - id: 100usize, + id: 102usize, name: Str::new("pacing_rate_updated.bytes_per_second\0"), units: Units::Bytes, } .build(), info::Builder { - id: 101usize, + id: 103usize, name: Str::new("pacing_rate_updated.burst_size\0"), units: Units::Bytes, } .build(), info::Builder { - id: 102usize, + id: 104usize, name: Str::new("pacing_rate_updated.pacing_gain\0"), units: Units::None, } .build(), info::Builder { - id: 103usize, + id: 105usize, name: Str::new("bbr_state_changed\0"), units: Units::None, } .build(), info::Builder { - id: 104usize, + id: 106usize, name: Str::new("bbr_state_changed.state\0"), units: Units::None, } .build(), info::Builder { - id: 105usize, + id: 107usize, name: Str::new("dc_state_changed\0"), units: Units::None, } .build(), info::Builder { - id: 106usize, + id: 108usize, name: Str::new("dc_state_changed.version_negotiated.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 107usize, + id: 109usize, name: Str::new("dc_state_changed.no_version_negotiated.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 108usize, + id: 110usize, name: Str::new("dc_state_changed.path_secrets.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 109usize, + id: 111usize, name: Str::new("dc_state_changed.complete.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 110usize, + id: 112usize, name: Str::new("dc_state_changed.state\0"), units: Units::None, } .build(), info::Builder { - id: 111usize, + id: 113usize, name: Str::new("connection_closed\0"), units: Units::None, } .build(), info::Builder { - id: 112usize, + id: 114usize, name: Str::new("connection_closed.latency\0"), units: Units::Duration, } .build(), info::Builder { - id: 113usize, + id: 115usize, name: Str::new("connection_closed.error\0"), units: Units::None, } .build(), info::Builder { - id: 114usize, + id: 116usize, name: Str::new("version_information\0"), units: Units::None, } .build(), info::Builder { - id: 115usize, + id: 117usize, name: Str::new("endpoint_packet_sent\0"), units: Units::None, } .build(), info::Builder { - id: 116usize, + id: 118usize, name: Str::new("endpoint_packet_received\0"), units: Units::None, } .build(), info::Builder { - id: 117usize, + id: 119usize, name: Str::new("endpoint_datagram_sent\0"), units: Units::None, } .build(), info::Builder { - id: 118usize, + id: 120usize, name: Str::new("endpoint_datagram_sent.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 119usize, + id: 121usize, name: Str::new("endpoint_datagram_sent.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 120usize, + id: 122usize, name: Str::new("endpoint_datagram_sent.gso_offset\0"), units: Units::None, } .build(), info::Builder { - id: 121usize, + id: 123usize, name: Str::new("endpoint_datagram_received\0"), units: Units::None, } .build(), info::Builder { - id: 122usize, + id: 124usize, name: Str::new("endpoint_datagram_received.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 123usize, + id: 125usize, name: Str::new("endpoint_datagram_received.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 124usize, + id: 126usize, name: Str::new("endpoint_datagram_dropped\0"), units: Units::None, } .build(), info::Builder { - id: 125usize, + id: 127usize, name: Str::new("endpoint_datagram_dropped.bytes\0"), units: Units::Bytes, } .build(), info::Builder { - id: 126usize, + id: 128usize, name: Str::new("endpoint_datagram_dropped.bytes.total\0"), units: Units::Bytes, } .build(), info::Builder { - id: 127usize, + id: 129usize, name: Str::new("endpoint_datagram_dropped.reason\0"), units: Units::None, } .build(), info::Builder { - id: 128usize, + id: 130usize, name: Str::new("endpoint_connection_attempt_failed\0"), units: Units::None, } .build(), info::Builder { - id: 129usize, + id: 131usize, name: Str::new("endpoint_connection_attempt_failed.error\0"), units: Units::None, } .build(), info::Builder { - id: 130usize, + id: 132usize, name: Str::new("platform_tx\0"), units: Units::None, } .build(), info::Builder { - id: 131usize, + id: 133usize, name: Str::new("platform_tx.packets.total\0"), units: Units::None, } .build(), info::Builder { - id: 132usize, + id: 134usize, name: Str::new("platform_tx.packets\0"), units: Units::None, } .build(), info::Builder { - id: 133usize, + id: 135usize, name: Str::new("platform_tx.syscalls.total\0"), units: Units::None, } .build(), info::Builder { - id: 134usize, + id: 136usize, name: Str::new("platform_tx.syscalls\0"), units: Units::None, } .build(), info::Builder { - id: 135usize, + id: 137usize, name: Str::new("platform_tx.syscalls.blocked.total\0"), units: Units::None, } .build(), info::Builder { - id: 136usize, + id: 138usize, name: Str::new("platform_tx.syscalls.blocked\0"), units: Units::None, } .build(), info::Builder { - id: 137usize, + id: 139usize, name: Str::new("platform_tx.errors.total\0"), units: Units::None, } .build(), info::Builder { - id: 138usize, + id: 140usize, name: Str::new("platform_tx.errors\0"), units: Units::None, } .build(), info::Builder { - id: 139usize, + id: 141usize, name: Str::new("platform_tx.errors.dropped.total\0"), units: Units::None, } .build(), info::Builder { - id: 140usize, + id: 142usize, name: Str::new("platform_tx.errors.dropped\0"), units: Units::None, } .build(), info::Builder { - id: 141usize, + id: 143usize, name: Str::new("platform_tx_error\0"), units: Units::None, } .build(), info::Builder { - id: 142usize, + id: 144usize, name: Str::new("platform_rx\0"), units: Units::None, } .build(), info::Builder { - id: 143usize, + id: 145usize, name: Str::new("platform_rx.packets.total\0"), units: Units::None, } .build(), info::Builder { - id: 144usize, + id: 146usize, name: Str::new("platform_rx.packets\0"), units: Units::None, } .build(), info::Builder { - id: 145usize, + id: 147usize, name: Str::new("platform_rx.syscalls.total\0"), units: Units::None, } .build(), info::Builder { - id: 146usize, + id: 148usize, name: Str::new("platform_rx.syscalls\0"), units: Units::None, } .build(), info::Builder { - id: 147usize, + id: 149usize, name: Str::new("platform_rx.syscalls.blocked.total\0"), units: Units::None, } .build(), info::Builder { - id: 148usize, + id: 150usize, name: Str::new("platform_rx.syscalls.blocked\0"), units: Units::None, } .build(), info::Builder { - id: 149usize, + id: 151usize, name: Str::new("platform_rx.errors.total\0"), units: Units::None, } .build(), info::Builder { - id: 150usize, + id: 152usize, name: Str::new("platform_rx.errors\0"), units: Units::None, } .build(), info::Builder { - id: 151usize, + id: 153usize, name: Str::new("platform_rx.errors.dropped.total\0"), units: Units::None, } .build(), info::Builder { - id: 152usize, + id: 154usize, name: Str::new("platform_rx.errors.dropped\0"), units: Units::None, } .build(), info::Builder { - id: 153usize, + id: 155usize, name: Str::new("platform_rx_error\0"), units: Units::None, } .build(), info::Builder { - id: 154usize, + id: 156usize, name: Str::new("platform_feature_configured\0"), units: Units::None, } .build(), info::Builder { - id: 155usize, + id: 157usize, name: Str::new("platform_event_loop_wakeup\0"), units: Units::None, } .build(), info::Builder { - id: 156usize, + id: 158usize, name: Str::new("platform_event_loop_sleep\0"), units: Units::None, } .build(), info::Builder { - id: 157usize, + id: 159usize, name: Str::new("platform_event_loop_sleep.processing_duration\0"), units: Units::Duration, } .build(), info::Builder { - id: 158usize, + id: 160usize, name: Str::new("platform_event_loop_started\0"), units: Units::None, } @@ -976,13 +988,13 @@ pub struct ConnectionContext { } pub struct Subscriber { #[allow(dead_code)] - counters: Box<[R::Counter; 74usize]>, + counters: Box<[R::Counter; 75usize]>, #[allow(dead_code)] bool_counters: Box<[R::BoolCounter; 3usize]>, #[allow(dead_code)] nominal_counters: Box<[R::NominalCounter]>, #[allow(dead_code)] - nominal_counter_offsets: Box<[usize; 28usize]>, + nominal_counter_offsets: Box<[usize; 29usize]>, #[allow(dead_code)] measures: Box<[R::Measure; 38usize]>, #[allow(dead_code)] @@ -1011,10 +1023,10 @@ impl Subscriber { #[allow(unused_mut)] #[inline] pub fn new(registry: R) -> Self { - let mut counters = Vec::with_capacity(74usize); + let mut counters = Vec::with_capacity(75usize); let mut bool_counters = Vec::with_capacity(3usize); - let mut nominal_counters = Vec::with_capacity(28usize); - let mut nominal_counter_offsets = Vec::with_capacity(28usize); + let mut nominal_counters = Vec::with_capacity(29usize); + let mut nominal_counter_offsets = Vec::with_capacity(29usize); let mut measures = Vec::with_capacity(38usize); let mut gauges = Vec::with_capacity(0usize); let mut timers = Vec::with_capacity(15usize); @@ -1032,71 +1044,72 @@ impl Subscriber { counters.push(registry.register_counter(&INFO[14usize])); counters.push(registry.register_counter(&INFO[17usize])); counters.push(registry.register_counter(&INFO[19usize])); - counters.push(registry.register_counter(&INFO[22usize])); - counters.push(registry.register_counter(&INFO[32usize])); + counters.push(registry.register_counter(&INFO[21usize])); + counters.push(registry.register_counter(&INFO[24usize])); counters.push(registry.register_counter(&INFO[34usize])); - counters.push(registry.register_counter(&INFO[35usize])); + counters.push(registry.register_counter(&INFO[36usize])); counters.push(registry.register_counter(&INFO[37usize])); counters.push(registry.register_counter(&INFO[39usize])); counters.push(registry.register_counter(&INFO[41usize])); - counters.push(registry.register_counter(&INFO[44usize])); - counters.push(registry.register_counter(&INFO[49usize])); - counters.push(registry.register_counter(&INFO[50usize])); - counters.push(registry.register_counter(&INFO[53usize])); + counters.push(registry.register_counter(&INFO[43usize])); + counters.push(registry.register_counter(&INFO[46usize])); + counters.push(registry.register_counter(&INFO[51usize])); + counters.push(registry.register_counter(&INFO[52usize])); counters.push(registry.register_counter(&INFO[55usize])); - counters.push(registry.register_counter(&INFO[56usize])); - counters.push(registry.register_counter(&INFO[59usize])); - counters.push(registry.register_counter(&INFO[60usize])); + counters.push(registry.register_counter(&INFO[57usize])); + counters.push(registry.register_counter(&INFO[58usize])); + counters.push(registry.register_counter(&INFO[61usize])); counters.push(registry.register_counter(&INFO[62usize])); - counters.push(registry.register_counter(&INFO[63usize])); - counters.push(registry.register_counter(&INFO[66usize])); - counters.push(registry.register_counter(&INFO[67usize])); + counters.push(registry.register_counter(&INFO[64usize])); + counters.push(registry.register_counter(&INFO[65usize])); + counters.push(registry.register_counter(&INFO[68usize])); counters.push(registry.register_counter(&INFO[69usize])); counters.push(registry.register_counter(&INFO[71usize])); - counters.push(registry.register_counter(&INFO[76usize])); - counters.push(registry.register_counter(&INFO[77usize])); + counters.push(registry.register_counter(&INFO[73usize])); + counters.push(registry.register_counter(&INFO[78usize])); counters.push(registry.register_counter(&INFO[79usize])); counters.push(registry.register_counter(&INFO[81usize])); counters.push(registry.register_counter(&INFO[83usize])); - counters.push(registry.register_counter(&INFO[84usize])); + counters.push(registry.register_counter(&INFO[85usize])); counters.push(registry.register_counter(&INFO[86usize])); - counters.push(registry.register_counter(&INFO[87usize])); + counters.push(registry.register_counter(&INFO[88usize])); counters.push(registry.register_counter(&INFO[89usize])); - counters.push(registry.register_counter(&INFO[90usize])); - counters.push(registry.register_counter(&INFO[94usize])); - counters.push(registry.register_counter(&INFO[98usize])); - counters.push(registry.register_counter(&INFO[99usize])); - counters.push(registry.register_counter(&INFO[103usize])); + counters.push(registry.register_counter(&INFO[91usize])); + counters.push(registry.register_counter(&INFO[92usize])); + counters.push(registry.register_counter(&INFO[96usize])); + counters.push(registry.register_counter(&INFO[100usize])); + 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[114usize])); - counters.push(registry.register_counter(&INFO[115usize])); + counters.push(registry.register_counter(&INFO[107usize])); + counters.push(registry.register_counter(&INFO[113usize])); counters.push(registry.register_counter(&INFO[116usize])); counters.push(registry.register_counter(&INFO[117usize])); - counters.push(registry.register_counter(&INFO[121usize])); - counters.push(registry.register_counter(&INFO[124usize])); - counters.push(registry.register_counter(&INFO[128usize])); + counters.push(registry.register_counter(&INFO[118usize])); + counters.push(registry.register_counter(&INFO[119usize])); + counters.push(registry.register_counter(&INFO[123usize])); + counters.push(registry.register_counter(&INFO[126usize])); counters.push(registry.register_counter(&INFO[130usize])); - counters.push(registry.register_counter(&INFO[131usize])); + counters.push(registry.register_counter(&INFO[132usize])); counters.push(registry.register_counter(&INFO[133usize])); counters.push(registry.register_counter(&INFO[135usize])); counters.push(registry.register_counter(&INFO[137usize])); counters.push(registry.register_counter(&INFO[139usize])); counters.push(registry.register_counter(&INFO[141usize])); - counters.push(registry.register_counter(&INFO[142usize])); counters.push(registry.register_counter(&INFO[143usize])); + counters.push(registry.register_counter(&INFO[144usize])); counters.push(registry.register_counter(&INFO[145usize])); 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[153usize])); - counters.push(registry.register_counter(&INFO[154usize])); counters.push(registry.register_counter(&INFO[155usize])); counters.push(registry.register_counter(&INFO[156usize])); + counters.push(registry.register_counter(&INFO[157usize])); counters.push(registry.register_counter(&INFO[158usize])); - bool_counters.push(registry.register_bool_counter(&INFO[21usize])); - bool_counters.push(registry.register_bool_counter(&INFO[31usize])); - bool_counters.push(registry.register_bool_counter(&INFO[93usize])); + counters.push(registry.register_counter(&INFO[160usize])); + bool_counters.push(registry.register_bool_counter(&INFO[23usize])); + bool_counters.push(registry.register_bool_counter(&INFO[33usize])); + bool_counters.push(registry.register_bool_counter(&INFO[95usize])); { #[allow(unused_imports)] use api::*; @@ -1177,12 +1190,23 @@ impl Subscriber { debug_assert_ne!(count, 0, "field type needs at least one variant"); nominal_counter_offsets.push(offset); } + { + let offset = nominal_counters.len(); + let mut count = 0; + for variant in ::VARIANTS.iter() { + nominal_counters + .push(registry.register_nominal_counter(&INFO[20usize], variant)); + count += 1; + } + debug_assert_ne!(count, 0, "field type needs at least one variant"); + nominal_counter_offsets.push(offset); + } { let offset = nominal_counters.len(); let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[33usize], variant)); + .push(registry.register_nominal_counter(&INFO[35usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1193,7 +1217,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[36usize], variant)); + .push(registry.register_nominal_counter(&INFO[38usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1204,7 +1228,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[38usize], variant)); + .push(registry.register_nominal_counter(&INFO[40usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1215,7 +1239,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[40usize], variant)); + .push(registry.register_nominal_counter(&INFO[42usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1226,7 +1250,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[42usize], variant)); + .push(registry.register_nominal_counter(&INFO[44usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1237,7 +1261,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[43usize], variant)); + .push(registry.register_nominal_counter(&INFO[45usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1248,7 +1272,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[48usize], variant)); + .push(registry.register_nominal_counter(&INFO[50usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1259,7 +1283,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[51usize], variant)); + .push(registry.register_nominal_counter(&INFO[53usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1270,7 +1294,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[52usize], variant)); + .push(registry.register_nominal_counter(&INFO[54usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1281,7 +1305,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[65usize], variant)); + .push(registry.register_nominal_counter(&INFO[67usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1292,7 +1316,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[68usize], variant)); + .push(registry.register_nominal_counter(&INFO[70usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1303,7 +1327,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[70usize], variant)); + .push(registry.register_nominal_counter(&INFO[72usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1314,7 +1338,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[75usize], variant)); + .push(registry.register_nominal_counter(&INFO[77usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1325,7 +1349,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[78usize], variant)); + .push(registry.register_nominal_counter(&INFO[80usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1336,7 +1360,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[92usize], variant)); + .push(registry.register_nominal_counter(&INFO[94usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1347,7 +1371,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[95usize], variant)); + .push(registry.register_nominal_counter(&INFO[97usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1358,7 +1382,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[104usize], variant)); + .push(registry.register_nominal_counter(&INFO[106usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1369,7 +1393,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[110usize], variant)); + .push(registry.register_nominal_counter(&INFO[112usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1380,7 +1404,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[113usize], variant)); + .push(registry.register_nominal_counter(&INFO[115usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1391,7 +1415,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[127usize], variant)); + .push(registry.register_nominal_counter(&INFO[129usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1402,7 +1426,7 @@ impl Subscriber { let mut count = 0; for variant in ::VARIANTS.iter() { nominal_counters - .push(registry.register_nominal_counter(&INFO[129usize], variant)); + .push(registry.register_nominal_counter(&INFO[131usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1410,58 +1434,58 @@ impl Subscriber { } } measures.push(registry.register_measure(&INFO[6usize])); - measures.push(registry.register_measure(&INFO[20usize])); - measures.push(registry.register_measure(&INFO[23usize])); - measures.push(registry.register_measure(&INFO[24usize])); + measures.push(registry.register_measure(&INFO[22usize])); measures.push(registry.register_measure(&INFO[25usize])); measures.push(registry.register_measure(&INFO[26usize])); measures.push(registry.register_measure(&INFO[27usize])); measures.push(registry.register_measure(&INFO[28usize])); measures.push(registry.register_measure(&INFO[29usize])); measures.push(registry.register_measure(&INFO[30usize])); - measures.push(registry.register_measure(&INFO[57usize])); - measures.push(registry.register_measure(&INFO[58usize])); - measures.push(registry.register_measure(&INFO[61usize])); - measures.push(registry.register_measure(&INFO[64usize])); - 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[97usize])); - measures.push(registry.register_measure(&INFO[100usize])); - measures.push(registry.register_measure(&INFO[101usize])); + measures.push(registry.register_measure(&INFO[31usize])); + measures.push(registry.register_measure(&INFO[32usize])); + measures.push(registry.register_measure(&INFO[59usize])); + measures.push(registry.register_measure(&INFO[60usize])); + measures.push(registry.register_measure(&INFO[63usize])); + measures.push(registry.register_measure(&INFO[66usize])); + measures.push(registry.register_measure(&INFO[87usize])); + measures.push(registry.register_measure(&INFO[90usize])); + measures.push(registry.register_measure(&INFO[93usize])); + measures.push(registry.register_measure(&INFO[99usize])); measures.push(registry.register_measure(&INFO[102usize])); - measures.push(registry.register_measure(&INFO[118usize])); - measures.push(registry.register_measure(&INFO[119usize])); + measures.push(registry.register_measure(&INFO[103usize])); + measures.push(registry.register_measure(&INFO[104usize])); measures.push(registry.register_measure(&INFO[120usize])); + measures.push(registry.register_measure(&INFO[121usize])); measures.push(registry.register_measure(&INFO[122usize])); - 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[126usize])); - measures.push(registry.register_measure(&INFO[132usize])); + measures.push(registry.register_measure(&INFO[127usize])); + measures.push(registry.register_measure(&INFO[128usize])); measures.push(registry.register_measure(&INFO[134usize])); measures.push(registry.register_measure(&INFO[136usize])); measures.push(registry.register_measure(&INFO[138usize])); measures.push(registry.register_measure(&INFO[140usize])); - measures.push(registry.register_measure(&INFO[144usize])); + measures.push(registry.register_measure(&INFO[142usize])); measures.push(registry.register_measure(&INFO[146usize])); measures.push(registry.register_measure(&INFO[148usize])); measures.push(registry.register_measure(&INFO[150usize])); measures.push(registry.register_measure(&INFO[152usize])); - timers.push(registry.register_timer(&INFO[45usize])); - timers.push(registry.register_timer(&INFO[46usize])); + measures.push(registry.register_measure(&INFO[154usize])); timers.push(registry.register_timer(&INFO[47usize])); - timers.push(registry.register_timer(&INFO[54usize])); - timers.push(registry.register_timer(&INFO[72usize])); - timers.push(registry.register_timer(&INFO[73usize])); + timers.push(registry.register_timer(&INFO[48usize])); + timers.push(registry.register_timer(&INFO[49usize])); + timers.push(registry.register_timer(&INFO[56usize])); timers.push(registry.register_timer(&INFO[74usize])); - timers.push(registry.register_timer(&INFO[80usize])); + timers.push(registry.register_timer(&INFO[75usize])); + timers.push(registry.register_timer(&INFO[76usize])); timers.push(registry.register_timer(&INFO[82usize])); - timers.push(registry.register_timer(&INFO[106usize])); - timers.push(registry.register_timer(&INFO[107usize])); + timers.push(registry.register_timer(&INFO[84usize])); timers.push(registry.register_timer(&INFO[108usize])); timers.push(registry.register_timer(&INFO[109usize])); - timers.push(registry.register_timer(&INFO[112usize])); - timers.push(registry.register_timer(&INFO[157usize])); + timers.push(registry.register_timer(&INFO[110usize])); + timers.push(registry.register_timer(&INFO[111usize])); + timers.push(registry.register_timer(&INFO[114usize])); + timers.push(registry.register_timer(&INFO[159usize])); { #[allow(unused_imports)] use api::*; @@ -1469,7 +1493,7 @@ impl Subscriber { let offset = nominal_timers.len(); let mut count = 0; for variant in ::VARIANTS.iter() { - nominal_timers.push(registry.register_nominal_timer(&INFO[96usize], variant)); + nominal_timers.push(registry.register_nominal_timer(&INFO[98usize], variant)); count += 1; } debug_assert_ne!(count, 0, "field type needs at least one variant"); @@ -1518,68 +1542,69 @@ impl Subscriber { 9usize => (&INFO[14usize], entry), 10usize => (&INFO[17usize], entry), 11usize => (&INFO[19usize], entry), - 12usize => (&INFO[22usize], entry), - 13usize => (&INFO[32usize], entry), + 12usize => (&INFO[21usize], entry), + 13usize => (&INFO[24usize], entry), 14usize => (&INFO[34usize], entry), - 15usize => (&INFO[35usize], entry), + 15usize => (&INFO[36usize], entry), 16usize => (&INFO[37usize], entry), 17usize => (&INFO[39usize], entry), 18usize => (&INFO[41usize], entry), - 19usize => (&INFO[44usize], entry), - 20usize => (&INFO[49usize], entry), - 21usize => (&INFO[50usize], entry), - 22usize => (&INFO[53usize], entry), + 19usize => (&INFO[43usize], entry), + 20usize => (&INFO[46usize], entry), + 21usize => (&INFO[51usize], entry), + 22usize => (&INFO[52usize], entry), 23usize => (&INFO[55usize], entry), - 24usize => (&INFO[56usize], entry), - 25usize => (&INFO[59usize], entry), - 26usize => (&INFO[60usize], entry), + 24usize => (&INFO[57usize], entry), + 25usize => (&INFO[58usize], entry), + 26usize => (&INFO[61usize], entry), 27usize => (&INFO[62usize], entry), - 28usize => (&INFO[63usize], entry), - 29usize => (&INFO[66usize], entry), - 30usize => (&INFO[67usize], entry), + 28usize => (&INFO[64usize], entry), + 29usize => (&INFO[65usize], entry), + 30usize => (&INFO[68usize], entry), 31usize => (&INFO[69usize], entry), 32usize => (&INFO[71usize], entry), - 33usize => (&INFO[76usize], entry), - 34usize => (&INFO[77usize], entry), + 33usize => (&INFO[73usize], entry), + 34usize => (&INFO[78usize], entry), 35usize => (&INFO[79usize], entry), 36usize => (&INFO[81usize], entry), 37usize => (&INFO[83usize], entry), - 38usize => (&INFO[84usize], entry), + 38usize => (&INFO[85usize], entry), 39usize => (&INFO[86usize], entry), - 40usize => (&INFO[87usize], entry), + 40usize => (&INFO[88usize], entry), 41usize => (&INFO[89usize], entry), - 42usize => (&INFO[90usize], entry), - 43usize => (&INFO[94usize], entry), - 44usize => (&INFO[98usize], entry), - 45usize => (&INFO[99usize], entry), - 46usize => (&INFO[103usize], entry), + 42usize => (&INFO[91usize], entry), + 43usize => (&INFO[92usize], entry), + 44usize => (&INFO[96usize], entry), + 45usize => (&INFO[100usize], entry), + 46usize => (&INFO[101usize], entry), 47usize => (&INFO[105usize], entry), - 48usize => (&INFO[111usize], entry), - 49usize => (&INFO[114usize], entry), - 50usize => (&INFO[115usize], entry), - 51usize => (&INFO[116usize], entry), - 52usize => (&INFO[117usize], entry), - 53usize => (&INFO[121usize], entry), - 54usize => (&INFO[124usize], entry), - 55usize => (&INFO[128usize], entry), + 48usize => (&INFO[107usize], entry), + 49usize => (&INFO[113usize], entry), + 50usize => (&INFO[116usize], entry), + 51usize => (&INFO[117usize], entry), + 52usize => (&INFO[118usize], entry), + 53usize => (&INFO[119usize], entry), + 54usize => (&INFO[123usize], entry), + 55usize => (&INFO[126usize], entry), 56usize => (&INFO[130usize], entry), - 57usize => (&INFO[131usize], entry), + 57usize => (&INFO[132usize], entry), 58usize => (&INFO[133usize], entry), 59usize => (&INFO[135usize], entry), 60usize => (&INFO[137usize], entry), 61usize => (&INFO[139usize], entry), 62usize => (&INFO[141usize], entry), - 63usize => (&INFO[142usize], entry), - 64usize => (&INFO[143usize], entry), + 63usize => (&INFO[143usize], entry), + 64usize => (&INFO[144usize], entry), 65usize => (&INFO[145usize], entry), 66usize => (&INFO[147usize], entry), 67usize => (&INFO[149usize], entry), 68usize => (&INFO[151usize], entry), 69usize => (&INFO[153usize], entry), - 70usize => (&INFO[154usize], entry), - 71usize => (&INFO[155usize], entry), - 72usize => (&INFO[156usize], entry), + 70usize => (&INFO[155usize], entry), + 71usize => (&INFO[156usize], entry), + 72usize => (&INFO[157usize], entry), 73usize => (&INFO[158usize], entry), + 74usize => (&INFO[160usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1597,9 +1622,9 @@ impl Subscriber { .iter() .enumerate() .map(|(idx, entry)| match idx { - 0usize => (&INFO[21usize], entry), - 1usize => (&INFO[31usize], entry), - 2usize => (&INFO[93usize], entry), + 0usize => (&INFO[23usize], entry), + 1usize => (&INFO[33usize], entry), + 2usize => (&INFO[95usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1664,15 +1689,15 @@ impl Subscriber { } 7usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[33usize], entries, variants) + (&INFO[20usize], entries, variants) } 8usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[36usize], entries, variants) + (&INFO[35usize], entries, variants) } 9usize => { let offset = *entry; @@ -1682,112 +1707,118 @@ impl Subscriber { } 10usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; (&INFO[40usize], entries, variants) } 11usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; (&INFO[42usize], entries, variants) } 12usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[43usize], entries, variants) + (&INFO[44usize], entries, variants) } 13usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[48usize], entries, variants) + (&INFO[45usize], entries, variants) } 14usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[51usize], entries, variants) + (&INFO[50usize], entries, variants) } 15usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[52usize], entries, variants) + (&INFO[53usize], entries, variants) } 16usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[65usize], entries, variants) + (&INFO[54usize], entries, variants) } 17usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[68usize], entries, variants) + (&INFO[67usize], entries, variants) } 18usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; (&INFO[70usize], entries, variants) } 19usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[75usize], entries, variants) + (&INFO[72usize], entries, variants) } 20usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[78usize], entries, variants) + (&INFO[77usize], entries, variants) } 21usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[92usize], entries, variants) + (&INFO[80usize], entries, variants) } 22usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[95usize], entries, variants) + (&INFO[94usize], entries, variants) } 23usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[104usize], entries, variants) + (&INFO[97usize], entries, variants) } 24usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[110usize], entries, variants) + (&INFO[106usize], entries, variants) } 25usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[113usize], entries, variants) + (&INFO[112usize], entries, variants) } 26usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; - (&INFO[127usize], entries, variants) + (&INFO[115usize], entries, variants) } 27usize => { let offset = *entry; - let variants = ::VARIANTS; + let variants = ::VARIANTS; let entries = &self.nominal_counters[offset..offset + variants.len()]; (&INFO[129usize], entries, variants) } + 28usize => { + let offset = *entry; + let variants = ::VARIANTS; + let entries = &self.nominal_counters[offset..offset + variants.len()]; + (&INFO[131usize], entries, variants) + } _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1807,43 +1838,43 @@ impl Subscriber { .enumerate() .map(|(idx, entry)| match idx { 0usize => (&INFO[6usize], entry), - 1usize => (&INFO[20usize], entry), - 2usize => (&INFO[23usize], entry), - 3usize => (&INFO[24usize], entry), - 4usize => (&INFO[25usize], entry), - 5usize => (&INFO[26usize], entry), - 6usize => (&INFO[27usize], entry), - 7usize => (&INFO[28usize], entry), - 8usize => (&INFO[29usize], entry), - 9usize => (&INFO[30usize], entry), - 10usize => (&INFO[57usize], entry), - 11usize => (&INFO[58usize], entry), - 12usize => (&INFO[61usize], entry), - 13usize => (&INFO[64usize], entry), - 14usize => (&INFO[85usize], entry), - 15usize => (&INFO[88usize], entry), - 16usize => (&INFO[91usize], entry), - 17usize => (&INFO[97usize], entry), - 18usize => (&INFO[100usize], entry), - 19usize => (&INFO[101usize], entry), - 20usize => (&INFO[102usize], entry), - 21usize => (&INFO[118usize], entry), - 22usize => (&INFO[119usize], entry), - 23usize => (&INFO[120usize], entry), - 24usize => (&INFO[122usize], entry), - 25usize => (&INFO[123usize], entry), - 26usize => (&INFO[125usize], entry), - 27usize => (&INFO[126usize], entry), - 28usize => (&INFO[132usize], entry), - 29usize => (&INFO[134usize], entry), - 30usize => (&INFO[136usize], entry), - 31usize => (&INFO[138usize], entry), - 32usize => (&INFO[140usize], entry), - 33usize => (&INFO[144usize], entry), - 34usize => (&INFO[146usize], entry), - 35usize => (&INFO[148usize], entry), - 36usize => (&INFO[150usize], entry), - 37usize => (&INFO[152usize], entry), + 1usize => (&INFO[22usize], entry), + 2usize => (&INFO[25usize], entry), + 3usize => (&INFO[26usize], entry), + 4usize => (&INFO[27usize], entry), + 5usize => (&INFO[28usize], entry), + 6usize => (&INFO[29usize], entry), + 7usize => (&INFO[30usize], entry), + 8usize => (&INFO[31usize], entry), + 9usize => (&INFO[32usize], entry), + 10usize => (&INFO[59usize], entry), + 11usize => (&INFO[60usize], entry), + 12usize => (&INFO[63usize], entry), + 13usize => (&INFO[66usize], entry), + 14usize => (&INFO[87usize], entry), + 15usize => (&INFO[90usize], entry), + 16usize => (&INFO[93usize], entry), + 17usize => (&INFO[99usize], entry), + 18usize => (&INFO[102usize], entry), + 19usize => (&INFO[103usize], entry), + 20usize => (&INFO[104usize], entry), + 21usize => (&INFO[120usize], entry), + 22usize => (&INFO[121usize], entry), + 23usize => (&INFO[122usize], entry), + 24usize => (&INFO[124usize], entry), + 25usize => (&INFO[125usize], entry), + 26usize => (&INFO[127usize], entry), + 27usize => (&INFO[128usize], entry), + 28usize => (&INFO[134usize], entry), + 29usize => (&INFO[136usize], entry), + 30usize => (&INFO[138usize], entry), + 31usize => (&INFO[140usize], entry), + 32usize => (&INFO[142usize], entry), + 33usize => (&INFO[146usize], entry), + 34usize => (&INFO[148usize], entry), + 35usize => (&INFO[150usize], entry), + 36usize => (&INFO[152usize], entry), + 37usize => (&INFO[154usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -1873,21 +1904,21 @@ impl Subscriber { .iter() .enumerate() .map(|(idx, entry)| match idx { - 0usize => (&INFO[45usize], entry), - 1usize => (&INFO[46usize], entry), - 2usize => (&INFO[47usize], entry), - 3usize => (&INFO[54usize], entry), - 4usize => (&INFO[72usize], entry), - 5usize => (&INFO[73usize], entry), - 6usize => (&INFO[74usize], entry), - 7usize => (&INFO[80usize], entry), - 8usize => (&INFO[82usize], entry), - 9usize => (&INFO[106usize], entry), - 10usize => (&INFO[107usize], entry), - 11usize => (&INFO[108usize], entry), - 12usize => (&INFO[109usize], entry), - 13usize => (&INFO[112usize], entry), - 14usize => (&INFO[157usize], entry), + 0usize => (&INFO[47usize], entry), + 1usize => (&INFO[48usize], entry), + 2usize => (&INFO[49usize], entry), + 3usize => (&INFO[56usize], entry), + 4usize => (&INFO[74usize], entry), + 5usize => (&INFO[75usize], entry), + 6usize => (&INFO[76usize], entry), + 7usize => (&INFO[82usize], entry), + 8usize => (&INFO[84usize], entry), + 9usize => (&INFO[108usize], entry), + 10usize => (&INFO[109usize], entry), + 11usize => (&INFO[110usize], entry), + 12usize => (&INFO[111usize], entry), + 13usize => (&INFO[114usize], entry), + 14usize => (&INFO[159usize], entry), _ => unsafe { core::hint::unreachable_unchecked() }, }) } @@ -2059,19 +2090,34 @@ impl event::Subscriber for Subscriber { let _ = event; } #[inline] - fn on_packet_lost( + fn on_connection_close_frame_received( &mut self, context: &mut Self::ConnectionContext, meta: &api::ConnectionMeta, - event: &api::PacketLost, + event: &api::ConnectionCloseFrameReceived, ) { #[allow(unused_imports)] use api::*; self.count(17usize, 10usize, 1usize); self.count_nominal(18usize, 6usize, &event.packet_header); - self.count(19usize, 11usize, event.bytes_lost); - self.measure(20usize, 1usize, event.bytes_lost); - self.count_bool(21usize, 0usize, event.is_mtu_probe); + let _ = context; + let _ = meta; + let _ = event; + } + #[inline] + fn on_packet_lost( + &mut self, + context: &mut Self::ConnectionContext, + meta: &api::ConnectionMeta, + event: &api::PacketLost, + ) { + #[allow(unused_imports)] + use api::*; + self.count(19usize, 11usize, 1usize); + self.count_nominal(20usize, 7usize, &event.packet_header); + self.count(21usize, 12usize, event.bytes_lost); + self.measure(22usize, 1usize, event.bytes_lost); + self.count_bool(23usize, 0usize, event.is_mtu_probe); let _ = context; let _ = meta; let _ = event; @@ -2085,16 +2131,16 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(22usize, 12usize, 1usize); - self.measure(23usize, 2usize, event.min_rtt); - self.measure(24usize, 3usize, event.smoothed_rtt); - self.measure(25usize, 4usize, event.latest_rtt); - self.measure(26usize, 5usize, event.rtt_variance); - self.measure(27usize, 6usize, event.max_ack_delay); - self.measure(28usize, 7usize, event.pto_count); - self.measure(29usize, 8usize, event.congestion_window); - self.measure(30usize, 9usize, event.bytes_in_flight); - self.count_bool(31usize, 1usize, event.congestion_limited); + self.count(24usize, 13usize, 1usize); + self.measure(25usize, 2usize, event.min_rtt); + self.measure(26usize, 3usize, event.smoothed_rtt); + self.measure(27usize, 4usize, event.latest_rtt); + self.measure(28usize, 5usize, event.rtt_variance); + self.measure(29usize, 6usize, event.max_ack_delay); + self.measure(30usize, 7usize, event.pto_count); + self.measure(31usize, 8usize, event.congestion_window); + self.measure(32usize, 9usize, event.bytes_in_flight); + self.count_bool(33usize, 1usize, event.congestion_limited); let _ = context; let _ = meta; let _ = event; @@ -2108,8 +2154,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(32usize, 13usize, 1usize); - self.count_nominal(33usize, 7usize, &event.source); + self.count(34usize, 14usize, 1usize); + self.count_nominal(35usize, 8usize, &event.source); let _ = context; let _ = meta; let _ = event; @@ -2123,7 +2169,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(34usize, 14usize, 1usize); + self.count(36usize, 15usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -2137,8 +2183,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(35usize, 15usize, 1usize); - self.count_nominal(36usize, 8usize, &event.packet_header); + self.count(37usize, 16usize, 1usize); + self.count_nominal(38usize, 9usize, &event.packet_header); let _ = context; let _ = meta; let _ = event; @@ -2152,8 +2198,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(37usize, 16usize, 1usize); - self.count_nominal(38usize, 9usize, &event.packet_header); + self.count(39usize, 17usize, 1usize); + self.count_nominal(40usize, 10usize, &event.packet_header); let _ = context; let _ = meta; let _ = event; @@ -2167,8 +2213,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(39usize, 17usize, 1usize); - self.count_nominal(40usize, 10usize, &event.reason); + self.count(41usize, 18usize, 1usize); + self.count_nominal(42usize, 11usize, &event.reason); let _ = context; let _ = meta; let _ = event; @@ -2182,9 +2228,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(41usize, 18usize, 1usize); - self.count_nominal(42usize, 11usize, &event.key_type); - self.count_nominal(43usize, 12usize, &event.cipher_suite); + self.count(43usize, 19usize, 1usize); + self.count_nominal(44usize, 12usize, &event.key_type); + self.count_nominal(45usize, 13usize, &event.cipher_suite); let _ = context; let _ = meta; let _ = event; @@ -2198,14 +2244,14 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(44usize, 19usize, 1usize); + self.count(46usize, 20usize, 1usize); { fn check(evt: &api::KeySpaceDiscarded) -> bool { matches!(evt.space, KeySpace::Initial { .. }) } if check(event) { self.time( - 45usize, + 47usize, 0usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2217,7 +2263,7 @@ impl event::Subscriber for Subscriber { } if check(event) { self.time( - 46usize, + 48usize, 1usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2229,13 +2275,13 @@ impl event::Subscriber for Subscriber { } if check(event) { self.time( - 47usize, + 49usize, 2usize, meta.timestamp.saturating_duration_since(context.start_time), ); } } - self.count_nominal(48usize, 13usize, &event.space); + self.count_nominal(50usize, 14usize, &event.space); let _ = context; let _ = meta; let _ = event; @@ -2249,7 +2295,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(49usize, 20usize, 1usize); + self.count(51usize, 21usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -2263,9 +2309,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(50usize, 21usize, 1usize); - self.count_nominal(51usize, 14usize, &event.packet_header); - self.count_nominal(52usize, 15usize, &event.error); + self.count(52usize, 22usize, 1usize); + self.count_nominal(53usize, 15usize, &event.packet_header); + self.count_nominal(54usize, 16usize, &event.error); let _ = context; let _ = meta; let _ = event; @@ -2279,9 +2325,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(53usize, 22usize, 1usize); + self.count(55usize, 23usize, 1usize); self.time( - 54usize, + 56usize, 3usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2298,10 +2344,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(55usize, 23usize, 1usize); - self.count(56usize, 24usize, event.len); - self.measure(57usize, 10usize, event.len); - self.measure(58usize, 11usize, event.gso_offset); + self.count(57usize, 24usize, 1usize); + self.count(58usize, 25usize, event.len); + self.measure(59usize, 10usize, event.len); + self.measure(60usize, 11usize, event.gso_offset); let _ = context; let _ = meta; let _ = event; @@ -2315,9 +2361,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(59usize, 25usize, 1usize); - self.count(60usize, 26usize, event.len); - self.measure(61usize, 12usize, event.len); + self.count(61usize, 26usize, 1usize); + self.count(62usize, 27usize, event.len); + self.measure(63usize, 12usize, event.len); let _ = context; let _ = meta; let _ = event; @@ -2331,10 +2377,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(62usize, 27usize, 1usize); - self.count(63usize, 28usize, event.len); - self.measure(64usize, 13usize, event.len); - self.count_nominal(65usize, 16usize, &event.reason); + self.count(64usize, 28usize, 1usize); + self.count(65usize, 29usize, event.len); + self.measure(66usize, 13usize, event.len); + self.count_nominal(67usize, 17usize, &event.reason); let _ = context; let _ = meta; let _ = event; @@ -2348,7 +2394,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(66usize, 29usize, 1usize); + self.count(68usize, 30usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -2362,8 +2408,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(67usize, 30usize, 1usize); - self.count_nominal(68usize, 17usize, &event.state); + self.count(69usize, 31usize, 1usize); + self.count_nominal(70usize, 18usize, &event.state); let _ = context; let _ = meta; let _ = event; @@ -2377,8 +2423,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(69usize, 31usize, 1usize); - self.count_nominal(70usize, 18usize, &event.reason); + self.count(71usize, 32usize, 1usize); + self.count_nominal(72usize, 19usize, &event.reason); let _ = context; let _ = meta; let _ = event; @@ -2392,14 +2438,14 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(71usize, 32usize, 1usize); + self.count(73usize, 33usize, 1usize); { fn check(evt: &api::HandshakeStatusUpdated) -> bool { matches!(evt.status, HandshakeStatus::Complete { .. }) } if check(event) { self.time( - 72usize, + 74usize, 4usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2411,7 +2457,7 @@ impl event::Subscriber for Subscriber { } if check(event) { self.time( - 73usize, + 75usize, 5usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2423,13 +2469,13 @@ impl event::Subscriber for Subscriber { } if check(event) { self.time( - 74usize, + 76usize, 6usize, meta.timestamp.saturating_duration_since(context.start_time), ); } } - self.count_nominal(75usize, 19usize, &event.status); + self.count_nominal(77usize, 20usize, &event.status); let _ = context; let _ = meta; let _ = event; @@ -2443,7 +2489,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(76usize, 33usize, 1usize); + self.count(78usize, 34usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -2457,8 +2503,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(77usize, 34usize, 1usize); - self.count_nominal(78usize, 20usize, &event.path_challenge_status); + self.count(79usize, 35usize, 1usize); + self.count_nominal(80usize, 21usize, &event.path_challenge_status); let _ = context; let _ = meta; let _ = event; @@ -2472,9 +2518,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(79usize, 35usize, 1usize); + self.count(81usize, 36usize, 1usize); self.time( - 80usize, + 82usize, 7usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2491,9 +2537,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(81usize, 36usize, 1usize); + self.count(83usize, 37usize, 1usize); self.time( - 82usize, + 84usize, 8usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2510,9 +2556,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(83usize, 37usize, 1usize); - self.count(84usize, 38usize, event.bytes); - self.measure(85usize, 14usize, event.bytes); + self.count(85usize, 38usize, 1usize); + self.count(86usize, 39usize, event.bytes); + self.measure(87usize, 14usize, event.bytes); let _ = context; let _ = meta; let _ = event; @@ -2526,9 +2572,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(86usize, 39usize, 1usize); - self.count(87usize, 40usize, event.bytes); - self.measure(88usize, 15usize, event.bytes); + self.count(88usize, 40usize, 1usize); + self.count(89usize, 41usize, event.bytes); + self.measure(90usize, 15usize, event.bytes); let _ = context; let _ = meta; let _ = event; @@ -2542,7 +2588,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(89usize, 41usize, 1usize); + self.count(91usize, 42usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -2556,10 +2602,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(90usize, 42usize, 1usize); - self.measure(91usize, 16usize, event.mtu); - self.count_nominal(92usize, 21usize, &event.cause); - self.count_bool(93usize, 2usize, event.search_complete); + self.count(92usize, 43usize, 1usize); + self.measure(93usize, 16usize, event.mtu); + self.count_nominal(94usize, 22usize, &event.cause); + self.count_bool(95usize, 2usize, event.search_complete); let _ = context; let _ = meta; let _ = event; @@ -2573,15 +2619,15 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(94usize, 43usize, 1usize); - self.count_nominal(95usize, 22usize, &event.cause); + self.count(96usize, 44usize, 1usize); + self.count_nominal(97usize, 23usize, &event.cause); self.time_nominal( - 96usize, + 98usize, 0usize, &event.cause, meta.timestamp.saturating_duration_since(context.start_time), ); - self.measure(97usize, 17usize, event.congestion_window); + self.measure(99usize, 17usize, event.congestion_window); let _ = context; let _ = meta; let _ = event; @@ -2595,7 +2641,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(98usize, 44usize, 1usize); + self.count(100usize, 45usize, 1usize); let _ = context; let _ = meta; let _ = event; @@ -2609,10 +2655,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(99usize, 45usize, 1usize); - self.measure(100usize, 18usize, event.bytes_per_second); - self.measure(101usize, 19usize, event.burst_size); - self.measure(102usize, 20usize, event.pacing_gain); + self.count(101usize, 46usize, 1usize); + self.measure(102usize, 18usize, event.bytes_per_second); + self.measure(103usize, 19usize, event.burst_size); + self.measure(104usize, 20usize, event.pacing_gain); let _ = context; let _ = meta; let _ = event; @@ -2626,8 +2672,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(103usize, 46usize, 1usize); - self.count_nominal(104usize, 23usize, &event.state); + self.count(105usize, 47usize, 1usize); + self.count_nominal(106usize, 24usize, &event.state); let _ = context; let _ = meta; let _ = event; @@ -2641,14 +2687,14 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(105usize, 47usize, 1usize); + self.count(107usize, 48usize, 1usize); { fn check(evt: &api::DcStateChanged) -> bool { matches!(evt.state, DcState::VersionNegotiated { .. }) } if check(event) { self.time( - 106usize, + 108usize, 9usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2660,7 +2706,7 @@ impl event::Subscriber for Subscriber { } if check(event) { self.time( - 107usize, + 109usize, 10usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2672,7 +2718,7 @@ impl event::Subscriber for Subscriber { } if check(event) { self.time( - 108usize, + 110usize, 11usize, meta.timestamp.saturating_duration_since(context.start_time), ); @@ -2684,13 +2730,13 @@ impl event::Subscriber for Subscriber { } if check(event) { self.time( - 109usize, + 111usize, 12usize, meta.timestamp.saturating_duration_since(context.start_time), ); } } - self.count_nominal(110usize, 24usize, &event.state); + self.count_nominal(112usize, 25usize, &event.state); let _ = context; let _ = meta; let _ = event; @@ -2704,13 +2750,13 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(111usize, 48usize, 1usize); + self.count(113usize, 49usize, 1usize); self.time( - 112usize, + 114usize, 13usize, meta.timestamp.saturating_duration_since(context.start_time), ); - self.count_nominal(113usize, 25usize, &event.error); + self.count_nominal(115usize, 26usize, &event.error); let _ = context; let _ = meta; let _ = event; @@ -2723,7 +2769,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(114usize, 49usize, 1usize); + self.count(116usize, 50usize, 1usize); let _ = event; let _ = meta; } @@ -2735,7 +2781,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(115usize, 50usize, 1usize); + self.count(117usize, 51usize, 1usize); let _ = event; let _ = meta; } @@ -2747,7 +2793,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(116usize, 51usize, 1usize); + self.count(118usize, 52usize, 1usize); let _ = event; let _ = meta; } @@ -2759,10 +2805,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(117usize, 52usize, 1usize); - self.measure(118usize, 21usize, event.len); - self.measure(119usize, 22usize, event.len); - self.measure(120usize, 23usize, event.gso_offset); + self.count(119usize, 53usize, 1usize); + self.measure(120usize, 21usize, event.len); + self.measure(121usize, 22usize, event.len); + self.measure(122usize, 23usize, event.gso_offset); let _ = event; let _ = meta; } @@ -2774,9 +2820,9 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(121usize, 53usize, 1usize); - self.measure(122usize, 24usize, event.len); - self.measure(123usize, 25usize, event.len); + self.count(123usize, 54usize, 1usize); + self.measure(124usize, 24usize, event.len); + self.measure(125usize, 25usize, event.len); let _ = event; let _ = meta; } @@ -2788,10 +2834,10 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(124usize, 54usize, 1usize); - self.measure(125usize, 26usize, event.len); - self.measure(126usize, 27usize, event.len); - self.count_nominal(127usize, 26usize, &event.reason); + self.count(126usize, 55usize, 1usize); + self.measure(127usize, 26usize, event.len); + self.measure(128usize, 27usize, event.len); + self.count_nominal(129usize, 27usize, &event.reason); let _ = event; let _ = meta; } @@ -2803,8 +2849,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(128usize, 55usize, 1usize); - self.count_nominal(129usize, 27usize, &event.error); + self.count(130usize, 56usize, 1usize); + self.count_nominal(131usize, 28usize, &event.error); let _ = event; let _ = meta; } @@ -2812,17 +2858,17 @@ impl event::Subscriber for Subscriber { fn on_platform_tx(&mut self, meta: &api::EndpointMeta, event: &api::PlatformTx) { #[allow(unused_imports)] use api::*; - self.count(130usize, 56usize, 1usize); - self.count(131usize, 57usize, event.count); - self.measure(132usize, 28usize, event.count); - self.count(133usize, 58usize, event.syscalls); - self.measure(134usize, 29usize, event.syscalls); - self.count(135usize, 59usize, event.blocked_syscalls); - self.measure(136usize, 30usize, event.blocked_syscalls); - self.count(137usize, 60usize, event.total_errors); - self.measure(138usize, 31usize, event.total_errors); - self.count(139usize, 61usize, event.dropped_errors); - self.measure(140usize, 32usize, event.dropped_errors); + self.count(132usize, 57usize, 1usize); + self.count(133usize, 58usize, event.count); + self.measure(134usize, 28usize, event.count); + self.count(135usize, 59usize, event.syscalls); + self.measure(136usize, 29usize, event.syscalls); + self.count(137usize, 60usize, event.blocked_syscalls); + self.measure(138usize, 30usize, event.blocked_syscalls); + self.count(139usize, 61usize, event.total_errors); + self.measure(140usize, 31usize, event.total_errors); + self.count(141usize, 62usize, event.dropped_errors); + self.measure(142usize, 32usize, event.dropped_errors); let _ = event; let _ = meta; } @@ -2830,7 +2876,7 @@ impl event::Subscriber for Subscriber { fn on_platform_tx_error(&mut self, meta: &api::EndpointMeta, event: &api::PlatformTxError) { #[allow(unused_imports)] use api::*; - self.count(141usize, 62usize, 1usize); + self.count(143usize, 63usize, 1usize); let _ = event; let _ = meta; } @@ -2838,17 +2884,17 @@ impl event::Subscriber for Subscriber { fn on_platform_rx(&mut self, meta: &api::EndpointMeta, event: &api::PlatformRx) { #[allow(unused_imports)] use api::*; - self.count(142usize, 63usize, 1usize); - self.count(143usize, 64usize, event.count); - self.measure(144usize, 33usize, event.count); - self.count(145usize, 65usize, event.syscalls); - self.measure(146usize, 34usize, event.syscalls); - self.count(147usize, 66usize, event.blocked_syscalls); - self.measure(148usize, 35usize, event.blocked_syscalls); - self.count(149usize, 67usize, event.total_errors); - self.measure(150usize, 36usize, event.total_errors); - self.count(151usize, 68usize, event.dropped_errors); - self.measure(152usize, 37usize, event.dropped_errors); + self.count(144usize, 64usize, 1usize); + self.count(145usize, 65usize, event.count); + self.measure(146usize, 33usize, event.count); + self.count(147usize, 66usize, event.syscalls); + self.measure(148usize, 34usize, event.syscalls); + self.count(149usize, 67usize, event.blocked_syscalls); + self.measure(150usize, 35usize, event.blocked_syscalls); + self.count(151usize, 68usize, event.total_errors); + self.measure(152usize, 36usize, event.total_errors); + self.count(153usize, 69usize, event.dropped_errors); + self.measure(154usize, 37usize, event.dropped_errors); let _ = event; let _ = meta; } @@ -2856,7 +2902,7 @@ impl event::Subscriber for Subscriber { fn on_platform_rx_error(&mut self, meta: &api::EndpointMeta, event: &api::PlatformRxError) { #[allow(unused_imports)] use api::*; - self.count(153usize, 69usize, 1usize); + self.count(155usize, 70usize, 1usize); let _ = event; let _ = meta; } @@ -2868,7 +2914,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(154usize, 70usize, 1usize); + self.count(156usize, 71usize, 1usize); let _ = event; let _ = meta; } @@ -2880,7 +2926,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(155usize, 71usize, 1usize); + self.count(157usize, 72usize, 1usize); let _ = event; let _ = meta; } @@ -2892,8 +2938,8 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(156usize, 72usize, 1usize); - self.time(157usize, 14usize, event.processing_duration); + self.count(158usize, 73usize, 1usize); + self.time(159usize, 14usize, event.processing_duration); let _ = event; let _ = meta; } @@ -2905,7 +2951,7 @@ impl event::Subscriber for Subscriber { ) { #[allow(unused_imports)] use api::*; - self.count(158usize, 73usize, 1usize); + self.count(160usize, 74usize, 1usize); let _ = event; let _ = meta; } diff --git a/quic/s2n-quic-core/src/event/generated/metrics/probe.rs b/quic/s2n-quic-core/src/event/generated/metrics/probe.rs index 90370ea060..86b40a0bba 100644 --- a/quic/s2n-quic-core/src/event/generated/metrics/probe.rs +++ b/quic/s2n-quic-core/src/event/generated/metrics/probe.rs @@ -29,70 +29,71 @@ mod counter { 10usize => Self(path_created), 11usize => Self(frame_sent), 14usize => Self(frame_received), - 17usize => Self(packet_lost), - 19usize => Self(packet_lost__bytes__total), - 22usize => Self(recovery_metrics), - 32usize => Self(congestion), - 34usize => Self(rx_ack_range_dropped), - 35usize => Self(ack_range_received), - 37usize => Self(ack_range_sent), - 39usize => Self(packet_dropped), - 41usize => Self(key_update), - 44usize => Self(key_space_discarded), - 49usize => Self(connection_started), - 50usize => Self(duplicate_packet), - 53usize => Self(transport_parameters_received), - 55usize => Self(datagram_sent), - 56usize => Self(datagram_sent__bytes__total), - 59usize => Self(datagram_received), - 60usize => Self(datagram_received__bytes__total), - 62usize => Self(datagram_dropped), - 63usize => Self(datagram_dropped__bytes__total), - 66usize => Self(connection_id_updated), - 67usize => Self(ecn_state_changed), - 69usize => Self(connection_migration_denied), - 71usize => Self(handshake_status_updated), - 76usize => Self(tls_exporter_ready), - 77usize => Self(path_challenge_updated), - 79usize => Self(tls_client_hello), - 81usize => Self(tls_server_hello), - 83usize => Self(rx_stream_progress), - 84usize => Self(rx_stream_progress__bytes__total), - 86usize => Self(tx_stream_progress), - 87usize => Self(tx_stream_progress__bytes__total), - 89usize => Self(keep_alive_timer_expired), - 90usize => Self(mtu_updated), - 94usize => Self(slow_start_exited), - 98usize => Self(delivery_rate_sampled), - 99usize => Self(pacing_rate_updated), - 103usize => Self(bbr_state_changed), - 105usize => Self(dc_state_changed), - 111usize => Self(connection_closed), - 114usize => Self(version_information), - 115usize => Self(endpoint_packet_sent), - 116usize => Self(endpoint_packet_received), - 117usize => Self(endpoint_datagram_sent), - 121usize => Self(endpoint_datagram_received), - 124usize => Self(endpoint_datagram_dropped), - 128usize => Self(endpoint_connection_attempt_failed), - 130usize => Self(platform_tx), - 131usize => Self(platform_tx__packets__total), - 133usize => Self(platform_tx__syscalls__total), - 135usize => Self(platform_tx__syscalls__blocked__total), - 137usize => Self(platform_tx__errors__total), - 139usize => Self(platform_tx__errors__dropped__total), - 141usize => Self(platform_tx_error), - 142usize => Self(platform_rx), - 143usize => Self(platform_rx__packets__total), - 145usize => Self(platform_rx__syscalls__total), - 147usize => Self(platform_rx__syscalls__blocked__total), - 149usize => Self(platform_rx__errors__total), - 151usize => Self(platform_rx__errors__dropped__total), - 153usize => Self(platform_rx_error), - 154usize => Self(platform_feature_configured), - 155usize => Self(platform_event_loop_wakeup), - 156usize => Self(platform_event_loop_sleep), - 158usize => Self(platform_event_loop_started), + 17usize => Self(connection_close_frame_received), + 19usize => Self(packet_lost), + 21usize => Self(packet_lost__bytes__total), + 24usize => Self(recovery_metrics), + 34usize => Self(congestion), + 36usize => Self(rx_ack_range_dropped), + 37usize => Self(ack_range_received), + 39usize => Self(ack_range_sent), + 41usize => Self(packet_dropped), + 43usize => Self(key_update), + 46usize => Self(key_space_discarded), + 51usize => Self(connection_started), + 52usize => Self(duplicate_packet), + 55usize => Self(transport_parameters_received), + 57usize => Self(datagram_sent), + 58usize => Self(datagram_sent__bytes__total), + 61usize => Self(datagram_received), + 62usize => Self(datagram_received__bytes__total), + 64usize => Self(datagram_dropped), + 65usize => Self(datagram_dropped__bytes__total), + 68usize => Self(connection_id_updated), + 69usize => Self(ecn_state_changed), + 71usize => Self(connection_migration_denied), + 73usize => Self(handshake_status_updated), + 78usize => Self(tls_exporter_ready), + 79usize => Self(path_challenge_updated), + 81usize => Self(tls_client_hello), + 83usize => Self(tls_server_hello), + 85usize => Self(rx_stream_progress), + 86usize => Self(rx_stream_progress__bytes__total), + 88usize => Self(tx_stream_progress), + 89usize => Self(tx_stream_progress__bytes__total), + 91usize => Self(keep_alive_timer_expired), + 92usize => Self(mtu_updated), + 96usize => Self(slow_start_exited), + 100usize => Self(delivery_rate_sampled), + 101usize => Self(pacing_rate_updated), + 105usize => Self(bbr_state_changed), + 107usize => Self(dc_state_changed), + 113usize => Self(connection_closed), + 116usize => Self(version_information), + 117usize => Self(endpoint_packet_sent), + 118usize => Self(endpoint_packet_received), + 119usize => Self(endpoint_datagram_sent), + 123usize => Self(endpoint_datagram_received), + 126usize => Self(endpoint_datagram_dropped), + 130usize => Self(endpoint_connection_attempt_failed), + 132usize => Self(platform_tx), + 133usize => Self(platform_tx__packets__total), + 135usize => Self(platform_tx__syscalls__total), + 137usize => Self(platform_tx__syscalls__blocked__total), + 139usize => Self(platform_tx__errors__total), + 141usize => Self(platform_tx__errors__dropped__total), + 143usize => Self(platform_tx_error), + 144usize => Self(platform_rx), + 145usize => Self(platform_rx__packets__total), + 147usize => Self(platform_rx__syscalls__total), + 149usize => Self(platform_rx__syscalls__blocked__total), + 151usize => Self(platform_rx__errors__total), + 153usize => Self(platform_rx__errors__dropped__total), + 155usize => Self(platform_rx_error), + 156usize => Self(platform_feature_configured), + 157usize => Self(platform_event_loop_wakeup), + 158usize => Self(platform_event_loop_sleep), + 160usize => Self(platform_event_loop_started), _ => unreachable!("invalid info: {info:?}"), } } @@ -124,6 +125,8 @@ mod counter { fn frame_sent(value: u64); # [link_name = s2n_quic__event__counter__frame_received] fn frame_received(value: u64); + # [link_name = s2n_quic__event__counter__connection_close_frame_received] + fn connection_close_frame_received(value: u64); # [link_name = s2n_quic__event__counter__packet_lost] fn packet_lost(value: u64); # [link_name = s2n_quic__event__counter__packet_lost__bytes__total] @@ -261,9 +264,9 @@ mod counter { impl Recorder { pub(crate) fn new(info: &'static Info) -> Self { match info.id { - 21usize => Self(packet_lost__is_mtu_probe), - 31usize => Self(recovery_metrics__congestion_limited), - 93usize => Self(mtu_updated__search_complete), + 23usize => Self(packet_lost__is_mtu_probe), + 33usize => Self(recovery_metrics__congestion_limited), + 95usize => Self(mtu_updated__search_complete), _ => unreachable!("invalid info: {info:?}"), } } @@ -298,28 +301,29 @@ mod counter { 13usize => Self(frame_sent__frame), 15usize => Self(frame_received__packet), 16usize => Self(frame_received__frame), - 18usize => Self(packet_lost__kind), - 33usize => Self(congestion__source), - 36usize => Self(ack_range_received__packet), - 38usize => Self(ack_range_sent__packet), - 40usize => Self(packet_dropped__reason), - 42usize => Self(key_update__key_type), - 43usize => Self(key_update__cipher_suite), - 48usize => Self(key_space_discarded__space), - 51usize => Self(duplicate_packet__kind), - 52usize => Self(duplicate_packet__error), - 65usize => Self(datagram_dropped__reason), - 68usize => Self(ecn_state_changed__state), - 70usize => Self(connection_migration_denied__reason), - 75usize => Self(handshake_status_updated__status), - 78usize => Self(path_challenge_updated__status), - 92usize => Self(mtu_updated__cause), - 95usize => Self(slow_start_exited__cause), - 104usize => Self(bbr_state_changed__state), - 110usize => Self(dc_state_changed__state), - 113usize => Self(connection_closed__error), - 127usize => Self(endpoint_datagram_dropped__reason), - 129usize => Self(endpoint_connection_attempt_failed__error), + 18usize => Self(connection_close_frame_received__packet), + 20usize => Self(packet_lost__kind), + 35usize => Self(congestion__source), + 38usize => Self(ack_range_received__packet), + 40usize => Self(ack_range_sent__packet), + 42usize => Self(packet_dropped__reason), + 44usize => Self(key_update__key_type), + 45usize => Self(key_update__cipher_suite), + 50usize => Self(key_space_discarded__space), + 53usize => Self(duplicate_packet__kind), + 54usize => Self(duplicate_packet__error), + 67usize => Self(datagram_dropped__reason), + 70usize => Self(ecn_state_changed__state), + 72usize => Self(connection_migration_denied__reason), + 77usize => Self(handshake_status_updated__status), + 80usize => Self(path_challenge_updated__status), + 94usize => Self(mtu_updated__cause), + 97usize => Self(slow_start_exited__cause), + 106usize => Self(bbr_state_changed__state), + 112usize => Self(dc_state_changed__state), + 115usize => Self(connection_closed__error), + 129usize => Self(endpoint_datagram_dropped__reason), + 131usize => Self(endpoint_connection_attempt_failed__error), _ => unreachable!("invalid info: {info:?}"), } } @@ -348,6 +352,12 @@ mod counter { fn frame_received__packet(value: u64, variant: u64, variant_name: &info::Str); # [link_name = s2n_quic__event__counter__nominal__frame_received__frame] fn frame_received__frame(value: u64, variant: u64, variant_name: &info::Str); + # [link_name = s2n_quic__event__counter__nominal__connection_close_frame_received__packet] + fn connection_close_frame_received__packet( + value: u64, + variant: u64, + variant_name: &info::Str, + ); # [link_name = s2n_quic__event__counter__nominal__packet_lost__kind] fn packet_lost__kind(value: u64, variant: u64, variant_name: &info::Str); # [link_name = s2n_quic__event__counter__nominal__congestion__source] @@ -425,43 +435,43 @@ mod measure { pub(crate) fn new(info: &'static Info) -> Self { match info.id { 6usize => Self(packet_sent__bytes), - 20usize => Self(packet_lost__bytes), - 23usize => Self(recovery_metrics__min_rtt), - 24usize => Self(recovery_metrics__smoothed_rtt), - 25usize => Self(recovery_metrics__latest_rtt), - 26usize => Self(recovery_metrics__rtt_variance), - 27usize => Self(recovery_metrics__max_ack_delay), - 28usize => Self(recovery_metrics__pto_count), - 29usize => Self(recovery_metrics__congestion_window), - 30usize => Self(recovery_metrics__bytes_in_flight), - 57usize => Self(datagram_sent__bytes), - 58usize => Self(datagram_sent__gso_offset), - 61usize => Self(datagram_received__bytes), - 64usize => Self(datagram_dropped__bytes), - 85usize => Self(rx_stream_progress__bytes), - 88usize => Self(tx_stream_progress__bytes), - 91usize => Self(mtu_updated__mtu), - 97usize => Self(slow_start_exited__congestion_window), - 100usize => Self(pacing_rate_updated__bytes_per_second), - 101usize => Self(pacing_rate_updated__burst_size), - 102usize => Self(pacing_rate_updated__pacing_gain), - 118usize => Self(endpoint_datagram_sent__bytes), - 119usize => Self(endpoint_datagram_sent__bytes__total), - 120usize => Self(endpoint_datagram_sent__gso_offset), - 122usize => Self(endpoint_datagram_received__bytes), - 123usize => Self(endpoint_datagram_received__bytes__total), - 125usize => Self(endpoint_datagram_dropped__bytes), - 126usize => Self(endpoint_datagram_dropped__bytes__total), - 132usize => Self(platform_tx__packets), - 134usize => Self(platform_tx__syscalls), - 136usize => Self(platform_tx__syscalls__blocked), - 138usize => Self(platform_tx__errors), - 140usize => Self(platform_tx__errors__dropped), - 144usize => Self(platform_rx__packets), - 146usize => Self(platform_rx__syscalls), - 148usize => Self(platform_rx__syscalls__blocked), - 150usize => Self(platform_rx__errors), - 152usize => Self(platform_rx__errors__dropped), + 22usize => Self(packet_lost__bytes), + 25usize => Self(recovery_metrics__min_rtt), + 26usize => Self(recovery_metrics__smoothed_rtt), + 27usize => Self(recovery_metrics__latest_rtt), + 28usize => Self(recovery_metrics__rtt_variance), + 29usize => Self(recovery_metrics__max_ack_delay), + 30usize => Self(recovery_metrics__pto_count), + 31usize => Self(recovery_metrics__congestion_window), + 32usize => Self(recovery_metrics__bytes_in_flight), + 59usize => Self(datagram_sent__bytes), + 60usize => Self(datagram_sent__gso_offset), + 63usize => Self(datagram_received__bytes), + 66usize => Self(datagram_dropped__bytes), + 87usize => Self(rx_stream_progress__bytes), + 90usize => Self(tx_stream_progress__bytes), + 93usize => Self(mtu_updated__mtu), + 99usize => Self(slow_start_exited__congestion_window), + 102usize => Self(pacing_rate_updated__bytes_per_second), + 103usize => Self(pacing_rate_updated__burst_size), + 104usize => Self(pacing_rate_updated__pacing_gain), + 120usize => Self(endpoint_datagram_sent__bytes), + 121usize => Self(endpoint_datagram_sent__bytes__total), + 122usize => Self(endpoint_datagram_sent__gso_offset), + 124usize => Self(endpoint_datagram_received__bytes), + 125usize => Self(endpoint_datagram_received__bytes__total), + 127usize => Self(endpoint_datagram_dropped__bytes), + 128usize => Self(endpoint_datagram_dropped__bytes__total), + 134usize => Self(platform_tx__packets), + 136usize => Self(platform_tx__syscalls), + 138usize => Self(platform_tx__syscalls__blocked), + 140usize => Self(platform_tx__errors), + 142usize => Self(platform_tx__errors__dropped), + 146usize => Self(platform_rx__packets), + 148usize => Self(platform_rx__syscalls), + 150usize => Self(platform_rx__syscalls__blocked), + 152usize => Self(platform_rx__errors), + 154usize => Self(platform_rx__errors__dropped), _ => unreachable!("invalid info: {info:?}"), } } @@ -576,21 +586,21 @@ mod timer { impl Recorder { pub(crate) fn new(info: &'static Info) -> Self { match info.id { - 45usize => Self(key_space_discarded__initial__latency), - 46usize => Self(key_space_discarded__handshake__latency), - 47usize => Self(key_space_discarded__one_rtt__latency), - 54usize => Self(transport_parameters_received__latency), - 72usize => Self(handshake_status_updated__complete__latency), - 73usize => Self(handshake_status_updated__confirmed__latency), - 74usize => Self(handshake_status_updated__handshake_done_acked__latency), - 80usize => Self(tls_client_hello__latency), - 82usize => Self(tls_server_hello__latency), - 106usize => Self(dc_state_changed__version_negotiated__latency), - 107usize => Self(dc_state_changed__no_version_negotiated__latency), - 108usize => Self(dc_state_changed__path_secrets__latency), - 109usize => Self(dc_state_changed__complete__latency), - 112usize => Self(connection_closed__latency), - 157usize => Self(platform_event_loop_sleep__processing_duration), + 47usize => Self(key_space_discarded__initial__latency), + 48usize => Self(key_space_discarded__handshake__latency), + 49usize => Self(key_space_discarded__one_rtt__latency), + 56usize => Self(transport_parameters_received__latency), + 74usize => Self(handshake_status_updated__complete__latency), + 75usize => Self(handshake_status_updated__confirmed__latency), + 76usize => Self(handshake_status_updated__handshake_done_acked__latency), + 82usize => Self(tls_client_hello__latency), + 84usize => Self(tls_server_hello__latency), + 108usize => Self(dc_state_changed__version_negotiated__latency), + 109usize => Self(dc_state_changed__no_version_negotiated__latency), + 110usize => Self(dc_state_changed__path_secrets__latency), + 111usize => Self(dc_state_changed__complete__latency), + 114usize => Self(connection_closed__latency), + 159usize => Self(platform_event_loop_sleep__processing_duration), _ => unreachable!("invalid info: {info:?}"), } } @@ -642,7 +652,7 @@ mod timer { impl Recorder { pub(crate) fn new(info: &'static Info, _variant: &'static info::Variant) -> Self { match info.id { - 96usize => Self(slow_start_exited__latency), + 98usize => Self(slow_start_exited__latency), _ => unreachable!("invalid info: {info:?}"), } } diff --git a/quic/s2n-quic-core/src/packet/encoding.rs b/quic/s2n-quic-core/src/packet/encoding.rs index 992255da20..14d7609f88 100644 --- a/quic/s2n-quic-core/src/packet/encoding.rs +++ b/quic/s2n-quic-core/src/packet/encoding.rs @@ -254,7 +254,7 @@ pub trait PacketEncoder= minimum_payload_len`. However, the packet + // Ideally we would check that the `payload_len >= minimum_payload_len`. However, the packet // interceptor may rewrite the packet into something smaller. Instead of preventing that // here, we will rely on the `crate::transmission::Transmission` logic to ensure the // padding is initially written to ensure the minimum is met before interception is applied. diff --git a/quic/s2n-quic-transport/src/space/application.rs b/quic/s2n-quic-transport/src/space/application.rs index e22bb450a8..f1dea86ec2 100644 --- a/quic/s2n-quic-transport/src/space/application.rs +++ b/quic/s2n-quic-transport/src/space/application.rs @@ -886,12 +886,25 @@ impl PacketSpace for ApplicationSpace ) } - fn handle_connection_close_frame( + fn handle_connection_close_frame( &mut self, - _frame: ConnectionClose, - _timestamp: Timestamp, - _path: &mut Path, + frame: ConnectionClose, + path_id: path::Id, + path: &mut Path, + packet_number: PacketNumber, + publisher: &mut Pub, ) -> Result<(), transport::Error> { + publisher.on_connection_close_frame_received( + event::builder::ConnectionCloseFrameReceived { + packet_header: event::builder::PacketHeader::new( + packet_number, + publisher.quic_version(), + ), + path: path_event!(path, path_id), + frame: frame.into_event(), + }, + ); + Ok(()) } diff --git a/quic/s2n-quic-transport/src/space/handshake.rs b/quic/s2n-quic-transport/src/space/handshake.rs index 3abd5f0f6d..f64f5766ff 100644 --- a/quic/s2n-quic-transport/src/space/handshake.rs +++ b/quic/s2n-quic-transport/src/space/handshake.rs @@ -569,12 +569,25 @@ impl PacketSpace for HandshakeSpace { ) } - fn handle_connection_close_frame( + fn handle_connection_close_frame( &mut self, frame: ConnectionClose, - _timestamp: Timestamp, - _path: &mut Path, + path_id: path::Id, + path: &mut Path, + packet_number: PacketNumber, + publisher: &mut Pub, ) -> Result<(), transport::Error> { + publisher.on_connection_close_frame_received( + event::builder::ConnectionCloseFrameReceived { + packet_header: event::builder::PacketHeader::new( + packet_number, + publisher.quic_version(), + ), + path: path_event!(path, path_id), + frame: frame.into_event(), + }, + ); + //= https://www.rfc-editor.org/rfc/rfc9000#section-17.2.4 //# Handshake packets MAY contain //# CONNECTION_CLOSE frames of type 0x1c. diff --git a/quic/s2n-quic-transport/src/space/initial.rs b/quic/s2n-quic-transport/src/space/initial.rs index 30017ad1fd..6e79c3c75b 100644 --- a/quic/s2n-quic-transport/src/space/initial.rs +++ b/quic/s2n-quic-transport/src/space/initial.rs @@ -707,12 +707,25 @@ impl PacketSpace for InitialSpace { ) } - fn handle_connection_close_frame( + fn handle_connection_close_frame( &mut self, frame: ConnectionClose, - _timestamp: Timestamp, - _path: &mut Path, + path_id: path::Id, + path: &mut Path, + packet_number: PacketNumber, + publisher: &mut Pub, ) -> Result<(), transport::Error> { + publisher.on_connection_close_frame_received( + event::builder::ConnectionCloseFrameReceived { + packet_header: event::builder::PacketHeader::new( + packet_number, + publisher.quic_version(), + ), + path: path_event!(path, path_id), + frame: frame.into_event(), + }, + ); + //= https://www.rfc-editor.org/rfc/rfc9000#section-17.2.2 //# CONNECTION_CLOSE frames of type 0x1c are also //# permitted. diff --git a/quic/s2n-quic-transport/src/space/mod.rs b/quic/s2n-quic-transport/src/space/mod.rs index 0be931f0e9..9c02489683 100644 --- a/quic/s2n-quic-transport/src/space/mod.rs +++ b/quic/s2n-quic-transport/src/space/mod.rs @@ -697,11 +697,13 @@ pub trait PacketSpace: Sized { publisher: &mut Pub, ) -> Result<(), transport::Error>; - fn handle_connection_close_frame( + fn handle_connection_close_frame( &mut self, frame: ConnectionClose, - timestamp: Timestamp, + path_id: path::Id, path: &mut Path, + packet_number: PacketNumber, + publisher: &mut Pub, ) -> Result<(), transport::Error>; fn handle_handshake_done_frame( @@ -942,8 +944,10 @@ pub trait PacketSpace: Sized { let on_error = on_frame_processed!(frame); self.handle_connection_close_frame( frame, - datagram.timestamp, + path_id, &mut path_manager[path_id], + packet_number, + publisher, ) .map_err(on_error)?; diff --git a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_handshake_self_test__events.snap b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_handshake_self_test__events.snap index 443982c714..95c9559b1a 100644 --- a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_handshake_self_test__events.snap +++ b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_handshake_self_test__events.snap @@ -400,6 +400,8 @@ count#packet_received.kind|ONE_RTT=1 count#frame_received=1 count#frame_received.packet|ONE_RTT=1 count#frame_received.frame|CONNECTION_CLOSE=1 +count#connection_close_frame_received=1 +count#connection_close_frame_received.packet|ONE_RTT=1 count#connection_closed=1 timer#connection_closed.latency=299.999ms count#connection_closed.error|CLOSED=1 diff --git a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_auth_failure_self_test__events.snap b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_auth_failure_self_test__events.snap index bc7c6250a0..cd6376a231 100644 --- a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_auth_failure_self_test__events.snap +++ b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_auth_failure_self_test__events.snap @@ -1,7 +1,6 @@ --- source: quic/s2n-quic-core/src/event/snapshot.rs input_file: quic/s2n-quic/src/tests/dc.rs -snapshot_kind: text --- === client === count#platform_event_loop_started=1 @@ -232,6 +231,8 @@ count#packet_received.kind|HANDSHAKE=1 count#frame_received=1 count#frame_received.packet|HANDSHAKE=1 count#frame_received.frame|CONNECTION_CLOSE=1 +count#connection_close_frame_received=1 +count#connection_close_frame_received.packet|HANDSHAKE=1 count#connection_closed=1 timer#connection_closed.latency=199.999ms count#connection_closed.error|TLS_HANDSHAKE_FAILURE=1 @@ -253,6 +254,8 @@ count#packet_received.kind|ONE_RTT=1 count#frame_received=1 count#frame_received.packet|ONE_RTT=1 count#frame_received.frame|CONNECTION_CLOSE=1 +count#connection_close_frame_received=1 +count#connection_close_frame_received.packet|ONE_RTT=1 count#platform_event_loop_sleep=1 timer#platform_event_loop_sleep.processing_duration=1µs count#platform_event_loop_wakeup=1 diff --git a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_client_not_supported_self_test__events.snap b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_client_not_supported_self_test__events.snap index dc6613f361..0469709eda 100644 --- a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_client_not_supported_self_test__events.snap +++ b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_client_not_supported_self_test__events.snap @@ -265,6 +265,8 @@ count#packet_received.kind|ONE_RTT=1 count#frame_received=1 count#frame_received.packet|ONE_RTT=1 count#frame_received.frame|CONNECTION_CLOSE=1 +count#connection_close_frame_received=1 +count#connection_close_frame_received.packet|ONE_RTT=1 count#connection_closed=1 timer#connection_closed.latency=199.999ms count#connection_closed.error|APPLICATION=1 diff --git a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_self_test__events.snap b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_self_test__events.snap index 6c1cef1091..18cf322197 100644 --- a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_self_test__events.snap +++ b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_self_test__events.snap @@ -405,6 +405,8 @@ count#packet_received.kind|ONE_RTT=1 count#frame_received=1 count#frame_received.packet|ONE_RTT=1 count#frame_received.frame|CONNECTION_CLOSE=1 +count#connection_close_frame_received=1 +count#connection_close_frame_received.packet|ONE_RTT=1 count#connection_closed=1 timer#connection_closed.latency=299.999ms count#connection_closed.error|CLOSED=1 diff --git a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_server_not_supported_self_test__events.snap b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_server_not_supported_self_test__events.snap index 89455a0217..ebf521a7be 100644 --- a/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_server_not_supported_self_test__events.snap +++ b/quic/s2n-quic/src/tests/snapshots/tests__dc__dc_mtls_handshake_server_not_supported_self_test__events.snap @@ -485,6 +485,8 @@ count#packet_received.kind|ONE_RTT=1 count#frame_received=1 count#frame_received.packet|ONE_RTT=1 count#frame_received.frame|CONNECTION_CLOSE=1 +count#connection_close_frame_received=1 +count#connection_close_frame_received.packet|ONE_RTT=1 count#connection_closed=1 timer#connection_closed.latency=100ms count#connection_closed.error|APPLICATION=1