215 lines
9.3 KiB
Rust
215 lines
9.3 KiB
Rust
impl Pool {
|
|
pub fn view(&self) -> Value {
|
|
let members = self
|
|
.members
|
|
.iter()
|
|
.map(|m| {
|
|
let h = lock(&m.state.health);
|
|
let failure = lock(&m.state.last_failure);
|
|
let member_health = self.settings.health_for(&m.definition);
|
|
let status = if !m.definition.enabled {
|
|
"disabled"
|
|
} else if m.definition.drain {
|
|
"draining"
|
|
} else if h.healthy {
|
|
"up"
|
|
} else if !h.checked && member_health.mode != HealthMode::Off {
|
|
"checking"
|
|
} else {
|
|
"down"
|
|
};
|
|
|
|
let mut item = serde_json::Map::new();
|
|
item.insert("id".into(), json!(m.definition.id));
|
|
item.insert("url".into(), json!(m.definition.url));
|
|
item.insert("protocol".into(), json!(m.definition.protocol));
|
|
item.insert("weight".into(), json!(m.definition.weight));
|
|
item.insert("backup".into(), json!(m.definition.backup));
|
|
item.insert(
|
|
"health_check_enabled".into(),
|
|
json!(m.definition.health_check_enabled),
|
|
);
|
|
item.insert("health_mode".into(), json!(member_health.mode));
|
|
item.insert(
|
|
"max_concurrent_requests".into(),
|
|
json!(m.definition.max_concurrent_requests),
|
|
);
|
|
item.insert(
|
|
"queue_timeout_ms".into(),
|
|
json!(m.definition.queue_timeout_ms),
|
|
);
|
|
item.insert("status".into(), json!(status));
|
|
item.insert("healthy".into(), json!(h.healthy));
|
|
item.insert(
|
|
"active".into(),
|
|
json!(m.state.active.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"requests".into(),
|
|
json!(m.state.requests.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"errors".into(),
|
|
json!(m.state.errors.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"bytes_in".into(),
|
|
json!(m.state.bytes_in.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"bytes_out".into(),
|
|
json!(m.state.bytes_out.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"traffic_bytes_per_second".into(),
|
|
json!(m.state.traffic_rate()),
|
|
);
|
|
let client_rotation = m.backend.client.rotation_stats();
|
|
item.insert(
|
|
"upstream_client_generation".into(),
|
|
json!(client_rotation.generation),
|
|
);
|
|
item.insert(
|
|
"upstream_client_generation_requests".into(),
|
|
json!(client_rotation.generation_requests),
|
|
);
|
|
item.insert(
|
|
"upstream_client_generation_age_seconds".into(),
|
|
json!(client_rotation.generation_age_seconds),
|
|
);
|
|
item.insert(
|
|
"upstream_client_rotations_total".into(),
|
|
json!(client_rotation.rotations),
|
|
);
|
|
let observed = m.backend.client.protocol_stats();
|
|
item.insert(
|
|
"upstream_protocol_observed".into(),
|
|
json!(observed.last_version),
|
|
);
|
|
item.insert(
|
|
"upstream_protocol_last_seen_ms".into(),
|
|
json!(observed.observed_at_ms),
|
|
);
|
|
item.insert(
|
|
"upstream_protocol_http1_total".into(),
|
|
json!(observed.http1_responses),
|
|
);
|
|
item.insert(
|
|
"upstream_protocol_http2_total".into(),
|
|
json!(observed.http2_responses),
|
|
);
|
|
item.insert("latency_ms".into(), json!(h.latency_us as f64 / 1000.0));
|
|
item.insert("ewma_latency_ms".into(), json!(h.ewma_us as f64 / 1000.0));
|
|
item.insert("last_probe_ms".into(), json!(h.last_probe_ms));
|
|
item.insert("last_result".into(), json!(h.result));
|
|
item.insert("last_passive_result".into(), json!(h.passive_result));
|
|
item.insert("failures".into(), json!(h.failures));
|
|
item.insert("passive_failures".into(), json!(h.passive_failures));
|
|
item.insert("successes".into(), json!(h.successes));
|
|
item.insert("passive_successes".into(), json!(h.passive_successes));
|
|
item.insert("transitions".into(), json!(h.transitions));
|
|
item.insert("unhealthy_source".into(), json!(h.unhealthy_source));
|
|
item.insert("unhealthy_reason".into(), json!(h.unhealthy_reason));
|
|
item.insert(
|
|
"http_5xx_total".into(),
|
|
json!(m.state.http_5xx_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"timeouts_total".into(),
|
|
json!(m.state.timeouts_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"connect_errors_total".into(),
|
|
json!(m.state.connect_errors_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"io_errors_total".into(),
|
|
json!(m.state.io_errors_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"slow_responses_total".into(),
|
|
json!(m.state.slow_responses_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"retry_attempts_total".into(),
|
|
json!(m.state.retry_attempts_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"retry_successes_total".into(),
|
|
json!(m.state.retry_successes_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"capacity_rejections_total".into(),
|
|
json!(m.state.capacity_rejections_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"queue_timeouts_total".into(),
|
|
json!(m.state.queue_timeouts_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"dns_errors_total".into(),
|
|
json!(m.state.dns_errors_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"tls_errors_total".into(),
|
|
json!(m.state.tls_errors_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"response_header_timeouts_total".into(),
|
|
json!(m
|
|
.state
|
|
.response_header_timeouts_total
|
|
.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"read_timeouts_total".into(),
|
|
json!(m.state.read_timeouts_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"send_timeouts_total".into(),
|
|
json!(m.state.send_timeouts_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert("last_failure_at_ms".into(), json!(failure.at_ms));
|
|
item.insert("last_failure_class".into(), json!(failure.class));
|
|
item.insert("last_failure_detail".into(), json!(failure.detail.as_str()));
|
|
item.insert(
|
|
"last_ejected_ms".into(),
|
|
json!(m.state.last_ejected_ms.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"last_recovered_ms".into(),
|
|
json!(m.state.last_recovered_ms.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"active_health_failures_total".into(),
|
|
json!(m.state.active_health_failures_total.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"passive_health_failures_total".into(),
|
|
json!(m
|
|
.state
|
|
.passive_health_failures_total
|
|
.load(Ordering::Relaxed)),
|
|
);
|
|
item.insert(
|
|
"last_status".into(),
|
|
json!(m.state.last_status.load(Ordering::Relaxed)),
|
|
);
|
|
Value::Object(item)
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
json!({
|
|
"id": self.id,
|
|
"algorithm": self.settings.algorithm,
|
|
"ready": self.ready(),
|
|
"health_mode": self.settings.health_check.mode,
|
|
"passive_health": self.settings.passive_health,
|
|
"retry": self.settings.retry,
|
|
"sticky_mode": self.settings.sticky.mode,
|
|
"keepalive": self.settings.keepalive,
|
|
"members": members,
|
|
})
|
|
}
|
|
}
|