shinyloadtest

https://rstudio.github.io/shinyloadtest/
Admin
shinyloadtest is a load testing tool for Shiny applications that helps developers estimate user...
Tokens:14,908
Snippets:190
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example of Recording a Session

Source: https://rstudio.github.io/shinyloadtest/reference/record_session.html

This example demonstrates how to call the record_session function with a target application URL. The code is wrapped in a \"dontrun\" block, indicating it's an example that should not be automatically executed.

```r
if (FALSE) { # \dontrun{
record_session("https://example.com/your-shiny-app/")
} # }
```

--------------------------------

### Install shinycannon on macOS

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Install shinycannon on macOS by copying the script to the system's bin directory and making it executable. Java must be installed first.

```bash
sudo cp shinycannon-1.2.0-85f280d.sh /usr/local/bin/shinycannon; sudo chmod +x /usr/local/bin/shinycannon
```

--------------------------------

### Install shinycannon on SUSE Linux

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Install shinycannon on SUSE Linux using zypper. Ensure you have the correct RPM package.

```bash
zypper —-no-gpg-checks install -y shinycannon-1.2.0-suse-85f280d.x86_64.rpm
```

--------------------------------

### Install shinycannon on Ubuntu/Debian

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Install shinycannon on Debian-based Linux distributions using dpkg. Use the provided DEB package.

```bash
sudo dpkg -i shinycannon_1.2.0-85f280d_amd64.deb
```

--------------------------------

### Install shinyloadtest Package

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Install the shinyloadtest R package from GitHub. This is a prerequisite for recording and running load tests.

```r
devtools::install_github("rstudio/shinyloadtest")
```

--------------------------------

### Example: Run shinyloadtest Report

Source: https://rstudio.github.io/shinyloadtest/reference/shinyloadtest_report.html

This is an example of how to call the `shinyloadtest_report` function with demo data. It is wrapped in `if (FALSE)` to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
shinyloadtest_report(slt_demo_data_1)
} # }
```

--------------------------------

### Install shinycannon on Redhat/Fedora/CentOS

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Install shinycannon on Red Hat-based Linux distributions using yum. Use the provided RPM package.

```bash
sudo yum install -y shinycannon-1.2.0-85f280d.x86_64.rpm
```

--------------------------------

### Accessing the example dataset

Source: https://rstudio.github.io/shinyloadtest/reference/slt_demo_data_16.html

This R code snippet shows how to access the `slt_demo_data_16` dataset. This dataset is pre-loaded and contains latency metrics from a simulated load test.

```r
slt_demo_data_16
```

--------------------------------

### Install SSL Certificate into Java Keystore

Source: https://rstudio.github.io/shinyloadtest/articles/troubleshooting-ssl.html

Import the downloaded SSL certificate into the Java Keystore. Replace '<JAVA_HOME>' with your system's Java home directory and '<server_name>' with a chosen alias. On Linux, you may need to use 'sudo'. You will be prompted for the keystore password (default is 'changeit') and to trust the certificate.

```bash
<JAVA_HOME>/bin/keytool -import -alias <server_name> -keystore <JAVA_HOME>/jre/lib/security/cacerts -file public.crt
```

--------------------------------

### Access Example Load Test Data

Source: https://rstudio.github.io/shinyloadtest/reference/slt_demo_data_4.html

This R code snippet shows how to access the `slt_demo_data_4` dataset, which contains example metrics from a 4-user load test. This data is useful for testing reporting functions.

```r
slt_demo_data_4
```

--------------------------------

### Record a User Session

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Record a typical user session by running `record_session` with the application's solo URL. This starts a local proxy server that captures interactions for later playback. Interact with the application in the opened browser window for 1-2 minutes.

```r
library(shinyloadtest)
record_session("https://rsc.example.com/content/1234/")
```

--------------------------------

### slt_demo_data_16

Source: https://rstudio.github.io/shinyloadtest/reference/index.html

Example metrics data for a load test with 16 concurrent users.

```APIDOC
## slt_demo_data_16

### Description
Example metrics for a 16-user load test.

