diff --git a/dc/s2n-quic-dc/events/acceptor.rs b/dc/s2n-quic-dc/events/acceptor.rs index 038785f268..3afae2df66 100644 --- a/dc/s2n-quic-dc/events/acceptor.rs +++ b/dc/s2n-quic-dc/events/acceptor.rs @@ -177,6 +177,10 @@ struct AcceptorTcpTlsStreamRejected<'a> { #[builder(&'a s2n_quic_core::inet::SocketAddress)] remote_address: SocketAddress<'a>, + /// The local address of the server + #[builder(&'a s2n_quic_core::inet::SocketAddress)] + local_address: SocketAddress<'a>, + /// The amount of time the TCP stream spent on handshaking before being rejected /// since being accepted from the kernel #[timer("sojourn_time")] @@ -198,6 +202,10 @@ struct AcceptorTcpSyntheticTlsStreamRejected<'a> { #[builder(&'a s2n_quic_core::inet::SocketAddress)] remote_address: SocketAddress<'a>, + /// The local address of the server + #[builder(&'a s2n_quic_core::inet::SocketAddress)] + local_address: SocketAddress<'a>, + /// The amount of time the TCP stream spent on handshaking before being rejected /// since being accepted from the kernel #[timer("sojourn_time")] diff --git a/dc/s2n-quic-dc/events/connection.rs b/dc/s2n-quic-dc/events/connection.rs index 9076d363f3..440a84d3ed 100644 --- a/dc/s2n-quic-dc/events/connection.rs +++ b/dc/s2n-quic-dc/events/connection.rs @@ -297,10 +297,14 @@ pub struct StreamTcpConnect { /// Tracks TLS stream establishment. #[event("stream:tls_connect")] #[subject(endpoint)] -pub struct StreamTlsConnect { +pub struct StreamTlsConnect<'a> { #[bool_counter("error")] error: bool, + /// The remote address being connected to + #[builder(&'a s2n_quic_core::inet::SocketAddress)] + remote_address: SocketAddress<'a>, + // Does not include errors (otherwise we'd need to incorrectly emit zeros on tls_latency). #[timer("tcp_latency")] tcp_latency: core::time::Duration, @@ -310,6 +314,19 @@ pub struct StreamTlsConnect { tls_latency: core::time::Duration, } +/// Emitted when a TLS stream connect fails. +#[event("stream:tls_connect_error")] +#[subject(endpoint)] +pub struct StreamTlsConnectError<'a> { + /// The remote address being connected to + #[builder(&'a s2n_quic_core::inet::SocketAddress)] + remote_address: SocketAddress<'a>, + + /// The error encountered + #[builder(&'a std::io::Error)] + error: &'a std::io::Error, +} + /// Tracks stream connect where dcQUIC owns the TCP connect(). #[event("stream:connect")] #[subject(endpoint)] diff --git a/dc/s2n-quic-dc/src/event/generated.rs b/dc/s2n-quic-dc/src/event/generated.rs index 28df1f70ec..06f83bad60 100644 --- a/dc/s2n-quic-dc/src/event/generated.rs +++ b/dc/s2n-quic-dc/src/event/generated.rs @@ -245,6 +245,8 @@ pub mod api { pub struct AcceptorTcpTlsStreamRejected<'a> { /// The address of the packet's sender pub remote_address: SocketAddress<'a>, + /// The local address of the server + pub local_address: SocketAddress<'a>, /// The amount of time the TCP stream spent on handshaking before being rejected /// since being accepted from the kernel pub sojourn_time: core::time::Duration, @@ -256,6 +258,7 @@ pub mod api { fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { let mut fmt = fmt.debug_struct("AcceptorTcpTlsStreamRejected"); fmt.field("remote_address", &self.remote_address); + fmt.field("local_address", &self.local_address); fmt.field("sojourn_time", &self.sojourn_time); fmt.field("error", &self.error); fmt.finish() @@ -273,6 +276,8 @@ pub mod api { pub struct AcceptorTcpSyntheticTlsStreamRejected<'a> { /// The address of the packet's sender pub remote_address: SocketAddress<'a>, + /// The local address of the server + pub local_address: SocketAddress<'a>, /// The amount of time the TCP stream spent on handshaking before being rejected /// since being accepted from the kernel pub sojourn_time: core::time::Duration, @@ -284,6 +289,7 @@ pub mod api { fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { let mut fmt = fmt.debug_struct("AcceptorTcpSyntheticTlsStreamRejected"); fmt.field("remote_address", &self.remote_address); + fmt.field("local_address", &self.local_address); fmt.field("sojourn_time", &self.sojourn_time); fmt.field("error", &self.error); fmt.finish() @@ -1312,26 +1318,50 @@ pub mod api { #[derive(Clone, Debug)] #[non_exhaustive] /// Tracks TLS stream establishment. - pub struct StreamTlsConnect { + pub struct StreamTlsConnect<'a> { pub error: bool, + /// The remote address being connected to + pub remote_address: SocketAddress<'a>, pub tcp_latency: core::time::Duration, pub tls_latency: core::time::Duration, } #[cfg(any(test, feature = "testing"))] - impl crate::event::snapshot::Fmt for StreamTlsConnect { + impl<'a> crate::event::snapshot::Fmt for StreamTlsConnect<'a> { fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { let mut fmt = fmt.debug_struct("StreamTlsConnect"); fmt.field("error", &self.error); + fmt.field("remote_address", &self.remote_address); fmt.field("tcp_latency", &self.tcp_latency); fmt.field("tls_latency", &self.tls_latency); fmt.finish() } } - impl Event for StreamTlsConnect { + impl<'a> Event for StreamTlsConnect<'a> { const NAME: &'static str = "stream:tls_connect"; } #[derive(Clone, Debug)] #[non_exhaustive] + /// Emitted when a TLS stream connect fails. + pub struct StreamTlsConnectError<'a> { + /// The remote address being connected to + pub remote_address: SocketAddress<'a>, + /// The error encountered + pub error: &'a std::io::Error, + } + #[cfg(any(test, feature = "testing"))] + impl<'a> crate::event::snapshot::Fmt for StreamTlsConnectError<'a> { + fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result { + let mut fmt = fmt.debug_struct("StreamTlsConnectError"); + fmt.field("remote_address", &self.remote_address); + fmt.field("error", &self.error); + fmt.finish() + } + } + impl<'a> Event for StreamTlsConnectError<'a> { + const NAME: &'static str = "stream:tls_connect_error"; + } + #[derive(Clone, Debug)] + #[non_exhaustive] /// Tracks stream connect where dcQUIC owns the TCP connect(). pub struct StreamConnect { pub error: bool, @@ -2951,13 +2981,15 @@ pub mod tracing { let parent = self.parent(meta); let api::AcceptorTcpTlsStreamRejected { remote_address, + local_address, sojourn_time, error, } = event; tracing::event!( target : "acceptor_tcp_tls_stream_rejected", parent : parent, tracing::Level::DEBUG, { remote_address = - tracing::field::debug(remote_address), sojourn_time = + tracing::field::debug(remote_address), local_address = + tracing::field::debug(local_address), sojourn_time = tracing::field::debug(sojourn_time), error = tracing::field::debug(error) } ); @@ -2971,13 +3003,15 @@ pub mod tracing { let parent = self.parent(meta); let api::AcceptorTcpSyntheticTlsStreamRejected { remote_address, + local_address, sojourn_time, error, } = event; tracing::event!( target : "acceptor_tcp_synthetic_tls_stream_rejected", parent : parent, tracing::Level::DEBUG, { remote_address = - tracing::field::debug(remote_address), sojourn_time = + tracing::field::debug(remote_address), local_address = + tracing::field::debug(local_address), sojourn_time = tracing::field::debug(sojourn_time), error = tracing::field::debug(error) } ); @@ -3616,17 +3650,37 @@ pub mod tracing { let parent = self.parent(meta); let api::StreamTlsConnect { error, + remote_address, tcp_latency, tls_latency, } = event; tracing::event!( target : "stream_tls_connect", parent : parent, tracing::Level::DEBUG, { - error = tracing::field::debug(error), tcp_latency = + error = tracing::field::debug(error), remote_address = + tracing::field::debug(remote_address), tcp_latency = tracing::field::debug(tcp_latency), tls_latency = tracing::field::debug(tls_latency) } ); } #[inline] + fn on_stream_tls_connect_error( + &self, + meta: &api::EndpointMeta, + event: &api::StreamTlsConnectError, + ) { + let parent = self.parent(meta); + let api::StreamTlsConnectError { + remote_address, + error, + } = event; + tracing::event!( + target : "stream_tls_connect_error", parent : parent, + tracing::Level::DEBUG, { remote_address = + tracing::field::debug(remote_address), error = + tracing::field::debug(error) } + ); + } + #[inline] fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { let parent = self.parent(meta); let api::StreamConnect { @@ -4867,6 +4921,8 @@ pub mod builder { pub struct AcceptorTcpTlsStreamRejected<'a> { /// The address of the packet's sender pub remote_address: &'a s2n_quic_core::inet::SocketAddress, + /// The local address of the server + pub local_address: &'a s2n_quic_core::inet::SocketAddress, /// The amount of time the TCP stream spent on handshaking before being rejected /// since being accepted from the kernel pub sojourn_time: core::time::Duration, @@ -4878,11 +4934,13 @@ pub mod builder { fn into_event(self) -> api::AcceptorTcpTlsStreamRejected<'a> { let AcceptorTcpTlsStreamRejected { remote_address, + local_address, sojourn_time, error, } = self; api::AcceptorTcpTlsStreamRejected { remote_address: remote_address.into_event(), + local_address: local_address.into_event(), sojourn_time: sojourn_time.into_event(), error: error.into_event(), } @@ -4896,6 +4954,8 @@ pub mod builder { pub struct AcceptorTcpSyntheticTlsStreamRejected<'a> { /// The address of the packet's sender pub remote_address: &'a s2n_quic_core::inet::SocketAddress, + /// The local address of the server + pub local_address: &'a s2n_quic_core::inet::SocketAddress, /// The amount of time the TCP stream spent on handshaking before being rejected /// since being accepted from the kernel pub sojourn_time: core::time::Duration, @@ -4909,11 +4969,13 @@ pub mod builder { fn into_event(self) -> api::AcceptorTcpSyntheticTlsStreamRejected<'a> { let AcceptorTcpSyntheticTlsStreamRejected { remote_address, + local_address, sojourn_time, error, } = self; api::AcceptorTcpSyntheticTlsStreamRejected { remote_address: remote_address.into_event(), + local_address: local_address.into_event(), sojourn_time: sojourn_time.into_event(), error: error.into_event(), } @@ -5830,27 +5892,52 @@ pub mod builder { } #[derive(Clone, Debug)] /// Tracks TLS stream establishment. - pub struct StreamTlsConnect { + pub struct StreamTlsConnect<'a> { pub error: bool, + /// The remote address being connected to + pub remote_address: &'a s2n_quic_core::inet::SocketAddress, pub tcp_latency: core::time::Duration, pub tls_latency: core::time::Duration, } - impl IntoEvent for StreamTlsConnect { + impl<'a> IntoEvent> for StreamTlsConnect<'a> { #[inline] - fn into_event(self) -> api::StreamTlsConnect { + fn into_event(self) -> api::StreamTlsConnect<'a> { let StreamTlsConnect { error, + remote_address, tcp_latency, tls_latency, } = self; api::StreamTlsConnect { error: error.into_event(), + remote_address: remote_address.into_event(), tcp_latency: tcp_latency.into_event(), tls_latency: tls_latency.into_event(), } } } #[derive(Clone, Debug)] + /// Emitted when a TLS stream connect fails. + pub struct StreamTlsConnectError<'a> { + /// The remote address being connected to + pub remote_address: &'a s2n_quic_core::inet::SocketAddress, + /// The error encountered + pub error: &'a std::io::Error, + } + impl<'a> IntoEvent> for StreamTlsConnectError<'a> { + #[inline] + fn into_event(self) -> api::StreamTlsConnectError<'a> { + let StreamTlsConnectError { + remote_address, + error, + } = self; + api::StreamTlsConnectError { + remote_address: remote_address.into_event(), + error: error.into_event(), + } + } + } + #[derive(Clone, Debug)] /// Tracks stream connect where dcQUIC owns the TCP connect(). pub struct StreamConnect { pub error: bool, @@ -7715,6 +7802,16 @@ mod traits { let _ = meta; let _ = event; } + ///Called when the `StreamTlsConnectError` event is triggered + #[inline] + fn on_stream_tls_connect_error( + &self, + meta: &api::EndpointMeta, + event: &api::StreamTlsConnectError, + ) { + let _ = meta; + let _ = event; + } ///Called when the `StreamConnect` event is triggered #[inline] fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { @@ -8697,6 +8794,14 @@ mod traits { self.as_ref().on_stream_tls_connect(meta, event); } #[inline] + fn on_stream_tls_connect_error( + &self, + meta: &api::EndpointMeta, + event: &api::StreamTlsConnectError, + ) { + self.as_ref().on_stream_tls_connect_error(meta, event); + } + #[inline] fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { self.as_ref().on_stream_connect(meta, event); } @@ -9612,6 +9717,15 @@ mod traits { (self.1).on_stream_tls_connect(meta, event); } #[inline] + fn on_stream_tls_connect_error( + &self, + meta: &api::EndpointMeta, + event: &api::StreamTlsConnectError, + ) { + (self.0).on_stream_tls_connect_error(meta, event); + (self.1).on_stream_tls_connect_error(meta, event); + } + #[inline] fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { (self.0).on_stream_connect(meta, event); (self.1).on_stream_connect(meta, event); @@ -10181,6 +10295,8 @@ mod traits { fn on_stream_tcp_connect(&self, event: builder::StreamTcpConnect); ///Publishes a `StreamTlsConnect` event to the publisher's subscriber fn on_stream_tls_connect(&self, event: builder::StreamTlsConnect); + ///Publishes a `StreamTlsConnectError` event to the publisher's subscriber + fn on_stream_tls_connect_error(&self, event: builder::StreamTlsConnectError); ///Publishes a `StreamConnect` event to the publisher's subscriber fn on_stream_connect(&self, event: builder::StreamConnect); ///Publishes a `StreamConnectError` event to the publisher's subscriber @@ -10517,6 +10633,13 @@ mod traits { self.subscriber.on_event(&self.meta, &event); } #[inline] + fn on_stream_tls_connect_error(&self, event: builder::StreamTlsConnectError) { + let event = event.into_event(); + self.subscriber + .on_stream_tls_connect_error(&self.meta, &event); + self.subscriber.on_event(&self.meta, &event); + } + #[inline] fn on_stream_connect(&self, event: builder::StreamConnect) { let event = event.into_event(); self.subscriber.on_stream_connect(&self.meta, &event); @@ -11302,6 +11425,7 @@ pub mod testing { pub acceptor_stream_dequeued: AtomicU64, pub stream_tcp_connect: AtomicU64, pub stream_tls_connect: AtomicU64, + pub stream_tls_connect_error: AtomicU64, pub stream_connect: AtomicU64, pub stream_connect_error: AtomicU64, pub endpoint_initialized: AtomicU64, @@ -11399,6 +11523,7 @@ pub mod testing { acceptor_stream_dequeued: AtomicU64::new(0), stream_tcp_connect: AtomicU64::new(0), stream_tls_connect: AtomicU64::new(0), + stream_tls_connect_error: AtomicU64::new(0), stream_connect: AtomicU64::new(0), stream_connect_error: AtomicU64::new(0), endpoint_initialized: AtomicU64::new(0), @@ -11755,6 +11880,18 @@ pub mod testing { let out = format!("{meta:?} {event:?}"); self.output.lock().unwrap().push(out); } + fn on_stream_tls_connect_error( + &self, + meta: &api::EndpointMeta, + event: &api::StreamTlsConnectError, + ) { + self.stream_tls_connect_error + .fetch_add(1, Ordering::Relaxed); + let meta = crate::event::snapshot::Fmt::to_snapshot(meta); + let event = crate::event::snapshot::Fmt::to_snapshot(event); + let out = format!("{meta:?} {event:?}"); + self.output.lock().unwrap().push(out); + } fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { self.stream_connect.fetch_add(1, Ordering::Relaxed); let meta = crate::event::snapshot::Fmt::to_snapshot(meta); @@ -12273,6 +12410,7 @@ pub mod testing { pub stream_decrypt_packet: AtomicU64, pub stream_tcp_connect: AtomicU64, pub stream_tls_connect: AtomicU64, + pub stream_tls_connect_error: AtomicU64, pub stream_connect: AtomicU64, pub stream_connect_error: AtomicU64, pub stream_packet_transmitted: AtomicU64, @@ -12403,6 +12541,7 @@ pub mod testing { stream_decrypt_packet: AtomicU64::new(0), stream_tcp_connect: AtomicU64::new(0), stream_tls_connect: AtomicU64::new(0), + stream_tls_connect_error: AtomicU64::new(0), stream_connect: AtomicU64::new(0), stream_connect_error: AtomicU64::new(0), stream_packet_transmitted: AtomicU64::new(0), @@ -13052,6 +13191,18 @@ pub mod testing { let out = format!("{meta:?} {event:?}"); self.output.lock().unwrap().push(out); } + fn on_stream_tls_connect_error( + &self, + meta: &api::EndpointMeta, + event: &api::StreamTlsConnectError, + ) { + self.stream_tls_connect_error + .fetch_add(1, Ordering::Relaxed); + let meta = crate::event::snapshot::Fmt::to_snapshot(meta); + let event = crate::event::snapshot::Fmt::to_snapshot(event); + let out = format!("{meta:?} {event:?}"); + self.output.lock().unwrap().push(out); + } fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { self.stream_connect.fetch_add(1, Ordering::Relaxed); let meta = crate::event::snapshot::Fmt::to_snapshot(meta); @@ -13758,6 +13909,7 @@ pub mod testing { pub stream_decrypt_packet: AtomicU64, pub stream_tcp_connect: AtomicU64, pub stream_tls_connect: AtomicU64, + pub stream_tls_connect_error: AtomicU64, pub stream_connect: AtomicU64, pub stream_connect_error: AtomicU64, pub stream_packet_transmitted: AtomicU64, @@ -13878,6 +14030,7 @@ pub mod testing { stream_decrypt_packet: AtomicU64::new(0), stream_tcp_connect: AtomicU64::new(0), stream_tls_connect: AtomicU64::new(0), + stream_tls_connect_error: AtomicU64::new(0), stream_connect: AtomicU64::new(0), stream_connect_error: AtomicU64::new(0), stream_packet_transmitted: AtomicU64::new(0), @@ -14151,6 +14304,14 @@ pub mod testing { let out = format!("{event:?}"); self.output.lock().unwrap().push(out); } + fn on_stream_tls_connect_error(&self, event: builder::StreamTlsConnectError) { + self.stream_tls_connect_error + .fetch_add(1, Ordering::Relaxed); + let event = event.into_event(); + let event = crate::event::snapshot::Fmt::to_snapshot(&event); + let out = format!("{event:?}"); + self.output.lock().unwrap().push(out); + } fn on_stream_connect(&self, event: builder::StreamConnect) { self.stream_connect.fetch_add(1, Ordering::Relaxed); let event = event.into_event(); diff --git a/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs b/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs index 1a2757d922..5756228fb0 100644 --- a/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs +++ b/dc/s2n-quic-dc/src/event/generated/metrics/aggregate.rs @@ -183,6 +183,7 @@ mod id { STREAM_TLS_CONNECT__ERROR, STREAM_TLS_CONNECT__TCP_LATENCY, STREAM_TLS_CONNECT__TLS_LATENCY, + STREAM_TLS_CONNECT_ERROR, STREAM_CONNECT, STREAM_CONNECT__ERROR, STREAM_CONNECT__TCP, @@ -630,6 +631,7 @@ mod id { InfoId::STREAM_TLS_CONNECT__TCP_LATENCY as usize; pub const STREAM_TLS_CONNECT__TLS_LATENCY: usize = InfoId::STREAM_TLS_CONNECT__TLS_LATENCY as usize; + pub const STREAM_TLS_CONNECT_ERROR: usize = InfoId::STREAM_TLS_CONNECT_ERROR as usize; pub const STREAM_CONNECT: usize = InfoId::STREAM_CONNECT as usize; pub const STREAM_CONNECT__ERROR: usize = InfoId::STREAM_CONNECT__ERROR as usize; pub const STREAM_CONNECT__TCP: usize = InfoId::STREAM_CONNECT__TCP as usize; @@ -996,6 +998,7 @@ mod id { COUNTERS_STREAM_DECRYPT_PACKET, COUNTERS_STREAM_TCP_CONNECT, COUNTERS_STREAM_TLS_CONNECT, + COUNTERS_STREAM_TLS_CONNECT_ERROR, COUNTERS_STREAM_CONNECT, COUNTERS_STREAM_CONNECT_ERROR, COUNTERS_STREAM_PACKET_TRANSMITTED, @@ -1157,6 +1160,8 @@ mod id { Counters::COUNTERS_STREAM_DECRYPT_PACKET as usize; pub const COUNTERS_STREAM_TCP_CONNECT: usize = Counters::COUNTERS_STREAM_TCP_CONNECT as usize; pub const COUNTERS_STREAM_TLS_CONNECT: usize = Counters::COUNTERS_STREAM_TLS_CONNECT as usize; + pub const COUNTERS_STREAM_TLS_CONNECT_ERROR: usize = + Counters::COUNTERS_STREAM_TLS_CONNECT_ERROR as usize; pub const COUNTERS_STREAM_CONNECT: usize = Counters::COUNTERS_STREAM_CONNECT as usize; pub const COUNTERS_STREAM_CONNECT_ERROR: usize = Counters::COUNTERS_STREAM_CONNECT_ERROR as usize; @@ -1992,7 +1997,7 @@ mod id { pub const TIMERS_STREAM_CONNECT_ERROR__LATENCY: usize = Timers::TIMERS_STREAM_CONNECT_ERROR__LATENCY as usize; } -static INFO: &[Info; 340usize] = &[ +static INFO: &[Info; 341usize] = &[ info::Builder { id: id::ACCEPTOR_TCP_STARTED, name: Str::new("acceptor_tcp_started\0"), @@ -2989,6 +2994,12 @@ static INFO: &[Info; 340usize] = &[ units: Units::Duration, } .build(), + info::Builder { + id: id::STREAM_TLS_CONNECT_ERROR, + name: Str::new("stream_tls_connect_error\0"), + units: Units::None, + } + .build(), info::Builder { id: id::STREAM_CONNECT, name: Str::new("stream_connect\0"), @@ -4071,7 +4082,7 @@ pub struct ConnectionContext { } pub struct Subscriber { #[allow(dead_code)] - counters: Box<[R::Counter; 113usize]>, + counters: Box<[R::Counter; 114usize]>, #[allow(dead_code)] bool_counters: Box<[R::BoolCounter; 25usize]>, #[allow(dead_code)] @@ -4106,7 +4117,7 @@ impl Subscriber { #[allow(unused_mut)] #[inline] pub fn new(registry: R) -> Self { - let mut counters = Vec::with_capacity(113usize); + let mut counters = Vec::with_capacity(114usize); let mut bool_counters = Vec::with_capacity(25usize); let mut nominal_counters = Vec::with_capacity(37usize); let mut nominal_counter_offsets = Vec::with_capacity(37usize); @@ -4175,6 +4186,7 @@ impl Subscriber { counters.push(registry.register_counter(&INFO[id::STREAM_DECRYPT_PACKET])); counters.push(registry.register_counter(&INFO[id::STREAM_TCP_CONNECT])); counters.push(registry.register_counter(&INFO[id::STREAM_TLS_CONNECT])); + counters.push(registry.register_counter(&INFO[id::STREAM_TLS_CONNECT_ERROR])); counters.push(registry.register_counter(&INFO[id::STREAM_CONNECT])); counters.push(registry.register_counter(&INFO[id::STREAM_CONNECT_ERROR])); counters.push(registry.register_counter(&INFO[id::STREAM_PACKET_TRANSMITTED])); @@ -5291,6 +5303,9 @@ impl Subscriber { id::COUNTERS_STREAM_DECRYPT_PACKET => (&INFO[id::STREAM_DECRYPT_PACKET], entry), id::COUNTERS_STREAM_TCP_CONNECT => (&INFO[id::STREAM_TCP_CONNECT], entry), id::COUNTERS_STREAM_TLS_CONNECT => (&INFO[id::STREAM_TLS_CONNECT], entry), + id::COUNTERS_STREAM_TLS_CONNECT_ERROR => { + (&INFO[id::STREAM_TLS_CONNECT_ERROR], entry) + } id::COUNTERS_STREAM_CONNECT => (&INFO[id::STREAM_CONNECT], entry), id::COUNTERS_STREAM_CONNECT_ERROR => (&INFO[id::STREAM_CONNECT_ERROR], entry), id::COUNTERS_STREAM_PACKET_TRANSMITTED => { @@ -8002,6 +8017,22 @@ impl event::Subscriber for Subscriber { let _ = meta; } #[inline] + fn on_stream_tls_connect_error( + &self, + meta: &api::EndpointMeta, + event: &api::StreamTlsConnectError, + ) { + #[allow(unused_imports)] + use api::*; + self.count( + id::STREAM_TLS_CONNECT_ERROR, + id::COUNTERS_STREAM_TLS_CONNECT_ERROR, + 1usize, + ); + let _ = event; + let _ = meta; + } + #[inline] fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) { #[allow(unused_imports)] use api::*; diff --git a/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs b/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs index 2299310002..8aa34e4d81 100644 --- a/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs +++ b/dc/s2n-quic-dc/src/event/generated/metrics/probe.rs @@ -179,6 +179,7 @@ mod id { STREAM_TLS_CONNECT__ERROR, STREAM_TLS_CONNECT__TCP_LATENCY, STREAM_TLS_CONNECT__TLS_LATENCY, + STREAM_TLS_CONNECT_ERROR, STREAM_CONNECT, STREAM_CONNECT__ERROR, STREAM_CONNECT__TCP, @@ -626,6 +627,7 @@ mod id { InfoId::STREAM_TLS_CONNECT__TCP_LATENCY as usize; pub const STREAM_TLS_CONNECT__TLS_LATENCY: usize = InfoId::STREAM_TLS_CONNECT__TLS_LATENCY as usize; + pub const STREAM_TLS_CONNECT_ERROR: usize = InfoId::STREAM_TLS_CONNECT_ERROR as usize; pub const STREAM_CONNECT: usize = InfoId::STREAM_CONNECT as usize; pub const STREAM_CONNECT__ERROR: usize = InfoId::STREAM_CONNECT__ERROR as usize; pub const STREAM_CONNECT__TCP: usize = InfoId::STREAM_CONNECT__TCP as usize; @@ -1014,6 +1016,7 @@ mod counter { id::STREAM_DECRYPT_PACKET => Self(stream_decrypt_packet), id::STREAM_TCP_CONNECT => Self(stream_tcp_connect), id::STREAM_TLS_CONNECT => Self(stream_tls_connect), + id::STREAM_TLS_CONNECT_ERROR => Self(stream_tls_connect_error), id::STREAM_CONNECT => Self(stream_connect), id::STREAM_CONNECT_ERROR => Self(stream_connect_error), id::STREAM_PACKET_TRANSMITTED => Self(stream_packet_transmitted), @@ -1272,6 +1275,9 @@ mod counter { #[link_name = s2n_quic_dc__event__counter__stream_tls_connect] fn stream_tls_connect(value: u64); #[link_name = + s2n_quic_dc__event__counter__stream_tls_connect_error] + fn stream_tls_connect_error(value: u64); + #[link_name = s2n_quic_dc__event__counter__stream_connect] fn stream_connect(value: u64); #[link_name = s2n_quic_dc__event__counter__stream_connect_error] diff --git a/dc/s2n-quic-dc/src/stream/client/tokio.rs b/dc/s2n-quic-dc/src/stream/client/tokio.rs index 429a2250c8..dbc75ec031 100644 --- a/dc/s2n-quic-dc/src/stream/client/tokio.rs +++ b/dc/s2n-quic-dc/src/stream/client/tokio.rs @@ -850,13 +850,24 @@ where let negotiate_end = env.clock().get_time(); + let remote_address: s2n_quic_core::inet::SocketAddress = addr.into(); + env.endpoint_publisher_with_time(negotiate_end) .on_stream_tls_connect(event::builder::StreamTlsConnect { error: res.is_err(), + remote_address: &remote_address, tcp_latency: kernel_start_time.saturating_duration_since(start), tls_latency: negotiate_end.saturating_duration_since(kernel_start_time), }); + if let Err(error) = &res { + env.endpoint_publisher_with_time(negotiate_end) + .on_stream_tls_connect_error(event::builder::StreamTlsConnectError { + remote_address: &remote_address, + error, + }); + } + // Return if negotiation failed. res?; diff --git a/dc/s2n-quic-dc/src/stream/server/tokio/tcp/tls.rs b/dc/s2n-quic-dc/src/stream/server/tokio/tcp/tls.rs index e81d749348..bb37940109 100644 --- a/dc/s2n-quic-dc/src/stream/server/tokio/tcp/tls.rs +++ b/dc/s2n-quic-dc/src/stream/server/tokio/tcp/tls.rs @@ -130,10 +130,17 @@ where &self, socket: super::LazyBoundStream, remote_address: s2n_quic_core::inet::SocketAddress, + local_address: s2n_quic_core::inet::SocketAddress, buffer: crate::msg::recv::Message, kernel_accept_time: Timestamp, ) { - match self.spawn_inner(socket, remote_address, buffer, kernel_accept_time) { + match self.spawn_inner( + socket, + remote_address, + local_address, + buffer, + kernel_accept_time, + ) { Ok(()) => {} Err(error) => { self.env @@ -141,6 +148,7 @@ where .on_acceptor_tcp_tls_stream_rejected( event::builder::AcceptorTcpTlsStreamRejected { remote_address: &remote_address, + local_address: &local_address, sojourn_time: self .env .clock() @@ -157,6 +165,7 @@ where &self, socket: super::LazyBoundStream, remote_addr: s2n_quic_core::inet::SocketAddress, + local_addr: s2n_quic_core::inet::SocketAddress, buffer: crate::msg::recv::Message, kernel_accept_time: Timestamp, ) -> Result<(), s2n_tls::error::Error> { @@ -198,6 +207,7 @@ where .on_acceptor_tcp_synthetic_tls_stream_rejected( event::builder::AcceptorTcpSyntheticTlsStreamRejected { remote_address: &remote_addr, + local_address: &local_addr, sojourn_time: env .clock() .get_time() @@ -210,6 +220,7 @@ where .on_acceptor_tcp_tls_stream_rejected( event::builder::AcceptorTcpTlsStreamRejected { remote_address: &remote_addr, + local_address: &local_addr, sojourn_time: env .clock() .get_time() diff --git a/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs b/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs index 0b20761c3b..0dec9516d7 100644 --- a/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs +++ b/dc/s2n-quic-dc/src/stream/server/tokio/tcp/worker.rs @@ -40,7 +40,7 @@ where env: Environment, secrets: secret::Map, accept_flavor: accept::Flavor, - local_port: u16, + local_addr: s2n_quic_core::inet::SocketAddress, } impl Context @@ -54,7 +54,7 @@ where env: acceptor.env.clone(), secrets: acceptor.secrets.clone(), accept_flavor: acceptor.accept_flavor, - local_port: acceptor.local_addr.port(), + local_addr: acceptor.local_addr.into(), } } } @@ -398,7 +398,13 @@ where InitialPacket::Dc(initial_packet) => initial_packet, InitialPacket::Tls => { if let Some(tls) = &self.tls { - tls.spawn(socket, remote_address, recv_buffer.take(), queue_time); + tls.spawn( + socket, + remote_address, + context.local_addr, + recv_buffer.take(), + queue_time, + ); } else { publisher.on_acceptor_tcp_packet_dropped( event::builder::AcceptorTcpPacketDropped { @@ -464,7 +470,7 @@ where let peer = env::tcp::Reregistered { socket, peer_addr: remote_address, - local_port: context.local_port, + local_port: context.local_addr.port(), recv_buffer, };