Enum ServerField 

#[repr(usize)]
pub enum ServerField {
    ServerEof = 0,
    ServerErr = 1,
    ServerTimedout = 2,
    ServerEjectedAt = 3,
    ServerDroppedRequests = 4,
    ServerTimedoutRequests = 5,
    ReadRequests = 6,
    ReadRequestBytes = 7,
    WriteRequests = 8,
    WriteRequestBytes = 9,
    ReadResponses = 10,
    ReadResponseBytes = 11,
    WriteResponses = 12,
    WriteResponseBytes = 13,
    InQueue = 14,
    InQueueBytes = 15,
    OutQueue = 16,
    OutQueueBytes = 17,
    RedisReqGet = 18,
    RedisReqSet = 19,
    RedisReqDel = 20,
    RedisReqIncrDecr = 21,
    RedisReqKeys = 22,
    RedisReqMget = 23,
    RedisReqScan = 24,
    RedisReqSort = 25,
    RedisReqLreqm = 26,
    RedisReqSunion = 27,
    RedisReqPing = 28,
    RedisReqLists = 29,
    RedisReqSets = 30,
    RedisReqHashes = 31,
    RedisReqSortedsets = 32,
    RedisReqOther = 33,
}

Typed handle for a server metric.

Each variant is a typed handle for a metric; its as usize value is also the index into the metric vector held by PoolStats / ServerStats.

Variants

ServerEof = 0

eof on server connections

ServerErr = 1

errors on server connections

ServerTimedout = 2

timeouts on server connections

ServerEjectedAt = 3

timestamp when server was ejected in usec since epoch

ServerDroppedRequests = 4

server dropped requests

ServerTimedoutRequests = 5

server timedout requests

ReadRequests = 6

read requests

ReadRequestBytes = 7

total read request bytes

WriteRequests = 8

write requests

WriteRequestBytes = 9

total write request bytes

ReadResponses = 10

read respones

ReadResponseBytes = 11

total read response bytes

WriteResponses = 12

write respones

WriteResponseBytes = 13

total write response bytes

InQueue = 14

requests in incoming queue

InQueueBytes = 15

current request bytes in incoming queue

OutQueue = 16

requests in outgoing queue

OutQueueBytes = 17

current request bytes in outgoing queue

RedisReqGet = 18

Redis get

RedisReqSet = 19

Redis set

RedisReqDel = 20

Redis del

RedisReqIncrDecr = 21

Redis incr or decr

RedisReqKeys = 22

Redis keys

RedisReqMget = 23

Redis mget

RedisReqScan = 24

Redis scan

RedisReqSort = 25

Redis sort

RedisReqLreqm = 26

Redis lreqm

RedisReqSunion = 27

Redis sunion

RedisReqPing = 28

Redis ping

RedisReqLists = 29

Redis lists

RedisReqSets = 30

Redis sets

RedisReqHashes = 31

Redis hashes

RedisReqSortedsets = 32

Redis sortedsets

RedisReqOther = 33

Redis other

Implementations

impl ServerField

pub const ALL: &'static [ServerField]

All variants of this metric set, in canonical order.

Examples

use dynomite::stats::ServerField;
assert!(!ServerField::ALL.is_empty());

pub fn name(self) -> &'static str

Lower-case identifier as it appears in the JSON output.

Examples

use dynomite::stats::ServerField;
let name = ServerField::ALL[0].name();
assert!(!name.is_empty());

pub fn kind(self) -> StatsMetricType

Whether this metric is a counter, gauge, or timestamp.

Examples

use dynomite::stats::{ServerField, StatsMetricType};
let k = ServerField::ALL[0].kind();
assert!(matches!(k, StatsMetricType::Counter | StatsMetricType::Gauge | StatsMetricType::Timestamp));

pub fn description(self) -> &'static str

Human-readable description used by --describe-stats.

Examples

use dynomite::stats::ServerField;
let d = ServerField::ALL[0].description();
assert!(!d.is_empty());

pub fn index(self) -> usize

Index of this metric in the corresponding stats vector.

Examples

use dynomite::stats::ServerField;
assert_eq!(ServerField::ALL[0].index(), 0);

Trait Implementations

impl Clone for ServerField

fn clone(&self) -> ServerField

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ServerField

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ServerField

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ServerField

fn eq(&self, other: &ServerField) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ServerField

impl Eq for ServerField

impl StructuralPartialEq for ServerField