### Data Structure
This is a dataset and does not have a specific function signature. Its structure is not detailed in the provided documentation.
```

--------------------------------

### slt_demo_data_1

Source: https://rstudio.github.io/shinyloadtest/reference/index.html

Example metrics data for a load test with 1 concurrent user.

```APIDOC
## slt_demo_data_1

### Description
Example metrics for a 1-user load test.

### Data Structure
This is a dataset and does not have a specific function signature. Its structure is not detailed in the provided documentation.
```

--------------------------------

### slt_demo_data_4

Source: https://rstudio.github.io/shinyloadtest/reference/index.html

Example metrics data for a load test with 4 concurrent users.

```APIDOC
## slt_demo_data_4

### Description
Example metrics for a 4-user load test.

### Data Structure
This is a dataset and does not have a specific function signature. Its structure is not detailed in the provided documentation.
```

--------------------------------

### Access Example Metrics Data - R

Source: https://rstudio.github.io/shinyloadtest/reference/slt_demo_data_1.html

Load the `slt_demo_data_1` dataset, which contains latency data for a 1-user load test. This data is useful for generating reports with `shinyloadtest_report`.

```r
slt_demo_data_1
```

--------------------------------

### Download SSL Certificate (Windows)

Source: https://rstudio.github.io/shinyloadtest/articles/troubleshooting-ssl.html

This command downloads the SSL certificate of a target server on Windows. It requires OpenSSL and sed for Windows to be installed. Replace 'google.com' with the target server's hostname or IP address. The '-servername' parameter is important for SNI.

```bash
openssl s_client -connect google.com:443 -servername google.com:443 < NUL | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > public.crt
```

--------------------------------

### Set Environment Variables for Zsh (Linux/macOS)

Source: https://rstudio.github.io/shinyloadtest/articles/load-testing-authenticated-apps.html

Set SHINYCANNON_CONNECT_API_KEY environment variable in zsh to authenticate shinycannon. History is disabled for commands starting with a space.

```zsh
$ # Disable history for any command that starts with a space
$ setopt HIST_IGNORE_SPACE
$  export SHINYCANNON_CONNECT_API_KEY=$CONNECT_API_KEY
$ 
$ shinycannon connect_recording.log https://connect.example.com/content/545/ --workers 5 --loaded-duration-minutes 2 --output-dir run2
```

--------------------------------

### Find JAVA_HOME Directory

Source: https://rstudio.github.io/shinyloadtest/articles/troubleshooting-ssl.html

Execute this command to determine the JAVA_HOME directory on your system. This is necessary for locating the Java Keystore when installing certificates. On Linux, if the $JAVA_HOME environment variable is set, you can use that instead.

```bash
jrunscript -e 'java.lang.System.out.println(java.lang.System.getProperty("java.home"));'
```

--------------------------------

### Load and Process Run Metrics with R

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Load metrics from multiple runs into a dataframe for analysis. Ensure the shinyloadtest package is installed.

```r
library(shinyloadtest)
df <- load_runs("Run 1" = "run1", "Run 5" = "run5")
```

--------------------------------

### Set Environment Variables for Bash (Linux/macOS)

Source: https://rstudio.github.io/shinyloadtest/articles/load-testing-authenticated-apps.html

Set SHINYCANNON_USER and SHINYCANNON_PASS environment variables in bash to authenticate shinycannon. History is disabled for commands starting with a space.

```bash
$ # Disable history for any command that starts with a space
$ HISTCONTROL=ignoreboth
$  export SHINYCANNON_USER=myUser
$  export SHINYCANNON_PASS=myPass
$ 
$ shinycannon recording.log https://shinyapp.example.com/ --workers 5 --loaded-duration-minutes 2 --output-dir run1
```

--------------------------------

### Record Shiny App Session

Source: https://rstudio.github.io/shinyloadtest/reference/record_session.html

Use this function to start a reverse proxy that records traffic between your browser and a Shiny app. Ensure the target app URL is correct. The recording is saved to a file and can be used with shinycannon.

```r
record_session(
  target_app_url,
  host = "127.0.0.1",
  port = 8600,
  output_file = "recording.log",
  open_browser = TRUE,
  connect_api_key = NULL
)
```

--------------------------------

### Generate Shiny Load Test Report

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Load multiple runs into a data frame and generate an HTML report to compare performance. Ensure the 'shinyloadtest' library is installed and loaded.

```r
library(shinyloadtest)
df <- load_runs("Run 5" = "run5", "Run 5 new" = "run5-new-settings")
shinyloadtest_report(df, "report2.html")
```

--------------------------------

### Display ShinyCannon Help

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

View detailed help documentation for all available arguments and options for the shinycannon tool.

```bash
shinycannon -h
```

--------------------------------

### Download SSL Certificate (Linux)

Source: https://rstudio.github.io/shinyloadtest/articles/troubleshooting-ssl.html

Use this command to download the SSL certificate of a target server on Linux. Ensure you replace 'example.com' with the actual hostname or IP address. The '-servername' parameter is crucial for SNI-enabled servers.

```bash
openssl s_client -connect example.com:443 -servername example.com:443 < /dev/null | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > public.crt
```

--------------------------------

### Run Baseline Load Test

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Perform an initial load test with a single worker to establish baseline performance metrics. This run uses the generated `recording.log` file and the application's solo URL. Adjust parameters like `--loaded-duration-minutes` and `--output-dir` as needed.

```bash
shinycannon recording.log https://rsc.example.com/content/1234/ --workers 1 --loaded-duration-minutes 5 --output-dir run1
```

--------------------------------

### Run shinycannon for Baseline Metrics

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Execute shinycannon with a single user to generate baseline performance metrics. This data serves as a reference point before scaling up.

```bash
shinycannon run --users 1 --output baseline_metrics/
```

--------------------------------

### Run shinycannon on macOS

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Execute shinycannon on macOS to generate load. Provide the path to a recording and the application URL.

```bash
shinycannon -h
```

```bash
shinycannon [RECORDING-PATH] [APP-URL]
```

--------------------------------

### Run shinycannon on Windows

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Execute shinycannon on Windows using Java. Specify the path to the JAR file and provide recording path and application URL.

```bash
java -jar shinycannon-1.2.0-85f280d.jar -h
```

```bash
java -jar shinycannon-1.2.0-85f280d.jar [RECORDING-PATH] [APP-URL]
```

--------------------------------

### Benchmark Shiny App with New Settings

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Run shinycannon to benchmark the application with updated worker and connection settings. Specify the output directory for the results.

```bash
shinycannon recording.log https://rsc.example.com/content/1234/ --workers 5 --loaded-duration-minutes 5 --output-dir run5-new-settings
```

--------------------------------

### Run Comparison Load Test

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Conduct a comparison load test with multiple workers to simulate expected concurrent users. This run uses the same recording and application URL but increases the `--workers` count to simulate higher load. The output is saved to a different directory.

```bash
shinycannon recording.log https://rsc.example.com/content/1234/ --workers 5 --loaded-duration-minutes 5 --output-dir run5
```

--------------------------------

### Run Load Test with shinycannon

Source: https://rstudio.github.io/shinyloadtest/index.html

Execute a load test using the shinycannon command-line tool. This command replays a recorded session simulating multiple users. Adjust workers, duration, and output directory as needed. On Windows, use 'java -jar shinycannon-VERSION.jar' instead of 'shinycannon'.

```bash
shinycannon recording.log https://shinyapp.example.com/ --workers 5 --loaded-duration-minutes 2 --output-dir run1
```

--------------------------------

### load_runs()

Source: https://rstudio.github.io/shinyloadtest/reference/index.html

Creates tidy load test results from recorded sessions.

```APIDOC
## load_runs()

