1use crate::event::{self, api, metrics::Recorder};
9#[cfg(feature = "alloc")]
10pub(crate) mod aggregate;
11pub(crate) mod probe;
12#[derive(Debug)]
13pub struct Subscriber<S: event::Subscriber>
14where
15 S::ConnectionContext: Recorder,
16{
17 subscriber: S,
18}
19impl<S: event::Subscriber> Subscriber<S>
20where
21 S::ConnectionContext: Recorder,
22{
23 pub fn new(subscriber: S) -> Self {
24 Self { subscriber }
25 }
26}
27pub struct Context<R: Recorder> {
28 recorder: R,
29 application_protocol_information: u64,
30 server_name_information: u64,
31 key_exchange_group: u64,
32 packet_skipped: u64,
33 packet_sent: u64,
34 packet_received: u64,
35 active_path_updated: u64,
36 path_created: u64,
37 frame_sent: u64,
38 frame_received: u64,
39 connection_close_frame_received: u64,
40 packet_lost: u64,
41 recovery_metrics: u64,
42 congestion: u64,
43 ack_processed: u64,
44 rx_ack_range_dropped: u64,
45 ack_range_received: u64,
46 ack_range_sent: u64,
47 packet_dropped: u64,
48 key_update: u64,
49 key_space_discarded: u64,
50 connection_started: u64,
51 duplicate_packet: u64,
52 transport_parameters_received: u64,
53 datagram_sent: u64,
54 datagram_received: u64,
55 datagram_dropped: u64,
56 handshake_remote_address_change_observed: u64,
57 connection_id_updated: u64,
58 ecn_state_changed: u64,
59 connection_migration_denied: u64,
60 handshake_status_updated: u64,
61 tls_exporter_ready: u64,
62 tls_handshake_failed: u64,
63 path_challenge_updated: u64,
64 tls_client_hello: u64,
65 tls_server_hello: u64,
66 rx_stream_progress: u64,
67 tx_stream_progress: u64,
68 keep_alive_timer_expired: u64,
69 mtu_updated: u64,
70 mtu_probing_complete_received: u64,
71 slow_start_exited: u64,
72 delivery_rate_sampled: u64,
73 pacing_rate_updated: u64,
74 bbr_state_changed: u64,
75 dc_state_changed: u64,
76 dc_path_created: u64,
77 connection_closed: u64,
78}
79impl<R: Recorder> Context<R> {
80 pub fn inner(&self) -> &R {
81 &self.recorder
82 }
83 pub fn inner_mut(&mut self) -> &mut R {
84 &mut self.recorder
85 }
86}
87impl<S: event::Subscriber> event::Subscriber for Subscriber<S>
88where
89 S::ConnectionContext: Recorder,
90{
91 type ConnectionContext = Context<S::ConnectionContext>;
92 fn create_connection_context(
93 &mut self,
94 meta: &api::ConnectionMeta,
95 info: &api::ConnectionInfo,
96 ) -> Self::ConnectionContext {
97 Context {
98 recorder: self.subscriber.create_connection_context(meta, info),
99 application_protocol_information: 0,
100 server_name_information: 0,
101 key_exchange_group: 0,
102 packet_skipped: 0,
103 packet_sent: 0,
104 packet_received: 0,
105 active_path_updated: 0,
106 path_created: 0,
107 frame_sent: 0,
108 frame_received: 0,
109 connection_close_frame_received: 0,
110 packet_lost: 0,
111 recovery_metrics: 0,
112 congestion: 0,
113 ack_processed: 0,
114 rx_ack_range_dropped: 0,
115 ack_range_received: 0,
116 ack_range_sent: 0,
117 packet_dropped: 0,
118 key_update: 0,
119 key_space_discarded: 0,
120 connection_started: 0,
121 duplicate_packet: 0,
122 transport_parameters_received: 0,
123 datagram_sent: 0,
124 datagram_received: 0,
125 datagram_dropped: 0,
126 handshake_remote_address_change_observed: 0,
127 connection_id_updated: 0,
128 ecn_state_changed: 0,
129 connection_migration_denied: 0,
130 handshake_status_updated: 0,
131 tls_exporter_ready: 0,
132 tls_handshake_failed: 0,
133 path_challenge_updated: 0,
134 tls_client_hello: 0,
135 tls_server_hello: 0,
136 rx_stream_progress: 0,
137 tx_stream_progress: 0,
138 keep_alive_timer_expired: 0,
139 mtu_updated: 0,
140 mtu_probing_complete_received: 0,
141 slow_start_exited: 0,
142 delivery_rate_sampled: 0,
143 pacing_rate_updated: 0,
144 bbr_state_changed: 0,
145 dc_state_changed: 0,
146 dc_path_created: 0,
147 connection_closed: 0,
148 }
149 }
150 #[inline]
151 fn on_application_protocol_information(
152 &mut self,
153 context: &mut Self::ConnectionContext,
154 meta: &api::ConnectionMeta,
155 event: &api::ApplicationProtocolInformation,
156 ) {
157 context.application_protocol_information += 1;
158 self.subscriber
159 .on_application_protocol_information(&mut context.recorder, meta, event);
160 }
161 #[inline]
162 fn on_server_name_information(
163 &mut self,
164 context: &mut Self::ConnectionContext,
165 meta: &api::ConnectionMeta,
166 event: &api::ServerNameInformation,
167 ) {
168 context.server_name_information += 1;
169 self.subscriber
170 .on_server_name_information(&mut context.recorder, meta, event);
171 }
172 #[inline]
173 fn on_key_exchange_group(
174 &mut self,
175 context: &mut Self::ConnectionContext,
176 meta: &api::ConnectionMeta,
177 event: &api::KeyExchangeGroup,
178 ) {
179 context.key_exchange_group += 1;
180 self.subscriber
181 .on_key_exchange_group(&mut context.recorder, meta, event);
182 }
183 #[inline]
184 fn on_packet_skipped(
185 &mut self,
186 context: &mut Self::ConnectionContext,
187 meta: &api::ConnectionMeta,
188 event: &api::PacketSkipped,
189 ) {
190 context.packet_skipped += 1;
191 self.subscriber
192 .on_packet_skipped(&mut context.recorder, meta, event);
193 }
194 #[inline]
195 fn on_packet_sent(
196 &mut self,
197 context: &mut Self::ConnectionContext,
198 meta: &api::ConnectionMeta,
199 event: &api::PacketSent,
200 ) {
201 context.packet_sent += 1;
202 self.subscriber
203 .on_packet_sent(&mut context.recorder, meta, event);
204 }
205 #[inline]
206 fn on_packet_received(
207 &mut self,
208 context: &mut Self::ConnectionContext,
209 meta: &api::ConnectionMeta,
210 event: &api::PacketReceived,
211 ) {
212 context.packet_received += 1;
213 self.subscriber
214 .on_packet_received(&mut context.recorder, meta, event);
215 }
216 #[inline]
217 fn on_active_path_updated(
218 &mut self,
219 context: &mut Self::ConnectionContext,
220 meta: &api::ConnectionMeta,
221 event: &api::ActivePathUpdated,
222 ) {
223 context.active_path_updated += 1;
224 self.subscriber
225 .on_active_path_updated(&mut context.recorder, meta, event);
226 }
227 #[inline]
228 fn on_path_created(
229 &mut self,
230 context: &mut Self::ConnectionContext,
231 meta: &api::ConnectionMeta,
232 event: &api::PathCreated,
233 ) {
234 context.path_created += 1;
235 self.subscriber
236 .on_path_created(&mut context.recorder, meta, event);
237 }
238 #[inline]
239 fn on_frame_sent(
240 &mut self,
241 context: &mut Self::ConnectionContext,
242 meta: &api::ConnectionMeta,
243 event: &api::FrameSent,
244 ) {
245 context.frame_sent += 1;
246 self.subscriber
247 .on_frame_sent(&mut context.recorder, meta, event);
248 }
249 #[inline]
250 fn on_frame_received(
251 &mut self,
252 context: &mut Self::ConnectionContext,
253 meta: &api::ConnectionMeta,
254 event: &api::FrameReceived,
255 ) {
256 context.frame_received += 1;
257 self.subscriber
258 .on_frame_received(&mut context.recorder, meta, event);
259 }
260 #[inline]
261 fn on_connection_close_frame_received(
262 &mut self,
263 context: &mut Self::ConnectionContext,
264 meta: &api::ConnectionMeta,
265 event: &api::ConnectionCloseFrameReceived,
266 ) {
267 context.connection_close_frame_received += 1;
268 self.subscriber
269 .on_connection_close_frame_received(&mut context.recorder, meta, event);
270 }
271 #[inline]
272 fn on_packet_lost(
273 &mut self,
274 context: &mut Self::ConnectionContext,
275 meta: &api::ConnectionMeta,
276 event: &api::PacketLost,
277 ) {
278 context.packet_lost += 1;
279 self.subscriber
280 .on_packet_lost(&mut context.recorder, meta, event);
281 }
282 #[inline]
283 fn on_recovery_metrics(
284 &mut self,
285 context: &mut Self::ConnectionContext,
286 meta: &api::ConnectionMeta,
287 event: &api::RecoveryMetrics,
288 ) {
289 context.recovery_metrics += 1;
290 self.subscriber
291 .on_recovery_metrics(&mut context.recorder, meta, event);
292 }
293 #[inline]
294 fn on_congestion(
295 &mut self,
296 context: &mut Self::ConnectionContext,
297 meta: &api::ConnectionMeta,
298 event: &api::Congestion,
299 ) {
300 context.congestion += 1;
301 self.subscriber
302 .on_congestion(&mut context.recorder, meta, event);
303 }
304 #[inline]
305 #[allow(deprecated)]
306 fn on_ack_processed(
307 &mut self,
308 context: &mut Self::ConnectionContext,
309 meta: &api::ConnectionMeta,
310 event: &api::AckProcessed,
311 ) {
312 context.ack_processed += 1;
313 self.subscriber
314 .on_ack_processed(&mut context.recorder, meta, event);
315 }
316 #[inline]
317 fn on_rx_ack_range_dropped(
318 &mut self,
319 context: &mut Self::ConnectionContext,
320 meta: &api::ConnectionMeta,
321 event: &api::RxAckRangeDropped,
322 ) {
323 context.rx_ack_range_dropped += 1;
324 self.subscriber
325 .on_rx_ack_range_dropped(&mut context.recorder, meta, event);
326 }
327 #[inline]
328 fn on_ack_range_received(
329 &mut self,
330 context: &mut Self::ConnectionContext,
331 meta: &api::ConnectionMeta,
332 event: &api::AckRangeReceived,
333 ) {
334 context.ack_range_received += 1;
335 self.subscriber
336 .on_ack_range_received(&mut context.recorder, meta, event);
337 }
338 #[inline]
339 fn on_ack_range_sent(
340 &mut self,
341 context: &mut Self::ConnectionContext,
342 meta: &api::ConnectionMeta,
343 event: &api::AckRangeSent,
344 ) {
345 context.ack_range_sent += 1;
346 self.subscriber
347 .on_ack_range_sent(&mut context.recorder, meta, event);
348 }
349 #[inline]
350 fn on_packet_dropped(
351 &mut self,
352 context: &mut Self::ConnectionContext,
353 meta: &api::ConnectionMeta,
354 event: &api::PacketDropped,
355 ) {
356 context.packet_dropped += 1;
357 self.subscriber
358 .on_packet_dropped(&mut context.recorder, meta, event);
359 }
360 #[inline]
361 fn on_key_update(
362 &mut self,
363 context: &mut Self::ConnectionContext,
364 meta: &api::ConnectionMeta,
365 event: &api::KeyUpdate,
366 ) {
367 context.key_update += 1;
368 self.subscriber
369 .on_key_update(&mut context.recorder, meta, event);
370 }
371 #[inline]
372 fn on_key_space_discarded(
373 &mut self,
374 context: &mut Self::ConnectionContext,
375 meta: &api::ConnectionMeta,
376 event: &api::KeySpaceDiscarded,
377 ) {
378 context.key_space_discarded += 1;
379 self.subscriber
380 .on_key_space_discarded(&mut context.recorder, meta, event);
381 }
382 #[inline]
383 fn on_connection_started(
384 &mut self,
385 context: &mut Self::ConnectionContext,
386 meta: &api::ConnectionMeta,
387 event: &api::ConnectionStarted,
388 ) {
389 context.connection_started += 1;
390 self.subscriber
391 .on_connection_started(&mut context.recorder, meta, event);
392 }
393 #[inline]
394 fn on_duplicate_packet(
395 &mut self,
396 context: &mut Self::ConnectionContext,
397 meta: &api::ConnectionMeta,
398 event: &api::DuplicatePacket,
399 ) {
400 context.duplicate_packet += 1;
401 self.subscriber
402 .on_duplicate_packet(&mut context.recorder, meta, event);
403 }
404 #[inline]
405 fn on_transport_parameters_received(
406 &mut self,
407 context: &mut Self::ConnectionContext,
408 meta: &api::ConnectionMeta,
409 event: &api::TransportParametersReceived,
410 ) {
411 context.transport_parameters_received += 1;
412 self.subscriber
413 .on_transport_parameters_received(&mut context.recorder, meta, event);
414 }
415 #[inline]
416 fn on_datagram_sent(
417 &mut self,
418 context: &mut Self::ConnectionContext,
419 meta: &api::ConnectionMeta,
420 event: &api::DatagramSent,
421 ) {
422 context.datagram_sent += 1;
423 self.subscriber
424 .on_datagram_sent(&mut context.recorder, meta, event);
425 }
426 #[inline]
427 fn on_datagram_received(
428 &mut self,
429 context: &mut Self::ConnectionContext,
430 meta: &api::ConnectionMeta,
431 event: &api::DatagramReceived,
432 ) {
433 context.datagram_received += 1;
434 self.subscriber
435 .on_datagram_received(&mut context.recorder, meta, event);
436 }
437 #[inline]
438 fn on_datagram_dropped(
439 &mut self,
440 context: &mut Self::ConnectionContext,
441 meta: &api::ConnectionMeta,
442 event: &api::DatagramDropped,
443 ) {
444 context.datagram_dropped += 1;
445 self.subscriber
446 .on_datagram_dropped(&mut context.recorder, meta, event);
447 }
448 #[inline]
449 fn on_handshake_remote_address_change_observed(
450 &mut self,
451 context: &mut Self::ConnectionContext,
452 meta: &api::ConnectionMeta,
453 event: &api::HandshakeRemoteAddressChangeObserved,
454 ) {
455 context.handshake_remote_address_change_observed += 1;
456 self.subscriber.on_handshake_remote_address_change_observed(
457 &mut context.recorder,
458 meta,
459 event,
460 );
461 }
462 #[inline]
463 fn on_connection_id_updated(
464 &mut self,
465 context: &mut Self::ConnectionContext,
466 meta: &api::ConnectionMeta,
467 event: &api::ConnectionIdUpdated,
468 ) {
469 context.connection_id_updated += 1;
470 self.subscriber
471 .on_connection_id_updated(&mut context.recorder, meta, event);
472 }
473 #[inline]
474 fn on_ecn_state_changed(
475 &mut self,
476 context: &mut Self::ConnectionContext,
477 meta: &api::ConnectionMeta,
478 event: &api::EcnStateChanged,
479 ) {
480 context.ecn_state_changed += 1;
481 self.subscriber
482 .on_ecn_state_changed(&mut context.recorder, meta, event);
483 }
484 #[inline]
485 fn on_connection_migration_denied(
486 &mut self,
487 context: &mut Self::ConnectionContext,
488 meta: &api::ConnectionMeta,
489 event: &api::ConnectionMigrationDenied,
490 ) {
491 context.connection_migration_denied += 1;
492 self.subscriber
493 .on_connection_migration_denied(&mut context.recorder, meta, event);
494 }
495 #[inline]
496 fn on_handshake_status_updated(
497 &mut self,
498 context: &mut Self::ConnectionContext,
499 meta: &api::ConnectionMeta,
500 event: &api::HandshakeStatusUpdated,
501 ) {
502 context.handshake_status_updated += 1;
503 self.subscriber
504 .on_handshake_status_updated(&mut context.recorder, meta, event);
505 }
506 #[inline]
507 fn on_tls_exporter_ready(
508 &mut self,
509 context: &mut Self::ConnectionContext,
510 meta: &api::ConnectionMeta,
511 event: &api::TlsExporterReady,
512 ) {
513 context.tls_exporter_ready += 1;
514 self.subscriber
515 .on_tls_exporter_ready(&mut context.recorder, meta, event);
516 }
517 #[inline]
518 fn on_tls_handshake_failed(
519 &mut self,
520 context: &mut Self::ConnectionContext,
521 meta: &api::ConnectionMeta,
522 event: &api::TlsHandshakeFailed,
523 ) {
524 context.tls_handshake_failed += 1;
525 self.subscriber
526 .on_tls_handshake_failed(&mut context.recorder, meta, event);
527 }
528 #[inline]
529 fn on_path_challenge_updated(
530 &mut self,
531 context: &mut Self::ConnectionContext,
532 meta: &api::ConnectionMeta,
533 event: &api::PathChallengeUpdated,
534 ) {
535 context.path_challenge_updated += 1;
536 self.subscriber
537 .on_path_challenge_updated(&mut context.recorder, meta, event);
538 }
539 #[inline]
540 fn on_tls_client_hello(
541 &mut self,
542 context: &mut Self::ConnectionContext,
543 meta: &api::ConnectionMeta,
544 event: &api::TlsClientHello,
545 ) {
546 context.tls_client_hello += 1;
547 self.subscriber
548 .on_tls_client_hello(&mut context.recorder, meta, event);
549 }
550 #[inline]
551 fn on_tls_server_hello(
552 &mut self,
553 context: &mut Self::ConnectionContext,
554 meta: &api::ConnectionMeta,
555 event: &api::TlsServerHello,
556 ) {
557 context.tls_server_hello += 1;
558 self.subscriber
559 .on_tls_server_hello(&mut context.recorder, meta, event);
560 }
561 #[inline]
562 fn on_rx_stream_progress(
563 &mut self,
564 context: &mut Self::ConnectionContext,
565 meta: &api::ConnectionMeta,
566 event: &api::RxStreamProgress,
567 ) {
568 context.rx_stream_progress += 1;
569 self.subscriber
570 .on_rx_stream_progress(&mut context.recorder, meta, event);
571 }
572 #[inline]
573 fn on_tx_stream_progress(
574 &mut self,
575 context: &mut Self::ConnectionContext,
576 meta: &api::ConnectionMeta,
577 event: &api::TxStreamProgress,
578 ) {
579 context.tx_stream_progress += 1;
580 self.subscriber
581 .on_tx_stream_progress(&mut context.recorder, meta, event);
582 }
583 #[inline]
584 fn on_keep_alive_timer_expired(
585 &mut self,
586 context: &mut Self::ConnectionContext,
587 meta: &api::ConnectionMeta,
588 event: &api::KeepAliveTimerExpired,
589 ) {
590 context.keep_alive_timer_expired += 1;
591 self.subscriber
592 .on_keep_alive_timer_expired(&mut context.recorder, meta, event);
593 }
594 #[inline]
595 fn on_mtu_updated(
596 &mut self,
597 context: &mut Self::ConnectionContext,
598 meta: &api::ConnectionMeta,
599 event: &api::MtuUpdated,
600 ) {
601 context.mtu_updated += 1;
602 self.subscriber
603 .on_mtu_updated(&mut context.recorder, meta, event);
604 }
605 #[inline]
606 fn on_mtu_probing_complete_received(
607 &mut self,
608 context: &mut Self::ConnectionContext,
609 meta: &api::ConnectionMeta,
610 event: &api::MtuProbingCompleteReceived,
611 ) {
612 context.mtu_probing_complete_received += 1;
613 self.subscriber
614 .on_mtu_probing_complete_received(&mut context.recorder, meta, event);
615 }
616 #[inline]
617 fn on_slow_start_exited(
618 &mut self,
619 context: &mut Self::ConnectionContext,
620 meta: &api::ConnectionMeta,
621 event: &api::SlowStartExited,
622 ) {
623 context.slow_start_exited += 1;
624 self.subscriber
625 .on_slow_start_exited(&mut context.recorder, meta, event);
626 }
627 #[inline]
628 fn on_delivery_rate_sampled(
629 &mut self,
630 context: &mut Self::ConnectionContext,
631 meta: &api::ConnectionMeta,
632 event: &api::DeliveryRateSampled,
633 ) {
634 context.delivery_rate_sampled += 1;
635 self.subscriber
636 .on_delivery_rate_sampled(&mut context.recorder, meta, event);
637 }
638 #[inline]
639 fn on_pacing_rate_updated(
640 &mut self,
641 context: &mut Self::ConnectionContext,
642 meta: &api::ConnectionMeta,
643 event: &api::PacingRateUpdated,
644 ) {
645 context.pacing_rate_updated += 1;
646 self.subscriber
647 .on_pacing_rate_updated(&mut context.recorder, meta, event);
648 }
649 #[inline]
650 fn on_bbr_state_changed(
651 &mut self,
652 context: &mut Self::ConnectionContext,
653 meta: &api::ConnectionMeta,
654 event: &api::BbrStateChanged,
655 ) {
656 context.bbr_state_changed += 1;
657 self.subscriber
658 .on_bbr_state_changed(&mut context.recorder, meta, event);
659 }
660 #[inline]
661 fn on_dc_state_changed(
662 &mut self,
663 context: &mut Self::ConnectionContext,
664 meta: &api::ConnectionMeta,
665 event: &api::DcStateChanged,
666 ) {
667 context.dc_state_changed += 1;
668 self.subscriber
669 .on_dc_state_changed(&mut context.recorder, meta, event);
670 }
671 #[inline]
672 fn on_dc_path_created(
673 &mut self,
674 context: &mut Self::ConnectionContext,
675 meta: &api::ConnectionMeta,
676 event: &api::DcPathCreated,
677 ) {
678 context.dc_path_created += 1;
679 self.subscriber
680 .on_dc_path_created(&mut context.recorder, meta, event);
681 }
682 #[inline]
683 fn on_connection_closed(
684 &mut self,
685 context: &mut Self::ConnectionContext,
686 meta: &api::ConnectionMeta,
687 event: &api::ConnectionClosed,
688 ) {
689 context.connection_closed += 1;
690 self.subscriber
691 .on_connection_closed(&mut context.recorder, meta, event);
692 }
693}
694impl<R: Recorder> Drop for Context<R> {
695 fn drop(&mut self) {
696 self.recorder.increment_counter(
697 "application_protocol_information",
698 self.application_protocol_information as _,
699 );
700 self.recorder
701 .increment_counter("server_name_information", self.server_name_information as _);
702 self.recorder
703 .increment_counter("key_exchange_group", self.key_exchange_group as _);
704 self.recorder
705 .increment_counter("packet_skipped", self.packet_skipped as _);
706 self.recorder
707 .increment_counter("packet_sent", self.packet_sent as _);
708 self.recorder
709 .increment_counter("packet_received", self.packet_received as _);
710 self.recorder
711 .increment_counter("active_path_updated", self.active_path_updated as _);
712 self.recorder
713 .increment_counter("path_created", self.path_created as _);
714 self.recorder
715 .increment_counter("frame_sent", self.frame_sent as _);
716 self.recorder
717 .increment_counter("frame_received", self.frame_received as _);
718 self.recorder.increment_counter(
719 "connection_close_frame_received",
720 self.connection_close_frame_received as _,
721 );
722 self.recorder
723 .increment_counter("packet_lost", self.packet_lost as _);
724 self.recorder
725 .increment_counter("recovery_metrics", self.recovery_metrics as _);
726 self.recorder
727 .increment_counter("congestion", self.congestion as _);
728 self.recorder
729 .increment_counter("ack_processed", self.ack_processed as _);
730 self.recorder
731 .increment_counter("rx_ack_range_dropped", self.rx_ack_range_dropped as _);
732 self.recorder
733 .increment_counter("ack_range_received", self.ack_range_received as _);
734 self.recorder
735 .increment_counter("ack_range_sent", self.ack_range_sent as _);
736 self.recorder
737 .increment_counter("packet_dropped", self.packet_dropped as _);
738 self.recorder
739 .increment_counter("key_update", self.key_update as _);
740 self.recorder
741 .increment_counter("key_space_discarded", self.key_space_discarded as _);
742 self.recorder
743 .increment_counter("connection_started", self.connection_started as _);
744 self.recorder
745 .increment_counter("duplicate_packet", self.duplicate_packet as _);
746 self.recorder.increment_counter(
747 "transport_parameters_received",
748 self.transport_parameters_received as _,
749 );
750 self.recorder
751 .increment_counter("datagram_sent", self.datagram_sent as _);
752 self.recorder
753 .increment_counter("datagram_received", self.datagram_received as _);
754 self.recorder
755 .increment_counter("datagram_dropped", self.datagram_dropped as _);
756 self.recorder.increment_counter(
757 "handshake_remote_address_change_observed",
758 self.handshake_remote_address_change_observed as _,
759 );
760 self.recorder
761 .increment_counter("connection_id_updated", self.connection_id_updated as _);
762 self.recorder
763 .increment_counter("ecn_state_changed", self.ecn_state_changed as _);
764 self.recorder.increment_counter(
765 "connection_migration_denied",
766 self.connection_migration_denied as _,
767 );
768 self.recorder.increment_counter(
769 "handshake_status_updated",
770 self.handshake_status_updated as _,
771 );
772 self.recorder
773 .increment_counter("tls_exporter_ready", self.tls_exporter_ready as _);
774 self.recorder
775 .increment_counter("tls_handshake_failed", self.tls_handshake_failed as _);
776 self.recorder
777 .increment_counter("path_challenge_updated", self.path_challenge_updated as _);
778 self.recorder
779 .increment_counter("tls_client_hello", self.tls_client_hello as _);
780 self.recorder
781 .increment_counter("tls_server_hello", self.tls_server_hello as _);
782 self.recorder
783 .increment_counter("rx_stream_progress", self.rx_stream_progress as _);
784 self.recorder
785 .increment_counter("tx_stream_progress", self.tx_stream_progress as _);
786 self.recorder.increment_counter(
787 "keep_alive_timer_expired",
788 self.keep_alive_timer_expired as _,
789 );
790 self.recorder
791 .increment_counter("mtu_updated", self.mtu_updated as _);
792 self.recorder.increment_counter(
793 "mtu_probing_complete_received",
794 self.mtu_probing_complete_received as _,
795 );
796 self.recorder
797 .increment_counter("slow_start_exited", self.slow_start_exited as _);
798 self.recorder
799 .increment_counter("delivery_rate_sampled", self.delivery_rate_sampled as _);
800 self.recorder
801 .increment_counter("pacing_rate_updated", self.pacing_rate_updated as _);
802 self.recorder
803 .increment_counter("bbr_state_changed", self.bbr_state_changed as _);
804 self.recorder
805 .increment_counter("dc_state_changed", self.dc_state_changed as _);
806 self.recorder
807 .increment_counter("dc_path_created", self.dc_path_created as _);
808 self.recorder
809 .increment_counter("connection_closed", self.connection_closed as _);
810 }
811}