Struct goose::config::GooseConfiguration

pub struct GooseConfiguration {

    pub help: bool,
    pub version: bool,
    pub list: bool,
    pub host: String,
    pub users: Option<usize>,
    pub hatch_rate: Option<String>,
    pub startup_time: String,
    pub run_time: String,
    pub goose_log: String,
    pub log_level: u8,
    pub quiet: u8,
    pub verbose: u8,
    pub running_metrics: Option<usize>,
    pub no_reset_metrics: bool,
    pub no_metrics: bool,
    pub no_transaction_metrics: bool,
    pub no_scenario_metrics: bool,
    pub no_print_metrics: bool,
    pub no_error_summary: bool,
    pub report_file: String,
    pub no_granular_report: bool,
    pub request_log: String,
    pub request_format: Option<GooseLogFormat>,
    pub request_body: bool,
    pub transaction_log: String,
    pub transaction_format: Option<GooseLogFormat>,
    pub scenario_log: String,
    pub scenario_format: Option<GooseLogFormat>,
    pub error_log: String,
    pub error_format: Option<GooseLogFormat>,
    pub debug_log: String,
    pub debug_format: Option<GooseLogFormat>,
    pub no_debug_body: bool,
    pub no_status_codes: bool,
    pub iterations: usize,
    pub scenarios: Scenarios,
    pub scenarios_list: bool,
    pub no_telnet: bool,
    pub telnet_host: String,
    pub telnet_port: u16,
    pub no_websocket: bool,
    pub websocket_host: String,
    pub websocket_port: u16,
    pub no_autostart: bool,
    pub no_gzip: bool,
    pub timeout: Option<String>,
    pub co_mitigation: Option<GooseCoordinatedOmissionMitigation>,
    pub throttle_requests: usize,
    pub sticky_follow: bool,
    pub manager: bool,
    pub expect_workers: Option<usize>,
    pub no_hash_check: bool,
    pub manager_bind_host: String,
    pub manager_bind_port: u16,
    pub worker: bool,
    pub manager_host: String,
    pub manager_port: u16,
    /* private fields */
}

Runtime options available when launching a Goose load test.

Custom defaults can be programmatically set for most of these options using the GooseDefaults structure.

Help is generated for all of these options by passing a -h flag to an application built with the Goose Library.

Goose leverages gumdrop to derive the above help from the the below structure.

Fields

help: bool

Displays this help

version: bool

Prints version information

list: bool

Lists all transactions and exits

host: String