### Description
Creates tidy load test results.

### Parameters
This function does not explicitly list parameters in the provided documentation.
```

--------------------------------

### Load shinycannon library

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Load the shinyloadtest library in R. This is a prerequisite for using shinycannon.

```r
library(shinyloadtest)
```

--------------------------------

### record_session

Source: https://rstudio.github.io/shinyloadtest/reference/record_session.html

Creates a reverse proxy to record interactions with a Shiny application. The proxy runs at a specified host and port, saving the recording to an output file. Optionally, it can open a web browser to interact with the application.

```APIDOC
## record_session

### Description
Creates a reverse proxy at `http://host:port` that intercepts and records activity between your web browser and the Shiny application at `target_app_url`.

### Usage
```R
record_session(
  target_app_url,
  host = "127.0.0.1",
  port = 8600,
  output_file = "recording.log",
  open_browser = TRUE,
  connect_api_key = NULL
)
```

### Arguments

*   **target_app_url** (string) - The URL of the deployed application.
*   **host** (string) - The host where the proxy will run. Usually localhost is used.
*   **port** (integer) - The port for the reverse proxy. Default is 8600. Change this default if port 8600 is used by another service.
*   **output_file** (string) - The name of the generated recording file.
*   **open_browser** (boolean) - Whether to open a browser on the proxy (default=`TRUE`) or not (`FALSE`).
*   **connect_api_key** (string) - An Posit Connect api key. It may be useful to use `Sys.getenv("CONNECT_API_KEY")`.

