qlog: log sent Version Negotiation packets

qlog/event.go

@@ -233,6 +233,20 @@ func (e eventVersionNegotiationReceived) MarshalJSONObject(enc *gojay.Encoder) {
  enc.ArrayKey("supported_versions", versions(e.SupportedVersions))
 }
 
+type eventVersionNegotiationSent struct {
+ Header packetHeaderVersionNegotiation
+ SupportedVersions []versionNumber
+}
+
+func (e eventVersionNegotiationSent) Category() category { return categoryTransport }
+func (e eventVersionNegotiationSent) Name() string { return "packet_sent" }
+func (e eventVersionNegotiationSent) IsNil() bool { return false }
+
+func (e eventVersionNegotiationSent) MarshalJSONObject(enc *gojay.Encoder) {
+ enc.ObjectKey("header", e.Header)
+ enc.ArrayKey("supported_versions", versions(e.SupportedVersions))
+}
+
 type eventPacketBuffered struct {
  PacketType logging.PacketType
  PacketSize protocol.ByteCount

qlog/tracer.go

@@ -17,8 +17,20 @@ func NewTracer(w io.WriteCloser) *logging.Tracer {
  wr := *newWriter(w, tr)
  go wr.Run()
  return &logging.Tracer{
- SentPacket: nil,
- SentVersionNegotiationPacket: nil,
+ SentPacket: nil,
+ SentVersionNegotiationPacket: func(_ net.Addr, dest, src logging.ArbitraryLenConnectionID, versions []logging.VersionNumber) {
+ ver := make([]versionNumber, len(versions))
+ for i, v := range versions {
+ ver[i] = versionNumber(v)
+ }
+ wr.RecordEvent(time.Now(), &eventVersionNegotiationSent{
+ Header: packetHeaderVersionNegotiation{
+ SrcConnectionID: src,
+ DestConnectionID: dest,
+ },
+ SupportedVersions: ver,
+ })
+ },
  DroppedPacket: func(addr net.Addr, p logging.PacketType, count logging.ByteCount, reason logging.PacketDropReason) {
  wr.RecordEvent(time.Now(), eventPacketDropped{
  PacketType: p,

qlog/tracer_test.go

@@ -6,6 +6,7 @@ import (
  "net"
  "time"
 
+ "github.com/quic-go/quic-go/internal/protocol"
  "github.com/quic-go/quic-go/logging"
 
  . "github.com/onsi/ginkgo/v2"
@@ -46,6 +47,30 @@ var _ = Describe("Tracing", func() {
  })
 
  Context("Events", func() {
+ It("records sending of a Version Negotiation packet", func() {
+ tracer.SentVersionNegotiationPacket(
+ nil,
+ protocol.ArbitraryLenConnectionID{1, 2, 3, 4, 5, 6, 7, 8},
+ protocol.ArbitraryLenConnectionID{4, 3, 2, 1},
+ []protocol.Version{0xdeadbeef, 0xdecafbad},
+ )
+ tracer.Close()
+ entry := exportAndParseSingle(buf)
+ Expect(entry.Time).To(BeTemporally("~", time.Now(), scaleDuration(10*time.Millisecond)))
+ Expect(entry.Name).To(Equal("transport:packet_sent"))
+ ev := entry.Event
+ Expect(ev).To(HaveKey("header"))
+ Expect(ev).ToNot(HaveKey("frames"))
+ Expect(ev).To(HaveKey("supported_versions"))
+ Expect(ev["supported_versions"].([]interface{})).To(Equal([]interface{}{"deadbeef", "decafbad"}))
+ header := ev["header"]
+ Expect(header).To(HaveKeyWithValue("packet_type", "version_negotiation"))
+ Expect(header).ToNot(HaveKey("packet_number"))
+ Expect(header).ToNot(HaveKey("version"))
+ Expect(header).To(HaveKeyWithValue("dcid", "0102030405060708"))
+ Expect(header).To(HaveKeyWithValue("scid", "04030201"))
+ })
+
  It("records dropped packets", func() {
  addr := net.UDPAddr{IP: net.IPv4(1, 2, 3, 4), Port: 1234}
  tracer.DroppedPacket(&addr, logging.PacketTypeInitial, 1337, logging.PacketDropPayloadDecryptError)