Struct GooseMetrics

pub struct GooseMetrics {
    pub hash: u64,
    pub history: Vec<TestPlanHistory>,
    pub duration: usize,
    pub maximum_users: usize,
    pub total_users: usize,
    pub requests: GooseRequestMetrics,
    pub transactions: TransactionMetrics,
    pub scenarios: ScenarioMetrics,
    pub errors: GooseErrorMetrics,
    pub hosts: HashSet<String>,
    pub coordinated_omission_metrics: Option<CoordinatedOmissionMetrics>,
    /* private fields */
}

All metrics optionally collected during a Goose load test.

By default, Goose collects metrics during a load test in a GooseMetrics object that is returned by GooseAttack::execute() when a load test finishes.

Example

use goose::prelude::*;

#[tokio::main]
async fn main() -> Result<(), GooseError> {
    let goose_metrics: GooseMetrics = GooseAttack::initialize()?
        .register_scenario(scenario!("ExampleUsers")
            .register_transaction(transaction!(example_transaction))
        )
        // Set a default host so the load test will start.
        .set_default(GooseDefault::Host, "http://localhost/")?
        // Set a default run time so this test runs to completion.
        .set_default(GooseDefault::RunTime, 1)?
        .execute()
        .await?;

    // It is now possible to do something with the metrics collected by Goose.
    // For now, we'll just pretty-print the entire object.
    println!("{:#?}", goose_metrics);

    /**
    // For example:
    $ cargo run -- -H http://example.com -u1 -t1
    GooseMetrics {
        hash: 0,
        started: Some(
            2021-06-15T09:32:49.888147+02:00,
        ),
        duration: 1,
        users: 1,
        requests: {
            "GET /": GooseRequestMetricAggregate {
                path: "/",
                method: Get,
                response_times: {
                    3: 14,
                    4: 163,
                    5: 36,
                    6: 8,
                },
                min_response_time: 3,
                max_response_time: 6,
                total_response_time: 922,
                response_time_counter: 221,
                status_code_counts: {},
                success_count: 0,
                fail_count: 221,
                load_test_hash: 0,
            },
        },
        transactions: [
            [
                TransactionMetricAggregate {
                    scenario_index: 0,
                    scenario_name: "ExampleUsers",
                    transaction_index: 0,
                    transaction_name: "",
                    times: {
                        3: 14,
                        4: 161,
                        5: 38,
                        6: 8,
                    },
                    min_time: 3,
                    max_time: 6,
                    total_time: 924,
                    counter: 221,
                    success_count: 221,
                    fail_count: 0,
                },
            ],
        ],
        errors: {
            "503 Service Unavailable: /.GET./": GooseErrorMetric {
                method: Get,
                name: "/",
                error: "503 Service Unavailable: /",
                occurrences: 221,
            },
        },
        final_metrics: true,
        display_status_codes: false,
        display_metrics: true,
    }
    **/

    Ok(())
}

async fn example_transaction(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("/").await?;

    Ok(())
}

Fields

hash: u64

A hash of the load test, primarily used to validate all Workers in a Gaggle are running the same load test.

history: Vec<TestPlanHistory>

A vector recording the history of each load test step.

duration: usize

Total number of seconds the load test ran.

maximum_users: usize

Maximum number of users simulated during this load test.

This value may be smaller than what was configured at start time if the test didn’t run long enough for all configured users to start.

total_users: usize

Total number of users simulated during this load test.

requests: GooseRequestMetrics

Tracks details about each request made during the load test.

Can be disabled with the --no-metrics run-time option, or with GooseDefault::NoMetrics.

transactions: TransactionMetrics

Transactions details about each transaction that is invoked during the load test.

Can be disabled with either the --no-transaction-metrics or --no-metrics run-time options, or with either the GooseDefault::NoTransactionMetrics or GooseDefault::NoMetrics.

scenarios: ScenarioMetrics

Transactions details about each scenario that is invoked during the load test.

Can be disabled with either the --no-scenario-metrics or --no-metrics run-time options, or with either the GooseDefault::NoTransactionMetrics or GooseDefault::NoMetrics.

errors: GooseErrorMetrics

Tracks and counts each time an error is detected during the load test.

Can be disabled with either the --no-error-summary or --no-metrics run-time options, or with either the GooseDefault::NoErrorSummary or GooseDefault::NoMetrics.

hosts: HashSet<String>

Tracks all hosts that the load test is run against.

coordinated_omission_metrics: Option<CoordinatedOmissionMetrics>

Enhanced Coordinated Omission metrics tracking.

Tracks CO events, synthetic vs actual requests, and provides detailed analysis of coordinated omission impact on the load test.

Trait Implementations

impl Clone for GooseMetrics

fn clone(&self) -> GooseMetrics

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GooseMetrics

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

Formats the value using the given formatter.

impl Default for GooseMetrics

fn default() -> GooseMetrics

Returns the “default value” for a type.

impl Display for GooseMetrics

Implement format trait to allow displaying metrics.

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

Formats the value using the given formatter.

impl Serialize for GooseMetrics

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.