### Value
Creates a recording file that can be used as input to the `shinycannon` command-line load generation tool.

### Details
By default, after creating the reverse proxy, a web browser is opened automatically. As you interact with the application in the web browser, activity is written to the `output_file` (`recording.log` by default). To shut down the reverse proxy and complete the recording, close the web browser tab or window.

Recordings are used as input to the `shinycannon` command-line load-generation tool.

### `fileInput`/`DT`/`HTTP POST` support
Shiny's `shiny::fileInput()` input for uploading files, the `DT` package, and potentially other packages make HTTP POST requests to the target application. Because POST requests can be large, they are not stored directly in the recording file. Instead, new files adjacent to the recording are created for each HTTP POST request intercepted. The adjacent files are named after the recording with the pattern `<output_file>.post.<N>`, where `<output_file>` is the chosen recording file name and `<N>` is the number of the request. If present, these adjacent files must be kept alongside the recording file when the recording is played back with the `shinycannon` tool.

### Examples
```R
if (FALSE) { # \dontrun{
record_session("https://example.com/your-shiny-app/")
} # }
```
```

--------------------------------

### Run ShinyCannon Load Test

Source: https://rstudio.github.io/shinyloadtest/articles/shinycannon.html

Execute a load test with specified workers, duration, and output directory. Requires a recording log and application URL.

```bash
$ shinycannon recording.log https://shinyapp.example.com/ --workers 5 --loaded-duration-minutes 2 --output-dir run1
2018-08-29 15:06:14.191 INFO [progress] - Running: 0, Failed: 0, Done: 0
2018-08-29 15:06:14.193 INFO [thread01] - Warming up
2018-08-29 15:06:14.195 INFO [thread00] - Waiting for warmup to complete
2018-08-29 15:06:19.193 INFO [progress] - Running: 1, Failed: 0, Done: 0
2018-08-29 15:06:24.194 INFO [progress] - Running: 1, Failed: 0, Done: 0
2018-08-29 15:06:29.083 INFO [thread02] - Warming up
2018-08-29 15:06:29.195 INFO [progress] - Running: 1, Failed: 0, Done: 0
2018-08-29 15:06:34.195 INFO [progress] - Running: 2, Failed: 0, Done: 0
2018-08-29 15:06:39.196 INFO [progress] - Running: 2, Failed: 0, Done: 0
2018-08-29 15:06:43.973 INFO [thread03] - Warming up
2018-08-29 15:06:44.196 INFO [progress] - Running: 2, Failed: 0, Done: 0
2018-08-29 15:06:49.196 INFO [progress] - Running: 3, Failed: 0, Done: 0
2018-08-29 15:06:54.201 INFO [progress] - Running: 3, Failed: 0, Done: 0
2018-08-29 15:06:58.862 INFO [thread04] - Warming up
2018-08-29 15:06:59.201 INFO [progress] - Running: 3, Failed: 0, Done: 0
2018-08-29 15:07:04.201 INFO [progress] - Running: 4, Failed: 0, Done: 0
2018-08-29 15:07:09.202 INFO [progress] - Running: 4, Failed: 0, Done: 0
2018-08-29 15:07:13.751 INFO [thread05] - Warming up
2018-08-29 15:07:13.752 INFO [thread00] - Maintaining for 2 minutes (120000 ms)
2018-08-29 15:07:14.202 INFO [progress] - Running: 4, Failed: 0, Done: 0
2018-08-29 15:07:19.202 INFO [progress] - Running: 5, Failed: 0, Done: 0
2018-08-29 15:07:24.202 INFO [progress] - Running: 5, Failed: 0, Done: 0
...
```

--------------------------------

### Record a Realistic Session with shinyloadtest

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Use record_session to capture a realistic user interaction for load testing. This function is the first step in the benchmarking process.

```r
shinyloadtest::record_session(app_url = "http://cranwhales.posit.co/")
```

--------------------------------

### Run shinycannon with N Users

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Simulate N concurrent users interacting with the application using shinycannon. This step measures performance under expected load.

```bash
shinycannon run --users N --output n_user_metrics/
```

--------------------------------

### Plotting Functions

Source: https://rstudio.github.io/shinyloadtest/reference/index.html

A collection of functions for visualizing load test metrics and outputs.

```APIDOC
## Plotting Functions

