Emit qlog PacketSent events

Author: Ralith

quinn-proto/src/connection/mod.rs

@@ -1050,7 +1050,7 @@ impl Connection {
         // sending a datagram of this size
         builder.pad_to(MIN_INITIAL_SIZE);
 
-        builder.finish(self, buf);
+        builder.finish(self, now, buf);
         self.stats.udp_tx.on_sent(1, buf.len());
 
         Some(Transmit {

quinn-proto/src/connection/packet_builder.rs

@@ -191,7 +191,7 @@ impl PacketBuilder {
         let ack_eliciting = self.ack_eliciting;
         let exact_number = self.exact_number;
         let space_id = self.space;
-        let (size, padded) = self.finish(conn, buffer);
+        let (size, padded) = self.finish(conn, now, buffer);
         let sent = match sent {
             Some(sent) => sent,
             None => return,
@@ -229,7 +229,12 @@ impl PacketBuilder {
     }
 
     /// Encrypt packet, returning the length of the packet and whether padding was added
-    pub(super) fn finish(self, conn: &mut Connection, buffer: &mut Vec<u8>) -> (usize, bool) {
+    pub(super) fn finish(
+        self,
+        conn: &mut Connection,
+        now: Instant,
+        buffer: &mut Vec<u8>,
+    ) -> (usize, bool) {
         let pad = buffer.len() < self.min_size;
         if pad {
             trace!("PADDING * {}", self.min_size - buffer.len());
@@ -261,6 +266,16 @@ impl PacketBuilder {
             Some((self.exact_number, packet_crypto)),
         );
 
-        (buffer.len() - encode_start, pad)
+        let len = buffer.len() - encode_start;
+        conn.config.qlog_sink.emit_packet_sent(
+            self.exact_number,
+            len,
+            self.space,
+            self.space == SpaceId::Data && conn.spaces[SpaceId::Data].crypto.is_none(),
+            now,
+            conn.orig_rem_cid,
+        );
+
+        (len, pad)
     }
 }

quinn-proto/src/connection/qlog.rs

@@ -8,7 +8,7 @@ use std::sync::{Arc, Mutex};
 use qlog::{
     events::{
         Event, EventData,
-        quic::{PacketHeader, PacketLost, PacketLostTrigger, PacketType},
+        quic::{PacketHeader, PacketLost, PacketLostTrigger, PacketSent, PacketType},
     },
     streamer::QlogStreamer,
 };
@@ -98,7 +98,7 @@ impl QlogSink {
             let event = PacketLost {
                 header: Some(PacketHeader {
                     packet_number: Some(pn),
-                    packet_type: packet_type(space),
+                    packet_type: packet_type(space, false),
                     length: Some(info.size),
                     ..Default::default()
                 }),
@@ -112,6 +112,35 @@ impl QlogSink {
             stream.emit_event(orig_rem_cid, EventData::PacketLost(event), now);
         }
     }
+
+    pub(super) fn emit_packet_sent(
+        &self,
+        pn: u64,
+        len: usize,
+        space: SpaceId,
+        is_0rtt: bool,
+        now: Instant,
+        orig_rem_cid: ConnectionId,
+    ) {
+        #[cfg(feature = "qlog")]
+        {
+            let Some(stream) = self.stream.as_ref() else {
+                return;
+            };
+
+            let event = PacketSent {
+                header: PacketHeader {
+                    packet_number: Some(pn),
+                    packet_type: packet_type(space, is_0rtt),
+                    length: Some(len as u16),
+                    ..Default::default()
+                },
+                ..Default::default()
+            };
+
+            stream.emit_event(orig_rem_cid, EventData::PacketSent(event), now);
+        }
+    }
 }
 
 #[cfg(feature = "qlog")]
@@ -122,10 +151,11 @@ impl From<Option<QlogStream>> for QlogSink {
 }
 
 #[cfg(feature = "qlog")]
-fn packet_type(space: SpaceId) -> PacketType {
+fn packet_type(space: SpaceId, is_0rtt: bool) -> PacketType {
     match space {
         SpaceId::Initial => PacketType::Initial,
         SpaceId::Handshake => PacketType::Handshake,
+        SpaceId::Data if is_0rtt => PacketType::ZeroRtt,
         SpaceId::Data => PacketType::OneRtt,
     }
 }