perfgate-client

A Rust client library for the perfgate baseline service.

Overview

perfgate-client provides a type-safe, async client for interacting with the perfgate baseline server. It handles:

• API communication with automatic retries
• Authentication via API keys
• Fallback to local storage when the server is unavailable
• Integration with the perfgate CLI

Documentation: Getting Started with Baseline Server

Features

• Full API Support: Upload, download, list, promote, and delete baselines
• Automatic Retries: Configurable retry logic with exponential backoff
• Fallback Storage: Automatic fallback to local storage when server is unavailable
• Type-Safe: Strongly typed request and response models
• Async/Await: Built on Tokio for async operations

Installation

Add this to your Cargo.toml:

[dependencies]

perfgate-client = { path = "path/to/perfgate-client" }

Quick Start

use perfgate_client::{BaselineClient, ClientConfig, ListBaselinesQuery};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a client
    let config = ClientConfig::new("https://perfgate.example.com/api/v1")
        .with_api_key("your-api-key");
    
    let client = BaselineClient::new(config)?;
    
    // Check server health
    let health = client.health_check().await?;
    println!("Server status: {}", health.status);
    
    // List baselines
    let query = ListBaselinesQuery::new().with_limit(10);
    let response = client.list_baselines("my-project", &query).await?;
    
    for baseline in &response.baselines {
        println!("{}: {}", baseline.benchmark, baseline.version);
    }
    
    Ok(())
}

Fallback Storage

When the server is unavailable, the client can fall back to local file storage:

use perfgate_client::{BaselineClient, ClientConfig, FallbackClient, FallbackStorage};

let config = ClientConfig::new("https://perfgate.example.com/api/v1")
    .with_api_key("your-api-key")
    .with_fallback(FallbackStorage::local("./baselines"));

let client = BaselineClient::new(config)?;
let fallback_client = FallbackClient::new(
    client,
    Some(FallbackStorage::local("./baselines")),
);

// This will fall back to local storage if the server is unavailable
let baseline = fallback_client
    .get_latest_baseline("my-project", "my-bench")
    .await?;

Error Handling

use perfgate_client::{BaselineClient, ClientConfig, ClientError};

let config = ClientConfig::new("https://perfgate.example.com/api/v1");
let client = BaselineClient::new(config).unwrap();

match client.get_latest_baseline("my-project", "my-bench").await {
    Ok(baseline) => println!("Got baseline: {}", baseline.id),
    Err(ClientError::NotFoundError(msg)) => {
        eprintln!("Baseline not found: {}", msg);
    }
    Err(ClientError::AuthError(msg)) => {
        eprintln!("Authentication failed: {}", msg);
    }
    Err(ClientError::ConnectionError(msg)) => {
        eprintln!("Server unavailable: {}", msg);
    }
    Err(e) => eprintln!("Error: {}", e),
}

API Reference

BaselineClient

The main client for interacting with the baseline service.

FallbackClient

A client wrapper with automatic fallback to local storage.

Configuration

License

MIT OR Apache-2.0