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 run_time: String,
    pub goose_log: String,
    pub log_level: u8,
    pub verbose: u8,
    pub running_metrics: Option<usize>,
    pub no_reset_metrics: bool,
    pub no_metrics: bool,
    pub no_task_metrics: bool,
    pub no_error_summary: bool,
    pub report_file: String,
    pub request_log: String,
    pub request_format: Option<GooseLogFormat>,
    pub request_body: bool,
    pub task_log: String,
    pub task_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 status_codes: 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 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,
}

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. For example, using the following command from within the Goose source tree to run the included simple example:

cargo run --example simple -- -h

Goose will generate the following output from the GooseConfiguration structure:

Usage: target/debug/examples/simple [OPTIONS]

Options available when launching a Goose load test.


Optional arguments:
-h, --help                 Displays this help
-V, --version              Prints version information
-l, --list                 Lists all tasks and exits

-H, --host HOST            Defines host to load test (ie http://10.21.32.33)
-u, --users USERS          Sets concurrent users (default: number of CPUs)
-r, --hatch-rate RATE      Sets per-second user hatch rate (default: 1)
-t, --run-time TIME        Stops after (30s, 20m, 3h, 1h30m, etc)
-G, --goose-log NAME       Enables Goose log file and sets name
-g, --log-level            Sets Goose log level (-g, -gg, etc)
-v, --verbose              Sets Goose verbosity (-v, -vv, etc)

Metrics:
--running-metrics TIME     How often to optionally print running metrics
--no-reset-metrics         Doesn't reset metrics after all users have started
--no-metrics               Doesn't track metrics
--no-task-metrics          Doesn't track task metrics
--no-error-summary         Doesn't display an error summary
--report-file NAME         Create an html-formatted report
-R, --request-log NAME     Sets request log file name
--request-format FORMAT    Sets request log format (csv, json, raw, pretty)
--request-body             Include the request body in the request log
-T, --task-log NAME        Sets task log file name
--task-format FORMAT       Sets task log format (csv, json, raw, pretty)
-E, --error-log NAME       Sets error log file name
--error-format FORMAT      Sets error log format (csv, json, raw, pretty)
-D, --debug-log NAME       Sets debug log file name
--debug-format FORMAT      Sets debug log format (csv, json, raw, pretty)
--no-debug-body            Do not include the response body in the debug log
--status-codes             Tracks additional status code metrics

Advanced:
--no-telnet                Doesn't enable telnet Controller
--telnet-host HOST         Sets telnet Controller host (default: 0.0.0.0)
--telnet-port PORT         Sets telnet Controller TCP port (default: 5116)
--no-websocket             Doesn't enable WebSocket Controller
--websocket-host HOST      Sets WebSocket Controller host (default: 0.0.0.0)
--websocket-port PORT      Sets WebSocket Controller TCP port (default: 5117)
--no-autostart             Doesn't automatically start load test
--no-gzip                  Doesn't set the gzip Accept-Encoding header
--co-mitigation STRATEGY   Sets coordinated omission mitigation strategy
--throttle-requests VALUE  Sets maximum requests per second
--sticky-follow            Follows base_url redirect with subsequent requests

Gaggle:
--manager                  Enables distributed load test Manager mode
--expect-workers VALUE     Sets number of Workers to expect
--no-hash-check            Tells Manager to ignore load test checksum
--manager-bind-host HOST   Sets host Manager listens on (default: 0.0.0.0)
--manager-bind-port PORT   Sets port Manager listens on (default: 5115)
--worker                   Enables distributed load test Worker mode
--manager-host HOST        Sets host Worker connects to (default: 127.0.0.1)
--manager-port PORT        Sets port Worker connects to (default: 5115)

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

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)

run_time: String

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

goose_log: String

Enables Goose log file and sets name

log_level: u8

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

verbose: u8

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_task_metrics: bool

Doesn’t track task metrics

no_error_summary: bool

Doesn’t display an error summary

report_file: String

Create an html-formatted report

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

task_log: String

Sets task log file name

task_format: Option<GooseLogFormat>

Sets task 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

status_codes: bool

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

co_mitigation: Option<GooseCoordinatedOmissionMitigation>

Sets coordinated omission mitigation strategy

throttle_requests: usize

Sets maximum requests per second

sticky_follow: bool

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<'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.