Grcov report - quic_stat

1

#include "source/common/quic/quic_stat_names.h"

2

3

namespace Envoy {

4

namespace Quic {

5

6

#ifdef ENVOY_ENABLE_QUIC

7

8

// TODO(renjietang): Currently these stats are only available in downstream. Wire it up to upstream

9

// QUIC also.

10

QuicStatNames::QuicStatNames(Stats::SymbolTable& symbol_table)

11

43706

    : stat_name_pool_(symbol_table), symbol_table_(symbol_table),

12

43706

      http3_prefix_(stat_name_pool_.add("http3")), downstream_(stat_name_pool_.add("downstream")),

13

43706

      upstream_(stat_name_pool_.add("upstream")), from_self_(stat_name_pool_.add("tx")),

14

43706

      from_peer_(stat_name_pool_.add("rx")) {

15

  // Preallocate most used counters

16

  // Most popular in client initiated connection close.

17

43706

  connectionCloseStatName(quic::QUIC_NETWORK_IDLE_TIMEOUT);

18

  // Most popular in server initiated connection close.

19

43706

  connectionCloseStatName(quic::QUIC_SILENT_IDLE_TIMEOUT);

20

  // Most popular in client initiated stream reset.

21

43706

  resetStreamErrorStatName(quic::QUIC_STREAM_CANCELLED);

22

  // Most popular in server initiated stream reset.

23

43706

  resetStreamErrorStatName(quic::QUIC_STREAM_STREAM_CREATION_ERROR);

24

43706

25

26

7669

void QuicStatNames::incCounter(Stats::Scope& scope, const Stats::StatNameVec& names) {

27

7669

  Stats::SymbolTable::StoragePtr stat_name_storage = symbol_table_.join(names);

28

7669

  scope.counterFromStatName(Stats::StatName(stat_name_storage.get())).inc();

29

7669

30

31

void QuicStatNames::chargeQuicConnectionCloseStats(Stats::Scope& scope,

32

                                                   quic::QuicErrorCode error_code,

33

                                                   quic::ConnectionCloseSource source,

34

6068

                                                   bool is_upstream) {

35

6068

  ASSERT(&symbol_table_ == &scope.symbolTable());

36

37

6068

  if (error_code > quic::QUIC_LAST_ERROR) {

38

1

    error_code = quic::QUIC_LAST_ERROR;

39

1

40

41

6068

  const Stats::StatName connection_close = connectionCloseStatName(error_code);

42

6068

  incCounter(scope, {http3_prefix_, (is_upstream ? upstream_ : downstream_),

43

6068

                     (source == quic::ConnectionCloseSource::FROM_SELF ? from_self_ : from_peer_),

44

6068

                     connection_close});

45

6068

46

47

void QuicStatNames::chargeQuicResetStreamErrorStats(Stats::Scope& scope,

48

                                                    quic::QuicResetStreamError error_code,

49

1601

                                                    bool from_self, bool is_upstream) {

50

1601

  ASSERT(&symbol_table_ == &scope.symbolTable());

51

52

1601

  auto internal_code = error_code.internal_code();

53

1601

  if (internal_code > quic::QUIC_STREAM_LAST_ERROR) {

54

1

    internal_code = quic::QUIC_STREAM_LAST_ERROR;

55

1

56

57

1601

  const Stats::StatName stream_error = resetStreamErrorStatName(internal_code);

58

1601

  incCounter(scope, {http3_prefix_, (is_upstream ? upstream_ : downstream_),

59

1601

                     (from_self ? from_self_ : from_peer_), stream_error});

60

1601

61

62

93479

Stats::StatName QuicStatNames::connectionCloseStatName(quic::QuicErrorCode error_code) {

63

93479

  ASSERT(error_code <= quic::QUIC_LAST_ERROR);

64

65

93479

  return Stats::StatName(

66

93479

      connection_error_stat_names_.get(error_code, [this, error_code]() -> const uint8_t* {

67

90994

        return stat_name_pool_.addReturningStorage(

68

90994

            absl::StrCat("quic_connection_close_error_code_", QuicErrorCodeToString(error_code)));

69

90994

      }));

70

93479

71

72

89013

Stats::StatName QuicStatNames::resetStreamErrorStatName(quic::QuicRstStreamErrorCode error_code) {

73

89013

  ASSERT(error_code <= quic::QUIC_STREAM_LAST_ERROR);

74

75

89013

  return Stats::StatName(

76

89013

      reset_stream_error_stat_names_.get(error_code, [this, error_code]() -> const uint8_t* {

77

88207

        return stat_name_pool_.addReturningStorage(absl::StrCat(

78

88207

            "quic_reset_stream_error_code_", QuicRstStreamErrorCodeToString(error_code)));

79

88207

      }));

80

89013

81

82

#else

83

QuicStatNames::QuicStatNames(Stats::SymbolTable& /*symbol_table*/) {}

84

85

#endif

86

87

} // namespace Quic

88

} // namespace Envoy