Grcov report - stats

1

#include "source/extensions/common/wasm/stats_handler.h"

2

3

#include "source/extensions/common/wasm/context.h"

4

#include "source/extensions/common/wasm/wasm.h"

5

#include "source/extensions/common/wasm/wasm_vm.h"

6

7

namespace Envoy {

8

namespace Extensions {

9

namespace Common {

10

namespace Wasm {

11

12

454

Stats::ScopeSharedPtr CreateStatsHandler::lockAndCreateStats(const Stats::ScopeSharedPtr& scope) {

13

454

  absl::MutexLock l(mutex_);

14

454

  Stats::ScopeSharedPtr lock;

15

454

  if (!(lock = scope_.lock())) {

16

345

    resetStats();

17

345

    createStats(scope);

18

345

    scope_ = ScopeWeakPtr(scope);

19

345

    return scope;

20

345

21

109

  createStats(scope);

22

109

  return lock;

23

454

24

25

391

void CreateStatsHandler::resetStatsForTesting() {

26

391

  absl::MutexLock l(mutex_);

27

391

  resetStats();

28

391

29

30

454

void CreateStatsHandler::onEvent(WasmEvent event) {

31

454

  switch (event) {

32

8

  case WasmEvent::RemoteLoadCacheHit:

33

8

    create_wasm_stats_->remote_load_cache_hits_.inc();

34

8

    break;

35

4

  case WasmEvent::RemoteLoadCacheNegativeHit:

36

4

    create_wasm_stats_->remote_load_cache_negative_hits_.inc();

37

4

    break;

38

30

  case WasmEvent::RemoteLoadCacheMiss:

39

30

    create_wasm_stats_->remote_load_cache_misses_.inc();

40

30

    break;

41

20

  case WasmEvent::RemoteLoadCacheFetchSuccess:

42

20

    create_wasm_stats_->remote_load_fetch_successes_.inc();

43

20

    break;

44

14

  case WasmEvent::RemoteLoadCacheFetchFailure:

45

14

    create_wasm_stats_->remote_load_fetch_failures_.inc();

46

14

    break;

47

378

  default:

48

378

    break;

49

454

50

454

51

52

104

void CreateStatsHandler::onRemoteCacheEntriesChanged(int entries) {

53

104

  create_wasm_stats_->remote_load_cache_entries_.set(entries);

54

104

55

56

454

void CreateStatsHandler::createStats(const Stats::ScopeSharedPtr& scope) {

57

454

  if (!create_wasm_stats_) {

58

345

    create_wasm_stats_.reset(new CreateWasmStats{CREATE_WASM_STATS( // NOLINT

59

345

        POOL_COUNTER_PREFIX(*scope, "wasm."), POOL_GAUGE_PREFIX(*scope, "wasm."))});

60

345

61

454

62

63

736

void CreateStatsHandler::resetStats() { create_wasm_stats_.reset(); }

64

65

791

CreateStatsHandler& getCreateStatsHandler() { MUTABLE_CONSTRUCT_ON_FIRST_USE(CreateStatsHandler); }

66

67

std::atomic<int64_t> active_wasms;

68

69

2150

void LifecycleStatsHandler::onEvent(WasmEvent event) {

70

2150

  switch (event) {

71

1075

  case WasmEvent::VmShutDown:

72

1075

    lifecycle_stats_.active_.set(--active_wasms);

73

1075

    break;

74

1075

  case WasmEvent::VmCreated:

75

1075

    lifecycle_stats_.active_.set(++active_wasms);

76

1075

    lifecycle_stats_.created_.inc();

77

1075

    break;

78

  default:

79

    break;

80

2150

81

2150

82

83

214

int64_t LifecycleStatsHandler::getActiveVmCount() { return active_wasms; };

84

85

StatsHandler::StatsHandler(Stats::Scope& parent_scope, const std::string& prefix)

86

139

    : scope_(parent_scope.createScope(prefix)), wasm_stats_{WASM_STATS(POOL_COUNTER(*scope_))} {}

87

88

6

void StatsHandler::onEvent(WasmEvent event) const {

89

6

  switch (event) {

90

2

  case WasmEvent::VmReloadBackoff:

91

2

    wasm_stats_.vm_reload_backoff_.inc();

92

2

    break;

93

4

  case WasmEvent::VmReloadSuccess:

94

4

    wasm_stats_.vm_reload_success_.inc();

95

4

    break;

96

  case WasmEvent::VmReloadFailure:

97

    wasm_stats_.vm_reload_failure_.inc();

98

    break;

99

  default:

100

    break;

101

6

102

6

103

104

} // namespace Wasm

105

} // namespace Common

106

} // namespace Extensions

107

} // namespace Envoy