1 /*
2  * Copyright (c) Facebook, Inc. and its affiliates.
3  *
4  * This source code is licensed under the MIT license found in the
5  * LICENSE file in the root directory of this source tree.
6  *
7  */
8 
9 #pragma once
10 
11 #include <folly/Portability.h>
12 #include <folly/dynamic.h>
13 #include <quic/codec/Types.h>
14 #include <quic/logging/QLoggerConstants.h>
15 #include <memory>
16 #include <string>
17 #include <vector>
18 
19 namespace quic {
20 
21 class QLogFrame {
22  public:
23   QLogFrame() = default;
24   virtual ~QLogFrame() = default;
25   virtual folly::dynamic toDynamic() const = 0;
26 };
27 
28 class PaddingFrameLog : public QLogFrame {
29  public:
30   uint64_t numFrames;
PaddingFrameLog(uint64_t numFramesIn)31   explicit PaddingFrameLog(uint64_t numFramesIn) : numFrames{numFramesIn} {}
32 
33   ~PaddingFrameLog() override = default;
34   folly::dynamic toDynamic() const override;
35 };
36 
37 class RstStreamFrameLog : public QLogFrame {
38  public:
39   StreamId streamId;
40   ApplicationErrorCode errorCode;
41   uint64_t offset;
42 
RstStreamFrameLog(StreamId streamIdIn,ApplicationErrorCode errorCodeIn,uint64_t offsetIn)43   RstStreamFrameLog(
44       StreamId streamIdIn,
45       ApplicationErrorCode errorCodeIn,
46       uint64_t offsetIn)
47       : streamId{streamIdIn}, errorCode{errorCodeIn}, offset{offsetIn} {}
48 
49   ~RstStreamFrameLog() override = default;
50   folly::dynamic toDynamic() const override;
51 };
52 
53 class ConnectionCloseFrameLog : public QLogFrame {
54  public:
55   QuicErrorCode errorCode;
56   std::string reasonPhrase;
57   FrameType closingFrameType;
58 
ConnectionCloseFrameLog(QuicErrorCode errorCodeIn,std::string reasonPhraseIn,FrameType closingFrameTypeIn)59   ConnectionCloseFrameLog(
60       QuicErrorCode errorCodeIn,
61       std::string reasonPhraseIn,
62       FrameType closingFrameTypeIn)
63       : errorCode{std::move(errorCodeIn)},
64         reasonPhrase{std::move(reasonPhraseIn)},
65         closingFrameType{closingFrameTypeIn} {}
66 
67   ~ConnectionCloseFrameLog() override = default;
68   folly::dynamic toDynamic() const override;
69 };
70 
71 class MaxDataFrameLog : public QLogFrame {
72  public:
73   uint64_t maximumData;
74 
MaxDataFrameLog(uint64_t maximumDataIn)75   explicit MaxDataFrameLog(uint64_t maximumDataIn)
76       : maximumData{maximumDataIn} {}
77 
78   ~MaxDataFrameLog() override = default;
79   folly::dynamic toDynamic() const override;
80 };
81 
82 class MaxStreamDataFrameLog : public QLogFrame {
83  public:
84   StreamId streamId;
85   uint64_t maximumData;
86 
MaxStreamDataFrameLog(StreamId streamIdIn,uint64_t maximumDataIn)87   MaxStreamDataFrameLog(StreamId streamIdIn, uint64_t maximumDataIn)
88       : streamId{streamIdIn}, maximumData{maximumDataIn} {}
89 
90   ~MaxStreamDataFrameLog() override = default;
91   folly::dynamic toDynamic() const override;
92 };
93 
94 class MaxStreamsFrameLog : public QLogFrame {
95  public:
96   uint64_t maxStreams;
97   bool isForBidirectional;
98 
MaxStreamsFrameLog(uint64_t maxStreamsIn,bool isForBidirectionalIn)99   MaxStreamsFrameLog(uint64_t maxStreamsIn, bool isForBidirectionalIn)
100       : maxStreams{maxStreamsIn}, isForBidirectional{isForBidirectionalIn} {}
101   ~MaxStreamsFrameLog() override = default;
102   folly::dynamic toDynamic() const override;
103 };
104 
105 class StreamsBlockedFrameLog : public QLogFrame {
106  public:
107   uint64_t streamLimit;
108   bool isForBidirectional;
109 
StreamsBlockedFrameLog(uint64_t streamLimitIn,bool isForBidirectionalIn)110   StreamsBlockedFrameLog(uint64_t streamLimitIn, bool isForBidirectionalIn)
111       : streamLimit{streamLimitIn}, isForBidirectional{isForBidirectionalIn} {}
112 
113   ~StreamsBlockedFrameLog() override = default;
114   folly::dynamic toDynamic() const override;
115 };
116 
117 class PingFrameLog : public QLogFrame {
118  public:
119   PingFrameLog() = default;
120   ~PingFrameLog() override = default;
121   folly::dynamic toDynamic() const override;
122 };
123 
124 class DataBlockedFrameLog : public QLogFrame {
125  public:
126   uint64_t dataLimit;
127 
DataBlockedFrameLog(uint64_t dataLimitIn)128   explicit DataBlockedFrameLog(uint64_t dataLimitIn) : dataLimit{dataLimitIn} {}
129   ~DataBlockedFrameLog() override = default;
130   folly::dynamic toDynamic() const override;
131 };
132 
133 class KnobFrameLog : public QLogFrame {
134  public:
135   uint64_t knobSpace;
136   uint64_t knobId;
137   size_t knobBlobLen;
138 
KnobFrameLog(uint64_t knobSpaceIn,uint64_t knobIdIn,size_t knobBlobLenIn)139   explicit KnobFrameLog(
140       uint64_t knobSpaceIn,
141       uint64_t knobIdIn,
142       size_t knobBlobLenIn)
143       : knobSpace(knobSpaceIn), knobId(knobIdIn), knobBlobLen(knobBlobLenIn) {}
144   ~KnobFrameLog() override = default;
145   FOLLY_NODISCARD folly::dynamic toDynamic() const override;
146 };
147 
148 class AckFrequencyFrameLog : public QLogFrame {
149  public:
150   uint64_t sequenceNumber;
151   uint64_t packetTolerance;
152   uint64_t updateMaxAckDelay;
153   bool ignoreOrder;
154 
AckFrequencyFrameLog(uint64_t sequenceNumberIn,uint64_t packetToleranceIn,uint64_t updateMaxAckDelayIn,bool ignoreOrderIn)155   explicit AckFrequencyFrameLog(
156       uint64_t sequenceNumberIn,
157       uint64_t packetToleranceIn,
158       uint64_t updateMaxAckDelayIn,
159       bool ignoreOrderIn)
160       : sequenceNumber(sequenceNumberIn),
161         packetTolerance(packetToleranceIn),
162         updateMaxAckDelay(updateMaxAckDelayIn),
163         ignoreOrder(ignoreOrderIn) {}
164   ~AckFrequencyFrameLog() override = default;
165   FOLLY_NODISCARD folly::dynamic toDynamic() const override;
166 };
167 
168 class StreamDataBlockedFrameLog : public QLogFrame {
169  public:
170   StreamId streamId;
171   uint64_t dataLimit;
172 
StreamDataBlockedFrameLog(StreamId streamIdIn,uint64_t dataLimitIn)173   StreamDataBlockedFrameLog(StreamId streamIdIn, uint64_t dataLimitIn)
174       : streamId{streamIdIn}, dataLimit{dataLimitIn} {}
175   ~StreamDataBlockedFrameLog() override = default;
176   folly::dynamic toDynamic() const override;
177 };
178 
179 class ReadAckFrameLog : public QLogFrame {
180  public:
181   ReadAckFrame::Vec ackBlocks;
182   std::chrono::microseconds ackDelay;
183 
ReadAckFrameLog(const ReadAckFrame::Vec & ackBlocksIn,std::chrono::microseconds ackDelayIn)184   ReadAckFrameLog(
185       const ReadAckFrame::Vec& ackBlocksIn,
186       std::chrono::microseconds ackDelayIn)
187       : ackBlocks{ackBlocksIn}, ackDelay{ackDelayIn} {}
188   ~ReadAckFrameLog() override = default;
189   folly::dynamic toDynamic() const override;
190 };
191 
192 class WriteAckFrameLog : public QLogFrame {
193  public:
194   WriteAckFrame::AckBlockVec ackBlocks;
195   std::chrono::microseconds ackDelay;
196 
WriteAckFrameLog(const WriteAckFrame::AckBlockVec & ackBlocksIn,std::chrono::microseconds ackDelayIn)197   WriteAckFrameLog(
198       const WriteAckFrame::AckBlockVec& ackBlocksIn,
199       std::chrono::microseconds ackDelayIn)
200       : ackBlocks{ackBlocksIn}, ackDelay{ackDelayIn} {}
201   ~WriteAckFrameLog() override = default;
202   folly::dynamic toDynamic() const override;
203 };
204 
205 class StreamFrameLog : public QLogFrame {
206  public:
207   StreamId streamId;
208   uint64_t offset;
209   uint64_t len;
210   bool fin;
211 
StreamFrameLog(StreamId streamIdIn,uint64_t offsetIn,uint64_t lenIn,bool finIn)212   StreamFrameLog(
213       StreamId streamIdIn,
214       uint64_t offsetIn,
215       uint64_t lenIn,
216       bool finIn)
217       : streamId{streamIdIn}, offset{offsetIn}, len{lenIn}, fin{finIn} {}
218   ~StreamFrameLog() override = default;
219 
220   folly::dynamic toDynamic() const override;
221 };
222 
223 class CryptoFrameLog : public QLogFrame {
224  public:
225   uint64_t offset;
226   uint64_t len;
227 
CryptoFrameLog(uint64_t offsetIn,uint64_t lenIn)228   CryptoFrameLog(uint64_t offsetIn, uint64_t lenIn)
229       : offset{offsetIn}, len{lenIn} {}
230   ~CryptoFrameLog() override = default;
231   folly::dynamic toDynamic() const override;
232 };
233 
234 class StopSendingFrameLog : public QLogFrame {
235  public:
236   StreamId streamId;
237   ApplicationErrorCode errorCode;
238 
StopSendingFrameLog(StreamId streamIdIn,ApplicationErrorCode errorCodeIn)239   StopSendingFrameLog(StreamId streamIdIn, ApplicationErrorCode errorCodeIn)
240       : streamId{streamIdIn}, errorCode{errorCodeIn} {}
241   ~StopSendingFrameLog() override = default;
242   folly::dynamic toDynamic() const override;
243 };
244 
245 class PathChallengeFrameLog : public QLogFrame {
246  public:
247   uint64_t pathData;
248 
PathChallengeFrameLog(uint64_t pathDataIn)249   explicit PathChallengeFrameLog(uint64_t pathDataIn) : pathData{pathDataIn} {}
250   ~PathChallengeFrameLog() override = default;
251   folly::dynamic toDynamic() const override;
252 };
253 
254 class PathResponseFrameLog : public QLogFrame {
255  public:
256   uint64_t pathData;
257 
PathResponseFrameLog(uint64_t pathDataIn)258   explicit PathResponseFrameLog(uint64_t pathDataIn) : pathData{pathDataIn} {}
259   ~PathResponseFrameLog() override = default;
260   folly::dynamic toDynamic() const override;
261 };
262 
263 class NewConnectionIdFrameLog : public QLogFrame {
264  public:
265   uint16_t sequence;
266   StatelessResetToken token;
267 
NewConnectionIdFrameLog(uint16_t sequenceIn,StatelessResetToken tokenIn)268   NewConnectionIdFrameLog(uint16_t sequenceIn, StatelessResetToken tokenIn)
269       : sequence{sequenceIn}, token{tokenIn} {}
270   ~NewConnectionIdFrameLog() override = default;
271   folly::dynamic toDynamic() const override;
272 };
273 
274 class RetireConnectionIdFrameLog : public QLogFrame {
275  public:
276   uint64_t sequence;
277 
RetireConnectionIdFrameLog(uint64_t sequenceIn)278   RetireConnectionIdFrameLog(uint64_t sequenceIn) : sequence(sequenceIn) {}
279 
280   ~RetireConnectionIdFrameLog() override = default;
281   folly::dynamic toDynamic() const override;
282 };
283 
284 class ReadNewTokenFrameLog : public QLogFrame {
285  public:
286   ReadNewTokenFrameLog() = default;
287   ~ReadNewTokenFrameLog() override = default;
288   folly::dynamic toDynamic() const override;
289 };
290 
291 class HandshakeDoneFrameLog : public QLogFrame {
292  public:
293   HandshakeDoneFrameLog() = default;
294   ~HandshakeDoneFrameLog() override = default;
295   folly::dynamic toDynamic() const override;
296 };
297 
298 class VersionNegotiationLog {
299  public:
300   std::vector<QuicVersion> versions;
301 
VersionNegotiationLog(const std::vector<QuicVersion> & versionsIn)302   explicit VersionNegotiationLog(const std::vector<QuicVersion>& versionsIn)
303       : versions{versionsIn} {}
304   ~VersionNegotiationLog() = default;
305   folly::dynamic toDynamic() const;
306 };
307 
308 enum class QLogEventType : uint32_t {
309   PacketReceived,
310   PacketSent,
311   ConnectionClose,
312   TransportSummary,
313   CongestionMetricUpdate,
314   PacingMetricUpdate,
315   AppIdleUpdate,
316   PacketDrop,
317   DatagramReceived,
318   LossAlarm,
319   PacketsLost,
320   TransportStateUpdate,
321   PacketBuffered,
322   PacketAck,
323   MetricUpdate,
324   StreamStateUpdate,
325   PacingObservation,
326   AppLimitedUpdate,
327   BandwidthEstUpdate,
328   ConnectionMigration,
329   PathValidation,
330   PriorityUpdate
331 };
332 
333 folly::StringPiece toString(QLogEventType type);
334 
335 class QLogEvent {
336  public:
337   QLogEvent() = default;
338   virtual ~QLogEvent() = default;
339   virtual folly::dynamic toDynamic() const = 0;
340   std::chrono::microseconds refTime;
341   QLogEventType eventType;
342 };
343 
344 class QLogPacketEvent : public QLogEvent {
345  public:
346   QLogPacketEvent() = default;
347   ~QLogPacketEvent() override = default;
348   std::vector<std::unique_ptr<QLogFrame>> frames;
349   std::string packetType;
350   PacketNum packetNum{0};
351   uint64_t packetSize{0};
352 
353   folly::dynamic toDynamic() const override;
354 };
355 
356 class QLogVersionNegotiationEvent : public QLogEvent {
357  public:
358   QLogVersionNegotiationEvent() = default;
359   ~QLogVersionNegotiationEvent() override = default;
360   std::unique_ptr<VersionNegotiationLog> versionLog;
361   std::string packetType;
362   uint64_t packetSize{0};
363 
364   folly::dynamic toDynamic() const override;
365 };
366 
367 class QLogRetryEvent : public QLogEvent {
368  public:
369   QLogRetryEvent() = default;
370   ~QLogRetryEvent() override = default;
371 
372   std::string packetType;
373   uint64_t packetSize{0};
374   uint64_t tokenSize{0};
375 
376   folly::dynamic toDynamic() const override;
377 };
378 
379 class QLogConnectionCloseEvent : public QLogEvent {
380  public:
381   QLogConnectionCloseEvent(
382       std::string errorIn,
383       std::string reasonIn,
384       bool drainConnectionIn,
385       bool sendCloseImmediatelyIn,
386       std::chrono::microseconds refTimeIn);
387   ~QLogConnectionCloseEvent() override = default;
388   std::string error;
389   std::string reason;
390   bool drainConnection;
391   bool sendCloseImmediately;
392 
393   folly::dynamic toDynamic() const override;
394 };
395 
396 class QLogTransportSummaryEvent : public QLogEvent {
397  public:
398   QLogTransportSummaryEvent(
399       uint64_t totalBytesSent,
400       uint64_t totalBytesRecvd,
401       uint64_t sumCurWriteOffset,
402       uint64_t sumMaxObservedOffset,
403       uint64_t sumCurStreamBufferLen,
404       uint64_t totalBytesRetransmitted,
405       uint64_t totalStreamBytesCloned,
406       uint64_t totalBytesCloned,
407       uint64_t totalCryptoDataWritten,
408       uint64_t totalCryptoDataRecvd,
409       uint64_t currentWritableBytes,
410       uint64_t currentConnFlowControl,
411       bool usedZeroRtt,
412       QuicVersion version,
413       uint64_t dsrPacketCount,
414       std::chrono::microseconds refTimeIn);
415   ~QLogTransportSummaryEvent() override = default;
416   uint64_t totalBytesSent;
417   uint64_t totalBytesRecvd;
418   uint64_t sumCurWriteOffset;
419   uint64_t sumMaxObservedOffset;
420   uint64_t sumCurStreamBufferLen;
421   uint64_t totalBytesRetransmitted;
422   uint64_t totalStreamBytesCloned;
423   uint64_t totalBytesCloned;
424   uint64_t totalCryptoDataWritten;
425   uint64_t totalCryptoDataRecvd;
426   uint64_t currentWritableBytes;
427   uint64_t currentConnFlowControl;
428   bool usedZeroRtt;
429   QuicVersion quicVersion;
430   uint64_t dsrPacketCount;
431 
432   folly::dynamic toDynamic() const override;
433 };
434 
435 class QLogCongestionMetricUpdateEvent : public QLogEvent {
436  public:
437   QLogCongestionMetricUpdateEvent(
438       uint64_t bytesInFlight,
439       uint64_t currentCwnd,
440       std::string congestionEvent,
441       std::string state,
442       std::string recoveryState,
443       std::chrono::microseconds refTimeIn);
444   ~QLogCongestionMetricUpdateEvent() override = default;
445   uint64_t bytesInFlight;
446   uint64_t currentCwnd;
447   std::string congestionEvent;
448   std::string state;
449   std::string recoveryState;
450 
451   folly::dynamic toDynamic() const override;
452 };
453 
454 class QLogAppLimitedUpdateEvent : public QLogEvent {
455  public:
456   explicit QLogAppLimitedUpdateEvent(
457       bool limitedIn,
458       std::chrono::microseconds refTimeIn);
459   ~QLogAppLimitedUpdateEvent() override = default;
460 
461   folly::dynamic toDynamic() const override;
462 
463   bool limited;
464 };
465 
466 class QLogBandwidthEstUpdateEvent : public QLogEvent {
467  public:
468   explicit QLogBandwidthEstUpdateEvent(
469       uint64_t bytes,
470       std::chrono::microseconds interval,
471       std::chrono::microseconds refTimeIn);
472   ~QLogBandwidthEstUpdateEvent() override = default;
473 
474   folly::dynamic toDynamic() const override;
475 
476   uint64_t bytes;
477   std::chrono::microseconds interval;
478 };
479 
480 class QLogPacingMetricUpdateEvent : public QLogEvent {
481  public:
482   QLogPacingMetricUpdateEvent(
483       uint64_t pacingBurstSize,
484       std::chrono::microseconds pacingInterval,
485       std::chrono::microseconds refTime);
486   ~QLogPacingMetricUpdateEvent() override = default;
487   uint64_t pacingBurstSize;
488   std::chrono::microseconds pacingInterval;
489 
490   folly::dynamic toDynamic() const override;
491 };
492 
493 class QLogPacingObservationEvent : public QLogEvent {
494  public:
495   QLogPacingObservationEvent(
496       std::string actualIn,
497       std::string expectIn,
498       std::string conclusionIn,
499       std::chrono::microseconds refTimeIn);
500   std::string actual;
501   std::string expect;
502   std::string conclusion;
503 
504   ~QLogPacingObservationEvent() override = default;
505   folly::dynamic toDynamic() const override;
506 };
507 
508 class QLogAppIdleUpdateEvent : public QLogEvent {
509  public:
510   QLogAppIdleUpdateEvent(
511       std::string idleEvent,
512       bool idle,
513       std::chrono::microseconds refTime);
514   ~QLogAppIdleUpdateEvent() override = default;
515   std::string idleEvent;
516   bool idle;
517 
518   folly::dynamic toDynamic() const override;
519 };
520 
521 class QLogPacketDropEvent : public QLogEvent {
522  public:
523   QLogPacketDropEvent(
524       size_t packetSize,
525       std::string dropReason,
526       std::chrono::microseconds refTime);
527   ~QLogPacketDropEvent() override = default;
528   size_t packetSize;
529   std::string dropReason;
530 
531   folly::dynamic toDynamic() const override;
532 };
533 
534 class QLogDatagramReceivedEvent : public QLogEvent {
535  public:
536   QLogDatagramReceivedEvent(
537       uint64_t dataLen,
538       std::chrono::microseconds refTime);
539   ~QLogDatagramReceivedEvent() override = default;
540   uint64_t dataLen;
541 
542   folly::dynamic toDynamic() const override;
543 };
544 
545 class QLogLossAlarmEvent : public QLogEvent {
546  public:
547   QLogLossAlarmEvent(
548       PacketNum largestSent,
549       uint64_t alarmCount,
550       uint64_t outstandingPackets,
551       std::string type,
552       std::chrono::microseconds refTime);
553   ~QLogLossAlarmEvent() override = default;
554   PacketNum largestSent;
555   uint64_t alarmCount;
556   uint64_t outstandingPackets;
557   std::string type;
558   folly::dynamic toDynamic() const override;
559 };
560 
561 class QLogPacketsLostEvent : public QLogEvent {
562  public:
563   QLogPacketsLostEvent(
564       PacketNum largestLostPacketNum,
565       uint64_t lostBytes,
566       uint64_t lostPackets,
567       std::chrono::microseconds refTime);
568   ~QLogPacketsLostEvent() override = default;
569   PacketNum largestLostPacketNum;
570   uint64_t lostBytes;
571   uint64_t lostPackets;
572   folly::dynamic toDynamic() const override;
573 };
574 
575 class QLogTransportStateUpdateEvent : public QLogEvent {
576  public:
577   QLogTransportStateUpdateEvent(
578       std::string update,
579       std::chrono::microseconds refTime);
580   ~QLogTransportStateUpdateEvent() override = default;
581   std::string update;
582   folly::dynamic toDynamic() const override;
583 };
584 
585 class QLogPacketBufferedEvent : public QLogEvent {
586  public:
587   QLogPacketBufferedEvent(
588       ProtectionType protectionType,
589       uint64_t packetSize,
590       std::chrono::microseconds refTime);
591   ~QLogPacketBufferedEvent() override = default;
592   ProtectionType protectionType;
593   uint64_t packetSize;
594   folly::dynamic toDynamic() const override;
595 };
596 
597 class QLogPacketAckEvent : public QLogEvent {
598  public:
599   QLogPacketAckEvent(
600       PacketNumberSpace packetNumSpace,
601       PacketNum packetNum,
602       std::chrono::microseconds refTime);
603   ~QLogPacketAckEvent() override = default;
604   PacketNumberSpace packetNumSpace;
605   PacketNum packetNum;
606   folly::dynamic toDynamic() const override;
607 };
608 
609 class QLogMetricUpdateEvent : public QLogEvent {
610  public:
611   QLogMetricUpdateEvent(
612       std::chrono::microseconds latestRtt,
613       std::chrono::microseconds mrtt,
614       std::chrono::microseconds srtt,
615       std::chrono::microseconds ackDelay,
616       std::chrono::microseconds refTime);
617   ~QLogMetricUpdateEvent() override = default;
618   std::chrono::microseconds latestRtt;
619   std::chrono::microseconds mrtt;
620   std::chrono::microseconds srtt;
621   std::chrono::microseconds ackDelay;
622   folly::dynamic toDynamic() const override;
623 };
624 
625 class QLogStreamStateUpdateEvent : public QLogEvent {
626  public:
627   QLogStreamStateUpdateEvent(
628       StreamId id,
629       std::string update,
630       folly::Optional<std::chrono::milliseconds> timeSinceStreamCreation,
631       VantagePoint vantagePoint,
632       std::chrono::microseconds refTime);
633   ~QLogStreamStateUpdateEvent() override = default;
634   StreamId id;
635   std::string update;
636   folly::Optional<std::chrono::milliseconds> timeSinceStreamCreation;
637   folly::dynamic toDynamic() const override;
638 
639  private:
640   VantagePoint vantagePoint_;
641 };
642 
643 class QLogConnectionMigrationEvent : public QLogEvent {
644  public:
645   QLogConnectionMigrationEvent(
646       bool intentionalMigration,
647       VantagePoint vantagePoint,
648       std::chrono::microseconds refTime);
649 
650   ~QLogConnectionMigrationEvent() override = default;
651 
652   folly::dynamic toDynamic() const override;
653 
654   bool intentionalMigration_;
655   VantagePoint vantagePoint_;
656 };
657 
658 class QLogPathValidationEvent : public QLogEvent {
659  public:
660   // The VantagePoint represents who initiates the path validation (sends out
661   // Path Challenge).
662   QLogPathValidationEvent(
663       bool success,
664       VantagePoint vantagePoint,
665       std::chrono::microseconds refTime);
666 
667   ~QLogPathValidationEvent() override = default;
668 
669   folly::dynamic toDynamic() const override;
670   bool success_;
671   VantagePoint vantagePoint_;
672 };
673 
674 class QLogPriorityUpdateEvent : public QLogEvent {
675  public:
676   explicit QLogPriorityUpdateEvent(
677       StreamId id,
678       uint8_t urgency,
679       bool incremental,
680       std::chrono::microseconds refTimeIn);
681   ~QLogPriorityUpdateEvent() override = default;
682 
683   folly::dynamic toDynamic() const override;
684 
685  private:
686   StreamId streamId_;
687   uint8_t urgency_;
688   bool incremental_;
689 };
690 
691 } // namespace quic
692