### Description
Provides various functions to generate plots from shinyloadtest results, aiding in the analysis of load test performance.

### Functions
- `slt_time_boxplot()`
- `slt_time_concurrency()`
- `slt_waterfall()`
- `slt_hist_loadtimes()`
- `slt_user()`
- `slt_session()`
- `slt_session_duration()`
- `slt_session_latency()`
- `slt_http_latency()`
- `slt_websocket_latency()`

### Parameters
Specific parameters for each plotting function are not detailed in the provided documentation.
```

--------------------------------

### record_session()

Source: https://rstudio.github.io/shinyloadtest/reference/index.html

Records a user session for subsequent load testing.

```APIDOC
## record_session()

### Description
Records a session for load testing.

### Parameters
This function does not explicitly list parameters in the provided documentation.
```

--------------------------------

### Generate Shiny Load Test Report

Source: https://rstudio.github.io/shinyloadtest/articles/case-study-scaling.html

Create an HTML report summarizing the performance metrics from the loaded runs. The output file will be named 'report1.html'.

```r
shinyloadtest_report(df, "report1.html")
```

--------------------------------

### Generating User Gantt Chart

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Creates a Gantt chart illustrating the duration of events for each user within each run. Useful for visualizing user activity timelines.

```R
slt_user(slt_demo_data_4)
```

--------------------------------

### Generating Session Gantt Chart

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Displays a Gantt chart of events for each user session within a run. Helps in understanding the flow and timing of events in a session.

```R
slt_session(slt_demo_data_4)
```

--------------------------------

### Load shinyloadtest and dplyr Libraries

Source: https://rstudio.github.io/shinyloadtest/articles/analyzing-load-test-logs.html

Load the necessary R libraries for analyzing load test results.

```r
library(shinyloadtest)
library(dplyr)
```

--------------------------------

### load_runs

Source: https://rstudio.github.io/shinyloadtest/reference/load_runs.html

Translates one or more test result directories into a tidy data frame. Each row represents an event with detailed timing and session information.

```APIDOC
## load_runs

### Description
The `load_runs` function translates one or more test result directories created by the `shinycannon` tool into a tidy data frame. Each row in the resulting data frame represents an event, including identifiers and timing information.

### Usage
```R
load_runs(..., verbose = vroom::vroom_progress())
```

### Arguments
* `...`: Key-value pairs where the key is the desired name for the test and the value is a path to the test result directory.
* `verbose`: Whether or not to print progress for reading loadtest directories.

### Value
A tidy data frame with the test result data. Each row is an event. Columns include identifiers and timing information for the event. The variables are as follows:

* `run`: Name of the run
* `session_id`: Simulated session identifier, 0-based
* `user_id`: Simulated user identifier, 0-based
* `iteration`: User session identifier, 0-based
* `input_line_number`: Recording line number associated with event
* `event`: Type of the event
* `start`: Time the event started, in seconds, relative to the time at which all simulated users were running.
* `end`: Time the event ended, in seconds, relative to the time at which all simulated users were running.
* `time`: Event duration, in seconds
* `concurrency`: Number of events that happened at the same time as this one
* `maintenance`: Whether this event occurred before or after all simulated users were running
* `label`: Event-specific text label
* `json`: Raw message JSON and parsed JSON of the event

