use metrics::{counter, gauge, histogram};
use strum::IntoEnumIterator;
use strum_macros::{EnumIter, IntoStaticStr};
use super::{
overrides::BufferEvent,
titan::{EntryRejection, TitanMessage, TitanPriceLevelMessage, TitanQuoteStreamMessage},
};
const PRICE_LEVEL_SOCKET: &str = TitanPriceLevelMessage::SOCKET;
const QUOTE_STREAM_SOCKET: &str = TitanQuoteStreamMessage::SOCKET;
pub(super) const FRAMES_ACCEPTED: &str = "price_level_stream_frames_accepted_total";
pub(super) const FRAMES_REJECTED: &str = "price_level_stream_frames_rejected_total";
pub(super) const FRAME_AGE: &str = "price_level_stream_frame_age_seconds";
pub(super) const LAST_SEEN: &str = "price_level_stream_last_seen_timestamp_seconds";
pub(super) const SERVED_COMPONENTS: &str = "price_level_stream_served_components";
pub(super) const STALE_REMOVALS: &str = "price_level_stream_stale_removals_total";
pub(super) const SERVING_STATE: &str = "price_level_stream_serving_state";
pub(super) const RECONNECTS: &str = "price_level_stream_reconnects_total";
pub(super) const UNREGISTERED_PAMM_ENTRIES: &str =
"price_level_stream_unregistered_pamm_entries_total";
pub(super) const SKIPPED_BOOKS: &str = "price_level_stream_skipped_books_total";
pub(super) const REJECTED_SIDES: &str = "price_level_stream_rejected_sides_total";
pub(super) const OVERRIDE_MATCHES: &str = "price_level_stream_override_match_total";
pub(super) const OVERRIDE_BUFFER: &str = "price_level_stream_override_buffer_total";
pub(super) const REFUSED_OVERRIDE_ENTRIES: &str =
"price_level_stream_override_entries_refused_total";
pub(super) const UNREADABLE_QUOTE_SEQUENCE: &str =
"price_level_stream_unreadable_quote_sequence_total";
pub(super) const QUOTES_REFUSED: &str = "price_level_stream_quotes_refused_total";
pub(super) const SEQUENCE_SLOT_MISMATCH: &str = "price_level_stream_sequence_slot_mismatch_total";
pub(super) const OVERRIDE_ENTRY_MISSING_FIELD: &str =
"price_level_stream_override_entry_missing_field_total";
pub(super) const DUPLICATE_BOOKS: &str = "price_level_stream_duplicate_books_total";
pub(super) const MESSAGES_WITHOUT_SLOT: &str = "price_level_stream_messages_without_slot_total";
pub(super) const UNSERVED_VENUE_ENTRIES: &str = "price_level_stream_unserved_venue_entries_total";
pub(super) const OVERRIDE_ENTRY_SLOTS: &str = "price_level_stream_override_entry_storage_slots";
pub(super) const OVERRIDE_ENTRY_ACCOUNTS: &str = "price_level_stream_override_entry_accounts";
pub(super) const OVERRIDE_BLOCK_MISMATCH: &str = "price_level_stream_override_block_mismatch_total";
pub(super) const OVERRIDE_MERGED_SOURCES: &str = "price_level_stream_override_merged_sources_total";
pub(super) const OVERRIDE_SKIPPED_SOURCES: &str =
"price_level_stream_override_skipped_sources_total";
#[derive(Clone, Copy, Debug, PartialEq, Eq, IntoStaticStr, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub(super) enum RejectReason {
ParseError,
TooOld,
InFuture,
OutOfOrder,
BlockRegression,
BlockJump,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, IntoStaticStr, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub(super) enum ReconnectReason {
IdleTimeout,
Ended,
Closed,
ReadError,
ConnectFailed,
ConnectTimeout,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, IntoStaticStr, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub(super) enum SkipReason {
MalformedAddress,
UnadmittedToken,
OneAssetPair,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, IntoStaticStr, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub(super) enum SideRejectReason {
UnsupportedLevel,
NonFiniteAmount,
ZeroAmount,
ConflictingKnots,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, IntoStaticStr, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub(super) enum MatchOutcome {
SameSequence,
EarlierSequence,
NoneInSlot,
NoQuoteSequence,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, IntoStaticStr, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub(super) enum QuoteRefusedReason {
PriceLevelsExpired,
NotMonotonic,
UnknownPair,
NoLiquidity,
BelowSmallestQuote,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, IntoStaticStr, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub(super) enum MissingField {
BlockNumber,
Slot,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum ServingState {
Unserved = 0,
Serving = 1,
}
pub(super) fn record_frame_accepted() {
counter!(FRAMES_ACCEPTED).increment(1);
}
pub(super) fn record_frame_rejected(socket: &'static str, reason: RejectReason) {
counter!(FRAMES_REJECTED, "socket" => socket, "reason" => <&'static str>::from(reason))
.increment(1);
}
pub(super) fn record_frame_age(age_seconds: f64) {
histogram!(FRAME_AGE).record(age_seconds);
}
pub(super) fn record_last_seen(venue: &str, unix_seconds: u64) {
gauge!(LAST_SEEN, "venue" => venue.to_string()).set(unix_seconds as f64);
}
pub(super) fn record_served_components(venue: &str, count: usize) {
gauge!(SERVED_COMPONENTS, "venue" => venue.to_string()).set(count as f64);
}
pub(super) fn record_stale_removal(venue: &str) {
counter!(STALE_REMOVALS, "venue" => venue.to_string()).increment(1);
}
pub(super) fn init_stale_removals(venue: &str) {
counter!(STALE_REMOVALS, "venue" => venue.to_string()).increment(0);
}
pub(super) fn record_serving_state(state: ServingState) {
gauge!(SERVING_STATE).set(state as u8 as f64);
}
pub(super) fn record_reconnect(socket: &'static str, reason: ReconnectReason) {
counter!(RECONNECTS, "socket" => socket, "reason" => <&'static str>::from(reason)).increment(1);
}
pub(super) fn record_unregistered_pamm() {
counter!(UNREGISTERED_PAMM_ENTRIES).increment(1);
}
pub(super) fn record_skipped_book(reason: SkipReason) {
counter!(SKIPPED_BOOKS, "reason" => <&'static str>::from(reason)).increment(1);
}
pub(super) fn record_rejected_side(reason: SideRejectReason) {
counter!(REJECTED_SIDES, "reason" => <&'static str>::from(reason)).increment(1);
}
pub(super) fn record_override_match(venue: &str, outcome: MatchOutcome) {
let outcome = <&'static str>::from(outcome);
counter!(OVERRIDE_MATCHES, "venue" => venue.to_string(), "outcome" => outcome).increment(1);
}
pub(super) fn record_buffer_event(event: BufferEvent, times: u64) {
counter!(OVERRIDE_BUFFER, "event" => <&'static str>::from(event)).increment(times);
}
pub(super) fn record_refused_override_entry(reason: EntryRejection) {
counter!(REFUSED_OVERRIDE_ENTRIES, "reason" => <&'static str>::from(reason)).increment(1);
}
pub(super) fn record_quote_refused(reason: QuoteRefusedReason) {
counter!(QUOTES_REFUSED, "reason" => <&'static str>::from(reason)).increment(1);
}
pub(super) fn record_sequence_slot_mismatch(socket: &'static str) {
counter!(SEQUENCE_SLOT_MISMATCH, "socket" => socket).increment(1);
}
pub(super) fn record_override_entry_missing_field(field: MissingField) {
counter!(OVERRIDE_ENTRY_MISSING_FIELD, "field" => <&'static str>::from(field)).increment(1);
}
pub(super) fn record_duplicate_books() {
counter!(DUPLICATE_BOOKS).increment(1);
}
pub(super) fn record_unserved_venue_entry() {
counter!(UNSERVED_VENUE_ENTRIES).increment(1);
}
pub(super) fn record_override_entry_size(accounts: usize, slots: usize) {
histogram!(OVERRIDE_ENTRY_ACCOUNTS).record(accounts as f64);
histogram!(OVERRIDE_ENTRY_SLOTS).record(slots as f64);
}
pub(super) fn record_override_block_mismatch() {
counter!(OVERRIDE_BLOCK_MISMATCH).increment(1);
}
pub(super) fn record_override_merged_sources(venue: &str, sources: usize) {
counter!(OVERRIDE_MERGED_SOURCES, "venue" => venue.to_string()).increment(sources as u64);
}
pub(super) fn record_override_skipped_sources(venue: &str, sources: usize) {
counter!(OVERRIDE_SKIPPED_SOURCES, "venue" => venue.to_string()).increment(sources as u64);
}
pub(super) fn record_message_without_slot() {
counter!(MESSAGES_WITHOUT_SLOT).increment(1);
}
pub(super) fn record_unreadable_quote_sequence() {
counter!(UNREADABLE_QUOTE_SEQUENCE).increment(1);
}
pub(super) fn init_book_counters() {
for reason in SkipReason::iter() {
counter!(SKIPPED_BOOKS, "reason" => <&'static str>::from(reason)).increment(0);
}
for reason in SideRejectReason::iter() {
counter!(REJECTED_SIDES, "reason" => <&'static str>::from(reason)).increment(0);
}
for reason in QuoteRefusedReason::iter() {
counter!(QUOTES_REFUSED, "reason" => <&'static str>::from(reason)).increment(0);
}
counter!(UNREADABLE_QUOTE_SEQUENCE).increment(0);
counter!(SEQUENCE_SLOT_MISMATCH, "socket" => PRICE_LEVEL_SOCKET).increment(0);
counter!(DUPLICATE_BOOKS).increment(0);
counter!(MESSAGES_WITHOUT_SLOT).increment(0);
}
pub(super) fn init_override_counters() {
for event in BufferEvent::iter() {
counter!(OVERRIDE_BUFFER, "event" => <&'static str>::from(event)).increment(0);
}
for reason in EntryRejection::iter() {
counter!(REFUSED_OVERRIDE_ENTRIES, "reason" => <&'static str>::from(reason)).increment(0);
}
for field in MissingField::iter() {
let field = <&'static str>::from(field);
counter!(OVERRIDE_ENTRY_MISSING_FIELD, "field" => field).increment(0);
}
counter!(SEQUENCE_SLOT_MISMATCH, "socket" => QUOTE_STREAM_SOCKET).increment(0);
counter!(UNSERVED_VENUE_ENTRIES).increment(0);
counter!(OVERRIDE_BLOCK_MISMATCH).increment(0);
}
pub(super) fn init_override_venue_series(venue: &str) {
for outcome in MatchOutcome::iter() {
let outcome = <&'static str>::from(outcome);
counter!(OVERRIDE_MATCHES, "venue" => venue.to_string(), "outcome" => outcome).increment(0);
}
counter!(OVERRIDE_MERGED_SOURCES, "venue" => venue.to_string()).increment(0);
counter!(OVERRIDE_SKIPPED_SOURCES, "venue" => venue.to_string()).increment(0);
}
pub(super) fn init_socket_counters(quote_stream_socket: bool) {
for reason in RejectReason::iter() {
let reason = <&'static str>::from(reason);
counter!(FRAMES_REJECTED, "socket" => PRICE_LEVEL_SOCKET, "reason" => reason).increment(0);
}
for reason in ReconnectReason::iter() {
let reason = <&'static str>::from(reason);
counter!(RECONNECTS, "socket" => PRICE_LEVEL_SOCKET, "reason" => reason).increment(0);
}
if !quote_stream_socket {
return;
}
let parse_error = <&'static str>::from(RejectReason::ParseError);
counter!(FRAMES_REJECTED, "socket" => QUOTE_STREAM_SOCKET, "reason" => parse_error)
.increment(0);
for reason in ReconnectReason::iter() {
let reason = <&'static str>::from(reason);
counter!(RECONNECTS, "socket" => QUOTE_STREAM_SOCKET, "reason" => reason).increment(0);
}
}
#[cfg(test)]
pub(super) mod recorded {
use std::{
collections::{BTreeMap, HashMap},
future::Future,
};
use metrics_util::{
debugging::{DebugValue, DebuggingRecorder, Snapshot},
MetricKind,
};
pub(in super::super) type SnapshotMap =
HashMap<(MetricKind, String, BTreeMap<String, String>), DebugValue>;
pub(in super::super) fn record_async<T>(future: impl Future<Output = T>) -> (T, SnapshotMap) {
let recorder = DebuggingRecorder::new();
let snapshotter = recorder.snapshotter();
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
let output = metrics::with_local_recorder(&recorder, || runtime.block_on(future));
(output, snapshot_map(snapshotter.snapshot()))
}
pub(in super::super) fn snapshot_map(snapshot: Snapshot) -> SnapshotMap {
snapshot
.into_vec()
.into_iter()
.map(|(composite_key, _unit, _description, value)| {
let name = composite_key.key().name().to_string();
let labels = composite_key
.key()
.labels()
.map(|label| (label.key().to_string(), label.value().to_string()))
.collect();
((composite_key.kind(), name, labels), value)
})
.collect()
}
fn labels(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
pairs
.iter()
.map(|(key, value)| ((*key).to_string(), (*value).to_string()))
.collect()
}
pub(in super::super) fn counter_value(
snapshot: &SnapshotMap,
name: &str,
label_pairs: &[(&str, &str)],
) -> u64 {
match snapshot.get(&(MetricKind::Counter, name.to_string(), labels(label_pairs))) {
Some(DebugValue::Counter(value)) => *value,
Some(DebugValue::Gauge(_)) | Some(DebugValue::Histogram(_)) | None => 0,
}
}
pub(in super::super) fn counter_registered(
snapshot: &SnapshotMap,
name: &str,
label_pairs: &[(&str, &str)],
) -> bool {
snapshot.contains_key(&(MetricKind::Counter, name.to_string(), labels(label_pairs)))
}
pub(in super::super) fn registered_series(snapshot: &SnapshotMap, name: &str) -> usize {
snapshot
.keys()
.filter(|(_kind, series, _labels)| series == name)
.count()
}
pub(in super::super) fn all_label_values(snapshot: &SnapshotMap) -> Vec<&str> {
snapshot
.keys()
.flat_map(|(_kind, _name, labels)| labels.values().map(String::as_str))
.collect()
}
pub(in super::super) fn gauge_value(
snapshot: &SnapshotMap,
name: &str,
label_pairs: &[(&str, &str)],
) -> f64 {
match snapshot.get(&(MetricKind::Gauge, name.to_string(), labels(label_pairs))) {
Some(DebugValue::Gauge(value)) => value.into_inner(),
Some(DebugValue::Counter(_)) | Some(DebugValue::Histogram(_)) | None => f64::NAN,
}
}
pub(in super::super) fn histogram_values(
snapshot: &SnapshotMap,
name: &str,
label_pairs: &[(&str, &str)],
) -> Vec<f64> {
match snapshot.get(&(MetricKind::Histogram, name.to_string(), labels(label_pairs))) {
Some(DebugValue::Histogram(values)) => values
.iter()
.map(|value| value.into_inner())
.collect(),
Some(DebugValue::Counter(_)) | Some(DebugValue::Gauge(_)) | None => Vec::new(),
}
}
}
#[cfg(test)]
mod tests {
use rstest::rstest;
use super::{recorded::*, *};
#[test]
fn every_helper_emits_its_named_metric() {
let ((), snapshot) = record_async(async {
record_frame_accepted();
record_frame_rejected("price_levels", RejectReason::TooOld);
record_frame_rejected("price_levels", RejectReason::TooOld);
record_frame_age(0.25);
record_last_seen("fermiswap", 1_700_000_000);
record_served_components("fermiswap", 3);
record_stale_removal("fermiswap");
record_serving_state(ServingState::Serving);
record_reconnect("quote_stream", ReconnectReason::IdleTimeout);
record_unregistered_pamm();
record_skipped_book(SkipReason::MalformedAddress);
record_rejected_side(SideRejectReason::ConflictingKnots);
record_override_match("fermiswap", MatchOutcome::EarlierSequence);
record_buffer_event(BufferEvent::ResentWithDifferentState, 2);
record_refused_override_entry(EntryRejection::PairsAndSequencesDiffer);
record_unreadable_quote_sequence();
record_quote_refused(QuoteRefusedReason::BelowSmallestQuote);
record_sequence_slot_mismatch("quote_stream");
record_override_entry_missing_field(MissingField::BlockNumber);
record_duplicate_books();
record_unserved_venue_entry();
record_override_entry_size(3, 7);
record_override_block_mismatch();
record_override_merged_sources("metric", 2);
record_override_skipped_sources("metric", 1);
record_message_without_slot();
});
assert_eq!(counter_value(&snapshot, "price_level_stream_frames_accepted_total", &[]), 1);
assert_eq!(
counter_value(
&snapshot,
"price_level_stream_frames_rejected_total",
&[("socket", "price_levels"), ("reason", "too_old")]
),
2
);
assert_eq!(
histogram_values(&snapshot, "price_level_stream_frame_age_seconds", &[]),
vec![0.25]
);
assert_eq!(
gauge_value(
&snapshot,
"price_level_stream_last_seen_timestamp_seconds",
&[("venue", "fermiswap")]
),
1_700_000_000.0
);
assert_eq!(
gauge_value(
&snapshot,
"price_level_stream_served_components",
&[("venue", "fermiswap")]
),
3.0
);
assert_eq!(
counter_value(
&snapshot,
"price_level_stream_stale_removals_total",
&[("venue", "fermiswap")]
),
1
);
assert_eq!(gauge_value(&snapshot, "price_level_stream_serving_state", &[]), 1.0);
assert_eq!(
counter_value(
&snapshot,
"price_level_stream_reconnects_total",
&[("socket", "quote_stream"), ("reason", "idle_timeout")]
),
1
);
assert_eq!(
counter_value(&snapshot, "price_level_stream_unregistered_pamm_entries_total", &[]),
1
);
assert_eq!(
counter_value(
&snapshot,
"price_level_stream_skipped_books_total",
&[("reason", "malformed_address")]
),
1
);
assert_eq!(
counter_value(
&snapshot,
"price_level_stream_rejected_sides_total",
&[("reason", "conflicting_knots")]
),
1
);
for (name, labels, value) in [
(
"price_level_stream_override_match_total",
vec![("venue", "fermiswap"), ("outcome", "earlier_sequence")],
1,
),
(
"price_level_stream_override_buffer_total",
vec![("event", "resent_with_different_state")],
2,
),
(
"price_level_stream_override_entries_refused_total",
vec![("reason", "pairs_and_sequences_differ")],
1,
),
("price_level_stream_unreadable_quote_sequence_total", vec![], 1),
(
"price_level_stream_quotes_refused_total",
vec![("reason", "below_smallest_quote")],
1,
),
(
"price_level_stream_sequence_slot_mismatch_total",
vec![("socket", "quote_stream")],
1,
),
(
"price_level_stream_override_entry_missing_field_total",
vec![("field", "block_number")],
1,
),
("price_level_stream_duplicate_books_total", vec![], 1),
("price_level_stream_unserved_venue_entries_total", vec![], 1),
("price_level_stream_override_block_mismatch_total", vec![], 1),
("price_level_stream_override_merged_sources_total", vec![("venue", "metric")], 2),
("price_level_stream_override_skipped_sources_total", vec![("venue", "metric")], 1),
("price_level_stream_messages_without_slot_total", vec![], 1),
] {
assert_eq!(counter_value(&snapshot, name, &labels), value, "{name}");
}
assert_eq!(
histogram_values(&snapshot, "price_level_stream_override_entry_accounts", &[]),
vec![3.0]
);
assert_eq!(
histogram_values(&snapshot, "price_level_stream_override_entry_storage_slots", &[]),
vec![7.0]
);
}
#[test]
fn book_counters_start_at_zero_under_every_reason() {
let ((), snapshot) = record_async(async { init_book_counters() });
for reason in ["malformed_address", "unadmitted_token", "one_asset_pair"] {
let labels = [("reason", reason)];
assert!(
counter_registered(&snapshot, SKIPPED_BOOKS, &labels),
"skipped_books {reason} is a missing series"
);
assert_eq!(counter_value(&snapshot, SKIPPED_BOOKS, &labels), 0);
}
for reason in ["unsupported_level", "non_finite_amount", "zero_amount", "conflicting_knots"]
{
let labels = [("reason", reason)];
assert!(
counter_registered(&snapshot, REJECTED_SIDES, &labels),
"rejected_sides {reason} is a missing series"
);
assert_eq!(counter_value(&snapshot, REJECTED_SIDES, &labels), 0);
}
for reason in [
"price_levels_expired",
"not_monotonic",
"unknown_pair",
"no_liquidity",
"below_smallest_quote",
] {
let labels = [("reason", reason)];
assert!(
counter_registered(&snapshot, QUOTES_REFUSED, &labels),
"quotes_refused {reason} is a missing series"
);
}
for (name, labels) in [
(UNREADABLE_QUOTE_SEQUENCE, vec![]),
(DUPLICATE_BOOKS, vec![]),
(MESSAGES_WITHOUT_SLOT, vec![]),
(SEQUENCE_SLOT_MISMATCH, vec![("socket", "price_levels")]),
] {
assert!(counter_registered(&snapshot, name, &labels), "{name} is a missing series");
assert_eq!(counter_value(&snapshot, name, &labels), 0, "{name}");
}
}
#[test]
fn override_counters_start_at_zero_under_every_label() {
let ((), snapshot) = record_async(async {
init_override_counters();
init_override_venue_series("fermiswap");
});
let outcomes = ["same_sequence", "earlier_sequence", "none_in_slot", "no_quote_sequence"];
let events = [
"added",
"replaced_by_newer",
"older_than_held",
"resent_unchanged",
"resent_with_different_state",
"same_token_pair",
"arrived_outside_slot_window",
"left_slot_window",
"buffer_full",
];
let refusals = [
"undecodable",
"not_a_venue",
"not_an_account",
"malformed_pair",
"malformed_storage",
"malformed_quantity",
"no_timestamp",
"pairs_and_sequences_differ",
"empty",
"unsupported_override",
"over_cap",
];
assert_eq!(
events.len(),
BufferEvent::iter().count(),
"a BufferEvent is missing from this list"
);
assert_eq!(
refusals.len(),
EntryRejection::iter().count(),
"an EntryRejection is missing from this list"
);
for outcome in outcomes {
let labels = [("venue", "fermiswap"), ("outcome", outcome)];
assert!(counter_registered(&snapshot, OVERRIDE_MATCHES, &labels), "{outcome}");
}
assert_eq!(registered_series(&snapshot, OVERRIDE_MATCHES), outcomes.len());
for (name, key, values) in [
(OVERRIDE_BUFFER, "event", events.as_slice()),
(REFUSED_OVERRIDE_ENTRIES, "reason", refusals.as_slice()),
(OVERRIDE_ENTRY_MISSING_FIELD, "field", ["block_number", "slot"].as_slice()),
] {
for value in values {
let labels = [(key, *value)];
assert!(
counter_registered(&snapshot, name, &labels),
"{name} {value} is a missing series"
);
assert_eq!(counter_value(&snapshot, name, &labels), 0, "{name} {value}");
}
assert_eq!(
registered_series(&snapshot, name),
values.len(),
"{name} registered a series its label vocabulary does not name"
);
}
for (name, labels) in [
(SEQUENCE_SLOT_MISMATCH, vec![("socket", "quote_stream")]),
(UNSERVED_VENUE_ENTRIES, vec![]),
(OVERRIDE_BLOCK_MISMATCH, vec![]),
(OVERRIDE_MERGED_SOURCES, vec![("venue", "fermiswap")]),
(OVERRIDE_SKIPPED_SOURCES, vec![("venue", "fermiswap")]),
] {
assert!(counter_registered(&snapshot, name, &labels), "{name} is a missing series");
}
}
#[rstest]
#[case::with_the_quote_stream_socket(true)]
#[case::price_level_socket_only(false)]
fn socket_counters_start_at_zero_for_every_reachable_series(#[case] quote_stream_socket: bool) {
let ((), snapshot) = record_async(async { init_socket_counters(quote_stream_socket) });
let reject_reasons = [
"parse_error",
"too_old",
"in_future",
"out_of_order",
"block_regression",
"block_jump",
];
let reconnect_reasons =
["idle_timeout", "ended", "closed", "read_error", "connect_failed", "connect_timeout"];
for reason in reject_reasons {
let labels = [("socket", "price_levels"), ("reason", reason)];
assert!(counter_registered(&snapshot, FRAMES_REJECTED, &labels), "{reason}");
assert_eq!(counter_value(&snapshot, FRAMES_REJECTED, &labels), 0, "{reason}");
}
for reason in reconnect_reasons {
for socket in ["price_levels", "quote_stream"] {
let labels = [("socket", socket), ("reason", reason)];
let reachable = socket == "price_levels" || quote_stream_socket;
assert_eq!(
counter_registered(&snapshot, RECONNECTS, &labels),
reachable,
"{socket} {reason}"
);
}
}
assert_eq!(
counter_registered(
&snapshot,
FRAMES_REJECTED,
&[("socket", "quote_stream"), ("reason", "parse_error")]
),
quote_stream_socket
);
for reason in ["too_old", "in_future", "out_of_order", "block_regression", "block_jump"] {
assert!(
!counter_registered(
&snapshot,
FRAMES_REJECTED,
&[("socket", "quote_stream"), ("reason", reason)]
),
"{reason} cannot be recorded against the quote stream socket, yet it is registered"
);
}
assert_eq!(
registered_series(&snapshot, FRAMES_REJECTED),
if quote_stream_socket { reject_reasons.len() + 1 } else { reject_reasons.len() }
);
assert_eq!(
registered_series(&snapshot, RECONNECTS),
if quote_stream_socket { reconnect_reasons.len() * 2 } else { reconnect_reasons.len() }
);
}
}