libqueued 0.13.0

Library for queued
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use std::sync::atomic::AtomicU64;
use std::sync::atomic::Ordering;

#[derive(Default)]
pub struct Metrics {
  /// Total number of poll requests that failed due to no message being available.
  pub(crate) empty_poll_counter: AtomicU64,
  /// Amount of messages currently in the queue. They may have been created, polled, or updated.
  pub(crate) message_counter: AtomicU64,
  /// Total number of delete requests that failed due to the requested message not being found.
  pub(crate) missing_delete_counter: AtomicU64,
  /// Total number of update requests that failed due to the requested message not being found.
  pub(crate) missing_update_counter: AtomicU64,
  /// Total number of delete requests that did delete a message successfully.
  pub(crate) successful_delete_counter: AtomicU64,
  /// Total number of poll requests that did poll a message successfully.
  pub(crate) successful_poll_counter: AtomicU64,
  /// Total number of push requests that did push a message successfully.
  pub(crate) successful_push_counter: AtomicU64,
  /// Total number of update requests that did update a message successfully.
  pub(crate) successful_update_counter: AtomicU64,
  /// Total number of delete requests while the endpoint was suspended.
  pub(crate) suspended_delete_counter: AtomicU64,
  /// Total number of poll requests while the endpoint was suspended.
  pub(crate) suspended_poll_counter: AtomicU64,
  /// Total number of push requests while the endpoint was suspended.
  pub(crate) suspended_push_counter: AtomicU64,
  /// Total number of update requests while the endpoint was suspended.
  pub(crate) suspended_update_counter: AtomicU64,
  /// Total number of poll requests that were throttled.
  pub(crate) throttled_poll_counter: AtomicU64,
}

impl Metrics {
  pub fn empty_poll_counter(&self) -> u64 {
    self.empty_poll_counter.load(Ordering::Relaxed)
  }

  pub fn message_counter(&self) -> u64 {
    self.message_counter.load(Ordering::Relaxed)
  }

  pub fn missing_delete_counter(&self) -> u64 {
    self.missing_delete_counter.load(Ordering::Relaxed)
  }

  pub fn missing_update_counter(&self) -> u64 {
    self.missing_update_counter.load(Ordering::Relaxed)
  }

  pub fn successful_delete_counter(&self) -> u64 {
    self.successful_delete_counter.load(Ordering::Relaxed)
  }

  pub fn successful_poll_counter(&self) -> u64 {
    self.successful_poll_counter.load(Ordering::Relaxed)
  }

  pub fn successful_push_counter(&self) -> u64 {
    self.successful_push_counter.load(Ordering::Relaxed)
  }

  pub fn successful_update_counter(&self) -> u64 {
    self.successful_update_counter.load(Ordering::Relaxed)
  }

  pub fn suspended_delete_counter(&self) -> u64 {
    self.suspended_delete_counter.load(Ordering::Relaxed)
  }

  pub fn suspended_poll_counter(&self) -> u64 {
    self.suspended_poll_counter.load(Ordering::Relaxed)
  }

  pub fn suspended_push_counter(&self) -> u64 {
    self.suspended_push_counter.load(Ordering::Relaxed)
  }

  pub fn suspended_update_counter(&self) -> u64 {
    self.suspended_update_counter.load(Ordering::Relaxed)
  }

  pub fn throttled_poll_counter(&self) -> u64 {
    self.throttled_poll_counter.load(Ordering::Relaxed)
  }
}