### Examples
```R
if (FALSE) { # \dontrun{
load_runs(
  `1 core` = "results/run-1/",
  `2 cores` = "results/run-2/"
)
}
```
```

--------------------------------

### Record a Shiny App Session

Source: https://rstudio.github.io/shinyloadtest/index.html

Use this function to record a typical user session for a deployed Shiny application. The recording is saved to a file and used as the basis for load testing. Ensure the application URL is correct.

```r
shinyloadtest::record_session("https://shinyapp.example.com/")
```

--------------------------------

### Plotting Session Duration

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates a Gantt chart showing session times, ordered from fastest to slowest. Allows specifying a cutoff for analysis.

```R
slt_session_duration(slt_demo_data_4)
```

--------------------------------

### Load Multiple Load Test Runs with Labels

Source: https://rstudio.github.io/shinyloadtest/articles/analyzing-load-test-logs.html

Load results from multiple load test runs, assigning informative labels to each run. This is useful for comparing different test configurations.

```r
df <- load_runs(
  `1 user` = "test_sessions/demo1",
  `4 users` = "test_sessions/demo4",
  `16 users` = "test_sessions/demo16"
)
```

--------------------------------

### Plotting Session Latency

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Creates a stacked bar chart visualizing event durations for each session, providing insight into session latency. Requires a data frame from load_runs.

```R
slt_session_latency(slt_demo_data_4)
```

--------------------------------

### slt_user

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Creates a Gantt chart visualizing the duration of events for each user within each run.

```APIDOC
## slt_user()

### Description
Gantt chart of event duration for each user within each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.

### Value
A `ggplot` plot object.

### Example
```R
slt_user(slt_demo_data_4)
```
```

--------------------------------

### Plotting Histogram of Load Times

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Displays a histogram of page load times. Allows setting a maximum load time threshold for analysis. Defaults to 5 seconds.

```R
slt_hist_loadtimes(slt_demo_data_4)
```

--------------------------------

### slt_session

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates an event Gantt chart for each user session within each run.

```APIDOC
## slt_session()

### Description
Event gantt chart of each user session within each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.

### Value
A `ggplot` plot object.

### Example
```R
slt_session(slt_demo_data_4)
```
```

--------------------------------

### slt_session_duration

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Creates an event Gantt chart showing session times from fastest to slowest within each run.

```APIDOC
## slt_session_duration()

### Description
Event gantt chart of fastest to slowest session times within each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.
* `cutoff` (numeric) - Optional - Where to draw a horizontal or vertical line to display a reasonable cutoff line for requests.

### Value
A `ggplot` plot object.

### Example
```R
slt_session_duration(slt_demo_data_4)
```
```

--------------------------------

### Plotting Concurrency Over Time

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Visualizes the concurrency levels for each event over time for each run. Accepts a data frame from load_runs.

```R
slt_time_concurrency(slt_demo_data_4)
```

--------------------------------

### Plotting Load Times with Boxplot

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates a box plot to visualize the distribution of load times for each event across different runs. Requires a data frame from load_runs.

```R
slt_time_boxplot(slt_demo_data_4)
```

--------------------------------

### shinyloadtest_report()

Source: https://rstudio.github.io/shinyloadtest/reference/index.html

Generates a comprehensive report from load test results.

```APIDOC
## shinyloadtest_report()

### Description
Makes a shinyloadtest report.

### Parameters
This function does not explicitly list parameters in the provided documentation.
```

--------------------------------

### Load Single Load Test Run

Source: https://rstudio.github.io/shinyloadtest/articles/analyzing-load-test-logs.html

Load results from a single load test run into an R data frame. Provide the directory containing the test results.

```r
df <- load_runs("test_sessions/demo1")
```

--------------------------------

### slt_hist_loadtimes

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates a histogram of page load times, showing the distribution of how long pages take to load.

```APIDOC
## slt_hist_loadtimes()

### Description
Histogram of page load times.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.
* `max_load_time` (numeric) - Optional - The amount of time users will wait for the page to load when first requesting the app. Defaults to 5.