Defines host to load test (ie http://10.21.32.33)

users: Option<usize>

Sets concurrent users (default: number of CPUs)

hatch_rate: Option<String>

Sets per-second user hatch rate (default: 1)

startup_time: String

Starts users for up to (30s, 20m, 3h, 1h30m, etc)

run_time: String

Stops load test after (30s, 20m, 3h, 1h30m, etc)

goose_log: String

Enables Goose log file and sets name

log_level: u8

Increases Goose log level (-g, -gg, etc)

quiet: u8

Decreases Goose verbosity (-q, -qq, etc)

verbose: u8

Increases Goose verbosity (-v, -vv, etc)

running_metrics: Option<usize>

How often to optionally print running metrics

no_reset_metrics: bool

Doesn’t reset metrics after all users have started

no_metrics: bool

Doesn’t track metrics

no_transaction_metrics: bool

Doesn’t track transaction metrics

no_scenario_metrics: bool

Doesn’t track scenario metrics

no_print_metrics: bool

Doesn’t display metrics at end of load test

no_error_summary: bool

Doesn’t display an error summary

report_file: String

Create an html-formatted report

no_granular_report: bool

Disable granular graphs in report file

request_log: String

Sets request log file name

request_format: Option<GooseLogFormat>

Sets request log format (csv, json, raw, pretty)

request_body: bool

Include the request body in the request log

transaction_log: String

Sets transaction log file name

transaction_format: Option<GooseLogFormat>

Sets log format (csv, json, raw, pretty)

scenario_log: String

Sets scenario log file name

scenario_format: Option<GooseLogFormat>

Sets log format (csv, json, raw, pretty)

error_log: String

Sets error log file name

error_format: Option<GooseLogFormat>

Sets error log format (csv, json, raw, pretty)

debug_log: String

Sets debug log file name

debug_format: Option<GooseLogFormat>

Sets debug log format (csv, json, raw, pretty)

no_debug_body: bool

Do not include the response body in the debug log

no_status_codes: bool

Do not track status code metrics

iterations: usize

Sets how many times to run scenarios then exit

scenarios: Scenarios

Limits load test to only specified scenarios

scenarios_list: bool

Lists all scenarios and exits

no_telnet: bool

Doesn’t enable telnet Controller

telnet_host: String

Sets telnet Controller host (default: 0.0.0.0)

telnet_port: u16

Sets telnet Controller TCP port (default: 5116)

no_websocket: bool

Doesn’t enable WebSocket Controller

websocket_host: String

Sets WebSocket Controller host (default: 0.0.0.0)

websocket_port: u16

Sets WebSocket Controller TCP port (default: 5117)

no_autostart: bool

Doesn’t automatically start load test

no_gzip: bool

Doesn’t set the gzip Accept-Encoding header

timeout: Option<String>

Sets per-request timeout, in seconds (default: 60)

co_mitigation: Option<GooseCoordinatedOmissionMitigation>

Sets coordinated omission mitigation strategy

throttle_requests: usize

Sets maximum requests per second

sticky_follow: bool

Follows base_url redirect with subsequent requests

manager: bool

Enables distributed load test Manager mode

expect_workers: Option<usize>

Sets number of Workers to expect

no_hash_check: bool

Tells Manager to ignore load test checksum

manager_bind_host: String

Sets host Manager listens on (default: 0.0.0.0)

manager_bind_port: u16

Sets port Manager listens on (default: 5115)

worker: bool

Enables distributed load test Worker mode

manager_host: String

Sets host Worker connects to (default: 127.0.0.1)

manager_port: u16

Sets port Worker connects to (default: 5115)

Trait Implementations

impl Clone for GooseConfiguration

fn clone(&self) -> GooseConfiguration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GooseConfiguration

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

Formats the value using the given formatter.

impl Default for GooseConfiguration

fn default() -> GooseConfiguration

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GooseConfiguration

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Options for GooseConfiguration

fn parse<__S: AsRef<str>>(_parser: &mut Parser<'_, __S>) -> Result<Self, Error>

Parses arguments until the given parser is exhausted or until an error is encountered.

fn command(&self) -> Option<&dyn Options>

Returns the subcommand instance, if present.

fn command_name(&self) -> Option<&'static str>

Returns the name of a parsed command, if present.

fn help_requested(&self) -> bool

Returns whether the user supplied a “help” option to request usage information about the program or any contained subcommands.

fn parse_command<__S: AsRef<str>>(
    name: &str,
    _parser: &mut Parser<'_, __S>
) -> Result<Self, Error>

Parses options for the named command.

fn usage() -> &'static str

Returns a string showing usage and help for each supported option.

fn self_usage(&self) -> &'static str

Returns a string showing usage and help for this options instance.

fn command_list() -> Option<&'static str>

Returns a string listing available commands and help text.

fn command_usage(_name: &str) -> Option<&'static str>

Returns a usage string for the named command.

fn self_command_list(&self) -> Option<&'static str>

Returns a listing of available commands and help text.

fn parse_args<S>(args: &[S], style: ParsingStyle) -> Result<Self, Error>where
    S: AsRef<str>,

Parses arguments received from the command line.

fn parse_args_or_exit(style: ParsingStyle) -> Self

Parses arguments from the environment.

fn parse_args_default_or_exit() -> Self

Parses arguments from the environment, using the default parsing style.

fn parse_args_default<S>(args: &[S]) -> Result<Self, Error>where
    S: AsRef<str>,

Parses arguments received from the command line, using the default parsing style.

impl Serialize for GooseConfiguration

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

Serialize this value into the given Serde serializer.