Struct SpeedTestResult 

pub struct SpeedTestResult {
    pub bytes_received: usize,
    pub bytes_sent: usize,
    pub download_bps: f64,
    pub upload_bps: f64,
    pub download_mbps: f64,
    pub upload_mbps: f64,
    pub ping_ms: f64,
    pub client: ClientInfo,
    pub server: ServerInfo,
    pub share: Option<Value>,
    pub timestamp: String,
}

A processed and cached speedtest result ready for API serving.

This struct stores speeds both in bits per second and megabits per second, along with ping and metadata about client/server.

It is used to cache and respond with speedtest data efficiently.

Examples

use speedtest_statuspage::models::{SpeedTestResult, ClientInfo, ServerInfo};

let result = SpeedTestResult {
    bytes_received: 12345678,
    bytes_sent: 87654321,
    download_bps: 50000000.0,
    upload_bps: 10000000.0,
    download_mbps: 50.0,
    upload_mbps: 10.0,
    ping_ms: 20.0,
    client: ClientInfo {
        country: "UK".to_string(),
        ip: "192.0.2.1".to_string(),
        isp: "Example ISP".to_string(),
        ispdlavg: "50".to_string(),
        isprating: "4".to_string(),
        ispulavg: "10".to_string(),
        lat: "51.5074".to_string(),
        loggedin: "false".to_string(),
        lon: "-0.1278".to_string(),
        rating: "4.5".to_string(),
    },
    server: ServerInfo {
        cc: "GB".to_string(),
        country: "United Kingdom".to_string(),
        d: 5.0,
        host: "speedtest.example.com".to_string(),
        id: "12345".to_string(),
        lat: "51.5074".to_string(),
        latency: 10.5,
        lon: "-0.1278".to_string(),
        name: "London Server".to_string(),
        sponsor: "Example Sponsor".to_string(),
        url: "http://speedtest.example.com".to_string(),
    },
    share: None,
    timestamp: "2025-08-07T12:00:00Z".to_string(),
};

assert_eq!(result.download_mbps, 50.0);
assert_eq!(result.client.isp, "Example ISP");

Fields

bytes_received: usize

Number of bytes received.

bytes_sent: usize

Number of bytes sent.

download_bps: f64

Download speed in bits per second.

upload_bps: f64

Upload speed in bits per second.

download_mbps: f64

Download speed in megabits per second.

upload_mbps: f64

Upload speed in megabits per second.

ping_ms: f64

Ping time in milliseconds.

client: ClientInfo

Client information.

server: ServerInfo

Server information.

share: Option<Value>

Optional share data from the speedtest service.

timestamp: String

Timestamp of the speedtest.

Trait Implementations

impl Clone for SpeedTestResult

fn clone(&self) -> SpeedTestResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpeedTestResult

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

Formats the value using the given formatter.

impl Default for SpeedTestResult

fn default() -> SpeedTestResult

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SpeedTestResult

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SpeedTestResult

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.