### Value
A `ggplot` plot object.

### Example
```R
slt_hist_loadtimes(slt_demo_data_4)
```
```

--------------------------------

### slt_http_latency

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Creates a bar chart displaying the total HTTP latency for each session within each run.

```APIDOC
## slt_http_latency()

### Description
Bar chart of total HTTP latency for each session within each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.
* `cutoff` (numeric) - Optional - Where to draw a horizontal or vertical line to display a reasonable cutoff line for requests. Defaults to 5.

### Value
A `ggplot` plot object.

### Example
```R
slt_http_latency(slt_demo_data_4)
```
```

--------------------------------

### Generate Shiny Load Test Report

Source: https://rstudio.github.io/shinyloadtest/articles/analyzing-load-test-logs.html

Generate a standalone HTML report from the loaded load test data. This report provides diagnostic information across six pages.

```r
shinyloadtest_report(df, "report.html")
```

--------------------------------

### Display Loaded Data Structure

Source: https://rstudio.github.io/shinyloadtest/articles/analyzing-load-test-logs.html

Display the structure of the loaded load test data, which is returned as a tidy tibble. This shows the available variables for analysis.

```r
df
#> # A tibble: 11,729 × 13
#>    run    user_id session_id iteration input_line_number event    start
#>    <ord>    <int>      <int>     <int>             <int> <chr>    <dbl>
#>  1 1 user       0          0         0                 1 REQ_HOME 0    
#>  2 1 user       0          0         0                 2 REQ_GET  0.309
#>  3 1 user       0          0         0                 3 REQ_GET  0.316
#>  4 1 user       0          0         0                 4 REQ_GET  0.323
#>  5 1 user       0          0         0                 5 REQ_GET  0.33 
#>  6 1 user       0          0         0                 6 REQ_GET  0.339
#>  7 1 user       0          0         0                 7 REQ_GET  0.351
#>  8 1 user       0          0         0                 8 REQ_GET  0.361
#>  9 1 user       0          0         0                 9 REQ_GET  0.366
#> 10 1 user       0          0         0                10 REQ_GET  0.373
#> # ℹ 11,719 more rows
#> # ℹ 6 more variables: end <dbl>, time <dbl>, concurrency <dbl>,
#> #   maintenance <lgl>, label <ord>, json <list>
```

--------------------------------

### Plotting WebSocket Latency

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Creates a bar chart showing the maximum WebSocket latency for each session. A cutoff value can be set for analysis.

```R
slt_websocket_latency(slt_demo_data_4)
```

--------------------------------

### Load Runs Function Usage

Source: https://rstudio.github.io/shinyloadtest/reference/load_runs.html

Use this function to load and combine results from multiple load test runs into a single tidy data frame. Provide key-value pairs where the key is the desired name for the test and the value is the path to the test result directory.

```R
if (FALSE) { # \dontrun{
load_runs(
  `1 core` = "results/run-1/",
  `2 cores` = "results/run-2/"
)
} # }
```

--------------------------------

### Analyze Load Test Results

Source: https://rstudio.github.io/shinyloadtest/index.html

Read load test results into an R data frame and generate an HTML report for analysis. This report helps in inspecting the performance of the Shiny application under simulated load.

```r
df <- shinyloadtest::load_runs("run1")
shinyloadtest::shinyloadtest_report(df, "run1.html")
```

--------------------------------

### slt_time_concurrency

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Visualizes the time on concurrency for each event across different runs.

```APIDOC
## slt_time_concurrency()

### Description
Time on concurrency for each event for each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.
* `labels` (vector) - Optional - A vector of labels to include. If none are supplied, all labels will be used.

### Value
A `ggplot` plot object.

### Example
```R
slt_time_concurrency(slt_demo_data_4)
```
```

--------------------------------

### slt_session_latency

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates a stacked bar chart of event durations for each session within each run, highlighting latency.

```APIDOC
## slt_session_latency()

### Description
Stacked bar chart of event duration for each session within each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.

### Value
A `ggplot` plot object.

