#![allow(clippy::needless_lifetimes)]
use super::*;
pub(crate) mod metrics;
pub mod api {
use super::*;
#[allow(unused_imports)]
use crate::event::metrics::aggregate;
pub use s2n_quic_core::event::api::{EndpointType, SocketAddress, Subject};
pub use traits::Subscriber;
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpStarted<'a> {
pub id: usize,
pub local_address: SocketAddress<'a>,
pub backlog: usize,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpStarted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpStarted");
fmt.field("id", &self.id);
fmt.field("local_address", &self.local_address);
fmt.field("backlog", &self.backlog);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpStarted<'a> {
const NAME: &'static str = "acceptor:tcp:started";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpLoopIterationCompleted {
pub pending_streams: usize,
pub slots_idle: usize,
pub slot_utilization: f32,
pub processing_duration: core::time::Duration,
pub max_sojourn_time: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for AcceptorTcpLoopIterationCompleted {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpLoopIterationCompleted");
fmt.field("pending_streams", &self.pending_streams);
fmt.field("slots_idle", &self.slots_idle);
fmt.field("slot_utilization", &self.slot_utilization);
fmt.field("processing_duration", &self.processing_duration);
fmt.field("max_sojourn_time", &self.max_sojourn_time);
fmt.finish()
}
}
impl Event for AcceptorTcpLoopIterationCompleted {
const NAME: &'static str = "acceptor:tcp:loop_iteration_completed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpFreshEnqueued<'a> {
pub remote_address: SocketAddress<'a>,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpFreshEnqueued<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpFreshEnqueued");
fmt.field("remote_address", &self.remote_address);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpFreshEnqueued<'a> {
const NAME: &'static str = "acceptor:tcp:fresh:enqueued";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpFreshBatchCompleted {
pub enqueued: usize,
pub dropped: usize,
pub errored: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for AcceptorTcpFreshBatchCompleted {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpFreshBatchCompleted");
fmt.field("enqueued", &self.enqueued);
fmt.field("dropped", &self.dropped);
fmt.field("errored", &self.errored);
fmt.finish()
}
}
impl Event for AcceptorTcpFreshBatchCompleted {
const NAME: &'static str = "acceptor:tcp:fresh:batch_completed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpStreamDropped<'a> {
pub remote_address: SocketAddress<'a>,
pub reason: AcceptorTcpStreamDropReason,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpStreamDropped<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpStreamDropped");
fmt.field("remote_address", &self.remote_address);
fmt.field("reason", &self.reason);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpStreamDropped<'a> {
const NAME: &'static str = "acceptor:tcp:stream_dropped";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpStreamReplaced<'a> {
pub remote_address: SocketAddress<'a>,
pub sojourn_time: core::time::Duration,
pub buffer_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpStreamReplaced<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpStreamReplaced");
fmt.field("remote_address", &self.remote_address);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.field("buffer_len", &self.buffer_len);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpStreamReplaced<'a> {
const NAME: &'static str = "acceptor:tcp:stream_replaced";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpPacketReceived<'a> {
pub remote_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub payload_len: usize,
pub is_fin: bool,
pub is_fin_known: bool,
pub sojourn_time: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpPacketReceived<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpPacketReceived");
fmt.field("remote_address", &self.remote_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.field("payload_len", &self.payload_len);
fmt.field("is_fin", &self.is_fin);
fmt.field("is_fin_known", &self.is_fin_known);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpPacketReceived<'a> {
const NAME: &'static str = "acceptor:tcp:packet_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpTlsStarted<'a> {
pub remote_address: SocketAddress<'a>,
pub sojourn_time: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpTlsStarted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpTlsStarted");
fmt.field("remote_address", &self.remote_address);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpTlsStarted<'a> {
const NAME: &'static str = "acceptor:tcp:tls_started";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpTlsStreamEnqueued<'a> {
pub remote_address: SocketAddress<'a>,
pub sojourn_time: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpTlsStreamEnqueued<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpTlsStreamEnqueued");
fmt.field("remote_address", &self.remote_address);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpTlsStreamEnqueued<'a> {
const NAME: &'static str = "acceptor:tcp:tls_stream_enqueued";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpTlsStreamRejected<'a> {
pub remote_address: SocketAddress<'a>,
pub local_address: SocketAddress<'a>,
pub sojourn_time: core::time::Duration,
pub error: &'a std::io::Error,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpTlsStreamRejected<'a> {
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()
}
}
impl<'a> Event for AcceptorTcpTlsStreamRejected<'a> {
const NAME: &'static str = "acceptor:tcp:tls_stream_rejected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpSyntheticTlsStreamRejected<'a> {
pub remote_address: SocketAddress<'a>,
pub local_address: SocketAddress<'a>,
pub sojourn_time: core::time::Duration,
pub error: &'a std::io::Error,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpSyntheticTlsStreamRejected<'a> {
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()
}
}
impl<'a> Event for AcceptorTcpSyntheticTlsStreamRejected<'a> {
const NAME: &'static str = "acceptor:tcp:tls_synthetic_stream_rejected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpPacketDropped<'a> {
pub remote_address: SocketAddress<'a>,
pub reason: AcceptorPacketDropReason,
pub sojourn_time: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpPacketDropped<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpPacketDropped");
fmt.field("remote_address", &self.remote_address);
fmt.field("reason", &self.reason);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpPacketDropped<'a> {
const NAME: &'static str = "acceptor:tcp:packet_dropped";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpStreamEnqueued<'a> {
pub remote_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub blocked_count: usize,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpStreamEnqueued<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpStreamEnqueued");
fmt.field("remote_address", &self.remote_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.field("blocked_count", &self.blocked_count);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpStreamEnqueued<'a> {
const NAME: &'static str = "acceptor:tcp:stream_enqueued";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpIoError<'a> {
pub error: &'a std::io::Error,
pub source: AcceptorTcpIoErrorSource,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpIoError<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpIoError");
fmt.field("error", &self.error);
fmt.field("source", &self.source);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpIoError<'a> {
const NAME: &'static str = "acceptor:tcp:io_error";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpSocketSent<'a> {
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub blocked_count: usize,
pub payload_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpSocketSent<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpSocketSent");
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.field("blocked_count", &self.blocked_count);
fmt.field("payload_len", &self.payload_len);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpSocketSent<'a> {
const NAME: &'static str = "acceptor:tcp:socket_sent";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorTcpSocketReceived<'a> {
pub remote_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub transfer_time: core::time::Duration,
pub payload_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorTcpSocketReceived<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorTcpSocketReceived");
fmt.field("remote_address", &self.remote_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.field("transfer_time", &self.transfer_time);
fmt.field("payload_len", &self.payload_len);
fmt.finish()
}
}
impl<'a> Event for AcceptorTcpSocketReceived<'a> {
const NAME: &'static str = "acceptor:tcp:socket_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorUdpStarted<'a> {
pub id: usize,
pub local_address: SocketAddress<'a>,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorUdpStarted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorUdpStarted");
fmt.field("id", &self.id);
fmt.field("local_address", &self.local_address);
fmt.finish()
}
}
impl<'a> Event for AcceptorUdpStarted<'a> {
const NAME: &'static str = "acceptor:udp:started";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorUdpDatagramReceived<'a> {
pub remote_address: SocketAddress<'a>,
pub len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorUdpDatagramReceived<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorUdpDatagramReceived");
fmt.field("remote_address", &self.remote_address);
fmt.field("len", &self.len);
fmt.finish()
}
}
impl<'a> Event for AcceptorUdpDatagramReceived<'a> {
const NAME: &'static str = "acceptor:udp:datagram_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorUdpPacketReceived<'a> {
pub remote_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub payload_len: usize,
pub is_zero_offset: bool,
pub is_retransmission: bool,
pub is_fin: bool,
pub is_fin_known: bool,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorUdpPacketReceived<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorUdpPacketReceived");
fmt.field("remote_address", &self.remote_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.field("payload_len", &self.payload_len);
fmt.field("is_zero_offset", &self.is_zero_offset);
fmt.field("is_retransmission", &self.is_retransmission);
fmt.field("is_fin", &self.is_fin);
fmt.field("is_fin_known", &self.is_fin_known);
fmt.finish()
}
}
impl<'a> Event for AcceptorUdpPacketReceived<'a> {
const NAME: &'static str = "acceptor:udp:packet_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorUdpPacketDropped<'a> {
pub remote_address: SocketAddress<'a>,
pub reason: AcceptorPacketDropReason,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorUdpPacketDropped<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorUdpPacketDropped");
fmt.field("remote_address", &self.remote_address);
fmt.field("reason", &self.reason);
fmt.finish()
}
}
impl<'a> Event for AcceptorUdpPacketDropped<'a> {
const NAME: &'static str = "acceptor:udp:packet_dropped";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorUdpStreamEnqueued<'a> {
pub remote_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub stream_id: u64,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorUdpStreamEnqueued<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorUdpStreamEnqueued");
fmt.field("remote_address", &self.remote_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.finish()
}
}
impl<'a> Event for AcceptorUdpStreamEnqueued<'a> {
const NAME: &'static str = "acceptor:udp:stream_enqueued";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorUdpIoError<'a> {
pub error: &'a std::io::Error,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorUdpIoError<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorUdpIoError");
fmt.field("error", &self.error);
fmt.finish()
}
}
impl<'a> Event for AcceptorUdpIoError<'a> {
const NAME: &'static str = "acceptor:udp:io_error";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorStreamPruned<'a> {
pub remote_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub reason: AcceptorStreamPruneReason,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorStreamPruned<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorStreamPruned");
fmt.field("remote_address", &self.remote_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.field("reason", &self.reason);
fmt.finish()
}
}
impl<'a> Event for AcceptorStreamPruned<'a> {
const NAME: &'static str = "acceptor:stream_pruned";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct AcceptorStreamDequeued<'a> {
pub remote_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub queue_sojourn_time: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for AcceptorStreamDequeued<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("AcceptorStreamDequeued");
fmt.field("remote_address", &self.remote_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("stream_id", &self.stream_id);
fmt.field("sojourn_time", &self.sojourn_time);
fmt.field("queue_sojourn_time", &self.queue_sojourn_time);
fmt.finish()
}
}
impl<'a> Event for AcceptorStreamDequeued<'a> {
const NAME: &'static str = "acceptor:stream_dequeued";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum AcceptorTcpStreamDropReason {
#[non_exhaustive]
FreshQueueAtCapacity {},
#[non_exhaustive]
SlotsAtCapacity {},
}
impl aggregate::AsVariant for AcceptorTcpStreamDropReason {
const VARIANTS: &'static [aggregate::info::Variant] = &[
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("FRESH_QUEUE_AT_CAPACITY\0"),
id: 0usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("SLOTS_AT_CAPACITY\0"),
id: 1usize,
}
.build(),
];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::FreshQueueAtCapacity { .. } => 0usize,
Self::SlotsAtCapacity { .. } => 1usize,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum AcceptorTcpIoErrorSource {
#[non_exhaustive]
Accept {},
#[non_exhaustive]
Send {},
#[non_exhaustive]
UnixSend {},
#[non_exhaustive]
Recv {},
#[non_exhaustive]
Remote {},
#[non_exhaustive]
Local {},
#[non_exhaustive]
UnknownPathSecret {},
#[non_exhaustive]
System {},
}
impl aggregate::AsVariant for AcceptorTcpIoErrorSource {
const VARIANTS: &'static [aggregate::info::Variant] = &[
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("ACCEPT\0"),
id: 0usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("SEND\0"),
id: 1usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("UNIX_SEND\0"),
id: 2usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("RECV\0"),
id: 3usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("REMOTE\0"),
id: 4usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("LOCAL\0"),
id: 5usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("UNKNOWN_PATH_SECRET\0"),
id: 6usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("SYSTEM\0"),
id: 7usize,
}
.build(),
];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::Accept { .. } => 0usize,
Self::Send { .. } => 1usize,
Self::UnixSend { .. } => 2usize,
Self::Recv { .. } => 3usize,
Self::Remote { .. } => 4usize,
Self::Local { .. } => 5usize,
Self::UnknownPathSecret { .. } => 6usize,
Self::System { .. } => 7usize,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum AcceptorStreamPruneReason {
#[non_exhaustive]
MaxSojournTimeExceeded {},
#[non_exhaustive]
AcceptQueueCapacityExceeded {},
}
impl aggregate::AsVariant for AcceptorStreamPruneReason {
const VARIANTS: &'static [aggregate::info::Variant] = &[
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("MAX_SOJOURN_TIME_EXCEEDED\0"),
id: 0usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("ACCEPT_QUEUE_CAPACITY_EXCEEDED\0"),
id: 1usize,
}
.build(),
];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::MaxSojournTimeExceeded { .. } => 0usize,
Self::AcceptQueueCapacityExceeded { .. } => 1usize,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum AcceptorPacketDropReason {
#[non_exhaustive]
UnexpectedEof {},
#[non_exhaustive]
UnexpectedBytes {},
#[non_exhaustive]
LengthCapacityExceeded {},
#[non_exhaustive]
InvariantViolation { message: &'static str },
}
impl aggregate::AsVariant for AcceptorPacketDropReason {
const VARIANTS: &'static [aggregate::info::Variant] = &[
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("UNEXPECTED_EOF\0"),
id: 0usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("UNEXPECTED_BYTES\0"),
id: 1usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("LENGTH_CAPACITY_EXCEEDED\0"),
id: 2usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("INVARIANT_VIOLATION\0"),
id: 3usize,
}
.build(),
];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::UnexpectedEof { .. } => 0usize,
Self::UnexpectedBytes { .. } => 1usize,
Self::LengthCapacityExceeded { .. } => 2usize,
Self::InvariantViolation { .. } => 3usize,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ConnectionMeta {
pub id: u64,
pub timestamp: Timestamp,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for ConnectionMeta {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ConnectionMeta");
fmt.field("id", &self.id);
fmt.field("timestamp", &self.timestamp);
fmt.finish()
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct EndpointMeta {
pub timestamp: Timestamp,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for EndpointMeta {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("EndpointMeta");
fmt.field("timestamp", &self.timestamp);
fmt.finish()
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ConnectionInfo {}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for ConnectionInfo {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ConnectionInfo");
fmt.finish()
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteFlushed {
pub provided_len: usize,
pub committed_len: usize,
pub processing_duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteFlushed {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteFlushed");
fmt.field("provided_len", &self.provided_len);
fmt.field("committed_len", &self.committed_len);
fmt.field("processing_duration", &self.processing_duration);
fmt.finish()
}
}
impl Event for StreamWriteFlushed {
const NAME: &'static str = "stream:write_flushed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteFinFlushed {
pub provided_len: usize,
pub committed_len: usize,
pub processing_duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteFinFlushed {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteFinFlushed");
fmt.field("provided_len", &self.provided_len);
fmt.field("committed_len", &self.committed_len);
fmt.field("processing_duration", &self.processing_duration);
fmt.finish()
}
}
impl Event for StreamWriteFinFlushed {
const NAME: &'static str = "stream:write_fin_flushed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteBlocked {
pub provided_len: usize,
pub is_fin: bool,
pub processing_duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteBlocked {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteBlocked");
fmt.field("provided_len", &self.provided_len);
fmt.field("is_fin", &self.is_fin);
fmt.field("processing_duration", &self.processing_duration);
fmt.finish()
}
}
impl Event for StreamWriteBlocked {
const NAME: &'static str = "stream:write_blocked";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteErrored {
pub provided_len: usize,
pub is_fin: bool,
pub processing_duration: core::time::Duration,
pub errno: Option<i32>,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteErrored {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteErrored");
fmt.field("provided_len", &self.provided_len);
fmt.field("is_fin", &self.is_fin);
fmt.field("processing_duration", &self.processing_duration);
fmt.field("errno", &self.errno);
fmt.finish()
}
}
impl Event for StreamWriteErrored {
const NAME: &'static str = "stream:write_errored";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteKeyUpdated {
pub key_phase: u8,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteKeyUpdated {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteKeyUpdated");
fmt.field("key_phase", &self.key_phase);
fmt.finish()
}
}
impl Event for StreamWriteKeyUpdated {
const NAME: &'static str = "stream:write_key_updated";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteAllocated {
pub allocated_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteAllocated {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteAllocated");
fmt.field("allocated_len", &self.allocated_len);
fmt.finish()
}
}
impl Event for StreamWriteAllocated {
const NAME: &'static str = "stream:write_allocated";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteShutdown {
pub buffer_len: usize,
pub background: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteShutdown {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteShutdown");
fmt.field("buffer_len", &self.buffer_len);
fmt.field("background", &self.background);
fmt.finish()
}
}
impl Event for StreamWriteShutdown {
const NAME: &'static str = "stream:write_shutdown";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteSocketFlushed {
pub provided_len: usize,
pub committed_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteSocketFlushed {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteSocketFlushed");
fmt.field("provided_len", &self.provided_len);
fmt.field("committed_len", &self.committed_len);
fmt.finish()
}
}
impl Event for StreamWriteSocketFlushed {
const NAME: &'static str = "stream:write_socket_flushed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteSocketBlocked {
pub provided_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteSocketBlocked {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteSocketBlocked");
fmt.field("provided_len", &self.provided_len);
fmt.finish()
}
}
impl Event for StreamWriteSocketBlocked {
const NAME: &'static str = "stream:write_socket_blocked";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamWriteSocketErrored {
pub provided_len: usize,
pub errno: Option<i32>,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamWriteSocketErrored {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamWriteSocketErrored");
fmt.field("provided_len", &self.provided_len);
fmt.field("errno", &self.errno);
fmt.finish()
}
}
impl Event for StreamWriteSocketErrored {
const NAME: &'static str = "stream:write_socket_errored";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadFlushed {
pub capacity: usize,
pub committed_len: usize,
pub processing_duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadFlushed {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadFlushed");
fmt.field("capacity", &self.capacity);
fmt.field("committed_len", &self.committed_len);
fmt.field("processing_duration", &self.processing_duration);
fmt.finish()
}
}
impl Event for StreamReadFlushed {
const NAME: &'static str = "stream:read_flushed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadFinFlushed {
pub capacity: usize,
pub processing_duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadFinFlushed {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadFinFlushed");
fmt.field("capacity", &self.capacity);
fmt.field("processing_duration", &self.processing_duration);
fmt.finish()
}
}
impl Event for StreamReadFinFlushed {
const NAME: &'static str = "stream:read_fin_flushed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadBlocked {
pub capacity: usize,
pub processing_duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadBlocked {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadBlocked");
fmt.field("capacity", &self.capacity);
fmt.field("processing_duration", &self.processing_duration);
fmt.finish()
}
}
impl Event for StreamReadBlocked {
const NAME: &'static str = "stream:read_blocked";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadErrored {
pub capacity: usize,
pub processing_duration: core::time::Duration,
pub errno: Option<i32>,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadErrored {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadErrored");
fmt.field("capacity", &self.capacity);
fmt.field("processing_duration", &self.processing_duration);
fmt.field("errno", &self.errno);
fmt.finish()
}
}
impl Event for StreamReadErrored {
const NAME: &'static str = "stream:read_errored";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadKeyUpdated {
pub key_phase: u8,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadKeyUpdated {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadKeyUpdated");
fmt.field("key_phase", &self.key_phase);
fmt.finish()
}
}
impl Event for StreamReadKeyUpdated {
const NAME: &'static str = "stream:read_key_updated";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadShutdown {
pub background: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadShutdown {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadShutdown");
fmt.field("background", &self.background);
fmt.finish()
}
}
impl Event for StreamReadShutdown {
const NAME: &'static str = "stream:read_shutdown";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadSocketFlushed {
pub capacity: usize,
pub committed_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadSocketFlushed {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadSocketFlushed");
fmt.field("capacity", &self.capacity);
fmt.field("committed_len", &self.committed_len);
fmt.finish()
}
}
impl Event for StreamReadSocketFlushed {
const NAME: &'static str = "stream:read_socket_flushed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadSocketBlocked {
pub capacity: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadSocketBlocked {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadSocketBlocked");
fmt.field("capacity", &self.capacity);
fmt.finish()
}
}
impl Event for StreamReadSocketBlocked {
const NAME: &'static str = "stream:read_socket_blocked";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReadSocketErrored {
pub capacity: usize,
pub errno: Option<i32>,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReadSocketErrored {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReadSocketErrored");
fmt.field("capacity", &self.capacity);
fmt.field("errno", &self.errno);
fmt.finish()
}
}
impl Event for StreamReadSocketErrored {
const NAME: &'static str = "stream:read_socket_errored";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamDecryptPacket {
pub decrypted_in_place: bool,
pub forced_copy: usize,
pub required_application_buffer: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamDecryptPacket {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamDecryptPacket");
fmt.field("decrypted_in_place", &self.decrypted_in_place);
fmt.field("forced_copy", &self.forced_copy);
fmt.field(
"required_application_buffer",
&self.required_application_buffer,
);
fmt.finish()
}
}
impl Event for StreamDecryptPacket {
const NAME: &'static str = "stream:decrypt_packet";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamTcpConnect {
pub error: bool,
pub latency: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamTcpConnect {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamTcpConnect");
fmt.field("error", &self.error);
fmt.field("latency", &self.latency);
fmt.finish()
}
}
impl Event for StreamTcpConnect {
const NAME: &'static str = "stream:tcp_connect";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamTlsConnect<'a> {
pub error: bool,
pub remote_address: SocketAddress<'a>,
pub tcp_latency: core::time::Duration,
pub tls_latency: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
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<'a> Event for StreamTlsConnect<'a> {
const NAME: &'static str = "stream:tls_connect";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamTlsConnectError<'a> {
pub remote_address: SocketAddress<'a>,
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]
pub struct StreamConnect {
pub error: bool,
pub tcp_success: MaybeBoolCounter,
pub handshake_success: MaybeBoolCounter,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamConnect {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamConnect");
fmt.field("error", &self.error);
fmt.field("tcp_success", &self.tcp_success);
fmt.field("handshake_success", &self.handshake_success);
fmt.finish()
}
}
impl Event for StreamConnect {
const NAME: &'static str = "stream:connect";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamConnectError {
pub reason: StreamTcpConnectErrorReason,
pub latency: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamConnectError {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamConnectError");
fmt.field("reason", &self.reason);
fmt.field("latency", &self.latency);
fmt.finish()
}
}
impl Event for StreamConnectError {
const NAME: &'static str = "stream:connect_error";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamPacketTransmitted {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub is_fin: bool,
pub is_retransmission: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamPacketTransmitted {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamPacketTransmitted");
fmt.field("packet_len", &self.packet_len);
fmt.field("payload_len", &self.payload_len);
fmt.field("packet_number", &self.packet_number);
fmt.field("stream_offset", &self.stream_offset);
fmt.field("is_fin", &self.is_fin);
fmt.field("is_retransmission", &self.is_retransmission);
fmt.finish()
}
}
impl Event for StreamPacketTransmitted {
const NAME: &'static str = "stream:packet_transmitted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamProbeTransmitted {
pub packet_len: usize,
pub packet_number: u64,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamProbeTransmitted {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamProbeTransmitted");
fmt.field("packet_len", &self.packet_len);
fmt.field("packet_number", &self.packet_number);
fmt.finish()
}
}
impl Event for StreamProbeTransmitted {
const NAME: &'static str = "stream:probe_transmitted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamPacketReceived {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub is_fin: bool,
pub is_retransmission: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamPacketReceived {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamPacketReceived");
fmt.field("packet_len", &self.packet_len);
fmt.field("payload_len", &self.payload_len);
fmt.field("packet_number", &self.packet_number);
fmt.field("stream_offset", &self.stream_offset);
fmt.field("is_fin", &self.is_fin);
fmt.field("is_retransmission", &self.is_retransmission);
fmt.finish()
}
}
impl Event for StreamPacketReceived {
const NAME: &'static str = "stream:packet_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamPacketLost {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub time_sent: Timestamp,
pub lifetime: core::time::Duration,
pub is_retransmission: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamPacketLost {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamPacketLost");
fmt.field("packet_len", &self.packet_len);
fmt.field("payload_len", &self.payload_len);
fmt.field("packet_number", &self.packet_number);
fmt.field("stream_offset", &self.stream_offset);
fmt.field("time_sent", &self.time_sent);
fmt.field("lifetime", &self.lifetime);
fmt.field("is_retransmission", &self.is_retransmission);
fmt.finish()
}
}
impl Event for StreamPacketLost {
const NAME: &'static str = "stream:packet_lost";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamPacketAcked {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub time_sent: Timestamp,
pub lifetime: core::time::Duration,
pub is_retransmission: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamPacketAcked {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamPacketAcked");
fmt.field("packet_len", &self.packet_len);
fmt.field("payload_len", &self.payload_len);
fmt.field("packet_number", &self.packet_number);
fmt.field("stream_offset", &self.stream_offset);
fmt.field("time_sent", &self.time_sent);
fmt.field("lifetime", &self.lifetime);
fmt.field("is_retransmission", &self.is_retransmission);
fmt.finish()
}
}
impl Event for StreamPacketAcked {
const NAME: &'static str = "stream:packet_acked";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamPacketSpuriouslyRetransmitted {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub is_fin: bool,
pub is_retransmission: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamPacketSpuriouslyRetransmitted {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamPacketSpuriouslyRetransmitted");
fmt.field("packet_len", &self.packet_len);
fmt.field("payload_len", &self.payload_len);
fmt.field("packet_number", &self.packet_number);
fmt.field("stream_offset", &self.stream_offset);
fmt.field("is_fin", &self.is_fin);
fmt.field("is_retransmission", &self.is_retransmission);
fmt.finish()
}
}
impl Event for StreamPacketSpuriouslyRetransmitted {
const NAME: &'static str = "stream:packet_spuriously_retransmitted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamMaxDataReceived {
pub increase: u64,
pub new_max_data: u64,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamMaxDataReceived {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamMaxDataReceived");
fmt.field("increase", &self.increase);
fmt.field("new_max_data", &self.new_max_data);
fmt.finish()
}
}
impl Event for StreamMaxDataReceived {
const NAME: &'static str = "stream:max_data_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamControlPacketTransmitted {
pub packet_len: usize,
pub control_data_len: usize,
pub packet_number: u64,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamControlPacketTransmitted {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamControlPacketTransmitted");
fmt.field("packet_len", &self.packet_len);
fmt.field("control_data_len", &self.control_data_len);
fmt.field("packet_number", &self.packet_number);
fmt.finish()
}
}
impl Event for StreamControlPacketTransmitted {
const NAME: &'static str = "stream:control_packet_transmitted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamControlPacketReceived {
pub packet_len: usize,
pub control_data_len: usize,
pub packet_number: u64,
pub is_authenticated: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamControlPacketReceived {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamControlPacketReceived");
fmt.field("packet_len", &self.packet_len);
fmt.field("control_data_len", &self.control_data_len);
fmt.field("packet_number", &self.packet_number);
fmt.field("is_authenticated", &self.is_authenticated);
fmt.finish()
}
}
impl Event for StreamControlPacketReceived {
const NAME: &'static str = "stream:control_packet_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamReceiverErrored {
pub error: crate::stream::recv::Error,
pub source: s2n_quic_core::endpoint::Location,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamReceiverErrored {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamReceiverErrored");
fmt.field("error", &self.error);
fmt.field("source", &self.source);
fmt.finish()
}
}
impl Event for StreamReceiverErrored {
const NAME: &'static str = "stream:receiver_errored";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamSenderErrored {
pub error: crate::stream::send::Error,
pub source: s2n_quic_core::endpoint::Location,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamSenderErrored {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamSenderErrored");
fmt.field("error", &self.error);
fmt.field("source", &self.source);
fmt.finish()
}
}
impl Event for StreamSenderErrored {
const NAME: &'static str = "stream:sender_errored";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StreamHandshakePacketRejected {
pub reason: StreamHandshakePacketRejectedReason,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for StreamHandshakePacketRejected {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StreamHandshakePacketRejected");
fmt.field("reason", &self.reason);
fmt.finish()
}
}
impl Event for StreamHandshakePacketRejected {
const NAME: &'static str = "stream:handshake_packet_rejected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ConnectionClosed {}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for ConnectionClosed {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ConnectionClosed");
fmt.finish()
}
}
impl Event for ConnectionClosed {
const NAME: &'static str = "connection:closed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum MaybeBoolCounter {
#[non_exhaustive]
Success {},
#[non_exhaustive]
Failure {},
#[non_exhaustive]
Aborted {},
}
impl aggregate::AsVariant for MaybeBoolCounter {
const VARIANTS: &'static [aggregate::info::Variant] = &[
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("SUCCESS\0"),
id: 0usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("FAILURE\0"),
id: 1usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("ABORTED\0"),
id: 2usize,
}
.build(),
];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::Success { .. } => 0usize,
Self::Failure { .. } => 1usize,
Self::Aborted { .. } => 2usize,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum StreamTcpConnectErrorReason {
#[non_exhaustive]
TcpConnect {},
#[non_exhaustive]
Handshake {},
#[non_exhaustive]
AbortedPendingHandshake {},
#[non_exhaustive]
AbortedPendingConnect {},
#[non_exhaustive]
AbortedPendingBoth {},
}
impl aggregate::AsVariant for StreamTcpConnectErrorReason {
const VARIANTS: &'static [aggregate::info::Variant] = &[
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("TCP_CONNECT\0"),
id: 0usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("HANDSHAKE\0"),
id: 1usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("ABORTED_PENDING_HANDSHAKE\0"),
id: 2usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("ABORTED_PENDING_CONNECT\0"),
id: 3usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("ABORTED_PENDING_BOTH\0"),
id: 4usize,
}
.build(),
];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::TcpConnect { .. } => 0usize,
Self::Handshake { .. } => 1usize,
Self::AbortedPendingHandshake { .. } => 2usize,
Self::AbortedPendingConnect { .. } => 3usize,
Self::AbortedPendingBoth { .. } => 4usize,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum StreamHandshakePacketRejectedReason {
#[non_exhaustive]
InvalidQueueId {},
}
impl aggregate::AsVariant for StreamHandshakePacketRejectedReason {
const VARIANTS: &'static [aggregate::info::Variant] =
&[aggregate::info::variant::Builder {
name: aggregate::info::Str::new("INVALID_QUEUE_ID\0"),
id: 0usize,
}
.build()];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::InvalidQueueId { .. } => 0usize,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct EndpointInitialized<'a> {
pub acceptor_addr: SocketAddress<'a>,
pub handshake_addr: SocketAddress<'a>,
pub tcp: bool,
pub udp: bool,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for EndpointInitialized<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("EndpointInitialized");
fmt.field("acceptor_addr", &self.acceptor_addr);
fmt.field("handshake_addr", &self.handshake_addr);
fmt.field("tcp", &self.tcp);
fmt.field("udp", &self.udp);
fmt.finish()
}
}
impl<'a> Event for EndpointInitialized<'a> {
const NAME: &'static str = "endpoint:initialized";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct DcConnectionTimeout<'a> {
pub peer_address: SocketAddress<'a>,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for DcConnectionTimeout<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("DcConnectionTimeout");
fmt.field("peer_address", &self.peer_address);
fmt.finish()
}
}
impl<'a> Event for DcConnectionTimeout<'a> {
const NAME: &'static str = "dc:connection_timeout";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapInitialized {
pub capacity: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapInitialized {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapInitialized");
fmt.field("capacity", &self.capacity);
fmt.finish()
}
}
impl Event for PathSecretMapInitialized {
const NAME: &'static str = "path_secret_map:initialized";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapUninitialized {
pub capacity: usize,
pub entries: usize,
pub lifetime: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapUninitialized {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapUninitialized");
fmt.field("capacity", &self.capacity);
fmt.field("entries", &self.entries);
fmt.field("lifetime", &self.lifetime);
fmt.finish()
}
}
impl Event for PathSecretMapUninitialized {
const NAME: &'static str = "path_secret_map:uninitialized";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapBackgroundHandshakeRequested<'a> {
pub peer_address: SocketAddress<'a>,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapBackgroundHandshakeRequested<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapBackgroundHandshakeRequested");
fmt.field("peer_address", &self.peer_address);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapBackgroundHandshakeRequested<'a> {
const NAME: &'static str = "path_secret_map:background_handshake_requested";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapEntryInserted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapEntryInserted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapEntryInserted");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for PathSecretMapEntryInserted<'a> {
const NAME: &'static str = "path_secret_map:entry_inserted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapEntryReady<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapEntryReady<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapEntryReady");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for PathSecretMapEntryReady<'a> {
const NAME: &'static str = "path_secret_map:entry_ready";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapEntryReplaced<'a> {
pub peer_address: SocketAddress<'a>,
pub new_credential_id: &'a [u8],
pub previous_credential_id: &'a [u8],
pub replaced_age: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapEntryReplaced<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapEntryReplaced");
fmt.field("peer_address", &self.peer_address);
fmt.field("new_credential_id", &"[HIDDEN]");
fmt.field("previous_credential_id", &"[HIDDEN]");
fmt.field("replaced_age", &self.replaced_age);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapEntryReplaced<'a> {
const NAME: &'static str = "path_secret_map:entry_replaced";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapIdEntryEvicted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub age: core::time::Duration,
pub time_since_last_accessed: core::time::Duration,
pub reason: EvictionReason,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapIdEntryEvicted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapIdEntryEvicted");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("age", &"[HIDDEN]");
fmt.field("time_since_last_accessed", &self.time_since_last_accessed);
fmt.field("reason", &self.reason);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapIdEntryEvicted<'a> {
const NAME: &'static str = "path_secret_map:id_entry_evicted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapAddressEntryEvicted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub age: core::time::Duration,
pub time_since_last_accessed: core::time::Duration,
pub reason: EvictionReason,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapAddressEntryEvicted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapAddressEntryEvicted");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("age", &self.age);
fmt.field("time_since_last_accessed", &self.time_since_last_accessed);
fmt.field("reason", &self.reason);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapAddressEntryEvicted<'a> {
const NAME: &'static str = "path_secret_map:addr_entry_evicted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UnknownPathSecretPacketSent<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for UnknownPathSecretPacketSent<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("UnknownPathSecretPacketSent");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for UnknownPathSecretPacketSent<'a> {
const NAME: &'static str = "path_secret_map:unknown_path_secret_packet_sent";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UnknownPathSecretPacketReceived<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for UnknownPathSecretPacketReceived<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("UnknownPathSecretPacketReceived");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for UnknownPathSecretPacketReceived<'a> {
const NAME: &'static str = "path_secret_map:unknown_path_secret_packet_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UnknownPathSecretPacketAccepted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub age: core::time::Duration,
pub evicted: bool,
pub scheduled_handshake: bool,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for UnknownPathSecretPacketAccepted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("UnknownPathSecretPacketAccepted");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("age", &"[HIDDEN]");
fmt.field("evicted", &self.evicted);
fmt.field("scheduled_handshake", &self.scheduled_handshake);
fmt.finish()
}
}
impl<'a> Event for UnknownPathSecretPacketAccepted<'a> {
const NAME: &'static str = "path_secret_map:unknown_path_secret_packet_accepted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UnknownPathSecretPacketRejected<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for UnknownPathSecretPacketRejected<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("UnknownPathSecretPacketRejected");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for UnknownPathSecretPacketRejected<'a> {
const NAME: &'static str = "path_secret_map:unknown_path_secret_packet_rejected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UnknownPathSecretPacketDropped<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for UnknownPathSecretPacketDropped<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("UnknownPathSecretPacketDropped");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for UnknownPathSecretPacketDropped<'a> {
const NAME: &'static str = "path_secret_map:unknown_path_secret_packet_dropped";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct KeyAccepted<'a> {
pub credential_id: &'a [u8],
pub key_id: u64,
pub gap: u64,
pub forward_shift: u64,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for KeyAccepted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("KeyAccepted");
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("key_id", &self.key_id);
fmt.field("gap", &self.gap);
fmt.field("forward_shift", &self.forward_shift);
fmt.finish()
}
}
impl<'a> Event for KeyAccepted<'a> {
const NAME: &'static str = "path_secret_map:key_accepted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReplayDefinitelyDetected<'a> {
pub credential_id: &'a [u8],
pub key_id: u64,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for ReplayDefinitelyDetected<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ReplayDefinitelyDetected");
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("key_id", &self.key_id);
fmt.finish()
}
}
impl<'a> Event for ReplayDefinitelyDetected<'a> {
const NAME: &'static str = "path_secret_map:replay_definitely_detected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReplayPotentiallyDetected<'a> {
pub credential_id: &'a [u8],
pub key_id: u64,
pub gap: u64,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for ReplayPotentiallyDetected<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ReplayPotentiallyDetected");
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("key_id", &self.key_id);
fmt.field("gap", &self.gap);
fmt.finish()
}
}
impl<'a> Event for ReplayPotentiallyDetected<'a> {
const NAME: &'static str = "path_secret_map:replay_potentially_detected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReplayDetectedPacketSent<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for ReplayDetectedPacketSent<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ReplayDetectedPacketSent");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for ReplayDetectedPacketSent<'a> {
const NAME: &'static str = "path_secret_map:replay_detected_packet_sent";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReplayDetectedPacketReceived<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for ReplayDetectedPacketReceived<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ReplayDetectedPacketReceived");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for ReplayDetectedPacketReceived<'a> {
const NAME: &'static str = "path_secret_map:replay_detected_packet_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReplayDetectedPacketAccepted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub key_id: u64,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for ReplayDetectedPacketAccepted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ReplayDetectedPacketAccepted");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("key_id", &self.key_id);
fmt.finish()
}
}
impl<'a> Event for ReplayDetectedPacketAccepted<'a> {
const NAME: &'static str = "path_secret_map:replay_detected_packet_accepted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReplayDetectedPacketRejected<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for ReplayDetectedPacketRejected<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ReplayDetectedPacketRejected");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for ReplayDetectedPacketRejected<'a> {
const NAME: &'static str = "path_secret_map:replay_detected_packet_rejected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReplayDetectedPacketDropped<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for ReplayDetectedPacketDropped<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("ReplayDetectedPacketDropped");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for ReplayDetectedPacketDropped<'a> {
const NAME: &'static str = "path_secret_map:replay_detected_packet_dropped";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StaleKeyPacketSent<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for StaleKeyPacketSent<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StaleKeyPacketSent");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for StaleKeyPacketSent<'a> {
const NAME: &'static str = "path_secret_map:stale_key_packet_sent";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StaleKeyPacketReceived<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for StaleKeyPacketReceived<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StaleKeyPacketReceived");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for StaleKeyPacketReceived<'a> {
const NAME: &'static str = "path_secret_map:stale_key_packet_received";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StaleKeyPacketAccepted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for StaleKeyPacketAccepted<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StaleKeyPacketAccepted");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for StaleKeyPacketAccepted<'a> {
const NAME: &'static str = "path_secret_map:stale_key_packet_accepted";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StaleKeyPacketRejected<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for StaleKeyPacketRejected<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StaleKeyPacketRejected");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for StaleKeyPacketRejected<'a> {
const NAME: &'static str = "path_secret_map:stale_key_packet_rejected";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct StaleKeyPacketDropped<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for StaleKeyPacketDropped<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("StaleKeyPacketDropped");
fmt.field("peer_address", &self.peer_address);
fmt.field("credential_id", &"[HIDDEN]");
fmt.finish()
}
}
impl<'a> Event for StaleKeyPacketDropped<'a> {
const NAME: &'static str = "path_secret_map:stale_key_packet_dropped";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapAddressCacheAccessed<'a> {
pub peer_address: SocketAddress<'a>,
pub hit: bool,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapAddressCacheAccessed<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapAddressCacheAccessed");
fmt.field("peer_address", &self.peer_address);
fmt.field("hit", &self.hit);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapAddressCacheAccessed<'a> {
const NAME: &'static str = "path_secret_map:address_cache_accessed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapAddressCacheAccessedHit<'a> {
pub peer_address: SocketAddress<'a>,
pub age: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapAddressCacheAccessedHit<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapAddressCacheAccessedHit");
fmt.field("peer_address", &self.peer_address);
fmt.field("age", &self.age);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapAddressCacheAccessedHit<'a> {
const NAME: &'static str = "path_secret_map:address_cache_accessed_entry";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapIdCacheAccessed<'a> {
pub credential_id: &'a [u8],
pub hit: bool,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapIdCacheAccessed<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapIdCacheAccessed");
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("hit", &self.hit);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapIdCacheAccessed<'a> {
const NAME: &'static str = "path_secret_map:id_cache_accessed";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapIdCacheAccessedHit<'a> {
pub credential_id: &'a [u8],
pub age: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl<'a> crate::event::snapshot::Fmt for PathSecretMapIdCacheAccessedHit<'a> {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapIdCacheAccessedHit");
fmt.field("credential_id", &"[HIDDEN]");
fmt.field("age", &self.age);
fmt.finish()
}
}
impl<'a> Event for PathSecretMapIdCacheAccessedHit<'a> {
const NAME: &'static str = "path_secret_map:id_cache_accessed_entry";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapCleanerCycled {
pub id_entries: usize,
pub id_entries_retired: usize,
pub id_entries_active: usize,
pub id_entries_active_utilization: f32,
pub id_entries_utilization: f32,
pub id_entries_initial_utilization: f32,
pub address_entries: usize,
pub address_entries_active: usize,
pub address_entries_active_utilization: f32,
pub address_entries_retired: usize,
pub address_entries_utilization: f32,
pub address_entries_initial_utilization: f32,
pub id_entries_in_last_hs_period: usize,
pub id_entries_in_last_hs_period_utilization: f32,
pub handshake_requests: usize,
pub handshake_requests_skipped: usize,
pub handshake_lock_duration: core::time::Duration,
pub duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapCleanerCycled {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapCleanerCycled");
fmt.field("id_entries", &self.id_entries);
fmt.field("id_entries_retired", &self.id_entries_retired);
fmt.field("id_entries_active", &self.id_entries_active);
fmt.field(
"id_entries_active_utilization",
&self.id_entries_active_utilization,
);
fmt.field("id_entries_utilization", &self.id_entries_utilization);
fmt.field(
"id_entries_initial_utilization",
&self.id_entries_initial_utilization,
);
fmt.field("address_entries", &self.address_entries);
fmt.field("address_entries_active", &self.address_entries_active);
fmt.field(
"address_entries_active_utilization",
&self.address_entries_active_utilization,
);
fmt.field("address_entries_retired", &self.address_entries_retired);
fmt.field(
"address_entries_utilization",
&self.address_entries_utilization,
);
fmt.field(
"address_entries_initial_utilization",
&self.address_entries_initial_utilization,
);
fmt.field(
"id_entries_in_last_hs_period",
&self.id_entries_in_last_hs_period,
);
fmt.field(
"id_entries_in_last_hs_period_utilization",
&self.id_entries_in_last_hs_period_utilization,
);
fmt.field("handshake_requests", &self.handshake_requests);
fmt.field(
"handshake_requests_skipped",
&self.handshake_requests_skipped,
);
fmt.field("handshake_lock_duration", &self.handshake_lock_duration);
fmt.field("duration", &self.duration);
fmt.finish()
}
}
impl Event for PathSecretMapCleanerCycled {
const NAME: &'static str = "path_secret_map:cleaner_cycled";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapSerialized {
pub entries: usize,
pub file_size: usize,
pub duration: core::time::Duration,
pub error: bool,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapSerialized {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapSerialized");
fmt.field("entries", &self.entries);
fmt.field("file_size", &self.file_size);
fmt.field("duration", &self.duration);
fmt.field("error", &self.error);
fmt.finish()
}
}
impl Event for PathSecretMapSerialized {
const NAME: &'static str = "path_secret_map:serialized";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapIdWriteLock {
pub acquire: core::time::Duration,
pub duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapIdWriteLock {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapIdWriteLock");
fmt.field("acquire", &self.acquire);
fmt.field("duration", &self.duration);
fmt.finish()
}
}
impl Event for PathSecretMapIdWriteLock {
const NAME: &'static str = "path_secret_map:id_cache_write_lock";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapAddressWriteLock {
pub acquire: core::time::Duration,
pub duration: core::time::Duration,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapAddressWriteLock {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapAddressWriteLock");
fmt.field("acquire", &self.acquire);
fmt.field("duration", &self.duration);
fmt.finish()
}
}
impl Event for PathSecretMapAddressWriteLock {
const NAME: &'static str = "path_secret_map:address_cache_write_lock";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapDatagramEncrypt {
pub packet_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapDatagramEncrypt {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapDatagramEncrypt");
fmt.field("packet_len", &self.packet_len);
fmt.finish()
}
}
impl Event for PathSecretMapDatagramEncrypt {
const NAME: &'static str = "path_secret_map:datagram_encrypt";
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PathSecretMapDatagramDecrypt {
pub packet_len: usize,
}
#[cfg(any(test, feature = "testing"))]
impl crate::event::snapshot::Fmt for PathSecretMapDatagramDecrypt {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
let mut fmt = fmt.debug_struct("PathSecretMapDatagramDecrypt");
fmt.field("packet_len", &self.packet_len);
fmt.finish()
}
}
impl Event for PathSecretMapDatagramDecrypt {
const NAME: &'static str = "path_secret_map:datagram_decrypt";
}
#[non_exhaustive]
#[derive(Debug, Copy, Clone)]
pub enum EvictionReason {
#[non_exhaustive]
Capacity {},
#[non_exhaustive]
UnknownPathSecret {},
#[non_exhaustive]
Retiring {},
}
impl aggregate::AsVariant for EvictionReason {
const VARIANTS: &'static [aggregate::info::Variant] = &[
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("CAPACITY\0"),
id: 0usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("UNKNOWN_PATH_SECRET\0"),
id: 1usize,
}
.build(),
aggregate::info::variant::Builder {
name: aggregate::info::Str::new("RETIRING\0"),
id: 2usize,
}
.build(),
];
#[inline]
fn variant_idx(&self) -> usize {
match self {
Self::Capacity { .. } => 0usize,
Self::UnknownPathSecret { .. } => 1usize,
Self::Retiring { .. } => 2usize,
}
}
}
impl IntoEvent<builder::AcceptorPacketDropReason> for s2n_codec::DecoderError {
fn into_event(self) -> builder::AcceptorPacketDropReason {
use builder::AcceptorPacketDropReason as Reason;
use s2n_codec::DecoderError;
match self {
DecoderError::UnexpectedEof(_) => Reason::UnexpectedEof {},
DecoderError::UnexpectedBytes(_) => Reason::UnexpectedBytes {},
DecoderError::LengthCapacityExceeded => Reason::LengthCapacityExceeded {},
DecoderError::InvariantViolation(message) => Reason::InvariantViolation { message },
}
}
}
}
pub mod tracing {
use super::api;
#[derive(Clone, Debug)]
pub struct Subscriber {
root: tracing::Span,
}
impl Default for Subscriber {
fn default() -> Self {
let root = tracing::span!(
target : "s2n_quic_dc", tracing::Level::DEBUG, "s2n_quic_dc"
);
Self { root }
}
}
impl Subscriber {
fn parent<M: crate::event::Meta>(&self, _meta: &M) -> Option<tracing::Id> {
self.root.id()
}
}
impl super::Subscriber for Subscriber {
type ConnectionContext = tracing::Span;
fn create_connection_context(
&self,
meta: &api::ConnectionMeta,
_info: &api::ConnectionInfo,
) -> Self::ConnectionContext {
let parent = self.parent(meta);
tracing::span!(
target : "s2n_quic_dc", parent : parent, tracing::Level::DEBUG, "conn",
id = meta.id
)
}
#[inline]
fn on_acceptor_tcp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStarted,
) {
let parent = self.parent(meta);
let api::AcceptorTcpStarted {
id,
local_address,
backlog,
} = event;
tracing::event!(
target : "acceptor_tcp_started", parent : parent, tracing::Level::DEBUG,
{ id = tracing::field::debug(id), local_address =
tracing::field::debug(local_address), backlog =
tracing::field::debug(backlog) }
);
}
#[inline]
fn on_acceptor_tcp_loop_iteration_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpLoopIterationCompleted,
) {
let parent = self.parent(meta);
let api::AcceptorTcpLoopIterationCompleted {
pending_streams,
slots_idle,
slot_utilization,
processing_duration,
max_sojourn_time,
} = event;
tracing::event!(
target : "acceptor_tcp_loop_iteration_completed", parent : parent,
tracing::Level::DEBUG, { pending_streams =
tracing::field::debug(pending_streams), slots_idle =
tracing::field::debug(slots_idle), slot_utilization =
tracing::field::debug(slot_utilization), processing_duration =
tracing::field::debug(processing_duration), max_sojourn_time =
tracing::field::debug(max_sojourn_time) }
);
}
#[inline]
fn on_acceptor_tcp_fresh_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshEnqueued,
) {
let parent = self.parent(meta);
let api::AcceptorTcpFreshEnqueued { remote_address } = event;
tracing::event!(
target : "acceptor_tcp_fresh_enqueued", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address) }
);
}
#[inline]
fn on_acceptor_tcp_fresh_batch_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshBatchCompleted,
) {
let parent = self.parent(meta);
let api::AcceptorTcpFreshBatchCompleted {
enqueued,
dropped,
errored,
} = event;
tracing::event!(
target : "acceptor_tcp_fresh_batch_completed", parent : parent,
tracing::Level::DEBUG, { enqueued = tracing::field::debug(enqueued),
dropped = tracing::field::debug(dropped), errored =
tracing::field::debug(errored) }
);
}
#[inline]
fn on_acceptor_tcp_stream_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamDropped,
) {
let parent = self.parent(meta);
let api::AcceptorTcpStreamDropped {
remote_address,
reason,
} = event;
tracing::event!(
target : "acceptor_tcp_stream_dropped", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), reason =
tracing::field::debug(reason) }
);
}
#[inline]
fn on_acceptor_tcp_stream_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamReplaced,
) {
let parent = self.parent(meta);
let api::AcceptorTcpStreamReplaced {
remote_address,
sojourn_time,
buffer_len,
} = event;
tracing::event!(
target : "acceptor_tcp_stream_replaced", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), sojourn_time =
tracing::field::debug(sojourn_time), buffer_len =
tracing::field::debug(buffer_len) }
);
}
#[inline]
fn on_acceptor_tcp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketReceived,
) {
let parent = self.parent(meta);
let api::AcceptorTcpPacketReceived {
remote_address,
credential_id,
stream_id,
payload_len,
is_fin,
is_fin_known,
sojourn_time,
} = event;
tracing::event!(
target : "acceptor_tcp_packet_received", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id), payload_len =
tracing::field::debug(payload_len), is_fin =
tracing::field::debug(is_fin), is_fin_known =
tracing::field::debug(is_fin_known), sojourn_time =
tracing::field::debug(sojourn_time) }
);
}
#[inline]
fn on_acceptor_tcp_tls_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStarted,
) {
let parent = self.parent(meta);
let api::AcceptorTcpTlsStarted {
remote_address,
sojourn_time,
} = event;
tracing::event!(
target : "acceptor_tcp_tls_started", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), sojourn_time =
tracing::field::debug(sojourn_time) }
);
}
#[inline]
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamEnqueued,
) {
let parent = self.parent(meta);
let api::AcceptorTcpTlsStreamEnqueued {
remote_address,
sojourn_time,
} = event;
tracing::event!(
target : "acceptor_tcp_tls_stream_enqueued", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), sojourn_time =
tracing::field::debug(sojourn_time) }
);
}
#[inline]
fn on_acceptor_tcp_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamRejected,
) {
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), local_address =
tracing::field::debug(local_address), sojourn_time =
tracing::field::debug(sojourn_time), error = tracing::field::debug(error)
}
);
}
#[inline]
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSyntheticTlsStreamRejected,
) {
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), local_address =
tracing::field::debug(local_address), sojourn_time =
tracing::field::debug(sojourn_time), error = tracing::field::debug(error)
}
);
}
#[inline]
fn on_acceptor_tcp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketDropped,
) {
let parent = self.parent(meta);
let api::AcceptorTcpPacketDropped {
remote_address,
reason,
sojourn_time,
} = event;
tracing::event!(
target : "acceptor_tcp_packet_dropped", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), reason =
tracing::field::debug(reason), sojourn_time =
tracing::field::debug(sojourn_time) }
);
}
#[inline]
fn on_acceptor_tcp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamEnqueued,
) {
let parent = self.parent(meta);
let api::AcceptorTcpStreamEnqueued {
remote_address,
credential_id,
stream_id,
sojourn_time,
blocked_count,
} = event;
tracing::event!(
target : "acceptor_tcp_stream_enqueued", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id), sojourn_time =
tracing::field::debug(sojourn_time), blocked_count =
tracing::field::debug(blocked_count) }
);
}
#[inline]
fn on_acceptor_tcp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpIoError,
) {
let parent = self.parent(meta);
let api::AcceptorTcpIoError { error, source } = event;
tracing::event!(
target : "acceptor_tcp_io_error", parent : parent, tracing::Level::DEBUG,
{ error = tracing::field::debug(error), source =
tracing::field::debug(source) }
);
}
#[inline]
fn on_acceptor_tcp_socket_sent(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketSent,
) {
let parent = self.parent(meta);
let api::AcceptorTcpSocketSent {
credential_id,
stream_id,
sojourn_time,
blocked_count,
payload_len,
} = event;
tracing::event!(
target : "acceptor_tcp_socket_sent", parent : parent,
tracing::Level::DEBUG, { credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id), sojourn_time =
tracing::field::debug(sojourn_time), blocked_count =
tracing::field::debug(blocked_count), payload_len =
tracing::field::debug(payload_len) }
);
}
#[inline]
fn on_acceptor_tcp_socket_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketReceived,
) {
let parent = self.parent(meta);
let api::AcceptorTcpSocketReceived {
remote_address,
credential_id,
stream_id,
transfer_time,
payload_len,
} = event;
tracing::event!(
target : "acceptor_tcp_socket_received", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id), transfer_time =
tracing::field::debug(transfer_time), payload_len =
tracing::field::debug(payload_len) }
);
}
#[inline]
fn on_acceptor_udp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStarted,
) {
let parent = self.parent(meta);
let api::AcceptorUdpStarted { id, local_address } = event;
tracing::event!(
target : "acceptor_udp_started", parent : parent, tracing::Level::DEBUG,
{ id = tracing::field::debug(id), local_address =
tracing::field::debug(local_address) }
);
}
#[inline]
fn on_acceptor_udp_datagram_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpDatagramReceived,
) {
let parent = self.parent(meta);
let api::AcceptorUdpDatagramReceived {
remote_address,
len,
} = event;
tracing::event!(
target : "acceptor_udp_datagram_received", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), len = tracing::field::debug(len) }
);
}
#[inline]
fn on_acceptor_udp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketReceived,
) {
let parent = self.parent(meta);
let api::AcceptorUdpPacketReceived {
remote_address,
credential_id,
stream_id,
payload_len,
is_zero_offset,
is_retransmission,
is_fin,
is_fin_known,
} = event;
tracing::event!(
target : "acceptor_udp_packet_received", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id), payload_len =
tracing::field::debug(payload_len), is_zero_offset =
tracing::field::debug(is_zero_offset), is_retransmission =
tracing::field::debug(is_retransmission), is_fin =
tracing::field::debug(is_fin), is_fin_known =
tracing::field::debug(is_fin_known) }
);
}
#[inline]
fn on_acceptor_udp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketDropped,
) {
let parent = self.parent(meta);
let api::AcceptorUdpPacketDropped {
remote_address,
reason,
} = event;
tracing::event!(
target : "acceptor_udp_packet_dropped", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), reason =
tracing::field::debug(reason) }
);
}
#[inline]
fn on_acceptor_udp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStreamEnqueued,
) {
let parent = self.parent(meta);
let api::AcceptorUdpStreamEnqueued {
remote_address,
credential_id,
stream_id,
} = event;
tracing::event!(
target : "acceptor_udp_stream_enqueued", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id) }
);
}
#[inline]
fn on_acceptor_udp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpIoError,
) {
let parent = self.parent(meta);
let api::AcceptorUdpIoError { error } = event;
tracing::event!(
target : "acceptor_udp_io_error", parent : parent, tracing::Level::DEBUG,
{ error = tracing::field::debug(error) }
);
}
#[inline]
fn on_acceptor_stream_pruned(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamPruned,
) {
let parent = self.parent(meta);
let api::AcceptorStreamPruned {
remote_address,
credential_id,
stream_id,
sojourn_time,
reason,
} = event;
tracing::event!(
target : "acceptor_stream_pruned", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id), sojourn_time =
tracing::field::debug(sojourn_time), reason =
tracing::field::debug(reason) }
);
}
#[inline]
fn on_acceptor_stream_dequeued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamDequeued,
) {
let parent = self.parent(meta);
let api::AcceptorStreamDequeued {
remote_address,
credential_id,
stream_id,
sojourn_time,
queue_sojourn_time,
} = event;
tracing::event!(
target : "acceptor_stream_dequeued", parent : parent,
tracing::Level::DEBUG, { remote_address =
tracing::field::debug(remote_address), credential_id =
tracing::field::debug(credential_id), stream_id =
tracing::field::debug(stream_id), sojourn_time =
tracing::field::debug(sojourn_time), queue_sojourn_time =
tracing::field::debug(queue_sojourn_time) }
);
}
#[inline]
fn on_stream_write_flushed(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteFlushed,
) {
let id = context.id();
let api::StreamWriteFlushed {
provided_len,
committed_len,
processing_duration,
} = event;
tracing::event!(
target : "stream_write_flushed", parent : id, tracing::Level::DEBUG, {
provided_len = tracing::field::debug(provided_len), committed_len =
tracing::field::debug(committed_len), processing_duration =
tracing::field::debug(processing_duration) }
);
}
#[inline]
fn on_stream_write_fin_flushed(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteFinFlushed,
) {
let id = context.id();
let api::StreamWriteFinFlushed {
provided_len,
committed_len,
processing_duration,
} = event;
tracing::event!(
target : "stream_write_fin_flushed", parent : id, tracing::Level::DEBUG,
{ provided_len = tracing::field::debug(provided_len), committed_len =
tracing::field::debug(committed_len), processing_duration =
tracing::field::debug(processing_duration) }
);
}
#[inline]
fn on_stream_write_blocked(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteBlocked,
) {
let id = context.id();
let api::StreamWriteBlocked {
provided_len,
is_fin,
processing_duration,
} = event;
tracing::event!(
target : "stream_write_blocked", parent : id, tracing::Level::DEBUG, {
provided_len = tracing::field::debug(provided_len), is_fin =
tracing::field::debug(is_fin), processing_duration =
tracing::field::debug(processing_duration) }
);
}
#[inline]
fn on_stream_write_errored(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteErrored,
) {
let id = context.id();
let api::StreamWriteErrored {
provided_len,
is_fin,
processing_duration,
errno,
} = event;
tracing::event!(
target : "stream_write_errored", parent : id, tracing::Level::DEBUG, {
provided_len = tracing::field::debug(provided_len), is_fin =
tracing::field::debug(is_fin), processing_duration =
tracing::field::debug(processing_duration), errno =
tracing::field::debug(errno) }
);
}
#[inline]
fn on_stream_write_key_updated(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteKeyUpdated,
) {
let id = context.id();
let api::StreamWriteKeyUpdated { key_phase } = event;
tracing::event!(
target : "stream_write_key_updated", parent : id, tracing::Level::DEBUG,
{ key_phase = tracing::field::debug(key_phase) }
);
}
#[inline]
fn on_stream_write_allocated(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteAllocated,
) {
let id = context.id();
let api::StreamWriteAllocated { allocated_len } = event;
tracing::event!(
target : "stream_write_allocated", parent : id, tracing::Level::DEBUG, {
allocated_len = tracing::field::debug(allocated_len) }
);
}
#[inline]
fn on_stream_write_shutdown(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteShutdown,
) {
let id = context.id();
let api::StreamWriteShutdown {
buffer_len,
background,
} = event;
tracing::event!(
target : "stream_write_shutdown", parent : id, tracing::Level::DEBUG, {
buffer_len = tracing::field::debug(buffer_len), background =
tracing::field::debug(background) }
);
}
#[inline]
fn on_stream_write_socket_flushed(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketFlushed,
) {
let id = context.id();
let api::StreamWriteSocketFlushed {
provided_len,
committed_len,
} = event;
tracing::event!(
target : "stream_write_socket_flushed", parent : id,
tracing::Level::DEBUG, { provided_len =
tracing::field::debug(provided_len), committed_len =
tracing::field::debug(committed_len) }
);
}
#[inline]
fn on_stream_write_socket_blocked(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketBlocked,
) {
let id = context.id();
let api::StreamWriteSocketBlocked { provided_len } = event;
tracing::event!(
target : "stream_write_socket_blocked", parent : id,
tracing::Level::DEBUG, { provided_len =
tracing::field::debug(provided_len) }
);
}
#[inline]
fn on_stream_write_socket_errored(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketErrored,
) {
let id = context.id();
let api::StreamWriteSocketErrored {
provided_len,
errno,
} = event;
tracing::event!(
target : "stream_write_socket_errored", parent : id,
tracing::Level::DEBUG, { provided_len =
tracing::field::debug(provided_len), errno = tracing::field::debug(errno)
}
);
}
#[inline]
fn on_stream_read_flushed(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadFlushed,
) {
let id = context.id();
let api::StreamReadFlushed {
capacity,
committed_len,
processing_duration,
} = event;
tracing::event!(
target : "stream_read_flushed", parent : id, tracing::Level::DEBUG, {
capacity = tracing::field::debug(capacity), committed_len =
tracing::field::debug(committed_len), processing_duration =
tracing::field::debug(processing_duration) }
);
}
#[inline]
fn on_stream_read_fin_flushed(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadFinFlushed,
) {
let id = context.id();
let api::StreamReadFinFlushed {
capacity,
processing_duration,
} = event;
tracing::event!(
target : "stream_read_fin_flushed", parent : id, tracing::Level::DEBUG, {
capacity = tracing::field::debug(capacity), processing_duration =
tracing::field::debug(processing_duration) }
);
}
#[inline]
fn on_stream_read_blocked(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadBlocked,
) {
let id = context.id();
let api::StreamReadBlocked {
capacity,
processing_duration,
} = event;
tracing::event!(
target : "stream_read_blocked", parent : id, tracing::Level::DEBUG, {
capacity = tracing::field::debug(capacity), processing_duration =
tracing::field::debug(processing_duration) }
);
}
#[inline]
fn on_stream_read_errored(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadErrored,
) {
let id = context.id();
let api::StreamReadErrored {
capacity,
processing_duration,
errno,
} = event;
tracing::event!(
target : "stream_read_errored", parent : id, tracing::Level::DEBUG, {
capacity = tracing::field::debug(capacity), processing_duration =
tracing::field::debug(processing_duration), errno =
tracing::field::debug(errno) }
);
}
#[inline]
fn on_stream_read_key_updated(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadKeyUpdated,
) {
let id = context.id();
let api::StreamReadKeyUpdated { key_phase } = event;
tracing::event!(
target : "stream_read_key_updated", parent : id, tracing::Level::DEBUG, {
key_phase = tracing::field::debug(key_phase) }
);
}
#[inline]
fn on_stream_read_shutdown(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadShutdown,
) {
let id = context.id();
let api::StreamReadShutdown { background } = event;
tracing::event!(
target : "stream_read_shutdown", parent : id, tracing::Level::DEBUG, {
background = tracing::field::debug(background) }
);
}
#[inline]
fn on_stream_read_socket_flushed(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadSocketFlushed,
) {
let id = context.id();
let api::StreamReadSocketFlushed {
capacity,
committed_len,
} = event;
tracing::event!(
target : "stream_read_socket_flushed", parent : id,
tracing::Level::DEBUG, { capacity = tracing::field::debug(capacity),
committed_len = tracing::field::debug(committed_len) }
);
}
#[inline]
fn on_stream_read_socket_blocked(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadSocketBlocked,
) {
let id = context.id();
let api::StreamReadSocketBlocked { capacity } = event;
tracing::event!(
target : "stream_read_socket_blocked", parent : id,
tracing::Level::DEBUG, { capacity = tracing::field::debug(capacity) }
);
}
#[inline]
fn on_stream_read_socket_errored(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReadSocketErrored,
) {
let id = context.id();
let api::StreamReadSocketErrored { capacity, errno } = event;
tracing::event!(
target : "stream_read_socket_errored", parent : id,
tracing::Level::DEBUG, { capacity = tracing::field::debug(capacity),
errno = tracing::field::debug(errno) }
);
}
#[inline]
fn on_stream_decrypt_packet(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamDecryptPacket,
) {
let id = context.id();
let api::StreamDecryptPacket {
decrypted_in_place,
forced_copy,
required_application_buffer,
} = event;
tracing::event!(
target : "stream_decrypt_packet", parent : id, tracing::Level::DEBUG, {
decrypted_in_place = tracing::field::debug(decrypted_in_place),
forced_copy = tracing::field::debug(forced_copy),
required_application_buffer =
tracing::field::debug(required_application_buffer) }
);
}
#[inline]
fn on_stream_tcp_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTcpConnect) {
let parent = self.parent(meta);
let api::StreamTcpConnect { error, latency } = event;
tracing::event!(
target : "stream_tcp_connect", parent : parent, tracing::Level::DEBUG, {
error = tracing::field::debug(error), latency =
tracing::field::debug(latency) }
);
}
#[inline]
fn on_stream_tls_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTlsConnect) {
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), 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 {
error,
tcp_success,
handshake_success,
} = event;
tracing::event!(
target : "stream_connect", parent : parent, tracing::Level::DEBUG, {
error = tracing::field::debug(error), tcp_success =
tracing::field::debug(tcp_success), handshake_success =
tracing::field::debug(handshake_success) }
);
}
#[inline]
fn on_stream_connect_error(
&self,
meta: &api::EndpointMeta,
event: &api::StreamConnectError,
) {
let parent = self.parent(meta);
let api::StreamConnectError { reason, latency } = event;
tracing::event!(
target : "stream_connect_error", parent : parent, tracing::Level::DEBUG,
{ reason = tracing::field::debug(reason), latency =
tracing::field::debug(latency) }
);
}
#[inline]
fn on_stream_packet_transmitted(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamPacketTransmitted,
) {
let id = context.id();
let api::StreamPacketTransmitted {
packet_len,
payload_len,
packet_number,
stream_offset,
is_fin,
is_retransmission,
} = event;
tracing::event!(
target : "stream_packet_transmitted", parent : id, tracing::Level::DEBUG,
{ packet_len = tracing::field::debug(packet_len), payload_len =
tracing::field::debug(payload_len), packet_number =
tracing::field::debug(packet_number), stream_offset =
tracing::field::debug(stream_offset), is_fin =
tracing::field::debug(is_fin), is_retransmission =
tracing::field::debug(is_retransmission) }
);
}
#[inline]
fn on_stream_probe_transmitted(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamProbeTransmitted,
) {
let id = context.id();
let api::StreamProbeTransmitted {
packet_len,
packet_number,
} = event;
tracing::event!(
target : "stream_probe_transmitted", parent : id, tracing::Level::DEBUG,
{ packet_len = tracing::field::debug(packet_len), packet_number =
tracing::field::debug(packet_number) }
);
}
#[inline]
fn on_stream_packet_received(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamPacketReceived,
) {
let id = context.id();
let api::StreamPacketReceived {
packet_len,
payload_len,
packet_number,
stream_offset,
is_fin,
is_retransmission,
} = event;
tracing::event!(
target : "stream_packet_received", parent : id, tracing::Level::DEBUG, {
packet_len = tracing::field::debug(packet_len), payload_len =
tracing::field::debug(payload_len), packet_number =
tracing::field::debug(packet_number), stream_offset =
tracing::field::debug(stream_offset), is_fin =
tracing::field::debug(is_fin), is_retransmission =
tracing::field::debug(is_retransmission) }
);
}
#[inline]
fn on_stream_packet_lost(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamPacketLost,
) {
let id = context.id();
let api::StreamPacketLost {
packet_len,
payload_len,
packet_number,
stream_offset,
time_sent,
lifetime,
is_retransmission,
} = event;
tracing::event!(
target : "stream_packet_lost", parent : id, tracing::Level::DEBUG, {
packet_len = tracing::field::debug(packet_len), payload_len =
tracing::field::debug(payload_len), packet_number =
tracing::field::debug(packet_number), stream_offset =
tracing::field::debug(stream_offset), time_sent =
tracing::field::debug(time_sent), lifetime =
tracing::field::debug(lifetime), is_retransmission =
tracing::field::debug(is_retransmission) }
);
}
#[inline]
fn on_stream_packet_acked(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamPacketAcked,
) {
let id = context.id();
let api::StreamPacketAcked {
packet_len,
payload_len,
packet_number,
stream_offset,
time_sent,
lifetime,
is_retransmission,
} = event;
tracing::event!(
target : "stream_packet_acked", parent : id, tracing::Level::DEBUG, {
packet_len = tracing::field::debug(packet_len), payload_len =
tracing::field::debug(payload_len), packet_number =
tracing::field::debug(packet_number), stream_offset =
tracing::field::debug(stream_offset), time_sent =
tracing::field::debug(time_sent), lifetime =
tracing::field::debug(lifetime), is_retransmission =
tracing::field::debug(is_retransmission) }
);
}
#[inline]
fn on_stream_packet_spuriously_retransmitted(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamPacketSpuriouslyRetransmitted,
) {
let id = context.id();
let api::StreamPacketSpuriouslyRetransmitted {
packet_len,
payload_len,
packet_number,
stream_offset,
is_fin,
is_retransmission,
} = event;
tracing::event!(
target : "stream_packet_spuriously_retransmitted", parent : id,
tracing::Level::DEBUG, { packet_len = tracing::field::debug(packet_len),
payload_len = tracing::field::debug(payload_len), packet_number =
tracing::field::debug(packet_number), stream_offset =
tracing::field::debug(stream_offset), is_fin =
tracing::field::debug(is_fin), is_retransmission =
tracing::field::debug(is_retransmission) }
);
}
#[inline]
fn on_stream_max_data_received(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamMaxDataReceived,
) {
let id = context.id();
let api::StreamMaxDataReceived {
increase,
new_max_data,
} = event;
tracing::event!(
target : "stream_max_data_received", parent : id, tracing::Level::DEBUG,
{ increase = tracing::field::debug(increase), new_max_data =
tracing::field::debug(new_max_data) }
);
}
#[inline]
fn on_stream_control_packet_transmitted(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamControlPacketTransmitted,
) {
let id = context.id();
let api::StreamControlPacketTransmitted {
packet_len,
control_data_len,
packet_number,
} = event;
tracing::event!(
target : "stream_control_packet_transmitted", parent : id,
tracing::Level::DEBUG, { packet_len = tracing::field::debug(packet_len),
control_data_len = tracing::field::debug(control_data_len), packet_number
= tracing::field::debug(packet_number) }
);
}
#[inline]
fn on_stream_control_packet_received(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamControlPacketReceived,
) {
let id = context.id();
let api::StreamControlPacketReceived {
packet_len,
control_data_len,
packet_number,
is_authenticated,
} = event;
tracing::event!(
target : "stream_control_packet_received", parent : id,
tracing::Level::DEBUG, { packet_len = tracing::field::debug(packet_len),
control_data_len = tracing::field::debug(control_data_len), packet_number
= tracing::field::debug(packet_number), is_authenticated =
tracing::field::debug(is_authenticated) }
);
}
#[inline]
fn on_stream_receiver_errored(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamReceiverErrored,
) {
let id = context.id();
let api::StreamReceiverErrored { error, source } = event;
tracing::event!(
target : "stream_receiver_errored", parent : id, tracing::Level::DEBUG, {
error = tracing::field::debug(error), source =
tracing::field::debug(source) }
);
}
#[inline]
fn on_stream_sender_errored(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamSenderErrored,
) {
let id = context.id();
let api::StreamSenderErrored { error, source } = event;
tracing::event!(
target : "stream_sender_errored", parent : id, tracing::Level::DEBUG, {
error = tracing::field::debug(error), source =
tracing::field::debug(source) }
);
}
#[inline]
fn on_stream_handshake_packet_rejected(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::StreamHandshakePacketRejected,
) {
let id = context.id();
let api::StreamHandshakePacketRejected { reason } = event;
tracing::event!(
target : "stream_handshake_packet_rejected", parent : id,
tracing::Level::DEBUG, { reason = tracing::field::debug(reason) }
);
}
#[inline]
fn on_connection_closed(
&self,
context: &Self::ConnectionContext,
_meta: &api::ConnectionMeta,
event: &api::ConnectionClosed,
) {
let id = context.id();
let api::ConnectionClosed {} = event;
tracing::event!(
target : "connection_closed", parent : id, tracing::Level::DEBUG, {}
);
}
#[inline]
fn on_endpoint_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::EndpointInitialized,
) {
let parent = self.parent(meta);
let api::EndpointInitialized {
acceptor_addr,
handshake_addr,
tcp,
udp,
} = event;
tracing::event!(
target : "endpoint_initialized", parent : parent, tracing::Level::DEBUG,
{ acceptor_addr = tracing::field::debug(acceptor_addr), handshake_addr =
tracing::field::debug(handshake_addr), tcp = tracing::field::debug(tcp),
udp = tracing::field::debug(udp) }
);
}
#[inline]
fn on_dc_connection_timeout(
&self,
meta: &api::EndpointMeta,
event: &api::DcConnectionTimeout,
) {
let parent = self.parent(meta);
let api::DcConnectionTimeout { peer_address } = event;
tracing::event!(
target : "dc_connection_timeout", parent : parent, tracing::Level::DEBUG,
{ peer_address = tracing::field::debug(peer_address) }
);
}
#[inline]
fn on_path_secret_map_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapInitialized,
) {
let parent = self.parent(meta);
let api::PathSecretMapInitialized { capacity } = event;
tracing::event!(
target : "path_secret_map_initialized", parent : parent,
tracing::Level::DEBUG, { capacity = tracing::field::debug(capacity) }
);
}
#[inline]
fn on_path_secret_map_uninitialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapUninitialized,
) {
let parent = self.parent(meta);
let api::PathSecretMapUninitialized {
capacity,
entries,
lifetime,
} = event;
tracing::event!(
target : "path_secret_map_uninitialized", parent : parent,
tracing::Level::DEBUG, { capacity = tracing::field::debug(capacity),
entries = tracing::field::debug(entries), lifetime =
tracing::field::debug(lifetime) }
);
}
#[inline]
fn on_path_secret_map_background_handshake_requested(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapBackgroundHandshakeRequested,
) {
let parent = self.parent(meta);
let api::PathSecretMapBackgroundHandshakeRequested { peer_address } = event;
tracing::event!(
target : "path_secret_map_background_handshake_requested", parent :
parent, tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address) }
);
}
#[inline]
fn on_path_secret_map_entry_inserted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryInserted,
) {
let parent = self.parent(meta);
let api::PathSecretMapEntryInserted {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "path_secret_map_entry_inserted", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_path_secret_map_entry_ready(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReady,
) {
let parent = self.parent(meta);
let api::PathSecretMapEntryReady {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "path_secret_map_entry_ready", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_path_secret_map_entry_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReplaced,
) {
let parent = self.parent(meta);
let api::PathSecretMapEntryReplaced {
peer_address,
new_credential_id,
previous_credential_id,
replaced_age,
} = event;
tracing::event!(
target : "path_secret_map_entry_replaced", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), new_credential_id =
tracing::field::debug(new_credential_id), previous_credential_id =
tracing::field::debug(previous_credential_id), replaced_age =
tracing::field::debug(replaced_age) }
);
}
#[inline]
fn on_path_secret_map_id_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdEntryEvicted,
) {
let parent = self.parent(meta);
let api::PathSecretMapIdEntryEvicted {
peer_address,
credential_id,
age,
time_since_last_accessed,
reason,
} = event;
tracing::event!(
target : "path_secret_map_id_entry_evicted", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id), age = tracing::field::debug(age),
time_since_last_accessed =
tracing::field::debug(time_since_last_accessed), reason =
tracing::field::debug(reason) }
);
}
#[inline]
fn on_path_secret_map_address_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressEntryEvicted,
) {
let parent = self.parent(meta);
let api::PathSecretMapAddressEntryEvicted {
peer_address,
credential_id,
age,
time_since_last_accessed,
reason,
} = event;
tracing::event!(
target : "path_secret_map_address_entry_evicted", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id), age = tracing::field::debug(age),
time_since_last_accessed =
tracing::field::debug(time_since_last_accessed), reason =
tracing::field::debug(reason) }
);
}
#[inline]
fn on_unknown_path_secret_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketSent,
) {
let parent = self.parent(meta);
let api::UnknownPathSecretPacketSent {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "unknown_path_secret_packet_sent", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_unknown_path_secret_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketReceived,
) {
let parent = self.parent(meta);
let api::UnknownPathSecretPacketReceived {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "unknown_path_secret_packet_received", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_unknown_path_secret_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketAccepted,
) {
let parent = self.parent(meta);
let api::UnknownPathSecretPacketAccepted {
peer_address,
credential_id,
age,
evicted,
scheduled_handshake,
} = event;
tracing::event!(
target : "unknown_path_secret_packet_accepted", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id), age = tracing::field::debug(age),
evicted = tracing::field::debug(evicted), scheduled_handshake =
tracing::field::debug(scheduled_handshake) }
);
}
#[inline]
fn on_unknown_path_secret_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketRejected,
) {
let parent = self.parent(meta);
let api::UnknownPathSecretPacketRejected {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "unknown_path_secret_packet_rejected", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_unknown_path_secret_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketDropped,
) {
let parent = self.parent(meta);
let api::UnknownPathSecretPacketDropped {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "unknown_path_secret_packet_dropped", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_key_accepted(&self, meta: &api::EndpointMeta, event: &api::KeyAccepted) {
let parent = self.parent(meta);
let api::KeyAccepted {
credential_id,
key_id,
gap,
forward_shift,
} = event;
tracing::event!(
target : "key_accepted", parent : parent, tracing::Level::DEBUG, {
credential_id = tracing::field::debug(credential_id), key_id =
tracing::field::debug(key_id), gap = tracing::field::debug(gap),
forward_shift = tracing::field::debug(forward_shift) }
);
}
#[inline]
fn on_replay_definitely_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDefinitelyDetected,
) {
let parent = self.parent(meta);
let api::ReplayDefinitelyDetected {
credential_id,
key_id,
} = event;
tracing::event!(
target : "replay_definitely_detected", parent : parent,
tracing::Level::DEBUG, { credential_id =
tracing::field::debug(credential_id), key_id =
tracing::field::debug(key_id) }
);
}
#[inline]
fn on_replay_potentially_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayPotentiallyDetected,
) {
let parent = self.parent(meta);
let api::ReplayPotentiallyDetected {
credential_id,
key_id,
gap,
} = event;
tracing::event!(
target : "replay_potentially_detected", parent : parent,
tracing::Level::DEBUG, { credential_id =
tracing::field::debug(credential_id), key_id =
tracing::field::debug(key_id), gap = tracing::field::debug(gap) }
);
}
#[inline]
fn on_replay_detected_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketSent,
) {
let parent = self.parent(meta);
let api::ReplayDetectedPacketSent {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "replay_detected_packet_sent", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_replay_detected_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketReceived,
) {
let parent = self.parent(meta);
let api::ReplayDetectedPacketReceived {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "replay_detected_packet_received", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_replay_detected_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketAccepted,
) {
let parent = self.parent(meta);
let api::ReplayDetectedPacketAccepted {
peer_address,
credential_id,
key_id,
} = event;
tracing::event!(
target : "replay_detected_packet_accepted", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id), key_id =
tracing::field::debug(key_id) }
);
}
#[inline]
fn on_replay_detected_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketRejected,
) {
let parent = self.parent(meta);
let api::ReplayDetectedPacketRejected {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "replay_detected_packet_rejected", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_replay_detected_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketDropped,
) {
let parent = self.parent(meta);
let api::ReplayDetectedPacketDropped {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "replay_detected_packet_dropped", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_stale_key_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketSent,
) {
let parent = self.parent(meta);
let api::StaleKeyPacketSent {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "stale_key_packet_sent", parent : parent, tracing::Level::DEBUG,
{ peer_address = tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_stale_key_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketReceived,
) {
let parent = self.parent(meta);
let api::StaleKeyPacketReceived {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "stale_key_packet_received", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_stale_key_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketAccepted,
) {
let parent = self.parent(meta);
let api::StaleKeyPacketAccepted {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "stale_key_packet_accepted", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_stale_key_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketRejected,
) {
let parent = self.parent(meta);
let api::StaleKeyPacketRejected {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "stale_key_packet_rejected", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_stale_key_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketDropped,
) {
let parent = self.parent(meta);
let api::StaleKeyPacketDropped {
peer_address,
credential_id,
} = event;
tracing::event!(
target : "stale_key_packet_dropped", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), credential_id =
tracing::field::debug(credential_id) }
);
}
#[inline]
fn on_path_secret_map_address_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessed,
) {
let parent = self.parent(meta);
let api::PathSecretMapAddressCacheAccessed { peer_address, hit } = event;
tracing::event!(
target : "path_secret_map_address_cache_accessed", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), hit = tracing::field::debug(hit) }
);
}
#[inline]
fn on_path_secret_map_address_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessedHit,
) {
let parent = self.parent(meta);
let api::PathSecretMapAddressCacheAccessedHit { peer_address, age } = event;
tracing::event!(
target : "path_secret_map_address_cache_accessed_hit", parent : parent,
tracing::Level::DEBUG, { peer_address =
tracing::field::debug(peer_address), age = tracing::field::debug(age) }
);
}
#[inline]
fn on_path_secret_map_id_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessed,
) {
let parent = self.parent(meta);
let api::PathSecretMapIdCacheAccessed { credential_id, hit } = event;
tracing::event!(
target : "path_secret_map_id_cache_accessed", parent : parent,
tracing::Level::DEBUG, { credential_id =
tracing::field::debug(credential_id), hit = tracing::field::debug(hit) }
);
}
#[inline]
fn on_path_secret_map_id_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessedHit,
) {
let parent = self.parent(meta);
let api::PathSecretMapIdCacheAccessedHit { credential_id, age } = event;
tracing::event!(
target : "path_secret_map_id_cache_accessed_hit", parent : parent,
tracing::Level::DEBUG, { credential_id =
tracing::field::debug(credential_id), age = tracing::field::debug(age) }
);
}
#[inline]
fn on_path_secret_map_cleaner_cycled(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapCleanerCycled,
) {
let parent = self.parent(meta);
let api::PathSecretMapCleanerCycled {
id_entries,
id_entries_retired,
id_entries_active,
id_entries_active_utilization,
id_entries_utilization,
id_entries_initial_utilization,
address_entries,
address_entries_active,
address_entries_active_utilization,
address_entries_retired,
address_entries_utilization,
address_entries_initial_utilization,
id_entries_in_last_hs_period,
id_entries_in_last_hs_period_utilization,
handshake_requests,
handshake_requests_skipped,
handshake_lock_duration,
duration,
} = event;
tracing::event!(
target : "path_secret_map_cleaner_cycled", parent : parent,
tracing::Level::DEBUG, { id_entries = tracing::field::debug(id_entries),
id_entries_retired = tracing::field::debug(id_entries_retired),
id_entries_active = tracing::field::debug(id_entries_active),
id_entries_active_utilization =
tracing::field::debug(id_entries_active_utilization),
id_entries_utilization = tracing::field::debug(id_entries_utilization),
id_entries_initial_utilization =
tracing::field::debug(id_entries_initial_utilization), address_entries =
tracing::field::debug(address_entries), address_entries_active =
tracing::field::debug(address_entries_active),
address_entries_active_utilization =
tracing::field::debug(address_entries_active_utilization),
address_entries_retired = tracing::field::debug(address_entries_retired),
address_entries_utilization =
tracing::field::debug(address_entries_utilization),
address_entries_initial_utilization =
tracing::field::debug(address_entries_initial_utilization),
id_entries_in_last_hs_period =
tracing::field::debug(id_entries_in_last_hs_period),
id_entries_in_last_hs_period_utilization =
tracing::field::debug(id_entries_in_last_hs_period_utilization),
handshake_requests = tracing::field::debug(handshake_requests),
handshake_requests_skipped =
tracing::field::debug(handshake_requests_skipped),
handshake_lock_duration = tracing::field::debug(handshake_lock_duration),
duration = tracing::field::debug(duration) }
);
}
#[inline]
fn on_path_secret_map_serialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapSerialized,
) {
let parent = self.parent(meta);
let api::PathSecretMapSerialized {
entries,
file_size,
duration,
error,
} = event;
tracing::event!(
target : "path_secret_map_serialized", parent : parent,
tracing::Level::DEBUG, { entries = tracing::field::debug(entries),
file_size = tracing::field::debug(file_size), duration =
tracing::field::debug(duration), error = tracing::field::debug(error) }
);
}
#[inline]
fn on_path_secret_map_id_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdWriteLock,
) {
let parent = self.parent(meta);
let api::PathSecretMapIdWriteLock { acquire, duration } = event;
tracing::event!(
target : "path_secret_map_id_write_lock", parent : parent,
tracing::Level::DEBUG, { acquire = tracing::field::debug(acquire),
duration = tracing::field::debug(duration) }
);
}
#[inline]
fn on_path_secret_map_address_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressWriteLock,
) {
let parent = self.parent(meta);
let api::PathSecretMapAddressWriteLock { acquire, duration } = event;
tracing::event!(
target : "path_secret_map_address_write_lock", parent : parent,
tracing::Level::DEBUG, { acquire = tracing::field::debug(acquire),
duration = tracing::field::debug(duration) }
);
}
#[inline]
fn on_path_secret_map_datagram_encrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramEncrypt,
) {
let parent = self.parent(meta);
let api::PathSecretMapDatagramEncrypt { packet_len } = event;
tracing::event!(
target : "path_secret_map_datagram_encrypt", parent : parent,
tracing::Level::DEBUG, { packet_len = tracing::field::debug(packet_len) }
);
}
#[inline]
fn on_path_secret_map_datagram_decrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramDecrypt,
) {
let parent = self.parent(meta);
let api::PathSecretMapDatagramDecrypt { packet_len } = event;
tracing::event!(
target : "path_secret_map_datagram_decrypt", parent : parent,
tracing::Level::DEBUG, { packet_len = tracing::field::debug(packet_len) }
);
}
}
}
pub mod builder {
use super::*;
pub use s2n_quic_core::event::builder::{EndpointType, SocketAddress, Subject};
#[derive(Clone, Debug)]
pub struct AcceptorTcpStarted<'a> {
pub id: usize,
pub local_address: &'a s2n_quic_core::inet::SocketAddress,
pub backlog: usize,
}
impl<'a> IntoEvent<api::AcceptorTcpStarted<'a>> for AcceptorTcpStarted<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpStarted<'a> {
let AcceptorTcpStarted {
id,
local_address,
backlog,
} = self;
api::AcceptorTcpStarted {
id: id.into_event(),
local_address: local_address.into_event(),
backlog: backlog.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpLoopIterationCompleted {
pub pending_streams: usize,
pub slots_idle: usize,
pub slot_utilization: f32,
pub processing_duration: core::time::Duration,
pub max_sojourn_time: core::time::Duration,
}
impl IntoEvent<api::AcceptorTcpLoopIterationCompleted> for AcceptorTcpLoopIterationCompleted {
#[inline]
fn into_event(self) -> api::AcceptorTcpLoopIterationCompleted {
let AcceptorTcpLoopIterationCompleted {
pending_streams,
slots_idle,
slot_utilization,
processing_duration,
max_sojourn_time,
} = self;
api::AcceptorTcpLoopIterationCompleted {
pending_streams: pending_streams.into_event(),
slots_idle: slots_idle.into_event(),
slot_utilization: slot_utilization.into_event(),
processing_duration: processing_duration.into_event(),
max_sojourn_time: max_sojourn_time.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpFreshEnqueued<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
}
impl<'a> IntoEvent<api::AcceptorTcpFreshEnqueued<'a>> for AcceptorTcpFreshEnqueued<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpFreshEnqueued<'a> {
let AcceptorTcpFreshEnqueued { remote_address } = self;
api::AcceptorTcpFreshEnqueued {
remote_address: remote_address.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpFreshBatchCompleted {
pub enqueued: usize,
pub dropped: usize,
pub errored: usize,
}
impl IntoEvent<api::AcceptorTcpFreshBatchCompleted> for AcceptorTcpFreshBatchCompleted {
#[inline]
fn into_event(self) -> api::AcceptorTcpFreshBatchCompleted {
let AcceptorTcpFreshBatchCompleted {
enqueued,
dropped,
errored,
} = self;
api::AcceptorTcpFreshBatchCompleted {
enqueued: enqueued.into_event(),
dropped: dropped.into_event(),
errored: errored.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpStreamDropped<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub reason: AcceptorTcpStreamDropReason,
}
impl<'a> IntoEvent<api::AcceptorTcpStreamDropped<'a>> for AcceptorTcpStreamDropped<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpStreamDropped<'a> {
let AcceptorTcpStreamDropped {
remote_address,
reason,
} = self;
api::AcceptorTcpStreamDropped {
remote_address: remote_address.into_event(),
reason: reason.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpStreamReplaced<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub sojourn_time: core::time::Duration,
pub buffer_len: usize,
}
impl<'a> IntoEvent<api::AcceptorTcpStreamReplaced<'a>> for AcceptorTcpStreamReplaced<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpStreamReplaced<'a> {
let AcceptorTcpStreamReplaced {
remote_address,
sojourn_time,
buffer_len,
} = self;
api::AcceptorTcpStreamReplaced {
remote_address: remote_address.into_event(),
sojourn_time: sojourn_time.into_event(),
buffer_len: buffer_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpPacketReceived<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub payload_len: usize,
pub is_fin: bool,
pub is_fin_known: bool,
pub sojourn_time: core::time::Duration,
}
impl<'a> IntoEvent<api::AcceptorTcpPacketReceived<'a>> for AcceptorTcpPacketReceived<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpPacketReceived<'a> {
let AcceptorTcpPacketReceived {
remote_address,
credential_id,
stream_id,
payload_len,
is_fin,
is_fin_known,
sojourn_time,
} = self;
api::AcceptorTcpPacketReceived {
remote_address: remote_address.into_event(),
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
payload_len: payload_len.into_event(),
is_fin: is_fin.into_event(),
is_fin_known: is_fin_known.into_event(),
sojourn_time: sojourn_time.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpTlsStarted<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub sojourn_time: core::time::Duration,
}
impl<'a> IntoEvent<api::AcceptorTcpTlsStarted<'a>> for AcceptorTcpTlsStarted<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpTlsStarted<'a> {
let AcceptorTcpTlsStarted {
remote_address,
sojourn_time,
} = self;
api::AcceptorTcpTlsStarted {
remote_address: remote_address.into_event(),
sojourn_time: sojourn_time.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpTlsStreamEnqueued<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub sojourn_time: core::time::Duration,
}
impl<'a> IntoEvent<api::AcceptorTcpTlsStreamEnqueued<'a>> for AcceptorTcpTlsStreamEnqueued<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpTlsStreamEnqueued<'a> {
let AcceptorTcpTlsStreamEnqueued {
remote_address,
sojourn_time,
} = self;
api::AcceptorTcpTlsStreamEnqueued {
remote_address: remote_address.into_event(),
sojourn_time: sojourn_time.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpTlsStreamRejected<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub local_address: &'a s2n_quic_core::inet::SocketAddress,
pub sojourn_time: core::time::Duration,
pub error: &'a std::io::Error,
}
impl<'a> IntoEvent<api::AcceptorTcpTlsStreamRejected<'a>> for AcceptorTcpTlsStreamRejected<'a> {
#[inline]
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(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpSyntheticTlsStreamRejected<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub local_address: &'a s2n_quic_core::inet::SocketAddress,
pub sojourn_time: core::time::Duration,
pub error: &'a std::io::Error,
}
impl<'a> IntoEvent<api::AcceptorTcpSyntheticTlsStreamRejected<'a>>
for AcceptorTcpSyntheticTlsStreamRejected<'a>
{
#[inline]
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(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpPacketDropped<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub reason: AcceptorPacketDropReason,
pub sojourn_time: core::time::Duration,
}
impl<'a> IntoEvent<api::AcceptorTcpPacketDropped<'a>> for AcceptorTcpPacketDropped<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpPacketDropped<'a> {
let AcceptorTcpPacketDropped {
remote_address,
reason,
sojourn_time,
} = self;
api::AcceptorTcpPacketDropped {
remote_address: remote_address.into_event(),
reason: reason.into_event(),
sojourn_time: sojourn_time.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpStreamEnqueued<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub blocked_count: usize,
}
impl<'a> IntoEvent<api::AcceptorTcpStreamEnqueued<'a>> for AcceptorTcpStreamEnqueued<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpStreamEnqueued<'a> {
let AcceptorTcpStreamEnqueued {
remote_address,
credential_id,
stream_id,
sojourn_time,
blocked_count,
} = self;
api::AcceptorTcpStreamEnqueued {
remote_address: remote_address.into_event(),
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
sojourn_time: sojourn_time.into_event(),
blocked_count: blocked_count.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpIoError<'a> {
pub error: &'a std::io::Error,
pub source: AcceptorTcpIoErrorSource,
}
impl<'a> IntoEvent<api::AcceptorTcpIoError<'a>> for AcceptorTcpIoError<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpIoError<'a> {
let AcceptorTcpIoError { error, source } = self;
api::AcceptorTcpIoError {
error: error.into_event(),
source: source.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpSocketSent<'a> {
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub blocked_count: usize,
pub payload_len: usize,
}
impl<'a> IntoEvent<api::AcceptorTcpSocketSent<'a>> for AcceptorTcpSocketSent<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpSocketSent<'a> {
let AcceptorTcpSocketSent {
credential_id,
stream_id,
sojourn_time,
blocked_count,
payload_len,
} = self;
api::AcceptorTcpSocketSent {
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
sojourn_time: sojourn_time.into_event(),
blocked_count: blocked_count.into_event(),
payload_len: payload_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorTcpSocketReceived<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub transfer_time: core::time::Duration,
pub payload_len: usize,
}
impl<'a> IntoEvent<api::AcceptorTcpSocketReceived<'a>> for AcceptorTcpSocketReceived<'a> {
#[inline]
fn into_event(self) -> api::AcceptorTcpSocketReceived<'a> {
let AcceptorTcpSocketReceived {
remote_address,
credential_id,
stream_id,
transfer_time,
payload_len,
} = self;
api::AcceptorTcpSocketReceived {
remote_address: remote_address.into_event(),
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
transfer_time: transfer_time.into_event(),
payload_len: payload_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorUdpStarted<'a> {
pub id: usize,
pub local_address: SocketAddress<'a>,
}
impl<'a> IntoEvent<api::AcceptorUdpStarted<'a>> for AcceptorUdpStarted<'a> {
#[inline]
fn into_event(self) -> api::AcceptorUdpStarted<'a> {
let AcceptorUdpStarted { id, local_address } = self;
api::AcceptorUdpStarted {
id: id.into_event(),
local_address: local_address.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorUdpDatagramReceived<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub len: usize,
}
impl<'a> IntoEvent<api::AcceptorUdpDatagramReceived<'a>> for AcceptorUdpDatagramReceived<'a> {
#[inline]
fn into_event(self) -> api::AcceptorUdpDatagramReceived<'a> {
let AcceptorUdpDatagramReceived {
remote_address,
len,
} = self;
api::AcceptorUdpDatagramReceived {
remote_address: remote_address.into_event(),
len: len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorUdpPacketReceived<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub payload_len: usize,
pub is_zero_offset: bool,
pub is_retransmission: bool,
pub is_fin: bool,
pub is_fin_known: bool,
}
impl<'a> IntoEvent<api::AcceptorUdpPacketReceived<'a>> for AcceptorUdpPacketReceived<'a> {
#[inline]
fn into_event(self) -> api::AcceptorUdpPacketReceived<'a> {
let AcceptorUdpPacketReceived {
remote_address,
credential_id,
stream_id,
payload_len,
is_zero_offset,
is_retransmission,
is_fin,
is_fin_known,
} = self;
api::AcceptorUdpPacketReceived {
remote_address: remote_address.into_event(),
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
payload_len: payload_len.into_event(),
is_zero_offset: is_zero_offset.into_event(),
is_retransmission: is_retransmission.into_event(),
is_fin: is_fin.into_event(),
is_fin_known: is_fin_known.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorUdpPacketDropped<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub reason: AcceptorPacketDropReason,
}
impl<'a> IntoEvent<api::AcceptorUdpPacketDropped<'a>> for AcceptorUdpPacketDropped<'a> {
#[inline]
fn into_event(self) -> api::AcceptorUdpPacketDropped<'a> {
let AcceptorUdpPacketDropped {
remote_address,
reason,
} = self;
api::AcceptorUdpPacketDropped {
remote_address: remote_address.into_event(),
reason: reason.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorUdpStreamEnqueued<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub credential_id: &'a [u8],
pub stream_id: u64,
}
impl<'a> IntoEvent<api::AcceptorUdpStreamEnqueued<'a>> for AcceptorUdpStreamEnqueued<'a> {
#[inline]
fn into_event(self) -> api::AcceptorUdpStreamEnqueued<'a> {
let AcceptorUdpStreamEnqueued {
remote_address,
credential_id,
stream_id,
} = self;
api::AcceptorUdpStreamEnqueued {
remote_address: remote_address.into_event(),
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorUdpIoError<'a> {
pub error: &'a std::io::Error,
}
impl<'a> IntoEvent<api::AcceptorUdpIoError<'a>> for AcceptorUdpIoError<'a> {
#[inline]
fn into_event(self) -> api::AcceptorUdpIoError<'a> {
let AcceptorUdpIoError { error } = self;
api::AcceptorUdpIoError {
error: error.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorStreamPruned<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub reason: AcceptorStreamPruneReason,
}
impl<'a> IntoEvent<api::AcceptorStreamPruned<'a>> for AcceptorStreamPruned<'a> {
#[inline]
fn into_event(self) -> api::AcceptorStreamPruned<'a> {
let AcceptorStreamPruned {
remote_address,
credential_id,
stream_id,
sojourn_time,
reason,
} = self;
api::AcceptorStreamPruned {
remote_address: remote_address.into_event(),
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
sojourn_time: sojourn_time.into_event(),
reason: reason.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct AcceptorStreamDequeued<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub credential_id: &'a [u8],
pub stream_id: u64,
pub sojourn_time: core::time::Duration,
pub queue_sojourn_time: core::time::Duration,
}
impl<'a> IntoEvent<api::AcceptorStreamDequeued<'a>> for AcceptorStreamDequeued<'a> {
#[inline]
fn into_event(self) -> api::AcceptorStreamDequeued<'a> {
let AcceptorStreamDequeued {
remote_address,
credential_id,
stream_id,
sojourn_time,
queue_sojourn_time,
} = self;
api::AcceptorStreamDequeued {
remote_address: remote_address.into_event(),
credential_id: credential_id.into_event(),
stream_id: stream_id.into_event(),
sojourn_time: sojourn_time.into_event(),
queue_sojourn_time: queue_sojourn_time.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub enum AcceptorTcpStreamDropReason {
FreshQueueAtCapacity,
SlotsAtCapacity,
}
impl IntoEvent<api::AcceptorTcpStreamDropReason> for AcceptorTcpStreamDropReason {
#[inline]
fn into_event(self) -> api::AcceptorTcpStreamDropReason {
use api::AcceptorTcpStreamDropReason::*;
match self {
Self::FreshQueueAtCapacity => FreshQueueAtCapacity {},
Self::SlotsAtCapacity => SlotsAtCapacity {},
}
}
}
#[derive(Clone, Debug)]
pub enum AcceptorTcpIoErrorSource {
Accept,
Send,
UnixSend,
Recv,
Remote,
Local,
UnknownPathSecret,
System,
}
impl IntoEvent<api::AcceptorTcpIoErrorSource> for AcceptorTcpIoErrorSource {
#[inline]
fn into_event(self) -> api::AcceptorTcpIoErrorSource {
use api::AcceptorTcpIoErrorSource::*;
match self {
Self::Accept => Accept {},
Self::Send => Send {},
Self::UnixSend => UnixSend {},
Self::Recv => Recv {},
Self::Remote => Remote {},
Self::Local => Local {},
Self::UnknownPathSecret => UnknownPathSecret {},
Self::System => System {},
}
}
}
#[derive(Clone, Debug)]
pub enum AcceptorStreamPruneReason {
MaxSojournTimeExceeded,
AcceptQueueCapacityExceeded,
}
impl IntoEvent<api::AcceptorStreamPruneReason> for AcceptorStreamPruneReason {
#[inline]
fn into_event(self) -> api::AcceptorStreamPruneReason {
use api::AcceptorStreamPruneReason::*;
match self {
Self::MaxSojournTimeExceeded => MaxSojournTimeExceeded {},
Self::AcceptQueueCapacityExceeded => AcceptQueueCapacityExceeded {},
}
}
}
#[derive(Clone, Debug)]
pub enum AcceptorPacketDropReason {
UnexpectedEof,
UnexpectedBytes,
LengthCapacityExceeded,
InvariantViolation { message: &'static str },
}
impl IntoEvent<api::AcceptorPacketDropReason> for AcceptorPacketDropReason {
#[inline]
fn into_event(self) -> api::AcceptorPacketDropReason {
use api::AcceptorPacketDropReason::*;
match self {
Self::UnexpectedEof => UnexpectedEof {},
Self::UnexpectedBytes => UnexpectedBytes {},
Self::LengthCapacityExceeded => LengthCapacityExceeded {},
Self::InvariantViolation { message } => InvariantViolation {
message: message.into_event(),
},
}
}
}
#[derive(Clone, Debug)]
pub struct ConnectionMeta {
pub id: u64,
pub timestamp: Timestamp,
}
impl IntoEvent<api::ConnectionMeta> for ConnectionMeta {
#[inline]
fn into_event(self) -> api::ConnectionMeta {
let ConnectionMeta { id, timestamp } = self;
api::ConnectionMeta {
id: id.into_event(),
timestamp: timestamp.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct EndpointMeta {
pub timestamp: Timestamp,
}
impl IntoEvent<api::EndpointMeta> for EndpointMeta {
#[inline]
fn into_event(self) -> api::EndpointMeta {
let EndpointMeta { timestamp } = self;
api::EndpointMeta {
timestamp: timestamp.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ConnectionInfo {}
impl IntoEvent<api::ConnectionInfo> for ConnectionInfo {
#[inline]
fn into_event(self) -> api::ConnectionInfo {
let ConnectionInfo {} = self;
api::ConnectionInfo {}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteFlushed {
pub provided_len: usize,
pub committed_len: usize,
pub processing_duration: core::time::Duration,
}
impl IntoEvent<api::StreamWriteFlushed> for StreamWriteFlushed {
#[inline]
fn into_event(self) -> api::StreamWriteFlushed {
let StreamWriteFlushed {
provided_len,
committed_len,
processing_duration,
} = self;
api::StreamWriteFlushed {
provided_len: provided_len.into_event(),
committed_len: committed_len.into_event(),
processing_duration: processing_duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteFinFlushed {
pub provided_len: usize,
pub committed_len: usize,
pub processing_duration: core::time::Duration,
}
impl IntoEvent<api::StreamWriteFinFlushed> for StreamWriteFinFlushed {
#[inline]
fn into_event(self) -> api::StreamWriteFinFlushed {
let StreamWriteFinFlushed {
provided_len,
committed_len,
processing_duration,
} = self;
api::StreamWriteFinFlushed {
provided_len: provided_len.into_event(),
committed_len: committed_len.into_event(),
processing_duration: processing_duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteBlocked {
pub provided_len: usize,
pub is_fin: bool,
pub processing_duration: core::time::Duration,
}
impl IntoEvent<api::StreamWriteBlocked> for StreamWriteBlocked {
#[inline]
fn into_event(self) -> api::StreamWriteBlocked {
let StreamWriteBlocked {
provided_len,
is_fin,
processing_duration,
} = self;
api::StreamWriteBlocked {
provided_len: provided_len.into_event(),
is_fin: is_fin.into_event(),
processing_duration: processing_duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteErrored {
pub provided_len: usize,
pub is_fin: bool,
pub processing_duration: core::time::Duration,
pub errno: Option<i32>,
}
impl IntoEvent<api::StreamWriteErrored> for StreamWriteErrored {
#[inline]
fn into_event(self) -> api::StreamWriteErrored {
let StreamWriteErrored {
provided_len,
is_fin,
processing_duration,
errno,
} = self;
api::StreamWriteErrored {
provided_len: provided_len.into_event(),
is_fin: is_fin.into_event(),
processing_duration: processing_duration.into_event(),
errno: errno.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteKeyUpdated {
pub key_phase: u8,
}
impl IntoEvent<api::StreamWriteKeyUpdated> for StreamWriteKeyUpdated {
#[inline]
fn into_event(self) -> api::StreamWriteKeyUpdated {
let StreamWriteKeyUpdated { key_phase } = self;
api::StreamWriteKeyUpdated {
key_phase: key_phase.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteAllocated {
pub allocated_len: usize,
}
impl IntoEvent<api::StreamWriteAllocated> for StreamWriteAllocated {
#[inline]
fn into_event(self) -> api::StreamWriteAllocated {
let StreamWriteAllocated { allocated_len } = self;
api::StreamWriteAllocated {
allocated_len: allocated_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteShutdown {
pub buffer_len: usize,
pub background: bool,
}
impl IntoEvent<api::StreamWriteShutdown> for StreamWriteShutdown {
#[inline]
fn into_event(self) -> api::StreamWriteShutdown {
let StreamWriteShutdown {
buffer_len,
background,
} = self;
api::StreamWriteShutdown {
buffer_len: buffer_len.into_event(),
background: background.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteSocketFlushed {
pub provided_len: usize,
pub committed_len: usize,
}
impl IntoEvent<api::StreamWriteSocketFlushed> for StreamWriteSocketFlushed {
#[inline]
fn into_event(self) -> api::StreamWriteSocketFlushed {
let StreamWriteSocketFlushed {
provided_len,
committed_len,
} = self;
api::StreamWriteSocketFlushed {
provided_len: provided_len.into_event(),
committed_len: committed_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteSocketBlocked {
pub provided_len: usize,
}
impl IntoEvent<api::StreamWriteSocketBlocked> for StreamWriteSocketBlocked {
#[inline]
fn into_event(self) -> api::StreamWriteSocketBlocked {
let StreamWriteSocketBlocked { provided_len } = self;
api::StreamWriteSocketBlocked {
provided_len: provided_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamWriteSocketErrored {
pub provided_len: usize,
pub errno: Option<i32>,
}
impl IntoEvent<api::StreamWriteSocketErrored> for StreamWriteSocketErrored {
#[inline]
fn into_event(self) -> api::StreamWriteSocketErrored {
let StreamWriteSocketErrored {
provided_len,
errno,
} = self;
api::StreamWriteSocketErrored {
provided_len: provided_len.into_event(),
errno: errno.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadFlushed {
pub capacity: usize,
pub committed_len: usize,
pub processing_duration: core::time::Duration,
}
impl IntoEvent<api::StreamReadFlushed> for StreamReadFlushed {
#[inline]
fn into_event(self) -> api::StreamReadFlushed {
let StreamReadFlushed {
capacity,
committed_len,
processing_duration,
} = self;
api::StreamReadFlushed {
capacity: capacity.into_event(),
committed_len: committed_len.into_event(),
processing_duration: processing_duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadFinFlushed {
pub capacity: usize,
pub processing_duration: core::time::Duration,
}
impl IntoEvent<api::StreamReadFinFlushed> for StreamReadFinFlushed {
#[inline]
fn into_event(self) -> api::StreamReadFinFlushed {
let StreamReadFinFlushed {
capacity,
processing_duration,
} = self;
api::StreamReadFinFlushed {
capacity: capacity.into_event(),
processing_duration: processing_duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadBlocked {
pub capacity: usize,
pub processing_duration: core::time::Duration,
}
impl IntoEvent<api::StreamReadBlocked> for StreamReadBlocked {
#[inline]
fn into_event(self) -> api::StreamReadBlocked {
let StreamReadBlocked {
capacity,
processing_duration,
} = self;
api::StreamReadBlocked {
capacity: capacity.into_event(),
processing_duration: processing_duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadErrored {
pub capacity: usize,
pub processing_duration: core::time::Duration,
pub errno: Option<i32>,
}
impl IntoEvent<api::StreamReadErrored> for StreamReadErrored {
#[inline]
fn into_event(self) -> api::StreamReadErrored {
let StreamReadErrored {
capacity,
processing_duration,
errno,
} = self;
api::StreamReadErrored {
capacity: capacity.into_event(),
processing_duration: processing_duration.into_event(),
errno: errno.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadKeyUpdated {
pub key_phase: u8,
}
impl IntoEvent<api::StreamReadKeyUpdated> for StreamReadKeyUpdated {
#[inline]
fn into_event(self) -> api::StreamReadKeyUpdated {
let StreamReadKeyUpdated { key_phase } = self;
api::StreamReadKeyUpdated {
key_phase: key_phase.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadShutdown {
pub background: bool,
}
impl IntoEvent<api::StreamReadShutdown> for StreamReadShutdown {
#[inline]
fn into_event(self) -> api::StreamReadShutdown {
let StreamReadShutdown { background } = self;
api::StreamReadShutdown {
background: background.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadSocketFlushed {
pub capacity: usize,
pub committed_len: usize,
}
impl IntoEvent<api::StreamReadSocketFlushed> for StreamReadSocketFlushed {
#[inline]
fn into_event(self) -> api::StreamReadSocketFlushed {
let StreamReadSocketFlushed {
capacity,
committed_len,
} = self;
api::StreamReadSocketFlushed {
capacity: capacity.into_event(),
committed_len: committed_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadSocketBlocked {
pub capacity: usize,
}
impl IntoEvent<api::StreamReadSocketBlocked> for StreamReadSocketBlocked {
#[inline]
fn into_event(self) -> api::StreamReadSocketBlocked {
let StreamReadSocketBlocked { capacity } = self;
api::StreamReadSocketBlocked {
capacity: capacity.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReadSocketErrored {
pub capacity: usize,
pub errno: Option<i32>,
}
impl IntoEvent<api::StreamReadSocketErrored> for StreamReadSocketErrored {
#[inline]
fn into_event(self) -> api::StreamReadSocketErrored {
let StreamReadSocketErrored { capacity, errno } = self;
api::StreamReadSocketErrored {
capacity: capacity.into_event(),
errno: errno.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamDecryptPacket {
pub decrypted_in_place: bool,
pub forced_copy: usize,
pub required_application_buffer: usize,
}
impl IntoEvent<api::StreamDecryptPacket> for StreamDecryptPacket {
#[inline]
fn into_event(self) -> api::StreamDecryptPacket {
let StreamDecryptPacket {
decrypted_in_place,
forced_copy,
required_application_buffer,
} = self;
api::StreamDecryptPacket {
decrypted_in_place: decrypted_in_place.into_event(),
forced_copy: forced_copy.into_event(),
required_application_buffer: required_application_buffer.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamTcpConnect {
pub error: bool,
pub latency: core::time::Duration,
}
impl IntoEvent<api::StreamTcpConnect> for StreamTcpConnect {
#[inline]
fn into_event(self) -> api::StreamTcpConnect {
let StreamTcpConnect { error, latency } = self;
api::StreamTcpConnect {
error: error.into_event(),
latency: latency.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamTlsConnect<'a> {
pub error: bool,
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub tcp_latency: core::time::Duration,
pub tls_latency: core::time::Duration,
}
impl<'a> IntoEvent<api::StreamTlsConnect<'a>> for StreamTlsConnect<'a> {
#[inline]
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)]
pub struct StreamTlsConnectError<'a> {
pub remote_address: &'a s2n_quic_core::inet::SocketAddress,
pub error: &'a std::io::Error,
}
impl<'a> IntoEvent<api::StreamTlsConnectError<'a>> 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)]
pub struct StreamConnect {
pub error: bool,
pub tcp_success: MaybeBoolCounter,
pub handshake_success: MaybeBoolCounter,
}
impl IntoEvent<api::StreamConnect> for StreamConnect {
#[inline]
fn into_event(self) -> api::StreamConnect {
let StreamConnect {
error,
tcp_success,
handshake_success,
} = self;
api::StreamConnect {
error: error.into_event(),
tcp_success: tcp_success.into_event(),
handshake_success: handshake_success.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamConnectError {
pub reason: StreamTcpConnectErrorReason,
pub latency: core::time::Duration,
}
impl IntoEvent<api::StreamConnectError> for StreamConnectError {
#[inline]
fn into_event(self) -> api::StreamConnectError {
let StreamConnectError { reason, latency } = self;
api::StreamConnectError {
reason: reason.into_event(),
latency: latency.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamPacketTransmitted {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub is_fin: bool,
pub is_retransmission: bool,
}
impl IntoEvent<api::StreamPacketTransmitted> for StreamPacketTransmitted {
#[inline]
fn into_event(self) -> api::StreamPacketTransmitted {
let StreamPacketTransmitted {
packet_len,
payload_len,
packet_number,
stream_offset,
is_fin,
is_retransmission,
} = self;
api::StreamPacketTransmitted {
packet_len: packet_len.into_event(),
payload_len: payload_len.into_event(),
packet_number: packet_number.into_event(),
stream_offset: stream_offset.into_event(),
is_fin: is_fin.into_event(),
is_retransmission: is_retransmission.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamProbeTransmitted {
pub packet_len: usize,
pub packet_number: u64,
}
impl IntoEvent<api::StreamProbeTransmitted> for StreamProbeTransmitted {
#[inline]
fn into_event(self) -> api::StreamProbeTransmitted {
let StreamProbeTransmitted {
packet_len,
packet_number,
} = self;
api::StreamProbeTransmitted {
packet_len: packet_len.into_event(),
packet_number: packet_number.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamPacketReceived {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub is_fin: bool,
pub is_retransmission: bool,
}
impl IntoEvent<api::StreamPacketReceived> for StreamPacketReceived {
#[inline]
fn into_event(self) -> api::StreamPacketReceived {
let StreamPacketReceived {
packet_len,
payload_len,
packet_number,
stream_offset,
is_fin,
is_retransmission,
} = self;
api::StreamPacketReceived {
packet_len: packet_len.into_event(),
payload_len: payload_len.into_event(),
packet_number: packet_number.into_event(),
stream_offset: stream_offset.into_event(),
is_fin: is_fin.into_event(),
is_retransmission: is_retransmission.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamPacketLost {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub time_sent: Timestamp,
pub lifetime: core::time::Duration,
pub is_retransmission: bool,
}
impl IntoEvent<api::StreamPacketLost> for StreamPacketLost {
#[inline]
fn into_event(self) -> api::StreamPacketLost {
let StreamPacketLost {
packet_len,
payload_len,
packet_number,
stream_offset,
time_sent,
lifetime,
is_retransmission,
} = self;
api::StreamPacketLost {
packet_len: packet_len.into_event(),
payload_len: payload_len.into_event(),
packet_number: packet_number.into_event(),
stream_offset: stream_offset.into_event(),
time_sent: time_sent.into_event(),
lifetime: lifetime.into_event(),
is_retransmission: is_retransmission.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamPacketAcked {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub time_sent: Timestamp,
pub lifetime: core::time::Duration,
pub is_retransmission: bool,
}
impl IntoEvent<api::StreamPacketAcked> for StreamPacketAcked {
#[inline]
fn into_event(self) -> api::StreamPacketAcked {
let StreamPacketAcked {
packet_len,
payload_len,
packet_number,
stream_offset,
time_sent,
lifetime,
is_retransmission,
} = self;
api::StreamPacketAcked {
packet_len: packet_len.into_event(),
payload_len: payload_len.into_event(),
packet_number: packet_number.into_event(),
stream_offset: stream_offset.into_event(),
time_sent: time_sent.into_event(),
lifetime: lifetime.into_event(),
is_retransmission: is_retransmission.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamPacketSpuriouslyRetransmitted {
pub packet_len: usize,
pub payload_len: usize,
pub packet_number: u64,
pub stream_offset: u64,
pub is_fin: bool,
pub is_retransmission: bool,
}
impl IntoEvent<api::StreamPacketSpuriouslyRetransmitted> for StreamPacketSpuriouslyRetransmitted {
#[inline]
fn into_event(self) -> api::StreamPacketSpuriouslyRetransmitted {
let StreamPacketSpuriouslyRetransmitted {
packet_len,
payload_len,
packet_number,
stream_offset,
is_fin,
is_retransmission,
} = self;
api::StreamPacketSpuriouslyRetransmitted {
packet_len: packet_len.into_event(),
payload_len: payload_len.into_event(),
packet_number: packet_number.into_event(),
stream_offset: stream_offset.into_event(),
is_fin: is_fin.into_event(),
is_retransmission: is_retransmission.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamMaxDataReceived {
pub increase: u64,
pub new_max_data: u64,
}
impl IntoEvent<api::StreamMaxDataReceived> for StreamMaxDataReceived {
#[inline]
fn into_event(self) -> api::StreamMaxDataReceived {
let StreamMaxDataReceived {
increase,
new_max_data,
} = self;
api::StreamMaxDataReceived {
increase: increase.into_event(),
new_max_data: new_max_data.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamControlPacketTransmitted {
pub packet_len: usize,
pub control_data_len: usize,
pub packet_number: u64,
}
impl IntoEvent<api::StreamControlPacketTransmitted> for StreamControlPacketTransmitted {
#[inline]
fn into_event(self) -> api::StreamControlPacketTransmitted {
let StreamControlPacketTransmitted {
packet_len,
control_data_len,
packet_number,
} = self;
api::StreamControlPacketTransmitted {
packet_len: packet_len.into_event(),
control_data_len: control_data_len.into_event(),
packet_number: packet_number.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamControlPacketReceived {
pub packet_len: usize,
pub control_data_len: usize,
pub packet_number: u64,
pub is_authenticated: bool,
}
impl IntoEvent<api::StreamControlPacketReceived> for StreamControlPacketReceived {
#[inline]
fn into_event(self) -> api::StreamControlPacketReceived {
let StreamControlPacketReceived {
packet_len,
control_data_len,
packet_number,
is_authenticated,
} = self;
api::StreamControlPacketReceived {
packet_len: packet_len.into_event(),
control_data_len: control_data_len.into_event(),
packet_number: packet_number.into_event(),
is_authenticated: is_authenticated.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamReceiverErrored {
pub error: crate::stream::recv::Error,
pub source: s2n_quic_core::endpoint::Location,
}
impl IntoEvent<api::StreamReceiverErrored> for StreamReceiverErrored {
#[inline]
fn into_event(self) -> api::StreamReceiverErrored {
let StreamReceiverErrored { error, source } = self;
api::StreamReceiverErrored {
error: error.into_event(),
source: source.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamSenderErrored {
pub error: crate::stream::send::Error,
pub source: s2n_quic_core::endpoint::Location,
}
impl IntoEvent<api::StreamSenderErrored> for StreamSenderErrored {
#[inline]
fn into_event(self) -> api::StreamSenderErrored {
let StreamSenderErrored { error, source } = self;
api::StreamSenderErrored {
error: error.into_event(),
source: source.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StreamHandshakePacketRejected {
pub reason: StreamHandshakePacketRejectedReason,
}
impl IntoEvent<api::StreamHandshakePacketRejected> for StreamHandshakePacketRejected {
#[inline]
fn into_event(self) -> api::StreamHandshakePacketRejected {
let StreamHandshakePacketRejected { reason } = self;
api::StreamHandshakePacketRejected {
reason: reason.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ConnectionClosed {}
impl IntoEvent<api::ConnectionClosed> for ConnectionClosed {
#[inline]
fn into_event(self) -> api::ConnectionClosed {
let ConnectionClosed {} = self;
api::ConnectionClosed {}
}
}
#[derive(Clone, Debug)]
pub enum MaybeBoolCounter {
Success,
Failure,
Aborted,
}
impl IntoEvent<api::MaybeBoolCounter> for MaybeBoolCounter {
#[inline]
fn into_event(self) -> api::MaybeBoolCounter {
use api::MaybeBoolCounter::*;
match self {
Self::Success => Success {},
Self::Failure => Failure {},
Self::Aborted => Aborted {},
}
}
}
#[derive(Clone, Debug)]
pub enum StreamTcpConnectErrorReason {
TcpConnect,
Handshake,
AbortedPendingHandshake,
AbortedPendingConnect,
AbortedPendingBoth,
}
impl IntoEvent<api::StreamTcpConnectErrorReason> for StreamTcpConnectErrorReason {
#[inline]
fn into_event(self) -> api::StreamTcpConnectErrorReason {
use api::StreamTcpConnectErrorReason::*;
match self {
Self::TcpConnect => TcpConnect {},
Self::Handshake => Handshake {},
Self::AbortedPendingHandshake => AbortedPendingHandshake {},
Self::AbortedPendingConnect => AbortedPendingConnect {},
Self::AbortedPendingBoth => AbortedPendingBoth {},
}
}
}
#[derive(Clone, Debug)]
pub enum StreamHandshakePacketRejectedReason {
InvalidQueueId,
}
impl IntoEvent<api::StreamHandshakePacketRejectedReason> for StreamHandshakePacketRejectedReason {
#[inline]
fn into_event(self) -> api::StreamHandshakePacketRejectedReason {
use api::StreamHandshakePacketRejectedReason::*;
match self {
Self::InvalidQueueId => InvalidQueueId {},
}
}
}
#[derive(Clone, Debug)]
pub struct EndpointInitialized<'a> {
pub acceptor_addr: SocketAddress<'a>,
pub handshake_addr: SocketAddress<'a>,
pub tcp: bool,
pub udp: bool,
}
impl<'a> IntoEvent<api::EndpointInitialized<'a>> for EndpointInitialized<'a> {
#[inline]
fn into_event(self) -> api::EndpointInitialized<'a> {
let EndpointInitialized {
acceptor_addr,
handshake_addr,
tcp,
udp,
} = self;
api::EndpointInitialized {
acceptor_addr: acceptor_addr.into_event(),
handshake_addr: handshake_addr.into_event(),
tcp: tcp.into_event(),
udp: udp.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct DcConnectionTimeout<'a> {
pub peer_address: SocketAddress<'a>,
}
impl<'a> IntoEvent<api::DcConnectionTimeout<'a>> for DcConnectionTimeout<'a> {
#[inline]
fn into_event(self) -> api::DcConnectionTimeout<'a> {
let DcConnectionTimeout { peer_address } = self;
api::DcConnectionTimeout {
peer_address: peer_address.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapInitialized {
pub capacity: usize,
}
impl IntoEvent<api::PathSecretMapInitialized> for PathSecretMapInitialized {
#[inline]
fn into_event(self) -> api::PathSecretMapInitialized {
let PathSecretMapInitialized { capacity } = self;
api::PathSecretMapInitialized {
capacity: capacity.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapUninitialized {
pub capacity: usize,
pub entries: usize,
pub lifetime: core::time::Duration,
}
impl IntoEvent<api::PathSecretMapUninitialized> for PathSecretMapUninitialized {
#[inline]
fn into_event(self) -> api::PathSecretMapUninitialized {
let PathSecretMapUninitialized {
capacity,
entries,
lifetime,
} = self;
api::PathSecretMapUninitialized {
capacity: capacity.into_event(),
entries: entries.into_event(),
lifetime: lifetime.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapBackgroundHandshakeRequested<'a> {
pub peer_address: SocketAddress<'a>,
}
impl<'a> IntoEvent<api::PathSecretMapBackgroundHandshakeRequested<'a>>
for PathSecretMapBackgroundHandshakeRequested<'a>
{
#[inline]
fn into_event(self) -> api::PathSecretMapBackgroundHandshakeRequested<'a> {
let PathSecretMapBackgroundHandshakeRequested { peer_address } = self;
api::PathSecretMapBackgroundHandshakeRequested {
peer_address: peer_address.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapEntryInserted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::PathSecretMapEntryInserted<'a>> for PathSecretMapEntryInserted<'a> {
#[inline]
fn into_event(self) -> api::PathSecretMapEntryInserted<'a> {
let PathSecretMapEntryInserted {
peer_address,
credential_id,
} = self;
api::PathSecretMapEntryInserted {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapEntryReady<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::PathSecretMapEntryReady<'a>> for PathSecretMapEntryReady<'a> {
#[inline]
fn into_event(self) -> api::PathSecretMapEntryReady<'a> {
let PathSecretMapEntryReady {
peer_address,
credential_id,
} = self;
api::PathSecretMapEntryReady {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapEntryReplaced<'a> {
pub peer_address: SocketAddress<'a>,
pub new_credential_id: &'a [u8],
pub previous_credential_id: &'a [u8],
pub replaced_age: core::time::Duration,
}
impl<'a> IntoEvent<api::PathSecretMapEntryReplaced<'a>> for PathSecretMapEntryReplaced<'a> {
#[inline]
fn into_event(self) -> api::PathSecretMapEntryReplaced<'a> {
let PathSecretMapEntryReplaced {
peer_address,
new_credential_id,
previous_credential_id,
replaced_age,
} = self;
api::PathSecretMapEntryReplaced {
peer_address: peer_address.into_event(),
new_credential_id: new_credential_id.into_event(),
previous_credential_id: previous_credential_id.into_event(),
replaced_age: replaced_age.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapIdEntryEvicted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub age: core::time::Duration,
pub time_since_last_accessed: core::time::Duration,
pub reason: EvictionReason,
}
impl<'a> IntoEvent<api::PathSecretMapIdEntryEvicted<'a>> for PathSecretMapIdEntryEvicted<'a> {
#[inline]
fn into_event(self) -> api::PathSecretMapIdEntryEvicted<'a> {
let PathSecretMapIdEntryEvicted {
peer_address,
credential_id,
age,
time_since_last_accessed,
reason,
} = self;
api::PathSecretMapIdEntryEvicted {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
age: age.into_event(),
time_since_last_accessed: time_since_last_accessed.into_event(),
reason: reason.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapAddressEntryEvicted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub age: core::time::Duration,
pub time_since_last_accessed: core::time::Duration,
pub reason: EvictionReason,
}
impl<'a> IntoEvent<api::PathSecretMapAddressEntryEvicted<'a>>
for PathSecretMapAddressEntryEvicted<'a>
{
#[inline]
fn into_event(self) -> api::PathSecretMapAddressEntryEvicted<'a> {
let PathSecretMapAddressEntryEvicted {
peer_address,
credential_id,
age,
time_since_last_accessed,
reason,
} = self;
api::PathSecretMapAddressEntryEvicted {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
age: age.into_event(),
time_since_last_accessed: time_since_last_accessed.into_event(),
reason: reason.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct UnknownPathSecretPacketSent<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::UnknownPathSecretPacketSent<'a>> for UnknownPathSecretPacketSent<'a> {
#[inline]
fn into_event(self) -> api::UnknownPathSecretPacketSent<'a> {
let UnknownPathSecretPacketSent {
peer_address,
credential_id,
} = self;
api::UnknownPathSecretPacketSent {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct UnknownPathSecretPacketReceived<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::UnknownPathSecretPacketReceived<'a>>
for UnknownPathSecretPacketReceived<'a>
{
#[inline]
fn into_event(self) -> api::UnknownPathSecretPacketReceived<'a> {
let UnknownPathSecretPacketReceived {
peer_address,
credential_id,
} = self;
api::UnknownPathSecretPacketReceived {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct UnknownPathSecretPacketAccepted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub age: core::time::Duration,
pub evicted: bool,
pub scheduled_handshake: bool,
}
impl<'a> IntoEvent<api::UnknownPathSecretPacketAccepted<'a>>
for UnknownPathSecretPacketAccepted<'a>
{
#[inline]
fn into_event(self) -> api::UnknownPathSecretPacketAccepted<'a> {
let UnknownPathSecretPacketAccepted {
peer_address,
credential_id,
age,
evicted,
scheduled_handshake,
} = self;
api::UnknownPathSecretPacketAccepted {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
age: age.into_event(),
evicted: evicted.into_event(),
scheduled_handshake: scheduled_handshake.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct UnknownPathSecretPacketRejected<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::UnknownPathSecretPacketRejected<'a>>
for UnknownPathSecretPacketRejected<'a>
{
#[inline]
fn into_event(self) -> api::UnknownPathSecretPacketRejected<'a> {
let UnknownPathSecretPacketRejected {
peer_address,
credential_id,
} = self;
api::UnknownPathSecretPacketRejected {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct UnknownPathSecretPacketDropped<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::UnknownPathSecretPacketDropped<'a>> for UnknownPathSecretPacketDropped<'a> {
#[inline]
fn into_event(self) -> api::UnknownPathSecretPacketDropped<'a> {
let UnknownPathSecretPacketDropped {
peer_address,
credential_id,
} = self;
api::UnknownPathSecretPacketDropped {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct KeyAccepted<'a> {
pub credential_id: &'a [u8],
pub key_id: u64,
pub gap: u64,
pub forward_shift: u64,
}
impl<'a> IntoEvent<api::KeyAccepted<'a>> for KeyAccepted<'a> {
#[inline]
fn into_event(self) -> api::KeyAccepted<'a> {
let KeyAccepted {
credential_id,
key_id,
gap,
forward_shift,
} = self;
api::KeyAccepted {
credential_id: credential_id.into_event(),
key_id: key_id.into_event(),
gap: gap.into_event(),
forward_shift: forward_shift.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ReplayDefinitelyDetected<'a> {
pub credential_id: &'a [u8],
pub key_id: u64,
}
impl<'a> IntoEvent<api::ReplayDefinitelyDetected<'a>> for ReplayDefinitelyDetected<'a> {
#[inline]
fn into_event(self) -> api::ReplayDefinitelyDetected<'a> {
let ReplayDefinitelyDetected {
credential_id,
key_id,
} = self;
api::ReplayDefinitelyDetected {
credential_id: credential_id.into_event(),
key_id: key_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ReplayPotentiallyDetected<'a> {
pub credential_id: &'a [u8],
pub key_id: u64,
pub gap: u64,
}
impl<'a> IntoEvent<api::ReplayPotentiallyDetected<'a>> for ReplayPotentiallyDetected<'a> {
#[inline]
fn into_event(self) -> api::ReplayPotentiallyDetected<'a> {
let ReplayPotentiallyDetected {
credential_id,
key_id,
gap,
} = self;
api::ReplayPotentiallyDetected {
credential_id: credential_id.into_event(),
key_id: key_id.into_event(),
gap: gap.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ReplayDetectedPacketSent<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::ReplayDetectedPacketSent<'a>> for ReplayDetectedPacketSent<'a> {
#[inline]
fn into_event(self) -> api::ReplayDetectedPacketSent<'a> {
let ReplayDetectedPacketSent {
peer_address,
credential_id,
} = self;
api::ReplayDetectedPacketSent {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ReplayDetectedPacketReceived<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::ReplayDetectedPacketReceived<'a>> for ReplayDetectedPacketReceived<'a> {
#[inline]
fn into_event(self) -> api::ReplayDetectedPacketReceived<'a> {
let ReplayDetectedPacketReceived {
peer_address,
credential_id,
} = self;
api::ReplayDetectedPacketReceived {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ReplayDetectedPacketAccepted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
pub key_id: u64,
}
impl<'a> IntoEvent<api::ReplayDetectedPacketAccepted<'a>> for ReplayDetectedPacketAccepted<'a> {
#[inline]
fn into_event(self) -> api::ReplayDetectedPacketAccepted<'a> {
let ReplayDetectedPacketAccepted {
peer_address,
credential_id,
key_id,
} = self;
api::ReplayDetectedPacketAccepted {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
key_id: key_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ReplayDetectedPacketRejected<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::ReplayDetectedPacketRejected<'a>> for ReplayDetectedPacketRejected<'a> {
#[inline]
fn into_event(self) -> api::ReplayDetectedPacketRejected<'a> {
let ReplayDetectedPacketRejected {
peer_address,
credential_id,
} = self;
api::ReplayDetectedPacketRejected {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct ReplayDetectedPacketDropped<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::ReplayDetectedPacketDropped<'a>> for ReplayDetectedPacketDropped<'a> {
#[inline]
fn into_event(self) -> api::ReplayDetectedPacketDropped<'a> {
let ReplayDetectedPacketDropped {
peer_address,
credential_id,
} = self;
api::ReplayDetectedPacketDropped {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StaleKeyPacketSent<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::StaleKeyPacketSent<'a>> for StaleKeyPacketSent<'a> {
#[inline]
fn into_event(self) -> api::StaleKeyPacketSent<'a> {
let StaleKeyPacketSent {
peer_address,
credential_id,
} = self;
api::StaleKeyPacketSent {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StaleKeyPacketReceived<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::StaleKeyPacketReceived<'a>> for StaleKeyPacketReceived<'a> {
#[inline]
fn into_event(self) -> api::StaleKeyPacketReceived<'a> {
let StaleKeyPacketReceived {
peer_address,
credential_id,
} = self;
api::StaleKeyPacketReceived {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StaleKeyPacketAccepted<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::StaleKeyPacketAccepted<'a>> for StaleKeyPacketAccepted<'a> {
#[inline]
fn into_event(self) -> api::StaleKeyPacketAccepted<'a> {
let StaleKeyPacketAccepted {
peer_address,
credential_id,
} = self;
api::StaleKeyPacketAccepted {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StaleKeyPacketRejected<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::StaleKeyPacketRejected<'a>> for StaleKeyPacketRejected<'a> {
#[inline]
fn into_event(self) -> api::StaleKeyPacketRejected<'a> {
let StaleKeyPacketRejected {
peer_address,
credential_id,
} = self;
api::StaleKeyPacketRejected {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct StaleKeyPacketDropped<'a> {
pub peer_address: SocketAddress<'a>,
pub credential_id: &'a [u8],
}
impl<'a> IntoEvent<api::StaleKeyPacketDropped<'a>> for StaleKeyPacketDropped<'a> {
#[inline]
fn into_event(self) -> api::StaleKeyPacketDropped<'a> {
let StaleKeyPacketDropped {
peer_address,
credential_id,
} = self;
api::StaleKeyPacketDropped {
peer_address: peer_address.into_event(),
credential_id: credential_id.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapAddressCacheAccessed<'a> {
pub peer_address: SocketAddress<'a>,
pub hit: bool,
}
impl<'a> IntoEvent<api::PathSecretMapAddressCacheAccessed<'a>>
for PathSecretMapAddressCacheAccessed<'a>
{
#[inline]
fn into_event(self) -> api::PathSecretMapAddressCacheAccessed<'a> {
let PathSecretMapAddressCacheAccessed { peer_address, hit } = self;
api::PathSecretMapAddressCacheAccessed {
peer_address: peer_address.into_event(),
hit: hit.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapAddressCacheAccessedHit<'a> {
pub peer_address: SocketAddress<'a>,
pub age: core::time::Duration,
}
impl<'a> IntoEvent<api::PathSecretMapAddressCacheAccessedHit<'a>>
for PathSecretMapAddressCacheAccessedHit<'a>
{
#[inline]
fn into_event(self) -> api::PathSecretMapAddressCacheAccessedHit<'a> {
let PathSecretMapAddressCacheAccessedHit { peer_address, age } = self;
api::PathSecretMapAddressCacheAccessedHit {
peer_address: peer_address.into_event(),
age: age.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapIdCacheAccessed<'a> {
pub credential_id: &'a [u8],
pub hit: bool,
}
impl<'a> IntoEvent<api::PathSecretMapIdCacheAccessed<'a>> for PathSecretMapIdCacheAccessed<'a> {
#[inline]
fn into_event(self) -> api::PathSecretMapIdCacheAccessed<'a> {
let PathSecretMapIdCacheAccessed { credential_id, hit } = self;
api::PathSecretMapIdCacheAccessed {
credential_id: credential_id.into_event(),
hit: hit.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapIdCacheAccessedHit<'a> {
pub credential_id: &'a [u8],
pub age: core::time::Duration,
}
impl<'a> IntoEvent<api::PathSecretMapIdCacheAccessedHit<'a>>
for PathSecretMapIdCacheAccessedHit<'a>
{
#[inline]
fn into_event(self) -> api::PathSecretMapIdCacheAccessedHit<'a> {
let PathSecretMapIdCacheAccessedHit { credential_id, age } = self;
api::PathSecretMapIdCacheAccessedHit {
credential_id: credential_id.into_event(),
age: age.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapCleanerCycled {
pub id_entries: usize,
pub id_entries_retired: usize,
pub id_entries_active: usize,
pub id_entries_active_utilization: f32,
pub id_entries_utilization: f32,
pub id_entries_initial_utilization: f32,
pub address_entries: usize,
pub address_entries_active: usize,
pub address_entries_active_utilization: f32,
pub address_entries_retired: usize,
pub address_entries_utilization: f32,
pub address_entries_initial_utilization: f32,
pub id_entries_in_last_hs_period: usize,
pub id_entries_in_last_hs_period_utilization: f32,
pub handshake_requests: usize,
pub handshake_requests_skipped: usize,
pub handshake_lock_duration: core::time::Duration,
pub duration: core::time::Duration,
}
impl IntoEvent<api::PathSecretMapCleanerCycled> for PathSecretMapCleanerCycled {
#[inline]
fn into_event(self) -> api::PathSecretMapCleanerCycled {
let PathSecretMapCleanerCycled {
id_entries,
id_entries_retired,
id_entries_active,
id_entries_active_utilization,
id_entries_utilization,
id_entries_initial_utilization,
address_entries,
address_entries_active,
address_entries_active_utilization,
address_entries_retired,
address_entries_utilization,
address_entries_initial_utilization,
id_entries_in_last_hs_period,
id_entries_in_last_hs_period_utilization,
handshake_requests,
handshake_requests_skipped,
handshake_lock_duration,
duration,
} = self;
api::PathSecretMapCleanerCycled {
id_entries: id_entries.into_event(),
id_entries_retired: id_entries_retired.into_event(),
id_entries_active: id_entries_active.into_event(),
id_entries_active_utilization: id_entries_active_utilization.into_event(),
id_entries_utilization: id_entries_utilization.into_event(),
id_entries_initial_utilization: id_entries_initial_utilization.into_event(),
address_entries: address_entries.into_event(),
address_entries_active: address_entries_active.into_event(),
address_entries_active_utilization: address_entries_active_utilization.into_event(),
address_entries_retired: address_entries_retired.into_event(),
address_entries_utilization: address_entries_utilization.into_event(),
address_entries_initial_utilization: address_entries_initial_utilization
.into_event(),
id_entries_in_last_hs_period: id_entries_in_last_hs_period.into_event(),
id_entries_in_last_hs_period_utilization: id_entries_in_last_hs_period_utilization
.into_event(),
handshake_requests: handshake_requests.into_event(),
handshake_requests_skipped: handshake_requests_skipped.into_event(),
handshake_lock_duration: handshake_lock_duration.into_event(),
duration: duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapSerialized {
pub entries: usize,
pub file_size: usize,
pub duration: core::time::Duration,
pub error: bool,
}
impl IntoEvent<api::PathSecretMapSerialized> for PathSecretMapSerialized {
#[inline]
fn into_event(self) -> api::PathSecretMapSerialized {
let PathSecretMapSerialized {
entries,
file_size,
duration,
error,
} = self;
api::PathSecretMapSerialized {
entries: entries.into_event(),
file_size: file_size.into_event(),
duration: duration.into_event(),
error: error.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapIdWriteLock {
pub acquire: core::time::Duration,
pub duration: core::time::Duration,
}
impl IntoEvent<api::PathSecretMapIdWriteLock> for PathSecretMapIdWriteLock {
#[inline]
fn into_event(self) -> api::PathSecretMapIdWriteLock {
let PathSecretMapIdWriteLock { acquire, duration } = self;
api::PathSecretMapIdWriteLock {
acquire: acquire.into_event(),
duration: duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapAddressWriteLock {
pub acquire: core::time::Duration,
pub duration: core::time::Duration,
}
impl IntoEvent<api::PathSecretMapAddressWriteLock> for PathSecretMapAddressWriteLock {
#[inline]
fn into_event(self) -> api::PathSecretMapAddressWriteLock {
let PathSecretMapAddressWriteLock { acquire, duration } = self;
api::PathSecretMapAddressWriteLock {
acquire: acquire.into_event(),
duration: duration.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapDatagramEncrypt {
pub packet_len: usize,
}
impl IntoEvent<api::PathSecretMapDatagramEncrypt> for PathSecretMapDatagramEncrypt {
#[inline]
fn into_event(self) -> api::PathSecretMapDatagramEncrypt {
let PathSecretMapDatagramEncrypt { packet_len } = self;
api::PathSecretMapDatagramEncrypt {
packet_len: packet_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub struct PathSecretMapDatagramDecrypt {
pub packet_len: usize,
}
impl IntoEvent<api::PathSecretMapDatagramDecrypt> for PathSecretMapDatagramDecrypt {
#[inline]
fn into_event(self) -> api::PathSecretMapDatagramDecrypt {
let PathSecretMapDatagramDecrypt { packet_len } = self;
api::PathSecretMapDatagramDecrypt {
packet_len: packet_len.into_event(),
}
}
}
#[derive(Clone, Debug)]
pub enum EvictionReason {
Capacity,
UnknownPathSecret,
Retiring,
}
impl IntoEvent<api::EvictionReason> for EvictionReason {
#[inline]
fn into_event(self) -> api::EvictionReason {
use api::EvictionReason::*;
match self {
Self::Capacity => Capacity {},
Self::UnknownPathSecret => UnknownPathSecret {},
Self::Retiring => Retiring {},
}
}
}
}
pub use traits::*;
mod traits {
use super::*;
use crate::event::Meta;
use core::fmt;
use s2n_quic_core::query;
pub trait Subscriber: 'static + Send + Sync {
type ConnectionContext: 'static + Send + Sync;
fn create_connection_context(
&self,
meta: &api::ConnectionMeta,
info: &api::ConnectionInfo,
) -> Self::ConnectionContext;
#[inline]
fn on_acceptor_tcp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStarted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_loop_iteration_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpLoopIterationCompleted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_fresh_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshEnqueued,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_fresh_batch_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshBatchCompleted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_stream_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamDropped,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_stream_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamReplaced,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketReceived,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_tls_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStarted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamEnqueued,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamRejected,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSyntheticTlsStreamRejected,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketDropped,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamEnqueued,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpIoError,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_socket_sent(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketSent,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_tcp_socket_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketReceived,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_udp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStarted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_udp_datagram_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpDatagramReceived,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_udp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketReceived,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_udp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketDropped,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_udp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStreamEnqueued,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_udp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpIoError,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_stream_pruned(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamPruned,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_acceptor_stream_dequeued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamDequeued,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFlushed,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_fin_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFinFlushed,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteBlocked,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteErrored,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_key_updated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteKeyUpdated,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_allocated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteAllocated,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_shutdown(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteShutdown,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_socket_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketFlushed,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_socket_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketBlocked,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_write_socket_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketErrored,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFlushed,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_fin_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFinFlushed,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadBlocked,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadErrored,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_key_updated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadKeyUpdated,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_shutdown(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadShutdown,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_socket_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketFlushed,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_socket_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketBlocked,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_read_socket_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketErrored,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_decrypt_packet(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamDecryptPacket,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_tcp_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTcpConnect) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_tls_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTlsConnect) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_tls_connect_error(
&self,
meta: &api::EndpointMeta,
event: &api::StreamTlsConnectError,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_connect(&self, meta: &api::EndpointMeta, event: &api::StreamConnect) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_connect_error(
&self,
meta: &api::EndpointMeta,
event: &api::StreamConnectError,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_packet_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketTransmitted,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_probe_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamProbeTransmitted,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_packet_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketReceived,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_packet_lost(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketLost,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_packet_acked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketAcked,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_packet_spuriously_retransmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketSpuriouslyRetransmitted,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_max_data_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamMaxDataReceived,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_control_packet_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketTransmitted,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_control_packet_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketReceived,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_receiver_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReceiverErrored,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_sender_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamSenderErrored,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_stream_handshake_packet_rejected(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamHandshakePacketRejected,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_connection_closed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionClosed,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn on_endpoint_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::EndpointInitialized,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_dc_connection_timeout(
&self,
meta: &api::EndpointMeta,
event: &api::DcConnectionTimeout,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapInitialized,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_uninitialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapUninitialized,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_background_handshake_requested(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapBackgroundHandshakeRequested,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_entry_inserted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryInserted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_entry_ready(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReady,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_entry_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReplaced,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_id_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdEntryEvicted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_address_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressEntryEvicted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_unknown_path_secret_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketSent,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_unknown_path_secret_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketReceived,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_unknown_path_secret_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketAccepted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_unknown_path_secret_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketRejected,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_unknown_path_secret_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketDropped,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_key_accepted(&self, meta: &api::EndpointMeta, event: &api::KeyAccepted) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_replay_definitely_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDefinitelyDetected,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_replay_potentially_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayPotentiallyDetected,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_replay_detected_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketSent,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_replay_detected_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketReceived,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_replay_detected_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketAccepted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_replay_detected_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketRejected,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_replay_detected_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketDropped,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stale_key_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketSent,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stale_key_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketReceived,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stale_key_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketAccepted,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stale_key_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketRejected,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_stale_key_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketDropped,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_address_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessed,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_address_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessedHit,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_id_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessed,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_id_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessedHit,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_cleaner_cycled(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapCleanerCycled,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_serialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapSerialized,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_id_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdWriteLock,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_address_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressWriteLock,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_datagram_encrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramEncrypt,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_path_secret_map_datagram_decrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramDecrypt,
) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_event<M: Meta, E: Event>(&self, meta: &M, event: &E) {
let _ = meta;
let _ = event;
}
#[inline]
fn on_connection_event<E: Event>(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &E,
) {
let _ = context;
let _ = meta;
let _ = event;
}
#[inline]
fn query(
context: &Self::ConnectionContext,
query: &mut dyn query::Query,
) -> query::ControlFlow {
query.execute(context)
}
}
impl<T: Subscriber> Subscriber for std::sync::Arc<T> {
type ConnectionContext = T::ConnectionContext;
#[inline]
fn create_connection_context(
&self,
meta: &api::ConnectionMeta,
info: &api::ConnectionInfo,
) -> Self::ConnectionContext {
self.as_ref().create_connection_context(meta, info)
}
#[inline]
fn on_acceptor_tcp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStarted,
) {
self.as_ref().on_acceptor_tcp_started(meta, event);
}
#[inline]
fn on_acceptor_tcp_loop_iteration_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpLoopIterationCompleted,
) {
self.as_ref()
.on_acceptor_tcp_loop_iteration_completed(meta, event);
}
#[inline]
fn on_acceptor_tcp_fresh_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshEnqueued,
) {
self.as_ref().on_acceptor_tcp_fresh_enqueued(meta, event);
}
#[inline]
fn on_acceptor_tcp_fresh_batch_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshBatchCompleted,
) {
self.as_ref()
.on_acceptor_tcp_fresh_batch_completed(meta, event);
}
#[inline]
fn on_acceptor_tcp_stream_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamDropped,
) {
self.as_ref().on_acceptor_tcp_stream_dropped(meta, event);
}
#[inline]
fn on_acceptor_tcp_stream_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamReplaced,
) {
self.as_ref().on_acceptor_tcp_stream_replaced(meta, event);
}
#[inline]
fn on_acceptor_tcp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketReceived,
) {
self.as_ref().on_acceptor_tcp_packet_received(meta, event);
}
#[inline]
fn on_acceptor_tcp_tls_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStarted,
) {
self.as_ref().on_acceptor_tcp_tls_started(meta, event);
}
#[inline]
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamEnqueued,
) {
self.as_ref()
.on_acceptor_tcp_tls_stream_enqueued(meta, event);
}
#[inline]
fn on_acceptor_tcp_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamRejected,
) {
self.as_ref()
.on_acceptor_tcp_tls_stream_rejected(meta, event);
}
#[inline]
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSyntheticTlsStreamRejected,
) {
self.as_ref()
.on_acceptor_tcp_synthetic_tls_stream_rejected(meta, event);
}
#[inline]
fn on_acceptor_tcp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketDropped,
) {
self.as_ref().on_acceptor_tcp_packet_dropped(meta, event);
}
#[inline]
fn on_acceptor_tcp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamEnqueued,
) {
self.as_ref().on_acceptor_tcp_stream_enqueued(meta, event);
}
#[inline]
fn on_acceptor_tcp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpIoError,
) {
self.as_ref().on_acceptor_tcp_io_error(meta, event);
}
#[inline]
fn on_acceptor_tcp_socket_sent(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketSent,
) {
self.as_ref().on_acceptor_tcp_socket_sent(meta, event);
}
#[inline]
fn on_acceptor_tcp_socket_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketReceived,
) {
self.as_ref().on_acceptor_tcp_socket_received(meta, event);
}
#[inline]
fn on_acceptor_udp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStarted,
) {
self.as_ref().on_acceptor_udp_started(meta, event);
}
#[inline]
fn on_acceptor_udp_datagram_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpDatagramReceived,
) {
self.as_ref().on_acceptor_udp_datagram_received(meta, event);
}
#[inline]
fn on_acceptor_udp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketReceived,
) {
self.as_ref().on_acceptor_udp_packet_received(meta, event);
}
#[inline]
fn on_acceptor_udp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketDropped,
) {
self.as_ref().on_acceptor_udp_packet_dropped(meta, event);
}
#[inline]
fn on_acceptor_udp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStreamEnqueued,
) {
self.as_ref().on_acceptor_udp_stream_enqueued(meta, event);
}
#[inline]
fn on_acceptor_udp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpIoError,
) {
self.as_ref().on_acceptor_udp_io_error(meta, event);
}
#[inline]
fn on_acceptor_stream_pruned(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamPruned,
) {
self.as_ref().on_acceptor_stream_pruned(meta, event);
}
#[inline]
fn on_acceptor_stream_dequeued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamDequeued,
) {
self.as_ref().on_acceptor_stream_dequeued(meta, event);
}
#[inline]
fn on_stream_write_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFlushed,
) {
self.as_ref().on_stream_write_flushed(context, meta, event);
}
#[inline]
fn on_stream_write_fin_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFinFlushed,
) {
self.as_ref()
.on_stream_write_fin_flushed(context, meta, event);
}
#[inline]
fn on_stream_write_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteBlocked,
) {
self.as_ref().on_stream_write_blocked(context, meta, event);
}
#[inline]
fn on_stream_write_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteErrored,
) {
self.as_ref().on_stream_write_errored(context, meta, event);
}
#[inline]
fn on_stream_write_key_updated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteKeyUpdated,
) {
self.as_ref()
.on_stream_write_key_updated(context, meta, event);
}
#[inline]
fn on_stream_write_allocated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteAllocated,
) {
self.as_ref()
.on_stream_write_allocated(context, meta, event);
}
#[inline]
fn on_stream_write_shutdown(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteShutdown,
) {
self.as_ref().on_stream_write_shutdown(context, meta, event);
}
#[inline]
fn on_stream_write_socket_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketFlushed,
) {
self.as_ref()
.on_stream_write_socket_flushed(context, meta, event);
}
#[inline]
fn on_stream_write_socket_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketBlocked,
) {
self.as_ref()
.on_stream_write_socket_blocked(context, meta, event);
}
#[inline]
fn on_stream_write_socket_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketErrored,
) {
self.as_ref()
.on_stream_write_socket_errored(context, meta, event);
}
#[inline]
fn on_stream_read_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFlushed,
) {
self.as_ref().on_stream_read_flushed(context, meta, event);
}
#[inline]
fn on_stream_read_fin_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFinFlushed,
) {
self.as_ref()
.on_stream_read_fin_flushed(context, meta, event);
}
#[inline]
fn on_stream_read_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadBlocked,
) {
self.as_ref().on_stream_read_blocked(context, meta, event);
}
#[inline]
fn on_stream_read_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadErrored,
) {
self.as_ref().on_stream_read_errored(context, meta, event);
}
#[inline]
fn on_stream_read_key_updated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadKeyUpdated,
) {
self.as_ref()
.on_stream_read_key_updated(context, meta, event);
}
#[inline]
fn on_stream_read_shutdown(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadShutdown,
) {
self.as_ref().on_stream_read_shutdown(context, meta, event);
}
#[inline]
fn on_stream_read_socket_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketFlushed,
) {
self.as_ref()
.on_stream_read_socket_flushed(context, meta, event);
}
#[inline]
fn on_stream_read_socket_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketBlocked,
) {
self.as_ref()
.on_stream_read_socket_blocked(context, meta, event);
}
#[inline]
fn on_stream_read_socket_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketErrored,
) {
self.as_ref()
.on_stream_read_socket_errored(context, meta, event);
}
#[inline]
fn on_stream_decrypt_packet(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamDecryptPacket,
) {
self.as_ref().on_stream_decrypt_packet(context, meta, event);
}
#[inline]
fn on_stream_tcp_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTcpConnect) {
self.as_ref().on_stream_tcp_connect(meta, event);
}
#[inline]
fn on_stream_tls_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTlsConnect) {
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);
}
#[inline]
fn on_stream_connect_error(
&self,
meta: &api::EndpointMeta,
event: &api::StreamConnectError,
) {
self.as_ref().on_stream_connect_error(meta, event);
}
#[inline]
fn on_stream_packet_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketTransmitted,
) {
self.as_ref()
.on_stream_packet_transmitted(context, meta, event);
}
#[inline]
fn on_stream_probe_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamProbeTransmitted,
) {
self.as_ref()
.on_stream_probe_transmitted(context, meta, event);
}
#[inline]
fn on_stream_packet_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketReceived,
) {
self.as_ref()
.on_stream_packet_received(context, meta, event);
}
#[inline]
fn on_stream_packet_lost(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketLost,
) {
self.as_ref().on_stream_packet_lost(context, meta, event);
}
#[inline]
fn on_stream_packet_acked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketAcked,
) {
self.as_ref().on_stream_packet_acked(context, meta, event);
}
#[inline]
fn on_stream_packet_spuriously_retransmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketSpuriouslyRetransmitted,
) {
self.as_ref()
.on_stream_packet_spuriously_retransmitted(context, meta, event);
}
#[inline]
fn on_stream_max_data_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamMaxDataReceived,
) {
self.as_ref()
.on_stream_max_data_received(context, meta, event);
}
#[inline]
fn on_stream_control_packet_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketTransmitted,
) {
self.as_ref()
.on_stream_control_packet_transmitted(context, meta, event);
}
#[inline]
fn on_stream_control_packet_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketReceived,
) {
self.as_ref()
.on_stream_control_packet_received(context, meta, event);
}
#[inline]
fn on_stream_receiver_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReceiverErrored,
) {
self.as_ref()
.on_stream_receiver_errored(context, meta, event);
}
#[inline]
fn on_stream_sender_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamSenderErrored,
) {
self.as_ref().on_stream_sender_errored(context, meta, event);
}
#[inline]
fn on_stream_handshake_packet_rejected(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamHandshakePacketRejected,
) {
self.as_ref()
.on_stream_handshake_packet_rejected(context, meta, event);
}
#[inline]
fn on_connection_closed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionClosed,
) {
self.as_ref().on_connection_closed(context, meta, event);
}
#[inline]
fn on_endpoint_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::EndpointInitialized,
) {
self.as_ref().on_endpoint_initialized(meta, event);
}
#[inline]
fn on_dc_connection_timeout(
&self,
meta: &api::EndpointMeta,
event: &api::DcConnectionTimeout,
) {
self.as_ref().on_dc_connection_timeout(meta, event);
}
#[inline]
fn on_path_secret_map_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapInitialized,
) {
self.as_ref().on_path_secret_map_initialized(meta, event);
}
#[inline]
fn on_path_secret_map_uninitialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapUninitialized,
) {
self.as_ref().on_path_secret_map_uninitialized(meta, event);
}
#[inline]
fn on_path_secret_map_background_handshake_requested(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapBackgroundHandshakeRequested,
) {
self.as_ref()
.on_path_secret_map_background_handshake_requested(meta, event);
}
#[inline]
fn on_path_secret_map_entry_inserted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryInserted,
) {
self.as_ref().on_path_secret_map_entry_inserted(meta, event);
}
#[inline]
fn on_path_secret_map_entry_ready(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReady,
) {
self.as_ref().on_path_secret_map_entry_ready(meta, event);
}
#[inline]
fn on_path_secret_map_entry_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReplaced,
) {
self.as_ref().on_path_secret_map_entry_replaced(meta, event);
}
#[inline]
fn on_path_secret_map_id_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdEntryEvicted,
) {
self.as_ref()
.on_path_secret_map_id_entry_evicted(meta, event);
}
#[inline]
fn on_path_secret_map_address_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressEntryEvicted,
) {
self.as_ref()
.on_path_secret_map_address_entry_evicted(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketSent,
) {
self.as_ref()
.on_unknown_path_secret_packet_sent(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketReceived,
) {
self.as_ref()
.on_unknown_path_secret_packet_received(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketAccepted,
) {
self.as_ref()
.on_unknown_path_secret_packet_accepted(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketRejected,
) {
self.as_ref()
.on_unknown_path_secret_packet_rejected(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketDropped,
) {
self.as_ref()
.on_unknown_path_secret_packet_dropped(meta, event);
}
#[inline]
fn on_key_accepted(&self, meta: &api::EndpointMeta, event: &api::KeyAccepted) {
self.as_ref().on_key_accepted(meta, event);
}
#[inline]
fn on_replay_definitely_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDefinitelyDetected,
) {
self.as_ref().on_replay_definitely_detected(meta, event);
}
#[inline]
fn on_replay_potentially_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayPotentiallyDetected,
) {
self.as_ref().on_replay_potentially_detected(meta, event);
}
#[inline]
fn on_replay_detected_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketSent,
) {
self.as_ref().on_replay_detected_packet_sent(meta, event);
}
#[inline]
fn on_replay_detected_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketReceived,
) {
self.as_ref()
.on_replay_detected_packet_received(meta, event);
}
#[inline]
fn on_replay_detected_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketAccepted,
) {
self.as_ref()
.on_replay_detected_packet_accepted(meta, event);
}
#[inline]
fn on_replay_detected_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketRejected,
) {
self.as_ref()
.on_replay_detected_packet_rejected(meta, event);
}
#[inline]
fn on_replay_detected_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketDropped,
) {
self.as_ref().on_replay_detected_packet_dropped(meta, event);
}
#[inline]
fn on_stale_key_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketSent,
) {
self.as_ref().on_stale_key_packet_sent(meta, event);
}
#[inline]
fn on_stale_key_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketReceived,
) {
self.as_ref().on_stale_key_packet_received(meta, event);
}
#[inline]
fn on_stale_key_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketAccepted,
) {
self.as_ref().on_stale_key_packet_accepted(meta, event);
}
#[inline]
fn on_stale_key_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketRejected,
) {
self.as_ref().on_stale_key_packet_rejected(meta, event);
}
#[inline]
fn on_stale_key_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketDropped,
) {
self.as_ref().on_stale_key_packet_dropped(meta, event);
}
#[inline]
fn on_path_secret_map_address_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessed,
) {
self.as_ref()
.on_path_secret_map_address_cache_accessed(meta, event);
}
#[inline]
fn on_path_secret_map_address_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessedHit,
) {
self.as_ref()
.on_path_secret_map_address_cache_accessed_hit(meta, event);
}
#[inline]
fn on_path_secret_map_id_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessed,
) {
self.as_ref()
.on_path_secret_map_id_cache_accessed(meta, event);
}
#[inline]
fn on_path_secret_map_id_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessedHit,
) {
self.as_ref()
.on_path_secret_map_id_cache_accessed_hit(meta, event);
}
#[inline]
fn on_path_secret_map_cleaner_cycled(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapCleanerCycled,
) {
self.as_ref().on_path_secret_map_cleaner_cycled(meta, event);
}
#[inline]
fn on_path_secret_map_serialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapSerialized,
) {
self.as_ref().on_path_secret_map_serialized(meta, event);
}
#[inline]
fn on_path_secret_map_id_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdWriteLock,
) {
self.as_ref().on_path_secret_map_id_write_lock(meta, event);
}
#[inline]
fn on_path_secret_map_address_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressWriteLock,
) {
self.as_ref()
.on_path_secret_map_address_write_lock(meta, event);
}
#[inline]
fn on_path_secret_map_datagram_encrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramEncrypt,
) {
self.as_ref()
.on_path_secret_map_datagram_encrypt(meta, event);
}
#[inline]
fn on_path_secret_map_datagram_decrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramDecrypt,
) {
self.as_ref()
.on_path_secret_map_datagram_decrypt(meta, event);
}
#[inline]
fn on_event<M: Meta, E: Event>(&self, meta: &M, event: &E) {
self.as_ref().on_event(meta, event);
}
#[inline]
fn on_connection_event<E: Event>(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &E,
) {
self.as_ref().on_connection_event(context, meta, event);
}
}
impl<A, B> Subscriber for (A, B)
where
A: Subscriber,
B: Subscriber,
{
type ConnectionContext = (A::ConnectionContext, B::ConnectionContext);
#[inline]
fn create_connection_context(
&self,
meta: &api::ConnectionMeta,
info: &api::ConnectionInfo,
) -> Self::ConnectionContext {
(
self.0.create_connection_context(meta, info),
self.1.create_connection_context(meta, info),
)
}
#[inline]
fn on_acceptor_tcp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStarted,
) {
(self.0).on_acceptor_tcp_started(meta, event);
(self.1).on_acceptor_tcp_started(meta, event);
}
#[inline]
fn on_acceptor_tcp_loop_iteration_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpLoopIterationCompleted,
) {
(self.0).on_acceptor_tcp_loop_iteration_completed(meta, event);
(self.1).on_acceptor_tcp_loop_iteration_completed(meta, event);
}
#[inline]
fn on_acceptor_tcp_fresh_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshEnqueued,
) {
(self.0).on_acceptor_tcp_fresh_enqueued(meta, event);
(self.1).on_acceptor_tcp_fresh_enqueued(meta, event);
}
#[inline]
fn on_acceptor_tcp_fresh_batch_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshBatchCompleted,
) {
(self.0).on_acceptor_tcp_fresh_batch_completed(meta, event);
(self.1).on_acceptor_tcp_fresh_batch_completed(meta, event);
}
#[inline]
fn on_acceptor_tcp_stream_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamDropped,
) {
(self.0).on_acceptor_tcp_stream_dropped(meta, event);
(self.1).on_acceptor_tcp_stream_dropped(meta, event);
}
#[inline]
fn on_acceptor_tcp_stream_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamReplaced,
) {
(self.0).on_acceptor_tcp_stream_replaced(meta, event);
(self.1).on_acceptor_tcp_stream_replaced(meta, event);
}
#[inline]
fn on_acceptor_tcp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketReceived,
) {
(self.0).on_acceptor_tcp_packet_received(meta, event);
(self.1).on_acceptor_tcp_packet_received(meta, event);
}
#[inline]
fn on_acceptor_tcp_tls_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStarted,
) {
(self.0).on_acceptor_tcp_tls_started(meta, event);
(self.1).on_acceptor_tcp_tls_started(meta, event);
}
#[inline]
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamEnqueued,
) {
(self.0).on_acceptor_tcp_tls_stream_enqueued(meta, event);
(self.1).on_acceptor_tcp_tls_stream_enqueued(meta, event);
}
#[inline]
fn on_acceptor_tcp_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamRejected,
) {
(self.0).on_acceptor_tcp_tls_stream_rejected(meta, event);
(self.1).on_acceptor_tcp_tls_stream_rejected(meta, event);
}
#[inline]
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSyntheticTlsStreamRejected,
) {
(self.0).on_acceptor_tcp_synthetic_tls_stream_rejected(meta, event);
(self.1).on_acceptor_tcp_synthetic_tls_stream_rejected(meta, event);
}
#[inline]
fn on_acceptor_tcp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketDropped,
) {
(self.0).on_acceptor_tcp_packet_dropped(meta, event);
(self.1).on_acceptor_tcp_packet_dropped(meta, event);
}
#[inline]
fn on_acceptor_tcp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamEnqueued,
) {
(self.0).on_acceptor_tcp_stream_enqueued(meta, event);
(self.1).on_acceptor_tcp_stream_enqueued(meta, event);
}
#[inline]
fn on_acceptor_tcp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpIoError,
) {
(self.0).on_acceptor_tcp_io_error(meta, event);
(self.1).on_acceptor_tcp_io_error(meta, event);
}
#[inline]
fn on_acceptor_tcp_socket_sent(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketSent,
) {
(self.0).on_acceptor_tcp_socket_sent(meta, event);
(self.1).on_acceptor_tcp_socket_sent(meta, event);
}
#[inline]
fn on_acceptor_tcp_socket_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketReceived,
) {
(self.0).on_acceptor_tcp_socket_received(meta, event);
(self.1).on_acceptor_tcp_socket_received(meta, event);
}
#[inline]
fn on_acceptor_udp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStarted,
) {
(self.0).on_acceptor_udp_started(meta, event);
(self.1).on_acceptor_udp_started(meta, event);
}
#[inline]
fn on_acceptor_udp_datagram_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpDatagramReceived,
) {
(self.0).on_acceptor_udp_datagram_received(meta, event);
(self.1).on_acceptor_udp_datagram_received(meta, event);
}
#[inline]
fn on_acceptor_udp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketReceived,
) {
(self.0).on_acceptor_udp_packet_received(meta, event);
(self.1).on_acceptor_udp_packet_received(meta, event);
}
#[inline]
fn on_acceptor_udp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketDropped,
) {
(self.0).on_acceptor_udp_packet_dropped(meta, event);
(self.1).on_acceptor_udp_packet_dropped(meta, event);
}
#[inline]
fn on_acceptor_udp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStreamEnqueued,
) {
(self.0).on_acceptor_udp_stream_enqueued(meta, event);
(self.1).on_acceptor_udp_stream_enqueued(meta, event);
}
#[inline]
fn on_acceptor_udp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpIoError,
) {
(self.0).on_acceptor_udp_io_error(meta, event);
(self.1).on_acceptor_udp_io_error(meta, event);
}
#[inline]
fn on_acceptor_stream_pruned(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamPruned,
) {
(self.0).on_acceptor_stream_pruned(meta, event);
(self.1).on_acceptor_stream_pruned(meta, event);
}
#[inline]
fn on_acceptor_stream_dequeued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamDequeued,
) {
(self.0).on_acceptor_stream_dequeued(meta, event);
(self.1).on_acceptor_stream_dequeued(meta, event);
}
#[inline]
fn on_stream_write_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFlushed,
) {
(self.0).on_stream_write_flushed(&context.0, meta, event);
(self.1).on_stream_write_flushed(&context.1, meta, event);
}
#[inline]
fn on_stream_write_fin_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFinFlushed,
) {
(self.0).on_stream_write_fin_flushed(&context.0, meta, event);
(self.1).on_stream_write_fin_flushed(&context.1, meta, event);
}
#[inline]
fn on_stream_write_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteBlocked,
) {
(self.0).on_stream_write_blocked(&context.0, meta, event);
(self.1).on_stream_write_blocked(&context.1, meta, event);
}
#[inline]
fn on_stream_write_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteErrored,
) {
(self.0).on_stream_write_errored(&context.0, meta, event);
(self.1).on_stream_write_errored(&context.1, meta, event);
}
#[inline]
fn on_stream_write_key_updated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteKeyUpdated,
) {
(self.0).on_stream_write_key_updated(&context.0, meta, event);
(self.1).on_stream_write_key_updated(&context.1, meta, event);
}
#[inline]
fn on_stream_write_allocated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteAllocated,
) {
(self.0).on_stream_write_allocated(&context.0, meta, event);
(self.1).on_stream_write_allocated(&context.1, meta, event);
}
#[inline]
fn on_stream_write_shutdown(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteShutdown,
) {
(self.0).on_stream_write_shutdown(&context.0, meta, event);
(self.1).on_stream_write_shutdown(&context.1, meta, event);
}
#[inline]
fn on_stream_write_socket_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketFlushed,
) {
(self.0).on_stream_write_socket_flushed(&context.0, meta, event);
(self.1).on_stream_write_socket_flushed(&context.1, meta, event);
}
#[inline]
fn on_stream_write_socket_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketBlocked,
) {
(self.0).on_stream_write_socket_blocked(&context.0, meta, event);
(self.1).on_stream_write_socket_blocked(&context.1, meta, event);
}
#[inline]
fn on_stream_write_socket_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketErrored,
) {
(self.0).on_stream_write_socket_errored(&context.0, meta, event);
(self.1).on_stream_write_socket_errored(&context.1, meta, event);
}
#[inline]
fn on_stream_read_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFlushed,
) {
(self.0).on_stream_read_flushed(&context.0, meta, event);
(self.1).on_stream_read_flushed(&context.1, meta, event);
}
#[inline]
fn on_stream_read_fin_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFinFlushed,
) {
(self.0).on_stream_read_fin_flushed(&context.0, meta, event);
(self.1).on_stream_read_fin_flushed(&context.1, meta, event);
}
#[inline]
fn on_stream_read_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadBlocked,
) {
(self.0).on_stream_read_blocked(&context.0, meta, event);
(self.1).on_stream_read_blocked(&context.1, meta, event);
}
#[inline]
fn on_stream_read_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadErrored,
) {
(self.0).on_stream_read_errored(&context.0, meta, event);
(self.1).on_stream_read_errored(&context.1, meta, event);
}
#[inline]
fn on_stream_read_key_updated(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadKeyUpdated,
) {
(self.0).on_stream_read_key_updated(&context.0, meta, event);
(self.1).on_stream_read_key_updated(&context.1, meta, event);
}
#[inline]
fn on_stream_read_shutdown(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadShutdown,
) {
(self.0).on_stream_read_shutdown(&context.0, meta, event);
(self.1).on_stream_read_shutdown(&context.1, meta, event);
}
#[inline]
fn on_stream_read_socket_flushed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketFlushed,
) {
(self.0).on_stream_read_socket_flushed(&context.0, meta, event);
(self.1).on_stream_read_socket_flushed(&context.1, meta, event);
}
#[inline]
fn on_stream_read_socket_blocked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketBlocked,
) {
(self.0).on_stream_read_socket_blocked(&context.0, meta, event);
(self.1).on_stream_read_socket_blocked(&context.1, meta, event);
}
#[inline]
fn on_stream_read_socket_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketErrored,
) {
(self.0).on_stream_read_socket_errored(&context.0, meta, event);
(self.1).on_stream_read_socket_errored(&context.1, meta, event);
}
#[inline]
fn on_stream_decrypt_packet(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamDecryptPacket,
) {
(self.0).on_stream_decrypt_packet(&context.0, meta, event);
(self.1).on_stream_decrypt_packet(&context.1, meta, event);
}
#[inline]
fn on_stream_tcp_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTcpConnect) {
(self.0).on_stream_tcp_connect(meta, event);
(self.1).on_stream_tcp_connect(meta, event);
}
#[inline]
fn on_stream_tls_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTlsConnect) {
(self.0).on_stream_tls_connect(meta, event);
(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);
}
#[inline]
fn on_stream_connect_error(
&self,
meta: &api::EndpointMeta,
event: &api::StreamConnectError,
) {
(self.0).on_stream_connect_error(meta, event);
(self.1).on_stream_connect_error(meta, event);
}
#[inline]
fn on_stream_packet_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketTransmitted,
) {
(self.0).on_stream_packet_transmitted(&context.0, meta, event);
(self.1).on_stream_packet_transmitted(&context.1, meta, event);
}
#[inline]
fn on_stream_probe_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamProbeTransmitted,
) {
(self.0).on_stream_probe_transmitted(&context.0, meta, event);
(self.1).on_stream_probe_transmitted(&context.1, meta, event);
}
#[inline]
fn on_stream_packet_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketReceived,
) {
(self.0).on_stream_packet_received(&context.0, meta, event);
(self.1).on_stream_packet_received(&context.1, meta, event);
}
#[inline]
fn on_stream_packet_lost(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketLost,
) {
(self.0).on_stream_packet_lost(&context.0, meta, event);
(self.1).on_stream_packet_lost(&context.1, meta, event);
}
#[inline]
fn on_stream_packet_acked(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketAcked,
) {
(self.0).on_stream_packet_acked(&context.0, meta, event);
(self.1).on_stream_packet_acked(&context.1, meta, event);
}
#[inline]
fn on_stream_packet_spuriously_retransmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketSpuriouslyRetransmitted,
) {
(self.0).on_stream_packet_spuriously_retransmitted(&context.0, meta, event);
(self.1).on_stream_packet_spuriously_retransmitted(&context.1, meta, event);
}
#[inline]
fn on_stream_max_data_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamMaxDataReceived,
) {
(self.0).on_stream_max_data_received(&context.0, meta, event);
(self.1).on_stream_max_data_received(&context.1, meta, event);
}
#[inline]
fn on_stream_control_packet_transmitted(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketTransmitted,
) {
(self.0).on_stream_control_packet_transmitted(&context.0, meta, event);
(self.1).on_stream_control_packet_transmitted(&context.1, meta, event);
}
#[inline]
fn on_stream_control_packet_received(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketReceived,
) {
(self.0).on_stream_control_packet_received(&context.0, meta, event);
(self.1).on_stream_control_packet_received(&context.1, meta, event);
}
#[inline]
fn on_stream_receiver_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReceiverErrored,
) {
(self.0).on_stream_receiver_errored(&context.0, meta, event);
(self.1).on_stream_receiver_errored(&context.1, meta, event);
}
#[inline]
fn on_stream_sender_errored(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamSenderErrored,
) {
(self.0).on_stream_sender_errored(&context.0, meta, event);
(self.1).on_stream_sender_errored(&context.1, meta, event);
}
#[inline]
fn on_stream_handshake_packet_rejected(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamHandshakePacketRejected,
) {
(self.0).on_stream_handshake_packet_rejected(&context.0, meta, event);
(self.1).on_stream_handshake_packet_rejected(&context.1, meta, event);
}
#[inline]
fn on_connection_closed(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionClosed,
) {
(self.0).on_connection_closed(&context.0, meta, event);
(self.1).on_connection_closed(&context.1, meta, event);
}
#[inline]
fn on_endpoint_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::EndpointInitialized,
) {
(self.0).on_endpoint_initialized(meta, event);
(self.1).on_endpoint_initialized(meta, event);
}
#[inline]
fn on_dc_connection_timeout(
&self,
meta: &api::EndpointMeta,
event: &api::DcConnectionTimeout,
) {
(self.0).on_dc_connection_timeout(meta, event);
(self.1).on_dc_connection_timeout(meta, event);
}
#[inline]
fn on_path_secret_map_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapInitialized,
) {
(self.0).on_path_secret_map_initialized(meta, event);
(self.1).on_path_secret_map_initialized(meta, event);
}
#[inline]
fn on_path_secret_map_uninitialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapUninitialized,
) {
(self.0).on_path_secret_map_uninitialized(meta, event);
(self.1).on_path_secret_map_uninitialized(meta, event);
}
#[inline]
fn on_path_secret_map_background_handshake_requested(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapBackgroundHandshakeRequested,
) {
(self.0).on_path_secret_map_background_handshake_requested(meta, event);
(self.1).on_path_secret_map_background_handshake_requested(meta, event);
}
#[inline]
fn on_path_secret_map_entry_inserted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryInserted,
) {
(self.0).on_path_secret_map_entry_inserted(meta, event);
(self.1).on_path_secret_map_entry_inserted(meta, event);
}
#[inline]
fn on_path_secret_map_entry_ready(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReady,
) {
(self.0).on_path_secret_map_entry_ready(meta, event);
(self.1).on_path_secret_map_entry_ready(meta, event);
}
#[inline]
fn on_path_secret_map_entry_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReplaced,
) {
(self.0).on_path_secret_map_entry_replaced(meta, event);
(self.1).on_path_secret_map_entry_replaced(meta, event);
}
#[inline]
fn on_path_secret_map_id_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdEntryEvicted,
) {
(self.0).on_path_secret_map_id_entry_evicted(meta, event);
(self.1).on_path_secret_map_id_entry_evicted(meta, event);
}
#[inline]
fn on_path_secret_map_address_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressEntryEvicted,
) {
(self.0).on_path_secret_map_address_entry_evicted(meta, event);
(self.1).on_path_secret_map_address_entry_evicted(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketSent,
) {
(self.0).on_unknown_path_secret_packet_sent(meta, event);
(self.1).on_unknown_path_secret_packet_sent(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketReceived,
) {
(self.0).on_unknown_path_secret_packet_received(meta, event);
(self.1).on_unknown_path_secret_packet_received(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketAccepted,
) {
(self.0).on_unknown_path_secret_packet_accepted(meta, event);
(self.1).on_unknown_path_secret_packet_accepted(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketRejected,
) {
(self.0).on_unknown_path_secret_packet_rejected(meta, event);
(self.1).on_unknown_path_secret_packet_rejected(meta, event);
}
#[inline]
fn on_unknown_path_secret_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketDropped,
) {
(self.0).on_unknown_path_secret_packet_dropped(meta, event);
(self.1).on_unknown_path_secret_packet_dropped(meta, event);
}
#[inline]
fn on_key_accepted(&self, meta: &api::EndpointMeta, event: &api::KeyAccepted) {
(self.0).on_key_accepted(meta, event);
(self.1).on_key_accepted(meta, event);
}
#[inline]
fn on_replay_definitely_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDefinitelyDetected,
) {
(self.0).on_replay_definitely_detected(meta, event);
(self.1).on_replay_definitely_detected(meta, event);
}
#[inline]
fn on_replay_potentially_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayPotentiallyDetected,
) {
(self.0).on_replay_potentially_detected(meta, event);
(self.1).on_replay_potentially_detected(meta, event);
}
#[inline]
fn on_replay_detected_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketSent,
) {
(self.0).on_replay_detected_packet_sent(meta, event);
(self.1).on_replay_detected_packet_sent(meta, event);
}
#[inline]
fn on_replay_detected_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketReceived,
) {
(self.0).on_replay_detected_packet_received(meta, event);
(self.1).on_replay_detected_packet_received(meta, event);
}
#[inline]
fn on_replay_detected_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketAccepted,
) {
(self.0).on_replay_detected_packet_accepted(meta, event);
(self.1).on_replay_detected_packet_accepted(meta, event);
}
#[inline]
fn on_replay_detected_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketRejected,
) {
(self.0).on_replay_detected_packet_rejected(meta, event);
(self.1).on_replay_detected_packet_rejected(meta, event);
}
#[inline]
fn on_replay_detected_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketDropped,
) {
(self.0).on_replay_detected_packet_dropped(meta, event);
(self.1).on_replay_detected_packet_dropped(meta, event);
}
#[inline]
fn on_stale_key_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketSent,
) {
(self.0).on_stale_key_packet_sent(meta, event);
(self.1).on_stale_key_packet_sent(meta, event);
}
#[inline]
fn on_stale_key_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketReceived,
) {
(self.0).on_stale_key_packet_received(meta, event);
(self.1).on_stale_key_packet_received(meta, event);
}
#[inline]
fn on_stale_key_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketAccepted,
) {
(self.0).on_stale_key_packet_accepted(meta, event);
(self.1).on_stale_key_packet_accepted(meta, event);
}
#[inline]
fn on_stale_key_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketRejected,
) {
(self.0).on_stale_key_packet_rejected(meta, event);
(self.1).on_stale_key_packet_rejected(meta, event);
}
#[inline]
fn on_stale_key_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketDropped,
) {
(self.0).on_stale_key_packet_dropped(meta, event);
(self.1).on_stale_key_packet_dropped(meta, event);
}
#[inline]
fn on_path_secret_map_address_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessed,
) {
(self.0).on_path_secret_map_address_cache_accessed(meta, event);
(self.1).on_path_secret_map_address_cache_accessed(meta, event);
}
#[inline]
fn on_path_secret_map_address_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessedHit,
) {
(self.0).on_path_secret_map_address_cache_accessed_hit(meta, event);
(self.1).on_path_secret_map_address_cache_accessed_hit(meta, event);
}
#[inline]
fn on_path_secret_map_id_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessed,
) {
(self.0).on_path_secret_map_id_cache_accessed(meta, event);
(self.1).on_path_secret_map_id_cache_accessed(meta, event);
}
#[inline]
fn on_path_secret_map_id_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessedHit,
) {
(self.0).on_path_secret_map_id_cache_accessed_hit(meta, event);
(self.1).on_path_secret_map_id_cache_accessed_hit(meta, event);
}
#[inline]
fn on_path_secret_map_cleaner_cycled(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapCleanerCycled,
) {
(self.0).on_path_secret_map_cleaner_cycled(meta, event);
(self.1).on_path_secret_map_cleaner_cycled(meta, event);
}
#[inline]
fn on_path_secret_map_serialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapSerialized,
) {
(self.0).on_path_secret_map_serialized(meta, event);
(self.1).on_path_secret_map_serialized(meta, event);
}
#[inline]
fn on_path_secret_map_id_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdWriteLock,
) {
(self.0).on_path_secret_map_id_write_lock(meta, event);
(self.1).on_path_secret_map_id_write_lock(meta, event);
}
#[inline]
fn on_path_secret_map_address_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressWriteLock,
) {
(self.0).on_path_secret_map_address_write_lock(meta, event);
(self.1).on_path_secret_map_address_write_lock(meta, event);
}
#[inline]
fn on_path_secret_map_datagram_encrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramEncrypt,
) {
(self.0).on_path_secret_map_datagram_encrypt(meta, event);
(self.1).on_path_secret_map_datagram_encrypt(meta, event);
}
#[inline]
fn on_path_secret_map_datagram_decrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramDecrypt,
) {
(self.0).on_path_secret_map_datagram_decrypt(meta, event);
(self.1).on_path_secret_map_datagram_decrypt(meta, event);
}
#[inline]
fn on_event<M: Meta, E: Event>(&self, meta: &M, event: &E) {
self.0.on_event(meta, event);
self.1.on_event(meta, event);
}
#[inline]
fn on_connection_event<E: Event>(
&self,
context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &E,
) {
self.0.on_connection_event(&context.0, meta, event);
self.1.on_connection_event(&context.1, meta, event);
}
#[inline]
fn query(
context: &Self::ConnectionContext,
query: &mut dyn query::Query,
) -> query::ControlFlow {
query
.execute(context)
.and_then(|| A::query(&context.0, query))
.and_then(|| B::query(&context.1, query))
}
}
pub trait EndpointPublisher {
fn on_acceptor_tcp_started(&self, event: builder::AcceptorTcpStarted);
fn on_acceptor_tcp_loop_iteration_completed(
&self,
event: builder::AcceptorTcpLoopIterationCompleted,
);
fn on_acceptor_tcp_fresh_enqueued(&self, event: builder::AcceptorTcpFreshEnqueued);
fn on_acceptor_tcp_fresh_batch_completed(
&self,
event: builder::AcceptorTcpFreshBatchCompleted,
);
fn on_acceptor_tcp_stream_dropped(&self, event: builder::AcceptorTcpStreamDropped);
fn on_acceptor_tcp_stream_replaced(&self, event: builder::AcceptorTcpStreamReplaced);
fn on_acceptor_tcp_packet_received(&self, event: builder::AcceptorTcpPacketReceived);
fn on_acceptor_tcp_tls_started(&self, event: builder::AcceptorTcpTlsStarted);
fn on_acceptor_tcp_tls_stream_enqueued(&self, event: builder::AcceptorTcpTlsStreamEnqueued);
fn on_acceptor_tcp_tls_stream_rejected(&self, event: builder::AcceptorTcpTlsStreamRejected);
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
event: builder::AcceptorTcpSyntheticTlsStreamRejected,
);
fn on_acceptor_tcp_packet_dropped(&self, event: builder::AcceptorTcpPacketDropped);
fn on_acceptor_tcp_stream_enqueued(&self, event: builder::AcceptorTcpStreamEnqueued);
fn on_acceptor_tcp_io_error(&self, event: builder::AcceptorTcpIoError);
fn on_acceptor_tcp_socket_sent(&self, event: builder::AcceptorTcpSocketSent);
fn on_acceptor_tcp_socket_received(&self, event: builder::AcceptorTcpSocketReceived);
fn on_acceptor_udp_started(&self, event: builder::AcceptorUdpStarted);
fn on_acceptor_udp_datagram_received(&self, event: builder::AcceptorUdpDatagramReceived);
fn on_acceptor_udp_packet_received(&self, event: builder::AcceptorUdpPacketReceived);
fn on_acceptor_udp_packet_dropped(&self, event: builder::AcceptorUdpPacketDropped);
fn on_acceptor_udp_stream_enqueued(&self, event: builder::AcceptorUdpStreamEnqueued);
fn on_acceptor_udp_io_error(&self, event: builder::AcceptorUdpIoError);
fn on_acceptor_stream_pruned(&self, event: builder::AcceptorStreamPruned);
fn on_acceptor_stream_dequeued(&self, event: builder::AcceptorStreamDequeued);
fn on_stream_tcp_connect(&self, event: builder::StreamTcpConnect);
fn on_stream_tls_connect(&self, event: builder::StreamTlsConnect);
fn on_stream_tls_connect_error(&self, event: builder::StreamTlsConnectError);
fn on_stream_connect(&self, event: builder::StreamConnect);
fn on_stream_connect_error(&self, event: builder::StreamConnectError);
fn on_endpoint_initialized(&self, event: builder::EndpointInitialized);
fn on_dc_connection_timeout(&self, event: builder::DcConnectionTimeout);
fn on_path_secret_map_initialized(&self, event: builder::PathSecretMapInitialized);
fn on_path_secret_map_uninitialized(&self, event: builder::PathSecretMapUninitialized);
fn on_path_secret_map_background_handshake_requested(
&self,
event: builder::PathSecretMapBackgroundHandshakeRequested,
);
fn on_path_secret_map_entry_inserted(&self, event: builder::PathSecretMapEntryInserted);
fn on_path_secret_map_entry_ready(&self, event: builder::PathSecretMapEntryReady);
fn on_path_secret_map_entry_replaced(&self, event: builder::PathSecretMapEntryReplaced);
fn on_path_secret_map_id_entry_evicted(&self, event: builder::PathSecretMapIdEntryEvicted);
fn on_path_secret_map_address_entry_evicted(
&self,
event: builder::PathSecretMapAddressEntryEvicted,
);
fn on_unknown_path_secret_packet_sent(&self, event: builder::UnknownPathSecretPacketSent);
fn on_unknown_path_secret_packet_received(
&self,
event: builder::UnknownPathSecretPacketReceived,
);
fn on_unknown_path_secret_packet_accepted(
&self,
event: builder::UnknownPathSecretPacketAccepted,
);
fn on_unknown_path_secret_packet_rejected(
&self,
event: builder::UnknownPathSecretPacketRejected,
);
fn on_unknown_path_secret_packet_dropped(
&self,
event: builder::UnknownPathSecretPacketDropped,
);
fn on_key_accepted(&self, event: builder::KeyAccepted);
fn on_replay_definitely_detected(&self, event: builder::ReplayDefinitelyDetected);
fn on_replay_potentially_detected(&self, event: builder::ReplayPotentiallyDetected);
fn on_replay_detected_packet_sent(&self, event: builder::ReplayDetectedPacketSent);
fn on_replay_detected_packet_received(&self, event: builder::ReplayDetectedPacketReceived);
fn on_replay_detected_packet_accepted(&self, event: builder::ReplayDetectedPacketAccepted);
fn on_replay_detected_packet_rejected(&self, event: builder::ReplayDetectedPacketRejected);
fn on_replay_detected_packet_dropped(&self, event: builder::ReplayDetectedPacketDropped);
fn on_stale_key_packet_sent(&self, event: builder::StaleKeyPacketSent);
fn on_stale_key_packet_received(&self, event: builder::StaleKeyPacketReceived);
fn on_stale_key_packet_accepted(&self, event: builder::StaleKeyPacketAccepted);
fn on_stale_key_packet_rejected(&self, event: builder::StaleKeyPacketRejected);
fn on_stale_key_packet_dropped(&self, event: builder::StaleKeyPacketDropped);
fn on_path_secret_map_address_cache_accessed(
&self,
event: builder::PathSecretMapAddressCacheAccessed,
);
fn on_path_secret_map_address_cache_accessed_hit(
&self,
event: builder::PathSecretMapAddressCacheAccessedHit,
);
fn on_path_secret_map_id_cache_accessed(
&self,
event: builder::PathSecretMapIdCacheAccessed,
);
fn on_path_secret_map_id_cache_accessed_hit(
&self,
event: builder::PathSecretMapIdCacheAccessedHit,
);
fn on_path_secret_map_cleaner_cycled(&self, event: builder::PathSecretMapCleanerCycled);
fn on_path_secret_map_serialized(&self, event: builder::PathSecretMapSerialized);
fn on_path_secret_map_id_write_lock(&self, event: builder::PathSecretMapIdWriteLock);
fn on_path_secret_map_address_write_lock(
&self,
event: builder::PathSecretMapAddressWriteLock,
);
fn on_path_secret_map_datagram_encrypt(&self, event: builder::PathSecretMapDatagramEncrypt);
fn on_path_secret_map_datagram_decrypt(&self, event: builder::PathSecretMapDatagramDecrypt);
fn quic_version(&self) -> Option<u32>;
}
pub struct EndpointPublisherSubscriber<'a, Sub: Subscriber> {
meta: api::EndpointMeta,
quic_version: Option<u32>,
subscriber: &'a Sub,
}
impl<'a, Sub: Subscriber> fmt::Debug for EndpointPublisherSubscriber<'a, Sub> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("ConnectionPublisherSubscriber")
.field("meta", &self.meta)
.field("quic_version", &self.quic_version)
.finish()
}
}
impl<'a, Sub: Subscriber> EndpointPublisherSubscriber<'a, Sub> {
#[inline]
pub fn new(
meta: builder::EndpointMeta,
quic_version: Option<u32>,
subscriber: &'a Sub,
) -> Self {
Self {
meta: meta.into_event(),
quic_version,
subscriber,
}
}
}
impl<'a, Sub: Subscriber> EndpointPublisher for EndpointPublisherSubscriber<'a, Sub> {
#[inline]
fn on_acceptor_tcp_started(&self, event: builder::AcceptorTcpStarted) {
let event = event.into_event();
self.subscriber.on_acceptor_tcp_started(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_loop_iteration_completed(
&self,
event: builder::AcceptorTcpLoopIterationCompleted,
) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_loop_iteration_completed(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_fresh_enqueued(&self, event: builder::AcceptorTcpFreshEnqueued) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_fresh_enqueued(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_fresh_batch_completed(
&self,
event: builder::AcceptorTcpFreshBatchCompleted,
) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_fresh_batch_completed(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_stream_dropped(&self, event: builder::AcceptorTcpStreamDropped) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_stream_dropped(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_stream_replaced(&self, event: builder::AcceptorTcpStreamReplaced) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_stream_replaced(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_packet_received(&self, event: builder::AcceptorTcpPacketReceived) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_packet_received(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_tls_started(&self, event: builder::AcceptorTcpTlsStarted) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_tls_started(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
event: builder::AcceptorTcpTlsStreamEnqueued,
) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_tls_stream_enqueued(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_tls_stream_rejected(
&self,
event: builder::AcceptorTcpTlsStreamRejected,
) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_tls_stream_rejected(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
event: builder::AcceptorTcpSyntheticTlsStreamRejected,
) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_synthetic_tls_stream_rejected(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_packet_dropped(&self, event: builder::AcceptorTcpPacketDropped) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_packet_dropped(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_stream_enqueued(&self, event: builder::AcceptorTcpStreamEnqueued) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_stream_enqueued(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_io_error(&self, event: builder::AcceptorTcpIoError) {
let event = event.into_event();
self.subscriber.on_acceptor_tcp_io_error(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_socket_sent(&self, event: builder::AcceptorTcpSocketSent) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_socket_sent(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_tcp_socket_received(&self, event: builder::AcceptorTcpSocketReceived) {
let event = event.into_event();
self.subscriber
.on_acceptor_tcp_socket_received(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_udp_started(&self, event: builder::AcceptorUdpStarted) {
let event = event.into_event();
self.subscriber.on_acceptor_udp_started(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_udp_datagram_received(&self, event: builder::AcceptorUdpDatagramReceived) {
let event = event.into_event();
self.subscriber
.on_acceptor_udp_datagram_received(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_udp_packet_received(&self, event: builder::AcceptorUdpPacketReceived) {
let event = event.into_event();
self.subscriber
.on_acceptor_udp_packet_received(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_udp_packet_dropped(&self, event: builder::AcceptorUdpPacketDropped) {
let event = event.into_event();
self.subscriber
.on_acceptor_udp_packet_dropped(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_udp_stream_enqueued(&self, event: builder::AcceptorUdpStreamEnqueued) {
let event = event.into_event();
self.subscriber
.on_acceptor_udp_stream_enqueued(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_udp_io_error(&self, event: builder::AcceptorUdpIoError) {
let event = event.into_event();
self.subscriber.on_acceptor_udp_io_error(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_stream_pruned(&self, event: builder::AcceptorStreamPruned) {
let event = event.into_event();
self.subscriber
.on_acceptor_stream_pruned(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_acceptor_stream_dequeued(&self, event: builder::AcceptorStreamDequeued) {
let event = event.into_event();
self.subscriber
.on_acceptor_stream_dequeued(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stream_tcp_connect(&self, event: builder::StreamTcpConnect) {
let event = event.into_event();
self.subscriber.on_stream_tcp_connect(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stream_tls_connect(&self, event: builder::StreamTlsConnect) {
let event = event.into_event();
self.subscriber.on_stream_tls_connect(&self.meta, &event);
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);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stream_connect_error(&self, event: builder::StreamConnectError) {
let event = event.into_event();
self.subscriber.on_stream_connect_error(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_endpoint_initialized(&self, event: builder::EndpointInitialized) {
let event = event.into_event();
self.subscriber.on_endpoint_initialized(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_dc_connection_timeout(&self, event: builder::DcConnectionTimeout) {
let event = event.into_event();
self.subscriber.on_dc_connection_timeout(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_initialized(&self, event: builder::PathSecretMapInitialized) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_initialized(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_uninitialized(&self, event: builder::PathSecretMapUninitialized) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_uninitialized(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_background_handshake_requested(
&self,
event: builder::PathSecretMapBackgroundHandshakeRequested,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_background_handshake_requested(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_entry_inserted(&self, event: builder::PathSecretMapEntryInserted) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_entry_inserted(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_entry_ready(&self, event: builder::PathSecretMapEntryReady) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_entry_ready(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_entry_replaced(&self, event: builder::PathSecretMapEntryReplaced) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_entry_replaced(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_id_entry_evicted(&self, event: builder::PathSecretMapIdEntryEvicted) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_id_entry_evicted(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_address_entry_evicted(
&self,
event: builder::PathSecretMapAddressEntryEvicted,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_address_entry_evicted(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_unknown_path_secret_packet_sent(&self, event: builder::UnknownPathSecretPacketSent) {
let event = event.into_event();
self.subscriber
.on_unknown_path_secret_packet_sent(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_unknown_path_secret_packet_received(
&self,
event: builder::UnknownPathSecretPacketReceived,
) {
let event = event.into_event();
self.subscriber
.on_unknown_path_secret_packet_received(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_unknown_path_secret_packet_accepted(
&self,
event: builder::UnknownPathSecretPacketAccepted,
) {
let event = event.into_event();
self.subscriber
.on_unknown_path_secret_packet_accepted(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_unknown_path_secret_packet_rejected(
&self,
event: builder::UnknownPathSecretPacketRejected,
) {
let event = event.into_event();
self.subscriber
.on_unknown_path_secret_packet_rejected(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_unknown_path_secret_packet_dropped(
&self,
event: builder::UnknownPathSecretPacketDropped,
) {
let event = event.into_event();
self.subscriber
.on_unknown_path_secret_packet_dropped(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_key_accepted(&self, event: builder::KeyAccepted) {
let event = event.into_event();
self.subscriber.on_key_accepted(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_replay_definitely_detected(&self, event: builder::ReplayDefinitelyDetected) {
let event = event.into_event();
self.subscriber
.on_replay_definitely_detected(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_replay_potentially_detected(&self, event: builder::ReplayPotentiallyDetected) {
let event = event.into_event();
self.subscriber
.on_replay_potentially_detected(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_replay_detected_packet_sent(&self, event: builder::ReplayDetectedPacketSent) {
let event = event.into_event();
self.subscriber
.on_replay_detected_packet_sent(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_replay_detected_packet_received(&self, event: builder::ReplayDetectedPacketReceived) {
let event = event.into_event();
self.subscriber
.on_replay_detected_packet_received(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_replay_detected_packet_accepted(&self, event: builder::ReplayDetectedPacketAccepted) {
let event = event.into_event();
self.subscriber
.on_replay_detected_packet_accepted(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_replay_detected_packet_rejected(&self, event: builder::ReplayDetectedPacketRejected) {
let event = event.into_event();
self.subscriber
.on_replay_detected_packet_rejected(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_replay_detected_packet_dropped(&self, event: builder::ReplayDetectedPacketDropped) {
let event = event.into_event();
self.subscriber
.on_replay_detected_packet_dropped(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stale_key_packet_sent(&self, event: builder::StaleKeyPacketSent) {
let event = event.into_event();
self.subscriber.on_stale_key_packet_sent(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stale_key_packet_received(&self, event: builder::StaleKeyPacketReceived) {
let event = event.into_event();
self.subscriber
.on_stale_key_packet_received(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stale_key_packet_accepted(&self, event: builder::StaleKeyPacketAccepted) {
let event = event.into_event();
self.subscriber
.on_stale_key_packet_accepted(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stale_key_packet_rejected(&self, event: builder::StaleKeyPacketRejected) {
let event = event.into_event();
self.subscriber
.on_stale_key_packet_rejected(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_stale_key_packet_dropped(&self, event: builder::StaleKeyPacketDropped) {
let event = event.into_event();
self.subscriber
.on_stale_key_packet_dropped(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_address_cache_accessed(
&self,
event: builder::PathSecretMapAddressCacheAccessed,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_address_cache_accessed(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_address_cache_accessed_hit(
&self,
event: builder::PathSecretMapAddressCacheAccessedHit,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_address_cache_accessed_hit(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_id_cache_accessed(
&self,
event: builder::PathSecretMapIdCacheAccessed,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_id_cache_accessed(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_id_cache_accessed_hit(
&self,
event: builder::PathSecretMapIdCacheAccessedHit,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_id_cache_accessed_hit(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_cleaner_cycled(&self, event: builder::PathSecretMapCleanerCycled) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_cleaner_cycled(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_serialized(&self, event: builder::PathSecretMapSerialized) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_serialized(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_id_write_lock(&self, event: builder::PathSecretMapIdWriteLock) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_id_write_lock(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_address_write_lock(
&self,
event: builder::PathSecretMapAddressWriteLock,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_address_write_lock(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_datagram_encrypt(
&self,
event: builder::PathSecretMapDatagramEncrypt,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_datagram_encrypt(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn on_path_secret_map_datagram_decrypt(
&self,
event: builder::PathSecretMapDatagramDecrypt,
) {
let event = event.into_event();
self.subscriber
.on_path_secret_map_datagram_decrypt(&self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn quic_version(&self) -> Option<u32> {
self.quic_version
}
}
pub trait ConnectionPublisher {
fn on_stream_write_flushed(&self, event: builder::StreamWriteFlushed);
fn on_stream_write_fin_flushed(&self, event: builder::StreamWriteFinFlushed);
fn on_stream_write_blocked(&self, event: builder::StreamWriteBlocked);
fn on_stream_write_errored(&self, event: builder::StreamWriteErrored);
fn on_stream_write_key_updated(&self, event: builder::StreamWriteKeyUpdated);
fn on_stream_write_allocated(&self, event: builder::StreamWriteAllocated);
fn on_stream_write_shutdown(&self, event: builder::StreamWriteShutdown);
fn on_stream_write_socket_flushed(&self, event: builder::StreamWriteSocketFlushed);
fn on_stream_write_socket_blocked(&self, event: builder::StreamWriteSocketBlocked);
fn on_stream_write_socket_errored(&self, event: builder::StreamWriteSocketErrored);
fn on_stream_read_flushed(&self, event: builder::StreamReadFlushed);
fn on_stream_read_fin_flushed(&self, event: builder::StreamReadFinFlushed);
fn on_stream_read_blocked(&self, event: builder::StreamReadBlocked);
fn on_stream_read_errored(&self, event: builder::StreamReadErrored);
fn on_stream_read_key_updated(&self, event: builder::StreamReadKeyUpdated);
fn on_stream_read_shutdown(&self, event: builder::StreamReadShutdown);
fn on_stream_read_socket_flushed(&self, event: builder::StreamReadSocketFlushed);
fn on_stream_read_socket_blocked(&self, event: builder::StreamReadSocketBlocked);
fn on_stream_read_socket_errored(&self, event: builder::StreamReadSocketErrored);
fn on_stream_decrypt_packet(&self, event: builder::StreamDecryptPacket);
fn on_stream_packet_transmitted(&self, event: builder::StreamPacketTransmitted);
fn on_stream_probe_transmitted(&self, event: builder::StreamProbeTransmitted);
fn on_stream_packet_received(&self, event: builder::StreamPacketReceived);
fn on_stream_packet_lost(&self, event: builder::StreamPacketLost);
fn on_stream_packet_acked(&self, event: builder::StreamPacketAcked);
fn on_stream_packet_spuriously_retransmitted(
&self,
event: builder::StreamPacketSpuriouslyRetransmitted,
);
fn on_stream_max_data_received(&self, event: builder::StreamMaxDataReceived);
fn on_stream_control_packet_transmitted(
&self,
event: builder::StreamControlPacketTransmitted,
);
fn on_stream_control_packet_received(&self, event: builder::StreamControlPacketReceived);
fn on_stream_receiver_errored(&self, event: builder::StreamReceiverErrored);
fn on_stream_sender_errored(&self, event: builder::StreamSenderErrored);
fn on_stream_handshake_packet_rejected(
&self,
event: builder::StreamHandshakePacketRejected,
);
fn on_connection_closed(&self, event: builder::ConnectionClosed);
fn quic_version(&self) -> u32;
fn subject(&self) -> api::Subject;
}
pub struct ConnectionPublisherSubscriber<'a, Sub: Subscriber> {
meta: api::ConnectionMeta,
quic_version: u32,
subscriber: &'a Sub,
context: &'a Sub::ConnectionContext,
}
impl<'a, Sub: Subscriber> fmt::Debug for ConnectionPublisherSubscriber<'a, Sub> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("ConnectionPublisherSubscriber")
.field("meta", &self.meta)
.field("quic_version", &self.quic_version)
.finish()
}
}
impl<'a, Sub: Subscriber> ConnectionPublisherSubscriber<'a, Sub> {
#[inline]
pub fn new(
meta: builder::ConnectionMeta,
quic_version: u32,
subscriber: &'a Sub,
context: &'a Sub::ConnectionContext,
) -> Self {
Self {
meta: meta.into_event(),
quic_version,
subscriber,
context,
}
}
}
impl<'a, Sub: Subscriber> ConnectionPublisher for ConnectionPublisherSubscriber<'a, Sub> {
#[inline]
fn on_stream_write_flushed(&self, event: builder::StreamWriteFlushed) {
let event = event.into_event();
self.subscriber
.on_stream_write_flushed(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_stream_write_fin_flushed(&self, event: builder::StreamWriteFinFlushed) {
let event = event.into_event();
self.subscriber
.on_stream_write_fin_flushed(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_stream_write_blocked(&self, event: builder::StreamWriteBlocked) {
let event = event.into_event();
self.subscriber
.on_stream_write_blocked(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_stream_write_errored(&self, event: builder::StreamWriteErrored) {
let event = event.into_event();
self.subscriber
.on_stream_write_errored(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_stream_write_key_updated(&self, event: builder::StreamWriteKeyUpdated) {
let event = event.into_event();
self.subscriber
.on_stream_write_key_updated(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_stream_write_allocated(&self, event: builder::StreamWriteAllocated) {
let event = event.into_event();
self.subscriber
.on_stream_write_allocated(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_stream_write_shutdown(&self, event: builder::StreamWriteShutdown) {
let event = event.into_event();
self.subscriber
.on_stream_write_shutdown(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_stream_write_socket_flushed(&self, event: builder::StreamWriteSocketFlushed) {
let event = event.into_event();
self.subscriber
.on_stream_write_socket_flushed(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_stream_write_socket_blocked(&self, event: builder::StreamWriteSocketBlocked) {
let event = event.into_event();
self.subscriber
.on_stream_write_socket_blocked(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_stream_write_socket_errored(&self, event: builder::StreamWriteSocketErrored) {
let event = event.into_event();
self.subscriber
.on_stream_write_socket_errored(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_stream_read_flushed(&self, event: builder::StreamReadFlushed) {
let event = event.into_event();
self.subscriber
.on_stream_read_flushed(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_stream_read_fin_flushed(&self, event: builder::StreamReadFinFlushed) {
let event = event.into_event();
self.subscriber
.on_stream_read_fin_flushed(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_stream_read_blocked(&self, event: builder::StreamReadBlocked) {
let event = event.into_event();
self.subscriber
.on_stream_read_blocked(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_stream_read_errored(&self, event: builder::StreamReadErrored) {
let event = event.into_event();
self.subscriber
.on_stream_read_errored(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_stream_read_key_updated(&self, event: builder::StreamReadKeyUpdated) {
let event = event.into_event();
self.subscriber
.on_stream_read_key_updated(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_stream_read_shutdown(&self, event: builder::StreamReadShutdown) {
let event = event.into_event();
self.subscriber
.on_stream_read_shutdown(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_stream_read_socket_flushed(&self, event: builder::StreamReadSocketFlushed) {
let event = event.into_event();
self.subscriber
.on_stream_read_socket_flushed(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_stream_read_socket_blocked(&self, event: builder::StreamReadSocketBlocked) {
let event = event.into_event();
self.subscriber
.on_stream_read_socket_blocked(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_stream_read_socket_errored(&self, event: builder::StreamReadSocketErrored) {
let event = event.into_event();
self.subscriber
.on_stream_read_socket_errored(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_stream_decrypt_packet(&self, event: builder::StreamDecryptPacket) {
let event = event.into_event();
self.subscriber
.on_stream_decrypt_packet(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_stream_packet_transmitted(&self, event: builder::StreamPacketTransmitted) {
let event = event.into_event();
self.subscriber
.on_stream_packet_transmitted(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_stream_probe_transmitted(&self, event: builder::StreamProbeTransmitted) {
let event = event.into_event();
self.subscriber
.on_stream_probe_transmitted(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_stream_packet_received(&self, event: builder::StreamPacketReceived) {
let event = event.into_event();
self.subscriber
.on_stream_packet_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_stream_packet_lost(&self, event: builder::StreamPacketLost) {
let event = event.into_event();
self.subscriber
.on_stream_packet_lost(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_stream_packet_acked(&self, event: builder::StreamPacketAcked) {
let event = event.into_event();
self.subscriber
.on_stream_packet_acked(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_stream_packet_spuriously_retransmitted(
&self,
event: builder::StreamPacketSpuriouslyRetransmitted,
) {
let event = event.into_event();
self.subscriber.on_stream_packet_spuriously_retransmitted(
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_stream_max_data_received(&self, event: builder::StreamMaxDataReceived) {
let event = event.into_event();
self.subscriber
.on_stream_max_data_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_stream_control_packet_transmitted(
&self,
event: builder::StreamControlPacketTransmitted,
) {
let event = event.into_event();
self.subscriber
.on_stream_control_packet_transmitted(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_stream_control_packet_received(&self, event: builder::StreamControlPacketReceived) {
let event = event.into_event();
self.subscriber
.on_stream_control_packet_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_stream_receiver_errored(&self, event: builder::StreamReceiverErrored) {
let event = event.into_event();
self.subscriber
.on_stream_receiver_errored(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_stream_sender_errored(&self, event: builder::StreamSenderErrored) {
let event = event.into_event();
self.subscriber
.on_stream_sender_errored(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_stream_handshake_packet_rejected(
&self,
event: builder::StreamHandshakePacketRejected,
) {
let event = event.into_event();
self.subscriber
.on_stream_handshake_packet_rejected(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_connection_closed(&self, event: builder::ConnectionClosed) {
let event = event.into_event();
self.subscriber
.on_connection_closed(self.context, &self.meta, &event);
self.subscriber
.on_connection_event(self.context, &self.meta, &event);
self.subscriber.on_event(&self.meta, &event);
}
#[inline]
fn quic_version(&self) -> u32 {
self.quic_version
}
#[inline]
fn subject(&self) -> api::Subject {
self.meta.subject()
}
}
}
#[cfg(any(test, feature = "testing"))]
pub mod testing {
use super::*;
use crate::event::snapshot::Location;
use core::sync::atomic::{AtomicU64, Ordering};
use std::sync::Mutex;
pub mod endpoint {
use super::*;
pub struct Subscriber {
location: Option<Location>,
output: Mutex<Vec<String>>,
pub acceptor_tcp_started: AtomicU64,
pub acceptor_tcp_loop_iteration_completed: AtomicU64,
pub acceptor_tcp_fresh_enqueued: AtomicU64,
pub acceptor_tcp_fresh_batch_completed: AtomicU64,
pub acceptor_tcp_stream_dropped: AtomicU64,
pub acceptor_tcp_stream_replaced: AtomicU64,
pub acceptor_tcp_packet_received: AtomicU64,
pub acceptor_tcp_tls_started: AtomicU64,
pub acceptor_tcp_tls_stream_enqueued: AtomicU64,
pub acceptor_tcp_tls_stream_rejected: AtomicU64,
pub acceptor_tcp_synthetic_tls_stream_rejected: AtomicU64,
pub acceptor_tcp_packet_dropped: AtomicU64,
pub acceptor_tcp_stream_enqueued: AtomicU64,
pub acceptor_tcp_io_error: AtomicU64,
pub acceptor_tcp_socket_sent: AtomicU64,
pub acceptor_tcp_socket_received: AtomicU64,
pub acceptor_udp_started: AtomicU64,
pub acceptor_udp_datagram_received: AtomicU64,
pub acceptor_udp_packet_received: AtomicU64,
pub acceptor_udp_packet_dropped: AtomicU64,
pub acceptor_udp_stream_enqueued: AtomicU64,
pub acceptor_udp_io_error: AtomicU64,
pub acceptor_stream_pruned: AtomicU64,
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,
pub dc_connection_timeout: AtomicU64,
pub path_secret_map_initialized: AtomicU64,
pub path_secret_map_uninitialized: AtomicU64,
pub path_secret_map_background_handshake_requested: AtomicU64,
pub path_secret_map_entry_inserted: AtomicU64,
pub path_secret_map_entry_ready: AtomicU64,
pub path_secret_map_entry_replaced: AtomicU64,
pub path_secret_map_id_entry_evicted: AtomicU64,
pub path_secret_map_address_entry_evicted: AtomicU64,
pub unknown_path_secret_packet_sent: AtomicU64,
pub unknown_path_secret_packet_received: AtomicU64,
pub unknown_path_secret_packet_accepted: AtomicU64,
pub unknown_path_secret_packet_rejected: AtomicU64,
pub unknown_path_secret_packet_dropped: AtomicU64,
pub key_accepted: AtomicU64,
pub replay_definitely_detected: AtomicU64,
pub replay_potentially_detected: AtomicU64,
pub replay_detected_packet_sent: AtomicU64,
pub replay_detected_packet_received: AtomicU64,
pub replay_detected_packet_accepted: AtomicU64,
pub replay_detected_packet_rejected: AtomicU64,
pub replay_detected_packet_dropped: AtomicU64,
pub stale_key_packet_sent: AtomicU64,
pub stale_key_packet_received: AtomicU64,
pub stale_key_packet_accepted: AtomicU64,
pub stale_key_packet_rejected: AtomicU64,
pub stale_key_packet_dropped: AtomicU64,
pub path_secret_map_address_cache_accessed: AtomicU64,
pub path_secret_map_address_cache_accessed_hit: AtomicU64,
pub path_secret_map_id_cache_accessed: AtomicU64,
pub path_secret_map_id_cache_accessed_hit: AtomicU64,
pub path_secret_map_cleaner_cycled: AtomicU64,
pub path_secret_map_serialized: AtomicU64,
pub path_secret_map_id_write_lock: AtomicU64,
pub path_secret_map_address_write_lock: AtomicU64,
pub path_secret_map_datagram_encrypt: AtomicU64,
pub path_secret_map_datagram_decrypt: AtomicU64,
}
impl Drop for Subscriber {
fn drop(&mut self) {
if std::thread::panicking() {
return;
}
if let Some(location) = self.location.as_ref() {
location.snapshot_log(&self.output.lock().unwrap());
}
}
}
impl Subscriber {
#[track_caller]
pub fn snapshot() -> Self {
let mut sub = Self::no_snapshot();
sub.location = Location::from_thread_name();
sub
}
#[track_caller]
pub fn named_snapshot<Name: core::fmt::Display>(name: Name) -> Self {
let mut sub = Self::no_snapshot();
sub.location = Some(Location::new(name));
sub
}
pub fn no_snapshot() -> Self {
Self {
location: None,
output: Default::default(),
acceptor_tcp_started: AtomicU64::new(0),
acceptor_tcp_loop_iteration_completed: AtomicU64::new(0),
acceptor_tcp_fresh_enqueued: AtomicU64::new(0),
acceptor_tcp_fresh_batch_completed: AtomicU64::new(0),
acceptor_tcp_stream_dropped: AtomicU64::new(0),
acceptor_tcp_stream_replaced: AtomicU64::new(0),
acceptor_tcp_packet_received: AtomicU64::new(0),
acceptor_tcp_tls_started: AtomicU64::new(0),
acceptor_tcp_tls_stream_enqueued: AtomicU64::new(0),
acceptor_tcp_tls_stream_rejected: AtomicU64::new(0),
acceptor_tcp_synthetic_tls_stream_rejected: AtomicU64::new(0),
acceptor_tcp_packet_dropped: AtomicU64::new(0),
acceptor_tcp_stream_enqueued: AtomicU64::new(0),
acceptor_tcp_io_error: AtomicU64::new(0),
acceptor_tcp_socket_sent: AtomicU64::new(0),
acceptor_tcp_socket_received: AtomicU64::new(0),
acceptor_udp_started: AtomicU64::new(0),
acceptor_udp_datagram_received: AtomicU64::new(0),
acceptor_udp_packet_received: AtomicU64::new(0),
acceptor_udp_packet_dropped: AtomicU64::new(0),
acceptor_udp_stream_enqueued: AtomicU64::new(0),
acceptor_udp_io_error: AtomicU64::new(0),
acceptor_stream_pruned: AtomicU64::new(0),
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),
dc_connection_timeout: AtomicU64::new(0),
path_secret_map_initialized: AtomicU64::new(0),
path_secret_map_uninitialized: AtomicU64::new(0),
path_secret_map_background_handshake_requested: AtomicU64::new(0),
path_secret_map_entry_inserted: AtomicU64::new(0),
path_secret_map_entry_ready: AtomicU64::new(0),
path_secret_map_entry_replaced: AtomicU64::new(0),
path_secret_map_id_entry_evicted: AtomicU64::new(0),
path_secret_map_address_entry_evicted: AtomicU64::new(0),
unknown_path_secret_packet_sent: AtomicU64::new(0),
unknown_path_secret_packet_received: AtomicU64::new(0),
unknown_path_secret_packet_accepted: AtomicU64::new(0),
unknown_path_secret_packet_rejected: AtomicU64::new(0),
unknown_path_secret_packet_dropped: AtomicU64::new(0),
key_accepted: AtomicU64::new(0),
replay_definitely_detected: AtomicU64::new(0),
replay_potentially_detected: AtomicU64::new(0),
replay_detected_packet_sent: AtomicU64::new(0),
replay_detected_packet_received: AtomicU64::new(0),
replay_detected_packet_accepted: AtomicU64::new(0),
replay_detected_packet_rejected: AtomicU64::new(0),
replay_detected_packet_dropped: AtomicU64::new(0),
stale_key_packet_sent: AtomicU64::new(0),
stale_key_packet_received: AtomicU64::new(0),
stale_key_packet_accepted: AtomicU64::new(0),
stale_key_packet_rejected: AtomicU64::new(0),
stale_key_packet_dropped: AtomicU64::new(0),
path_secret_map_address_cache_accessed: AtomicU64::new(0),
path_secret_map_address_cache_accessed_hit: AtomicU64::new(0),
path_secret_map_id_cache_accessed: AtomicU64::new(0),
path_secret_map_id_cache_accessed_hit: AtomicU64::new(0),
path_secret_map_cleaner_cycled: AtomicU64::new(0),
path_secret_map_serialized: AtomicU64::new(0),
path_secret_map_id_write_lock: AtomicU64::new(0),
path_secret_map_address_write_lock: AtomicU64::new(0),
path_secret_map_datagram_encrypt: AtomicU64::new(0),
path_secret_map_datagram_decrypt: AtomicU64::new(0),
}
}
}
impl super::super::Subscriber for Subscriber {
type ConnectionContext = ();
fn create_connection_context(
&self,
_meta: &api::ConnectionMeta,
_info: &api::ConnectionInfo,
) -> Self::ConnectionContext {
}
fn on_acceptor_tcp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStarted,
) {
self.acceptor_tcp_started.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_loop_iteration_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpLoopIterationCompleted,
) {
self.acceptor_tcp_loop_iteration_completed
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_fresh_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshEnqueued,
) {
self.acceptor_tcp_fresh_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_fresh_batch_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshBatchCompleted,
) {
self.acceptor_tcp_fresh_batch_completed
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamDropped,
) {
self.acceptor_tcp_stream_dropped
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamReplaced,
) {
self.acceptor_tcp_stream_replaced
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketReceived,
) {
self.acceptor_tcp_packet_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStarted,
) {
self.acceptor_tcp_tls_started
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamEnqueued,
) {
self.acceptor_tcp_tls_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamRejected,
) {
self.acceptor_tcp_tls_stream_rejected
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSyntheticTlsStreamRejected,
) {
self.acceptor_tcp_synthetic_tls_stream_rejected
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketDropped,
) {
self.acceptor_tcp_packet_dropped
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamEnqueued,
) {
self.acceptor_tcp_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpIoError,
) {
self.acceptor_tcp_io_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_acceptor_tcp_socket_sent(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketSent,
) {
self.acceptor_tcp_socket_sent
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_socket_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketReceived,
) {
self.acceptor_tcp_socket_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStarted,
) {
self.acceptor_udp_started.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_datagram_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpDatagramReceived,
) {
self.acceptor_udp_datagram_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketReceived,
) {
self.acceptor_udp_packet_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketDropped,
) {
self.acceptor_udp_packet_dropped
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStreamEnqueued,
) {
self.acceptor_udp_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpIoError,
) {
self.acceptor_udp_io_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_acceptor_stream_pruned(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamPruned,
) {
self.acceptor_stream_pruned.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_stream_dequeued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamDequeued,
) {
self.acceptor_stream_dequeued
.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_tcp_connect(
&self,
meta: &api::EndpointMeta,
event: &api::StreamTcpConnect,
) {
self.stream_tcp_connect.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_tls_connect(
&self,
meta: &api::EndpointMeta,
event: &api::StreamTlsConnect,
) {
self.stream_tls_connect.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_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);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_stream_connect_error(
&self,
meta: &api::EndpointMeta,
event: &api::StreamConnectError,
) {
self.stream_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_endpoint_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::EndpointInitialized,
) {
self.endpoint_initialized.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_dc_connection_timeout(
&self,
meta: &api::EndpointMeta,
event: &api::DcConnectionTimeout,
) {
self.dc_connection_timeout.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_path_secret_map_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapInitialized,
) {
self.path_secret_map_initialized
.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_path_secret_map_uninitialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapUninitialized,
) {
self.path_secret_map_uninitialized
.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_path_secret_map_background_handshake_requested(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapBackgroundHandshakeRequested,
) {
self.path_secret_map_background_handshake_requested
.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_path_secret_map_entry_inserted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryInserted,
) {
self.path_secret_map_entry_inserted
.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_path_secret_map_entry_ready(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReady,
) {
self.path_secret_map_entry_ready
.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_path_secret_map_entry_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReplaced,
) {
self.path_secret_map_entry_replaced
.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_path_secret_map_id_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdEntryEvicted,
) {
self.path_secret_map_id_entry_evicted
.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_path_secret_map_address_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressEntryEvicted,
) {
self.path_secret_map_address_entry_evicted
.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_unknown_path_secret_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketSent,
) {
self.unknown_path_secret_packet_sent
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_unknown_path_secret_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketReceived,
) {
self.unknown_path_secret_packet_received
.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_unknown_path_secret_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketAccepted,
) {
self.unknown_path_secret_packet_accepted
.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_unknown_path_secret_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketRejected,
) {
self.unknown_path_secret_packet_rejected
.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_unknown_path_secret_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketDropped,
) {
self.unknown_path_secret_packet_dropped
.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_key_accepted(&self, meta: &api::EndpointMeta, event: &api::KeyAccepted) {
self.key_accepted.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_replay_definitely_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDefinitelyDetected,
) {
self.replay_definitely_detected
.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_replay_potentially_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayPotentiallyDetected,
) {
self.replay_potentially_detected
.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_replay_detected_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketSent,
) {
self.replay_detected_packet_sent
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_replay_detected_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketReceived,
) {
self.replay_detected_packet_received
.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_replay_detected_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketAccepted,
) {
self.replay_detected_packet_accepted
.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_replay_detected_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketRejected,
) {
self.replay_detected_packet_rejected
.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_replay_detected_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketDropped,
) {
self.replay_detected_packet_dropped
.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_stale_key_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketSent,
) {
self.stale_key_packet_sent.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_stale_key_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketReceived,
) {
self.stale_key_packet_received
.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_stale_key_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketAccepted,
) {
self.stale_key_packet_accepted
.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_stale_key_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketRejected,
) {
self.stale_key_packet_rejected
.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_stale_key_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketDropped,
) {
self.stale_key_packet_dropped
.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_path_secret_map_address_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessed,
) {
self.path_secret_map_address_cache_accessed
.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_path_secret_map_address_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessedHit,
) {
self.path_secret_map_address_cache_accessed_hit
.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_path_secret_map_id_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessed,
) {
self.path_secret_map_id_cache_accessed
.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_path_secret_map_id_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessedHit,
) {
self.path_secret_map_id_cache_accessed_hit
.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_path_secret_map_cleaner_cycled(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapCleanerCycled,
) {
self.path_secret_map_cleaner_cycled
.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_path_secret_map_serialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapSerialized,
) {
self.path_secret_map_serialized
.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_path_secret_map_id_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdWriteLock,
) {
self.path_secret_map_id_write_lock
.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_path_secret_map_address_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressWriteLock,
) {
self.path_secret_map_address_write_lock
.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_path_secret_map_datagram_encrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramEncrypt,
) {
self.path_secret_map_datagram_encrypt
.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_path_secret_map_datagram_decrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramDecrypt,
) {
self.path_secret_map_datagram_decrypt
.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);
}
}
}
#[derive(Debug)]
pub struct Subscriber {
location: Option<Location>,
output: Mutex<Vec<String>>,
pub acceptor_tcp_started: AtomicU64,
pub acceptor_tcp_loop_iteration_completed: AtomicU64,
pub acceptor_tcp_fresh_enqueued: AtomicU64,
pub acceptor_tcp_fresh_batch_completed: AtomicU64,
pub acceptor_tcp_stream_dropped: AtomicU64,
pub acceptor_tcp_stream_replaced: AtomicU64,
pub acceptor_tcp_packet_received: AtomicU64,
pub acceptor_tcp_tls_started: AtomicU64,
pub acceptor_tcp_tls_stream_enqueued: AtomicU64,
pub acceptor_tcp_tls_stream_rejected: AtomicU64,
pub acceptor_tcp_synthetic_tls_stream_rejected: AtomicU64,
pub acceptor_tcp_packet_dropped: AtomicU64,
pub acceptor_tcp_stream_enqueued: AtomicU64,
pub acceptor_tcp_io_error: AtomicU64,
pub acceptor_tcp_socket_sent: AtomicU64,
pub acceptor_tcp_socket_received: AtomicU64,
pub acceptor_udp_started: AtomicU64,
pub acceptor_udp_datagram_received: AtomicU64,
pub acceptor_udp_packet_received: AtomicU64,
pub acceptor_udp_packet_dropped: AtomicU64,
pub acceptor_udp_stream_enqueued: AtomicU64,
pub acceptor_udp_io_error: AtomicU64,
pub acceptor_stream_pruned: AtomicU64,
pub acceptor_stream_dequeued: AtomicU64,
pub stream_write_flushed: AtomicU64,
pub stream_write_fin_flushed: AtomicU64,
pub stream_write_blocked: AtomicU64,
pub stream_write_errored: AtomicU64,
pub stream_write_key_updated: AtomicU64,
pub stream_write_allocated: AtomicU64,
pub stream_write_shutdown: AtomicU64,
pub stream_write_socket_flushed: AtomicU64,
pub stream_write_socket_blocked: AtomicU64,
pub stream_write_socket_errored: AtomicU64,
pub stream_read_flushed: AtomicU64,
pub stream_read_fin_flushed: AtomicU64,
pub stream_read_blocked: AtomicU64,
pub stream_read_errored: AtomicU64,
pub stream_read_key_updated: AtomicU64,
pub stream_read_shutdown: AtomicU64,
pub stream_read_socket_flushed: AtomicU64,
pub stream_read_socket_blocked: AtomicU64,
pub stream_read_socket_errored: AtomicU64,
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,
pub stream_probe_transmitted: AtomicU64,
pub stream_packet_received: AtomicU64,
pub stream_packet_lost: AtomicU64,
pub stream_packet_acked: AtomicU64,
pub stream_packet_spuriously_retransmitted: AtomicU64,
pub stream_max_data_received: AtomicU64,
pub stream_control_packet_transmitted: AtomicU64,
pub stream_control_packet_received: AtomicU64,
pub stream_receiver_errored: AtomicU64,
pub stream_sender_errored: AtomicU64,
pub stream_handshake_packet_rejected: AtomicU64,
pub connection_closed: AtomicU64,
pub endpoint_initialized: AtomicU64,
pub dc_connection_timeout: AtomicU64,
pub path_secret_map_initialized: AtomicU64,
pub path_secret_map_uninitialized: AtomicU64,
pub path_secret_map_background_handshake_requested: AtomicU64,
pub path_secret_map_entry_inserted: AtomicU64,
pub path_secret_map_entry_ready: AtomicU64,
pub path_secret_map_entry_replaced: AtomicU64,
pub path_secret_map_id_entry_evicted: AtomicU64,
pub path_secret_map_address_entry_evicted: AtomicU64,
pub unknown_path_secret_packet_sent: AtomicU64,
pub unknown_path_secret_packet_received: AtomicU64,
pub unknown_path_secret_packet_accepted: AtomicU64,
pub unknown_path_secret_packet_rejected: AtomicU64,
pub unknown_path_secret_packet_dropped: AtomicU64,
pub key_accepted: AtomicU64,
pub replay_definitely_detected: AtomicU64,
pub replay_potentially_detected: AtomicU64,
pub replay_detected_packet_sent: AtomicU64,
pub replay_detected_packet_received: AtomicU64,
pub replay_detected_packet_accepted: AtomicU64,
pub replay_detected_packet_rejected: AtomicU64,
pub replay_detected_packet_dropped: AtomicU64,
pub stale_key_packet_sent: AtomicU64,
pub stale_key_packet_received: AtomicU64,
pub stale_key_packet_accepted: AtomicU64,
pub stale_key_packet_rejected: AtomicU64,
pub stale_key_packet_dropped: AtomicU64,
pub path_secret_map_address_cache_accessed: AtomicU64,
pub path_secret_map_address_cache_accessed_hit: AtomicU64,
pub path_secret_map_id_cache_accessed: AtomicU64,
pub path_secret_map_id_cache_accessed_hit: AtomicU64,
pub path_secret_map_cleaner_cycled: AtomicU64,
pub path_secret_map_serialized: AtomicU64,
pub path_secret_map_id_write_lock: AtomicU64,
pub path_secret_map_address_write_lock: AtomicU64,
pub path_secret_map_datagram_encrypt: AtomicU64,
pub path_secret_map_datagram_decrypt: AtomicU64,
}
impl Drop for Subscriber {
fn drop(&mut self) {
if std::thread::panicking() {
return;
}
if let Some(location) = self.location.as_ref() {
location.snapshot_log(&self.output.lock().unwrap());
}
}
}
impl Subscriber {
#[track_caller]
pub fn snapshot() -> Self {
let mut sub = Self::no_snapshot();
sub.location = Location::from_thread_name();
sub
}
#[track_caller]
pub fn named_snapshot<Name: core::fmt::Display>(name: Name) -> Self {
let mut sub = Self::no_snapshot();
sub.location = Some(Location::new(name));
sub
}
pub fn no_snapshot() -> Self {
Self {
location: None,
output: Default::default(),
acceptor_tcp_started: AtomicU64::new(0),
acceptor_tcp_loop_iteration_completed: AtomicU64::new(0),
acceptor_tcp_fresh_enqueued: AtomicU64::new(0),
acceptor_tcp_fresh_batch_completed: AtomicU64::new(0),
acceptor_tcp_stream_dropped: AtomicU64::new(0),
acceptor_tcp_stream_replaced: AtomicU64::new(0),
acceptor_tcp_packet_received: AtomicU64::new(0),
acceptor_tcp_tls_started: AtomicU64::new(0),
acceptor_tcp_tls_stream_enqueued: AtomicU64::new(0),
acceptor_tcp_tls_stream_rejected: AtomicU64::new(0),
acceptor_tcp_synthetic_tls_stream_rejected: AtomicU64::new(0),
acceptor_tcp_packet_dropped: AtomicU64::new(0),
acceptor_tcp_stream_enqueued: AtomicU64::new(0),
acceptor_tcp_io_error: AtomicU64::new(0),
acceptor_tcp_socket_sent: AtomicU64::new(0),
acceptor_tcp_socket_received: AtomicU64::new(0),
acceptor_udp_started: AtomicU64::new(0),
acceptor_udp_datagram_received: AtomicU64::new(0),
acceptor_udp_packet_received: AtomicU64::new(0),
acceptor_udp_packet_dropped: AtomicU64::new(0),
acceptor_udp_stream_enqueued: AtomicU64::new(0),
acceptor_udp_io_error: AtomicU64::new(0),
acceptor_stream_pruned: AtomicU64::new(0),
acceptor_stream_dequeued: AtomicU64::new(0),
stream_write_flushed: AtomicU64::new(0),
stream_write_fin_flushed: AtomicU64::new(0),
stream_write_blocked: AtomicU64::new(0),
stream_write_errored: AtomicU64::new(0),
stream_write_key_updated: AtomicU64::new(0),
stream_write_allocated: AtomicU64::new(0),
stream_write_shutdown: AtomicU64::new(0),
stream_write_socket_flushed: AtomicU64::new(0),
stream_write_socket_blocked: AtomicU64::new(0),
stream_write_socket_errored: AtomicU64::new(0),
stream_read_flushed: AtomicU64::new(0),
stream_read_fin_flushed: AtomicU64::new(0),
stream_read_blocked: AtomicU64::new(0),
stream_read_errored: AtomicU64::new(0),
stream_read_key_updated: AtomicU64::new(0),
stream_read_shutdown: AtomicU64::new(0),
stream_read_socket_flushed: AtomicU64::new(0),
stream_read_socket_blocked: AtomicU64::new(0),
stream_read_socket_errored: AtomicU64::new(0),
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),
stream_probe_transmitted: AtomicU64::new(0),
stream_packet_received: AtomicU64::new(0),
stream_packet_lost: AtomicU64::new(0),
stream_packet_acked: AtomicU64::new(0),
stream_packet_spuriously_retransmitted: AtomicU64::new(0),
stream_max_data_received: AtomicU64::new(0),
stream_control_packet_transmitted: AtomicU64::new(0),
stream_control_packet_received: AtomicU64::new(0),
stream_receiver_errored: AtomicU64::new(0),
stream_sender_errored: AtomicU64::new(0),
stream_handshake_packet_rejected: AtomicU64::new(0),
connection_closed: AtomicU64::new(0),
endpoint_initialized: AtomicU64::new(0),
dc_connection_timeout: AtomicU64::new(0),
path_secret_map_initialized: AtomicU64::new(0),
path_secret_map_uninitialized: AtomicU64::new(0),
path_secret_map_background_handshake_requested: AtomicU64::new(0),
path_secret_map_entry_inserted: AtomicU64::new(0),
path_secret_map_entry_ready: AtomicU64::new(0),
path_secret_map_entry_replaced: AtomicU64::new(0),
path_secret_map_id_entry_evicted: AtomicU64::new(0),
path_secret_map_address_entry_evicted: AtomicU64::new(0),
unknown_path_secret_packet_sent: AtomicU64::new(0),
unknown_path_secret_packet_received: AtomicU64::new(0),
unknown_path_secret_packet_accepted: AtomicU64::new(0),
unknown_path_secret_packet_rejected: AtomicU64::new(0),
unknown_path_secret_packet_dropped: AtomicU64::new(0),
key_accepted: AtomicU64::new(0),
replay_definitely_detected: AtomicU64::new(0),
replay_potentially_detected: AtomicU64::new(0),
replay_detected_packet_sent: AtomicU64::new(0),
replay_detected_packet_received: AtomicU64::new(0),
replay_detected_packet_accepted: AtomicU64::new(0),
replay_detected_packet_rejected: AtomicU64::new(0),
replay_detected_packet_dropped: AtomicU64::new(0),
stale_key_packet_sent: AtomicU64::new(0),
stale_key_packet_received: AtomicU64::new(0),
stale_key_packet_accepted: AtomicU64::new(0),
stale_key_packet_rejected: AtomicU64::new(0),
stale_key_packet_dropped: AtomicU64::new(0),
path_secret_map_address_cache_accessed: AtomicU64::new(0),
path_secret_map_address_cache_accessed_hit: AtomicU64::new(0),
path_secret_map_id_cache_accessed: AtomicU64::new(0),
path_secret_map_id_cache_accessed_hit: AtomicU64::new(0),
path_secret_map_cleaner_cycled: AtomicU64::new(0),
path_secret_map_serialized: AtomicU64::new(0),
path_secret_map_id_write_lock: AtomicU64::new(0),
path_secret_map_address_write_lock: AtomicU64::new(0),
path_secret_map_datagram_encrypt: AtomicU64::new(0),
path_secret_map_datagram_decrypt: AtomicU64::new(0),
}
}
}
impl super::Subscriber for Subscriber {
type ConnectionContext = ();
fn create_connection_context(
&self,
_meta: &api::ConnectionMeta,
_info: &api::ConnectionInfo,
) -> Self::ConnectionContext {
}
fn on_acceptor_tcp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStarted,
) {
self.acceptor_tcp_started.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_loop_iteration_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpLoopIterationCompleted,
) {
self.acceptor_tcp_loop_iteration_completed
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_fresh_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshEnqueued,
) {
self.acceptor_tcp_fresh_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_fresh_batch_completed(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpFreshBatchCompleted,
) {
self.acceptor_tcp_fresh_batch_completed
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamDropped,
) {
self.acceptor_tcp_stream_dropped
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamReplaced,
) {
self.acceptor_tcp_stream_replaced
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketReceived,
) {
self.acceptor_tcp_packet_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStarted,
) {
self.acceptor_tcp_tls_started
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamEnqueued,
) {
self.acceptor_tcp_tls_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpTlsStreamRejected,
) {
self.acceptor_tcp_tls_stream_rejected
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSyntheticTlsStreamRejected,
) {
self.acceptor_tcp_synthetic_tls_stream_rejected
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpPacketDropped,
) {
self.acceptor_tcp_packet_dropped
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpStreamEnqueued,
) {
self.acceptor_tcp_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpIoError,
) {
self.acceptor_tcp_io_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_acceptor_tcp_socket_sent(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketSent,
) {
self.acceptor_tcp_socket_sent
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_socket_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorTcpSocketReceived,
) {
self.acceptor_tcp_socket_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_started(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStarted,
) {
self.acceptor_udp_started.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_datagram_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpDatagramReceived,
) {
self.acceptor_udp_datagram_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketReceived,
) {
self.acceptor_udp_packet_received
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpPacketDropped,
) {
self.acceptor_udp_packet_dropped
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_stream_enqueued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpStreamEnqueued,
) {
self.acceptor_udp_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_io_error(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorUdpIoError,
) {
self.acceptor_udp_io_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_acceptor_stream_pruned(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamPruned,
) {
self.acceptor_stream_pruned.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_stream_dequeued(
&self,
meta: &api::EndpointMeta,
event: &api::AcceptorStreamDequeued,
) {
self.acceptor_stream_dequeued
.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_write_flushed(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFlushed,
) {
self.stream_write_flushed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_fin_flushed(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteFinFlushed,
) {
self.stream_write_fin_flushed
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_blocked(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteBlocked,
) {
self.stream_write_blocked.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_errored(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteErrored,
) {
self.stream_write_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_key_updated(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteKeyUpdated,
) {
self.stream_write_key_updated
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_allocated(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteAllocated,
) {
self.stream_write_allocated.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_shutdown(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteShutdown,
) {
self.stream_write_shutdown.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_socket_flushed(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketFlushed,
) {
self.stream_write_socket_flushed
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_socket_blocked(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketBlocked,
) {
self.stream_write_socket_blocked
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_socket_errored(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamWriteSocketErrored,
) {
self.stream_write_socket_errored
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_flushed(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFlushed,
) {
self.stream_read_flushed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_fin_flushed(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadFinFlushed,
) {
self.stream_read_fin_flushed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_blocked(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadBlocked,
) {
self.stream_read_blocked.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_errored(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadErrored,
) {
self.stream_read_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_key_updated(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadKeyUpdated,
) {
self.stream_read_key_updated.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_shutdown(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadShutdown,
) {
self.stream_read_shutdown.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_socket_flushed(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketFlushed,
) {
self.stream_read_socket_flushed
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_socket_blocked(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketBlocked,
) {
self.stream_read_socket_blocked
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_socket_errored(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReadSocketErrored,
) {
self.stream_read_socket_errored
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_decrypt_packet(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamDecryptPacket,
) {
self.stream_decrypt_packet.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_tcp_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTcpConnect) {
self.stream_tcp_connect.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_tls_connect(&self, meta: &api::EndpointMeta, event: &api::StreamTlsConnect) {
self.stream_tls_connect.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_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);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_stream_connect_error(
&self,
meta: &api::EndpointMeta,
event: &api::StreamConnectError,
) {
self.stream_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_packet_transmitted(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketTransmitted,
) {
self.stream_packet_transmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_probe_transmitted(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamProbeTransmitted,
) {
self.stream_probe_transmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_received(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketReceived,
) {
self.stream_packet_received.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_lost(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketLost,
) {
self.stream_packet_lost.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_acked(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketAcked,
) {
self.stream_packet_acked.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_spuriously_retransmitted(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamPacketSpuriouslyRetransmitted,
) {
self.stream_packet_spuriously_retransmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_max_data_received(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamMaxDataReceived,
) {
self.stream_max_data_received
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_control_packet_transmitted(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketTransmitted,
) {
self.stream_control_packet_transmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_control_packet_received(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamControlPacketReceived,
) {
self.stream_control_packet_received
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_receiver_errored(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamReceiverErrored,
) {
self.stream_receiver_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_sender_errored(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamSenderErrored,
) {
self.stream_sender_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_handshake_packet_rejected(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::StreamHandshakePacketRejected,
) {
self.stream_handshake_packet_rejected
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_connection_closed(
&self,
_context: &Self::ConnectionContext,
meta: &api::ConnectionMeta,
event: &api::ConnectionClosed,
) {
self.connection_closed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_endpoint_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::EndpointInitialized,
) {
self.endpoint_initialized.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_dc_connection_timeout(
&self,
meta: &api::EndpointMeta,
event: &api::DcConnectionTimeout,
) {
self.dc_connection_timeout.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_path_secret_map_initialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapInitialized,
) {
self.path_secret_map_initialized
.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_path_secret_map_uninitialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapUninitialized,
) {
self.path_secret_map_uninitialized
.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_path_secret_map_background_handshake_requested(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapBackgroundHandshakeRequested,
) {
self.path_secret_map_background_handshake_requested
.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_path_secret_map_entry_inserted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryInserted,
) {
self.path_secret_map_entry_inserted
.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_path_secret_map_entry_ready(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReady,
) {
self.path_secret_map_entry_ready
.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_path_secret_map_entry_replaced(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapEntryReplaced,
) {
self.path_secret_map_entry_replaced
.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_path_secret_map_id_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdEntryEvicted,
) {
self.path_secret_map_id_entry_evicted
.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_path_secret_map_address_entry_evicted(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressEntryEvicted,
) {
self.path_secret_map_address_entry_evicted
.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_unknown_path_secret_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketSent,
) {
self.unknown_path_secret_packet_sent
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_unknown_path_secret_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketReceived,
) {
self.unknown_path_secret_packet_received
.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_unknown_path_secret_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketAccepted,
) {
self.unknown_path_secret_packet_accepted
.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_unknown_path_secret_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketRejected,
) {
self.unknown_path_secret_packet_rejected
.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_unknown_path_secret_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::UnknownPathSecretPacketDropped,
) {
self.unknown_path_secret_packet_dropped
.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_key_accepted(&self, meta: &api::EndpointMeta, event: &api::KeyAccepted) {
self.key_accepted.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_replay_definitely_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDefinitelyDetected,
) {
self.replay_definitely_detected
.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_replay_potentially_detected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayPotentiallyDetected,
) {
self.replay_potentially_detected
.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_replay_detected_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketSent,
) {
self.replay_detected_packet_sent
.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_replay_detected_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketReceived,
) {
self.replay_detected_packet_received
.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_replay_detected_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketAccepted,
) {
self.replay_detected_packet_accepted
.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_replay_detected_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketRejected,
) {
self.replay_detected_packet_rejected
.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_replay_detected_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::ReplayDetectedPacketDropped,
) {
self.replay_detected_packet_dropped
.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_stale_key_packet_sent(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketSent,
) {
self.stale_key_packet_sent.fetch_add(1, Ordering::Relaxed);
let meta = crate::event::snapshot::Fmt::to_snapshot(meta);
let event = crate::event::snapshot::Fmt::to_snapshot(event);
let out = format!("{meta:?} {event:?}");
self.output.lock().unwrap().push(out);
}
fn on_stale_key_packet_received(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketReceived,
) {
self.stale_key_packet_received
.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_stale_key_packet_accepted(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketAccepted,
) {
self.stale_key_packet_accepted
.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_stale_key_packet_rejected(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketRejected,
) {
self.stale_key_packet_rejected
.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_stale_key_packet_dropped(
&self,
meta: &api::EndpointMeta,
event: &api::StaleKeyPacketDropped,
) {
self.stale_key_packet_dropped
.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_path_secret_map_address_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessed,
) {
self.path_secret_map_address_cache_accessed
.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_path_secret_map_address_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressCacheAccessedHit,
) {
self.path_secret_map_address_cache_accessed_hit
.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_path_secret_map_id_cache_accessed(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessed,
) {
self.path_secret_map_id_cache_accessed
.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_path_secret_map_id_cache_accessed_hit(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdCacheAccessedHit,
) {
self.path_secret_map_id_cache_accessed_hit
.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_path_secret_map_cleaner_cycled(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapCleanerCycled,
) {
self.path_secret_map_cleaner_cycled
.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_path_secret_map_serialized(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapSerialized,
) {
self.path_secret_map_serialized
.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_path_secret_map_id_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapIdWriteLock,
) {
self.path_secret_map_id_write_lock
.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_path_secret_map_address_write_lock(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapAddressWriteLock,
) {
self.path_secret_map_address_write_lock
.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_path_secret_map_datagram_encrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramEncrypt,
) {
self.path_secret_map_datagram_encrypt
.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_path_secret_map_datagram_decrypt(
&self,
meta: &api::EndpointMeta,
event: &api::PathSecretMapDatagramDecrypt,
) {
self.path_secret_map_datagram_decrypt
.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);
}
}
#[derive(Debug)]
pub struct Publisher {
location: Option<Location>,
output: Mutex<Vec<String>>,
pub acceptor_tcp_started: AtomicU64,
pub acceptor_tcp_loop_iteration_completed: AtomicU64,
pub acceptor_tcp_fresh_enqueued: AtomicU64,
pub acceptor_tcp_fresh_batch_completed: AtomicU64,
pub acceptor_tcp_stream_dropped: AtomicU64,
pub acceptor_tcp_stream_replaced: AtomicU64,
pub acceptor_tcp_packet_received: AtomicU64,
pub acceptor_tcp_tls_started: AtomicU64,
pub acceptor_tcp_tls_stream_enqueued: AtomicU64,
pub acceptor_tcp_tls_stream_rejected: AtomicU64,
pub acceptor_tcp_synthetic_tls_stream_rejected: AtomicU64,
pub acceptor_tcp_packet_dropped: AtomicU64,
pub acceptor_tcp_stream_enqueued: AtomicU64,
pub acceptor_tcp_io_error: AtomicU64,
pub acceptor_tcp_socket_sent: AtomicU64,
pub acceptor_tcp_socket_received: AtomicU64,
pub acceptor_udp_started: AtomicU64,
pub acceptor_udp_datagram_received: AtomicU64,
pub acceptor_udp_packet_received: AtomicU64,
pub acceptor_udp_packet_dropped: AtomicU64,
pub acceptor_udp_stream_enqueued: AtomicU64,
pub acceptor_udp_io_error: AtomicU64,
pub acceptor_stream_pruned: AtomicU64,
pub acceptor_stream_dequeued: AtomicU64,
pub stream_write_flushed: AtomicU64,
pub stream_write_fin_flushed: AtomicU64,
pub stream_write_blocked: AtomicU64,
pub stream_write_errored: AtomicU64,
pub stream_write_key_updated: AtomicU64,
pub stream_write_allocated: AtomicU64,
pub stream_write_shutdown: AtomicU64,
pub stream_write_socket_flushed: AtomicU64,
pub stream_write_socket_blocked: AtomicU64,
pub stream_write_socket_errored: AtomicU64,
pub stream_read_flushed: AtomicU64,
pub stream_read_fin_flushed: AtomicU64,
pub stream_read_blocked: AtomicU64,
pub stream_read_errored: AtomicU64,
pub stream_read_key_updated: AtomicU64,
pub stream_read_shutdown: AtomicU64,
pub stream_read_socket_flushed: AtomicU64,
pub stream_read_socket_blocked: AtomicU64,
pub stream_read_socket_errored: AtomicU64,
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,
pub stream_probe_transmitted: AtomicU64,
pub stream_packet_received: AtomicU64,
pub stream_packet_lost: AtomicU64,
pub stream_packet_acked: AtomicU64,
pub stream_packet_spuriously_retransmitted: AtomicU64,
pub stream_max_data_received: AtomicU64,
pub stream_control_packet_transmitted: AtomicU64,
pub stream_control_packet_received: AtomicU64,
pub stream_receiver_errored: AtomicU64,
pub stream_sender_errored: AtomicU64,
pub stream_handshake_packet_rejected: AtomicU64,
pub connection_closed: AtomicU64,
pub endpoint_initialized: AtomicU64,
pub dc_connection_timeout: AtomicU64,
pub path_secret_map_initialized: AtomicU64,
pub path_secret_map_uninitialized: AtomicU64,
pub path_secret_map_background_handshake_requested: AtomicU64,
pub path_secret_map_entry_inserted: AtomicU64,
pub path_secret_map_entry_ready: AtomicU64,
pub path_secret_map_entry_replaced: AtomicU64,
pub path_secret_map_id_entry_evicted: AtomicU64,
pub path_secret_map_address_entry_evicted: AtomicU64,
pub unknown_path_secret_packet_sent: AtomicU64,
pub unknown_path_secret_packet_received: AtomicU64,
pub unknown_path_secret_packet_accepted: AtomicU64,
pub unknown_path_secret_packet_rejected: AtomicU64,
pub unknown_path_secret_packet_dropped: AtomicU64,
pub key_accepted: AtomicU64,
pub replay_definitely_detected: AtomicU64,
pub replay_potentially_detected: AtomicU64,
pub replay_detected_packet_sent: AtomicU64,
pub replay_detected_packet_received: AtomicU64,
pub replay_detected_packet_accepted: AtomicU64,
pub replay_detected_packet_rejected: AtomicU64,
pub replay_detected_packet_dropped: AtomicU64,
pub stale_key_packet_sent: AtomicU64,
pub stale_key_packet_received: AtomicU64,
pub stale_key_packet_accepted: AtomicU64,
pub stale_key_packet_rejected: AtomicU64,
pub stale_key_packet_dropped: AtomicU64,
pub path_secret_map_address_cache_accessed: AtomicU64,
pub path_secret_map_address_cache_accessed_hit: AtomicU64,
pub path_secret_map_id_cache_accessed: AtomicU64,
pub path_secret_map_id_cache_accessed_hit: AtomicU64,
pub path_secret_map_cleaner_cycled: AtomicU64,
pub path_secret_map_serialized: AtomicU64,
pub path_secret_map_id_write_lock: AtomicU64,
pub path_secret_map_address_write_lock: AtomicU64,
pub path_secret_map_datagram_encrypt: AtomicU64,
pub path_secret_map_datagram_decrypt: AtomicU64,
}
impl Publisher {
#[track_caller]
pub fn snapshot() -> Self {
let mut sub = Self::no_snapshot();
sub.location = Location::from_thread_name();
sub
}
#[track_caller]
pub fn named_snapshot<Name: core::fmt::Display>(name: Name) -> Self {
let mut sub = Self::no_snapshot();
sub.location = Some(Location::new(name));
sub
}
pub fn no_snapshot() -> Self {
Self {
location: None,
output: Default::default(),
acceptor_tcp_started: AtomicU64::new(0),
acceptor_tcp_loop_iteration_completed: AtomicU64::new(0),
acceptor_tcp_fresh_enqueued: AtomicU64::new(0),
acceptor_tcp_fresh_batch_completed: AtomicU64::new(0),
acceptor_tcp_stream_dropped: AtomicU64::new(0),
acceptor_tcp_stream_replaced: AtomicU64::new(0),
acceptor_tcp_packet_received: AtomicU64::new(0),
acceptor_tcp_tls_started: AtomicU64::new(0),
acceptor_tcp_tls_stream_enqueued: AtomicU64::new(0),
acceptor_tcp_tls_stream_rejected: AtomicU64::new(0),
acceptor_tcp_synthetic_tls_stream_rejected: AtomicU64::new(0),
acceptor_tcp_packet_dropped: AtomicU64::new(0),
acceptor_tcp_stream_enqueued: AtomicU64::new(0),
acceptor_tcp_io_error: AtomicU64::new(0),
acceptor_tcp_socket_sent: AtomicU64::new(0),
acceptor_tcp_socket_received: AtomicU64::new(0),
acceptor_udp_started: AtomicU64::new(0),
acceptor_udp_datagram_received: AtomicU64::new(0),
acceptor_udp_packet_received: AtomicU64::new(0),
acceptor_udp_packet_dropped: AtomicU64::new(0),
acceptor_udp_stream_enqueued: AtomicU64::new(0),
acceptor_udp_io_error: AtomicU64::new(0),
acceptor_stream_pruned: AtomicU64::new(0),
acceptor_stream_dequeued: AtomicU64::new(0),
stream_write_flushed: AtomicU64::new(0),
stream_write_fin_flushed: AtomicU64::new(0),
stream_write_blocked: AtomicU64::new(0),
stream_write_errored: AtomicU64::new(0),
stream_write_key_updated: AtomicU64::new(0),
stream_write_allocated: AtomicU64::new(0),
stream_write_shutdown: AtomicU64::new(0),
stream_write_socket_flushed: AtomicU64::new(0),
stream_write_socket_blocked: AtomicU64::new(0),
stream_write_socket_errored: AtomicU64::new(0),
stream_read_flushed: AtomicU64::new(0),
stream_read_fin_flushed: AtomicU64::new(0),
stream_read_blocked: AtomicU64::new(0),
stream_read_errored: AtomicU64::new(0),
stream_read_key_updated: AtomicU64::new(0),
stream_read_shutdown: AtomicU64::new(0),
stream_read_socket_flushed: AtomicU64::new(0),
stream_read_socket_blocked: AtomicU64::new(0),
stream_read_socket_errored: AtomicU64::new(0),
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),
stream_probe_transmitted: AtomicU64::new(0),
stream_packet_received: AtomicU64::new(0),
stream_packet_lost: AtomicU64::new(0),
stream_packet_acked: AtomicU64::new(0),
stream_packet_spuriously_retransmitted: AtomicU64::new(0),
stream_max_data_received: AtomicU64::new(0),
stream_control_packet_transmitted: AtomicU64::new(0),
stream_control_packet_received: AtomicU64::new(0),
stream_receiver_errored: AtomicU64::new(0),
stream_sender_errored: AtomicU64::new(0),
stream_handshake_packet_rejected: AtomicU64::new(0),
connection_closed: AtomicU64::new(0),
endpoint_initialized: AtomicU64::new(0),
dc_connection_timeout: AtomicU64::new(0),
path_secret_map_initialized: AtomicU64::new(0),
path_secret_map_uninitialized: AtomicU64::new(0),
path_secret_map_background_handshake_requested: AtomicU64::new(0),
path_secret_map_entry_inserted: AtomicU64::new(0),
path_secret_map_entry_ready: AtomicU64::new(0),
path_secret_map_entry_replaced: AtomicU64::new(0),
path_secret_map_id_entry_evicted: AtomicU64::new(0),
path_secret_map_address_entry_evicted: AtomicU64::new(0),
unknown_path_secret_packet_sent: AtomicU64::new(0),
unknown_path_secret_packet_received: AtomicU64::new(0),
unknown_path_secret_packet_accepted: AtomicU64::new(0),
unknown_path_secret_packet_rejected: AtomicU64::new(0),
unknown_path_secret_packet_dropped: AtomicU64::new(0),
key_accepted: AtomicU64::new(0),
replay_definitely_detected: AtomicU64::new(0),
replay_potentially_detected: AtomicU64::new(0),
replay_detected_packet_sent: AtomicU64::new(0),
replay_detected_packet_received: AtomicU64::new(0),
replay_detected_packet_accepted: AtomicU64::new(0),
replay_detected_packet_rejected: AtomicU64::new(0),
replay_detected_packet_dropped: AtomicU64::new(0),
stale_key_packet_sent: AtomicU64::new(0),
stale_key_packet_received: AtomicU64::new(0),
stale_key_packet_accepted: AtomicU64::new(0),
stale_key_packet_rejected: AtomicU64::new(0),
stale_key_packet_dropped: AtomicU64::new(0),
path_secret_map_address_cache_accessed: AtomicU64::new(0),
path_secret_map_address_cache_accessed_hit: AtomicU64::new(0),
path_secret_map_id_cache_accessed: AtomicU64::new(0),
path_secret_map_id_cache_accessed_hit: AtomicU64::new(0),
path_secret_map_cleaner_cycled: AtomicU64::new(0),
path_secret_map_serialized: AtomicU64::new(0),
path_secret_map_id_write_lock: AtomicU64::new(0),
path_secret_map_address_write_lock: AtomicU64::new(0),
path_secret_map_datagram_encrypt: AtomicU64::new(0),
path_secret_map_datagram_decrypt: AtomicU64::new(0),
}
}
}
impl super::EndpointPublisher for Publisher {
fn on_acceptor_tcp_started(&self, event: builder::AcceptorTcpStarted) {
self.acceptor_tcp_started.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_loop_iteration_completed(
&self,
event: builder::AcceptorTcpLoopIterationCompleted,
) {
self.acceptor_tcp_loop_iteration_completed
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_fresh_enqueued(&self, event: builder::AcceptorTcpFreshEnqueued) {
self.acceptor_tcp_fresh_enqueued
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_fresh_batch_completed(
&self,
event: builder::AcceptorTcpFreshBatchCompleted,
) {
self.acceptor_tcp_fresh_batch_completed
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_dropped(&self, event: builder::AcceptorTcpStreamDropped) {
self.acceptor_tcp_stream_dropped
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_replaced(&self, event: builder::AcceptorTcpStreamReplaced) {
self.acceptor_tcp_stream_replaced
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_packet_received(&self, event: builder::AcceptorTcpPacketReceived) {
self.acceptor_tcp_packet_received
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_started(&self, event: builder::AcceptorTcpTlsStarted) {
self.acceptor_tcp_tls_started
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_stream_enqueued(
&self,
event: builder::AcceptorTcpTlsStreamEnqueued,
) {
self.acceptor_tcp_tls_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_tls_stream_rejected(
&self,
event: builder::AcceptorTcpTlsStreamRejected,
) {
self.acceptor_tcp_tls_stream_rejected
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_synthetic_tls_stream_rejected(
&self,
event: builder::AcceptorTcpSyntheticTlsStreamRejected,
) {
self.acceptor_tcp_synthetic_tls_stream_rejected
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_packet_dropped(&self, event: builder::AcceptorTcpPacketDropped) {
self.acceptor_tcp_packet_dropped
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_stream_enqueued(&self, event: builder::AcceptorTcpStreamEnqueued) {
self.acceptor_tcp_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_io_error(&self, event: builder::AcceptorTcpIoError) {
self.acceptor_tcp_io_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_acceptor_tcp_socket_sent(&self, event: builder::AcceptorTcpSocketSent) {
self.acceptor_tcp_socket_sent
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_tcp_socket_received(&self, event: builder::AcceptorTcpSocketReceived) {
self.acceptor_tcp_socket_received
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_started(&self, event: builder::AcceptorUdpStarted) {
self.acceptor_udp_started.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_datagram_received(&self, event: builder::AcceptorUdpDatagramReceived) {
self.acceptor_udp_datagram_received
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_packet_received(&self, event: builder::AcceptorUdpPacketReceived) {
self.acceptor_udp_packet_received
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_packet_dropped(&self, event: builder::AcceptorUdpPacketDropped) {
self.acceptor_udp_packet_dropped
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_stream_enqueued(&self, event: builder::AcceptorUdpStreamEnqueued) {
self.acceptor_udp_stream_enqueued
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_udp_io_error(&self, event: builder::AcceptorUdpIoError) {
self.acceptor_udp_io_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_acceptor_stream_pruned(&self, event: builder::AcceptorStreamPruned) {
self.acceptor_stream_pruned.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_acceptor_stream_dequeued(&self, event: builder::AcceptorStreamDequeued) {
self.acceptor_stream_dequeued
.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_tcp_connect(&self, event: builder::StreamTcpConnect) {
self.stream_tcp_connect.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_tls_connect(&self, event: builder::StreamTlsConnect) {
self.stream_tls_connect.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_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();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_stream_connect_error(&self, event: builder::StreamConnectError) {
self.stream_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_endpoint_initialized(&self, event: builder::EndpointInitialized) {
self.endpoint_initialized.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_dc_connection_timeout(&self, event: builder::DcConnectionTimeout) {
self.dc_connection_timeout.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_path_secret_map_initialized(&self, event: builder::PathSecretMapInitialized) {
self.path_secret_map_initialized
.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_path_secret_map_uninitialized(&self, event: builder::PathSecretMapUninitialized) {
self.path_secret_map_uninitialized
.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_path_secret_map_background_handshake_requested(
&self,
event: builder::PathSecretMapBackgroundHandshakeRequested,
) {
self.path_secret_map_background_handshake_requested
.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_path_secret_map_entry_inserted(&self, event: builder::PathSecretMapEntryInserted) {
self.path_secret_map_entry_inserted
.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_path_secret_map_entry_ready(&self, event: builder::PathSecretMapEntryReady) {
self.path_secret_map_entry_ready
.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_path_secret_map_entry_replaced(&self, event: builder::PathSecretMapEntryReplaced) {
self.path_secret_map_entry_replaced
.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_path_secret_map_id_entry_evicted(&self, event: builder::PathSecretMapIdEntryEvicted) {
self.path_secret_map_id_entry_evicted
.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_path_secret_map_address_entry_evicted(
&self,
event: builder::PathSecretMapAddressEntryEvicted,
) {
self.path_secret_map_address_entry_evicted
.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_unknown_path_secret_packet_sent(&self, event: builder::UnknownPathSecretPacketSent) {
self.unknown_path_secret_packet_sent
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_unknown_path_secret_packet_received(
&self,
event: builder::UnknownPathSecretPacketReceived,
) {
self.unknown_path_secret_packet_received
.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_unknown_path_secret_packet_accepted(
&self,
event: builder::UnknownPathSecretPacketAccepted,
) {
self.unknown_path_secret_packet_accepted
.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_unknown_path_secret_packet_rejected(
&self,
event: builder::UnknownPathSecretPacketRejected,
) {
self.unknown_path_secret_packet_rejected
.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_unknown_path_secret_packet_dropped(
&self,
event: builder::UnknownPathSecretPacketDropped,
) {
self.unknown_path_secret_packet_dropped
.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_key_accepted(&self, event: builder::KeyAccepted) {
self.key_accepted.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_replay_definitely_detected(&self, event: builder::ReplayDefinitelyDetected) {
self.replay_definitely_detected
.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_replay_potentially_detected(&self, event: builder::ReplayPotentiallyDetected) {
self.replay_potentially_detected
.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_replay_detected_packet_sent(&self, event: builder::ReplayDetectedPacketSent) {
self.replay_detected_packet_sent
.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_replay_detected_packet_received(&self, event: builder::ReplayDetectedPacketReceived) {
self.replay_detected_packet_received
.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_replay_detected_packet_accepted(&self, event: builder::ReplayDetectedPacketAccepted) {
self.replay_detected_packet_accepted
.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_replay_detected_packet_rejected(&self, event: builder::ReplayDetectedPacketRejected) {
self.replay_detected_packet_rejected
.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_replay_detected_packet_dropped(&self, event: builder::ReplayDetectedPacketDropped) {
self.replay_detected_packet_dropped
.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_stale_key_packet_sent(&self, event: builder::StaleKeyPacketSent) {
self.stale_key_packet_sent.fetch_add(1, Ordering::Relaxed);
let event = event.into_event();
let event = crate::event::snapshot::Fmt::to_snapshot(&event);
let out = format!("{event:?}");
self.output.lock().unwrap().push(out);
}
fn on_stale_key_packet_received(&self, event: builder::StaleKeyPacketReceived) {
self.stale_key_packet_received
.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_stale_key_packet_accepted(&self, event: builder::StaleKeyPacketAccepted) {
self.stale_key_packet_accepted
.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_stale_key_packet_rejected(&self, event: builder::StaleKeyPacketRejected) {
self.stale_key_packet_rejected
.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_stale_key_packet_dropped(&self, event: builder::StaleKeyPacketDropped) {
self.stale_key_packet_dropped
.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_path_secret_map_address_cache_accessed(
&self,
event: builder::PathSecretMapAddressCacheAccessed,
) {
self.path_secret_map_address_cache_accessed
.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_path_secret_map_address_cache_accessed_hit(
&self,
event: builder::PathSecretMapAddressCacheAccessedHit,
) {
self.path_secret_map_address_cache_accessed_hit
.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_path_secret_map_id_cache_accessed(
&self,
event: builder::PathSecretMapIdCacheAccessed,
) {
self.path_secret_map_id_cache_accessed
.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_path_secret_map_id_cache_accessed_hit(
&self,
event: builder::PathSecretMapIdCacheAccessedHit,
) {
self.path_secret_map_id_cache_accessed_hit
.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_path_secret_map_cleaner_cycled(&self, event: builder::PathSecretMapCleanerCycled) {
self.path_secret_map_cleaner_cycled
.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_path_secret_map_serialized(&self, event: builder::PathSecretMapSerialized) {
self.path_secret_map_serialized
.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_path_secret_map_id_write_lock(&self, event: builder::PathSecretMapIdWriteLock) {
self.path_secret_map_id_write_lock
.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_path_secret_map_address_write_lock(
&self,
event: builder::PathSecretMapAddressWriteLock,
) {
self.path_secret_map_address_write_lock
.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_path_secret_map_datagram_encrypt(
&self,
event: builder::PathSecretMapDatagramEncrypt,
) {
self.path_secret_map_datagram_encrypt
.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_path_secret_map_datagram_decrypt(
&self,
event: builder::PathSecretMapDatagramDecrypt,
) {
self.path_secret_map_datagram_decrypt
.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 quic_version(&self) -> Option<u32> {
Some(1)
}
}
impl super::ConnectionPublisher for Publisher {
fn on_stream_write_flushed(&self, event: builder::StreamWriteFlushed) {
self.stream_write_flushed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_fin_flushed(&self, event: builder::StreamWriteFinFlushed) {
self.stream_write_fin_flushed
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_blocked(&self, event: builder::StreamWriteBlocked) {
self.stream_write_blocked.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_errored(&self, event: builder::StreamWriteErrored) {
self.stream_write_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_key_updated(&self, event: builder::StreamWriteKeyUpdated) {
self.stream_write_key_updated
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_allocated(&self, event: builder::StreamWriteAllocated) {
self.stream_write_allocated.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_shutdown(&self, event: builder::StreamWriteShutdown) {
self.stream_write_shutdown.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_socket_flushed(&self, event: builder::StreamWriteSocketFlushed) {
self.stream_write_socket_flushed
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_socket_blocked(&self, event: builder::StreamWriteSocketBlocked) {
self.stream_write_socket_blocked
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_write_socket_errored(&self, event: builder::StreamWriteSocketErrored) {
self.stream_write_socket_errored
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_flushed(&self, event: builder::StreamReadFlushed) {
self.stream_read_flushed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_fin_flushed(&self, event: builder::StreamReadFinFlushed) {
self.stream_read_fin_flushed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_blocked(&self, event: builder::StreamReadBlocked) {
self.stream_read_blocked.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_errored(&self, event: builder::StreamReadErrored) {
self.stream_read_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_key_updated(&self, event: builder::StreamReadKeyUpdated) {
self.stream_read_key_updated.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_shutdown(&self, event: builder::StreamReadShutdown) {
self.stream_read_shutdown.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_socket_flushed(&self, event: builder::StreamReadSocketFlushed) {
self.stream_read_socket_flushed
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_socket_blocked(&self, event: builder::StreamReadSocketBlocked) {
self.stream_read_socket_blocked
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_read_socket_errored(&self, event: builder::StreamReadSocketErrored) {
self.stream_read_socket_errored
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_decrypt_packet(&self, event: builder::StreamDecryptPacket) {
self.stream_decrypt_packet.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_transmitted(&self, event: builder::StreamPacketTransmitted) {
self.stream_packet_transmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_probe_transmitted(&self, event: builder::StreamProbeTransmitted) {
self.stream_probe_transmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_received(&self, event: builder::StreamPacketReceived) {
self.stream_packet_received.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_lost(&self, event: builder::StreamPacketLost) {
self.stream_packet_lost.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_acked(&self, event: builder::StreamPacketAcked) {
self.stream_packet_acked.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_packet_spuriously_retransmitted(
&self,
event: builder::StreamPacketSpuriouslyRetransmitted,
) {
self.stream_packet_spuriously_retransmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_max_data_received(&self, event: builder::StreamMaxDataReceived) {
self.stream_max_data_received
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_control_packet_transmitted(
&self,
event: builder::StreamControlPacketTransmitted,
) {
self.stream_control_packet_transmitted
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_control_packet_received(&self, event: builder::StreamControlPacketReceived) {
self.stream_control_packet_received
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_receiver_errored(&self, event: builder::StreamReceiverErrored) {
self.stream_receiver_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_sender_errored(&self, event: builder::StreamSenderErrored) {
self.stream_sender_errored.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_stream_handshake_packet_rejected(
&self,
event: builder::StreamHandshakePacketRejected,
) {
self.stream_handshake_packet_rejected
.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn on_connection_closed(&self, event: builder::ConnectionClosed) {
self.connection_closed.fetch_add(1, Ordering::Relaxed);
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.lock().unwrap().push(out);
}
}
fn quic_version(&self) -> u32 {
1
}
fn subject(&self) -> api::Subject {
builder::Subject::Connection { id: 0 }.into_event()
}
}
impl Drop for Publisher {
fn drop(&mut self) {
if std::thread::panicking() {
return;
}
if let Some(location) = self.location.as_ref() {
location.snapshot_log(&self.output.lock().unwrap());
}
}
}
}