### Example
```R
slt_session_latency(slt_demo_data_4)
```
```

--------------------------------

### shinyloadtest_report

Source: https://rstudio.github.io/shinyloadtest/reference/shinyloadtest_report.html

Generates an HTML report from a data frame of load test results.

```APIDOC
## shinyloadtest_report

### Description
Generates an HTML report from a data frame of load test results.

### Usage
```R
shinyloadtest_report(df, output = "shinyloadtest_report.html", duration_cutoff = c(attr(df, "recording_duration"), 60)[1], http_latency_cutoff = 5, max_websocket_cutoff = 20, open_browser = TRUE, self_contained = TRUE, verbose = TRUE)
```

### Arguments

*   **df** (data.frame) - Data frame returned from `load_runs()`.
*   **output** (string) - File where HTML output should be saved. Defaults to "shinyloadtest_report.html".
*   **duration_cutoff** (numeric) - Cutoff value for session duration plot. Defaults to the recording duration used to simulate `df` or 60 seconds.
*   **http_latency_cutoff** (numeric) - Cutoff value for total http latency plot. Defaults to 5.
*   **max_websocket_cutoff** (numeric) - Cutoff value for max websocket latency plot. Defaults to 20.
*   **open_browser** (boolean) - Whether to open the created output in the browser. Defaults to TRUE.
*   **self_contained** (boolean) - Boolean that determines if the final output should be a self contained html file. Defaults to TRUE.
*   **verbose** (boolean) - Boolean that determines if progress output is displayed. Defaults to TRUE.

### Value
The path to the report, invisibly.

### Examples

```R
if (FALSE) { # \dontrun{
shinyloadtest_report(slt_demo_data_1)
}
```
```

--------------------------------

### slt_websocket_latency

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates a bar chart showing the maximum WebSocket latency for each session within each run.

```APIDOC
## slt_websocket_latency()

### Description
Bar chart of maximum calculation (websocket) latency for each session within each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.
* `cutoff` (numeric) - Optional - Where to draw a horizontal or vertical line to display a reasonable cutoff line for requests. Defaults to 5.

### Value
A `ggplot` plot object.

### Example
```R
slt_websocket_latency(slt_demo_data_4)
```
```

--------------------------------

### Generate shinyloadtest HTML Report

Source: https://rstudio.github.io/shinyloadtest/reference/shinyloadtest_report.html

Use this function to generate an HTML report from a data frame of load test results. Customize cutoff values for plots and control browser opening and self-contained output.

```r
shinyloadtest_report(
  df,
  output = "shinyloadtest_report.html",
  duration_cutoff = c(attr(df, "recording_duration"), 60)[1],
  http_latency_cutoff = 5,
  max_websocket_cutoff = 20,
  open_browser = TRUE,
  self_contained = TRUE,
  verbose = TRUE
)
```

--------------------------------

### slt_waterfall

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Displays an event waterfall for each session within each run, illustrating the sequence and duration of events.

```APIDOC
## slt_waterfall()

### Description
Event waterfall for each session within each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.
* `limits` (numeric) - Optional - Passed into `scale_colour_gradientn`.

### Value
A `ggplot` plot object.

### Example
```R
slt_waterfall(slt_demo_data_4)
```
```

--------------------------------

### Plotting HTTP Latency

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates a bar chart displaying the total HTTP latency for each session. A cutoff value can be specified to highlight latency above a certain threshold.

```R
slt_http_latency(slt_demo_data_4)
```

--------------------------------

### slt_time_boxplot

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Generates a box plot showing the distribution of load times for each event in each run.

```APIDOC
## slt_time_boxplot()

### Description
Box plot of load times for each event in each run.

### Arguments
* `df` (data frame) - Required - Data frame returned from `load_runs`.
* `labels` (vector) - Optional - A vector of labels to include. If none are supplied, all labels will be used.

### Value
A `ggplot` plot object.

### Example
```R
slt_time_boxplot(slt_demo_data_4)
```
```

--------------------------------

### Generating Event Waterfall Plot

Source: https://rstudio.github.io/shinyloadtest/reference/slt_plot.html

Creates an event waterfall plot to show the sequence and duration of events within each session for a given run. Can optionally set color limits.

```R
slt_waterfall(slt_demo_data_4)
```
Tokens:
Raw