Drill is a HTTP load testing application written in Rust inspired by Ansible syntax

Overview

Drill

Drill is a HTTP load testing application written in Rust. The main goal for this project is to build a really lightweight tool as alternative to other that require JVM and other stuff.

You can write benchmark files, in YAML format, describing all the stuff you want to test.

It was inspired by Ansible syntax because it is really easy to use and extend.

Here is an example for benchmark.yml:

---

concurrency: 4
base: 'http://localhost:9000'
iterations: 5
rampup: 2

plan:
  - name: Include comments
    include: comments.yml

  - name: Fetch users
    request:
      url: /api/users.json

  - name: Fetch organizations
    request:
      url: /api/organizations

  - name: Fetch account
    request:
      url: /api/account
    assign: foo

  - name: Fetch manager user
    request:
      url: /api/users/{{ foo.body.manager_id }}

  - name: Assign values
    assign:
      key: bar
      value: "2"

  - name: Fetch user from assign
    request:
      url: /api/users/{{ bar }}

  - name: Fetch some users
    request:
      url: /api/users/{{ item }}
    with_items:
      - 70
      - 73
      - 75

  - name: Fetch some users by hash
    request:
      url: /api/users/{{ item.id }}
    with_items:
      - { id: 70 }
      - { id: 73 }
      - { id: 75 }

  - name: Fetch some users by range, index {{ index }}
    request:
      url: /api/users/{{ item }}
    with_items_range:
      start: 70
      step: 5
      stop: 75

  - name: Fetch some users from CSV, index {{ index }}
    request:
      url: /api/users/contacts/{{ item.id }}
    with_items_from_csv: ./fixtures/users.csv
    shuffle: true

  - name: POST some crafted JSONs stored in CSV, index {{ index }}
    request:
      url: /api/transactions
      method: POST
      body: '{{ item.txn }}'
      headers:
        Content-Type: 'application/json'
    with_items_from_csv:
      file_name: ./fixtures/transactions.csv
      quote_char: "\'"

  - name: Fetch no relative url
    request:
      url: http://localhost:9000/api/users.json

  - name: Interpolate environment variables
    request:
      url: http://localhost:9000/api/{{ EDITOR }}

  - name: Support for POST method
    request:
      url: /api/users
      method: POST
      body: foo=bar&arg={{ bar }}

  - name: Login user
    request:
      url: /login?user=example&password=3x4mpl3

  - name: Fetch counter
    request:
      url: /counter
    assign: memory

  - name: Fetch counter
    request:
      url: /counter
    assign: memory

  - name: Fetch endpoint
    request:
      url: /?counter={{ memory.body.counter }}

  - name: Reset counter
    request:
      method: DELETE
      url: /

  - name: Custom headers
    request:
      url: /admin
      headers:
        Authorization: Basic aHR0cHdhdGNoOmY=
        X-Foo: Bar
        X-Bar: Bar {{ memory.headers.token }}

As you can see, you can play with interpolations in different ways. This will let you specify a benchmark with different requests and dependencies between them.

If you want to know more about the benchmark file syntax, read this

Install

The easiest way right now is to install with cargo:

cargo install drill
drill --benchmark benchmark.yml --stats

or download the source code and compile it:

git clone [email protected]:fcsonline/drill.git && cd drill
cargo build --release
./target/release/drill --benchmark benchmark.yml --stats

Note: You will need to install libssl-dev and pkg-config packages.

Demo

demo

Features

This is the list of all features supported by the current version of drill:

  • Concurrency: run your benchmarks choosing the number of concurrent iterations.
  • Multi iterations: specify the number of iterations you want to run the benchmark.
  • Ramp-up: specify the amount of time it will take drill to start all iterations.
  • Delay: introduce controlled delay between requests. Example: assigns.yml
  • Dynamic urls: execute requests with dynamic interpolations in the url, like /api/users/{{ item }}
  • Dynamic headers: execute requests with dynamic headers. Example: headers.yml
  • Interpolate environment variables: set environment variables, like /api/users/{{ EDITOR }}
  • Request dependencies: create dependencies between requests with assign and url interpolations.
  • Split files: organize your benchmarks in multiple files and include them.
  • CSV support: read CSV files and build N requests fill dynamic interpolations with CSV data.
  • HTTP methods: build request with different http methods like GET, POST, PUT, PATCH, HEAD or DELETE.
  • Cookie support: create benchmarks with sessions because cookies are propagates between requests.
  • Stats: get nice statistics about all the requests. Example: cookies.yml
  • Thresholds: compare the current benchmark performance against a stored one session and fail if a threshold is exceeded.

Test it

Go to the example directory and you'll find a README how to test it in a safe environment.

Disclaimer: We really recommend not to run intensive benchmarks against production environments.

Command line interface

Full list of cli options, which is available under drill --help

drill 0.7.1
HTTP load testing application written in Rust inspired by Ansible syntax

USAGE:
    drill [OPTIONS] --benchmark <benchmark>

FLAGS:
    -h, --help       Prints help information
        --no-check-certificate    Disables SSL certification check. (Not recommended)
        --relaxed-interpolations    Do not panic if an interpolation is not present. (Not recommended)
    -s, --stats      Shows request statistics
    -q, --quiet      Skips output of individual request statistics
    -n, --nanosec    Shows statistics in nanoseconds
    -V, --version    Prints version information

OPTIONS:
    -b, --benchmark <benchmark>    Sets the benchmark file
    -c, --compare <compare>        Sets a compare file
    -r, --report <report>          Sets a report file
    -t, --threshold <threshold>    Sets a threshold value in ms amongst the compared file

Roadmap

  • Complete and improve the interpolation engine
  • Add writing to a file support

Contribute

This project started as a side project to learn Rust, so I'm sure that is full of mistakes and areas to be improve. If you think you can tweak the code to make it better, I'll really appreciate a pull request. ;)

Comments
  • Strip characters like double quotes in 'assign' JSON response values

    Strip characters like double quotes in 'assign' JSON response values

    Hi guys, not sure if there's a workaround for this current issue.

    I have a thread test suite that first posts to an endpoint /token, and assigns the response value. I want to get one attribute and pass it in as the token value in subsequent request headers, like this:

    GET /users/3472742
    Headers:
      Bearer as897c98webjk324jkfds9
    

    Instead, when I pass in this assign response attribute using {{ response.token }}, I get hard coded double quotes that break this request:

    GET /users/3472742
    Headers:
      Bearer "as897c98webjk324jkfds9"
    

    Is there any way in Drill to strip characters like these from JSON response values?

    opened by patrick-armitage 14
  • Introducing concurrency configuration

    Introducing concurrency configuration

    When using async, you don't need lots of threads to achieve more concurrency.

    10 threads 10 concurrency:

    Threads 10
    Iterations 1000
    Rampup 0
    Base URL http://localhost:9000
    
    
    Fetch users               Total requests            10000
    Fetch users               Successful requests       10000
    Fetch users               Failed requests           0
    Fetch users               Median time per request   2ms
    Fetch users               Average time per request  2ms
    Fetch users               Sample standard deviation 1ms
    
    Concurrency Level         10
    Time taken for tests      2.0 seconds
    Total requests            10000
    Successful requests       10000
    Failed requests           0
    Requests per second       5010.52 [#/sec]
    Median time per request   2ms
    Average time per request  2ms
    Sample standard deviation 1ms
    

    10 threads 50 concurrency:

    Threads 10
    Iterations 1000
    Rampup 0
    Base URL http://localhost:9000
    
    
    Fetch users               Total requests            50000
    Fetch users               Successful requests       50000
    Fetch users               Failed requests           0
    Fetch users               Median time per request   5ms
    Fetch users               Average time per request  5ms
    Fetch users               Sample standard deviation 2ms
    
    Concurrency Level         50
    Time taken for tests      5.1 seconds
    Total requests            50000
    Successful requests       50000
    Failed requests           0
    Requests per second       9792.15 [#/sec]
    Median time per request   5ms
    Average time per request  5ms
    Sample standard deviation 2ms
    
    opened by messense 7
  • Concurrency and randomness for with_items

    Concurrency and randomness for with_items

    I was testing drill with a large CSV file of different item IDs. Is there any supported way to randomize the execution order? Right now this means that my concurrency is basically lock-step requesting the same items in the same order which maximizes the benefits from caching. It'd be really nice if there was a way to have the order be randomized other than, say, running multiple instances scripting shuf on a CSV file for each one.

    enhancement 
    opened by acdha 6
  • RFC - Verbose Flag

    RFC - Verbose Flag

    I really miss some kind of flag to show more information about request/response

    I've been learning Rust last year and it's a feature I could implement myself if you guys find it interesting :+1:

    enhancement 
    opened by jrabello 6
  • POST-ing a sequence of JSON objects in Drill

    POST-ing a sequence of JSON objects in Drill

    The task I'd like to perform with Drill is to have it read a csv file filled with JSON objects representing a transaction (txn) and have it POST to an address with the JSON being the body of the transaction. I've been unsuccessful.

    Here is what a simplified yml file looks like

    ---
    
    threads: 1
    base: 'http://localhost:8669'
    iterations: 1
    rampup: 2
    
    plan:
      - name: POST transactions to standalone ledger from CSV
        request:
          url: /submit_transaction
          method: POST
          body: {{ item.txn }}
          headers:
            Content-Type: 'application/json'
        with_items_from_csv:
          file_name: ./log.csv
          quote_char: "\'"
    

    and the log.csv file looks like:

    txn
    '{"operations": [{"DefineAsset": {"body": {"asset": {"code": {"val":
    [114, 255, 1, 164, 16, 58, 220, 131, 26, 36, 233, 7, 83, 132, 2,
    250]}, "issuer": {"key":
    "RkcRIKYXs_t2CKgxFwLc2AMCKOQP2N0Q3kTuIVIbCII="}, "memo": "",
    "confidential_memo": null, "updatable": false, "traceable": false}},
    "pubkey": {"key": "RkcRIKYXs_t2CKgxFwLc2AMCKOQP2N0Q3kTuIVIbCII="},
    "signature": "b6gc3THsoVFlBlMSUP78IxwPY37c2k-yllJJMtLhc1FW0iko0jSlSOBfjzMbPLdfsE7Dt2ky8ZsxKR9JTMvFAw=="}}],
    "credentials": [], "memos": []}'
    

    What appears to be happening is that the POST occurs with an empty body, suggesting that the interpolation of the JSON into the body has gone wrong, or I've used the wrong syntax. Any ideas?

    opened by bpr 6
  • terminal colours not working on windows outside `cargo run`

    terminal colours not working on windows outside `cargo run`

    I tried building and using drill on Windows, with cargo install, for a particular client where I needed to use their SoE desktop in a quick project.

    The colour-printing code didn't work right; I got ANSI escape codes printed literally on the terminal. This was running in VScode, with either powershell or git bash. I got the same in the powershell gui window. I set CLICOLOR=0 and got on with the task, but I wanted to come back and fix the problem so I could leave them with a working setup.

    I then cloned the repo, but to my surprise cargo run showed the colours correctly. Invoking the same executable from target/release/drill.exe printed ANSI codes again!

    The windows console doesn't interpret ANSI codes by defaut, and needs a console API call to set it into the appropriate mode. It turns out, cargo uses this mode, and leaves it active when invoking the program via cargo run.

    The below patch fixes, or at least works around the problem.

    diff --git a/src/main.rs b/src/main.rs
    index 2164af2..3db592b 100644
    --- a/src/main.rs
    +++ b/src/main.rs
    @@ -35,6 +35,8 @@ fn main() {
       let no_check_certificate = matches.is_present("no-check-certificate");
       let quiet = matches.is_present("quiet");
       let nanosec = matches.is_present("nanosec");
    +  #[cfg(windows)]
    +  let _ = control::set_virtual_terminal(true);
     
       let begin = time::precise_time_s();
       let list_reports_result = benchmark::execute(benchmark_file, report_path_option, no_check_certificate, quiet, nanosec);
    

    Note: I'm a very infrequent Windows user, and this was my first time trying Rust on Windows. Unfortunately I didn't have a chance to fully test this change in all combinations while on site, so it might still misbehave in the case of redirected output or some other situation. See the comments at the top of https://github.com/mackwic/colored/blob/master/src/control.rs for more detail; there may be more that needs to be done to properly set up the windows console. That's one reason I've given a code example as a diff rather than a PR.

    Big hat-tip to @retep998 for pointing out the console-mode api, I was well down the wrong rabbit-hole looking at differences in other environment variables between the two invocation methods.

    opened by dcarosone 6
  • Allow for environment variables to be interpolated with test plans

    Allow for environment variables to be interpolated with test plans

    It would be really neat if we could add environment variables to the yaml plans.

    For example you could export some vars:

    $ export BASE_URL='http://localhost:8000'
    $ export CONCURRENCY=50
    $ export ITERATIONS=100
    

    and in the yaml plan make it look at the ENV vars:

    ---
    
    concurrency: {{ $CONCURRENCY }} 
    base: {{ $BASE_URL }}
    iterations: {{ $ITERATIONS }}
    
    plan:
      - name: homepage
        request:
          url: /
    
    opened by Stii 5
  • Programmatic API

    Programmatic API

    YAML is a configuration language, not a programming language. While writing tests, sometimes I want the power of a programming language.

    For example, I'd like to be able to POST n transactions to a URL, followed by a different specific POST to get a batching (with a factor of n) interface. This kind of thing is trivial to do in Locust but is harder to do without a programmatic API.

    I doubt that replacing the YAML front end with a different embedded language is something that appeals to the Drill community. Since I already work in Rust, I'd like it if some of the internals of Drill were opened up and enhanced so that I could write some of my tests in Rust, using Drill.

    opened by bpr 5
  • Question: how to pass a large payload to request body

    Question: how to pass a large payload to request body

    Hi again!

    I am trying to pass a large payload to a PUT request

    I trying converting to YAML and putting into the body but when my target API is called, it does not receive any body

    here is my scenario:

    ---
    threads: 1
    base: 'http://localhost:8080'
    iterations: 1
    
    plan:
      - name: Update Configuration
        request:
          url: /api/channel/v1/custom/integration/configurations/xyz
          method: PUT
          headers:
            Cookie: "{{ authCookie }}"
            Content-Type: "application/json"
          body:
            domainValidateEndpoint: http://localhost:3000
            crestBaseConfiguration:
              host: http://localhost:3000
              azureHost: http://localhost:3000
              azureManagementHost: http://localhost:3000
              azureResource: http://localhost:3000
              partnerBillingDay: 1
              partnerCenterApiHost: https://api.partnercenter.microsoft.com
              partnerCenterAuthHost: https://login.windows.net
              partnerCenterResource: https://api.partnercenter.microsoft.com
              azureProvisioningDelayInMinutes: 180
              credentialsSetupStep: COMPLETED
              apiSetupStep: COMPLETED
              apiAuthorizationStep: COMPLETED
              configuredByAppDirect: false
              crestConfigurations:
                USA:
                  azureConfig:
                    clientId: someId
                    clientSecret: someSecret
                    managementUsername: [email protected]
                    managementPassword: someSecret
                    grantType: PASSWORD
                    encrypted: false
                  partnerCenterConfiguration:
                    clientId: 6c9f572a-d69a-4e08-b4e5-194696492374
                    applicationDomain: dummy.onmicrosoft.com
                  resellerCaid: 6c9f572a-d69a-4e08-b4e5-194696492374
                  resellerDomain: dummy.onmicrosoft.com
                  resellerPurchaseEnabled: true
              cspAzureConfigValid: true
            mosiEnabled: false
            crestEnabled: true
            azureEnabled: true
    
    opened by picaron 5
  • Add a

    Add a "pick" option for requests

    Resolves #131

    Allows to pick a subset of items from with_items.
    Pick limits the amount of requests done instead of doing one for each item.
    When used in conjunction with shuffle, it can be used to send one request with a random item from the list.

    - name: One request with a random item
      request:
        url: /api/users/{{ item }}
      with_items:
        - 70
        - 73
        - 75
      shuffle: true
      pick: 1
    
    opened by hendric-dev 4
  • Assign response code for assertions

    Assign response code for assertions

    It would be great to be able to assert response codes in assertions, the same way as it is currently done with headers and body.

    For example

    plan:
      - name: Healthcheck
        request:
          url: /healthcheck
        assign: healthcheck
    
      - name: Healtchcheck status assertion
        assert:
          key: "healthcheck.response_code"
          value: "200"
    
    opened by puls-com-leon-komarovsky 4
  • Added ability to set default headers and to copy headers

    Added ability to set default headers and to copy headers

    Added some code to be able to both set default headers for a benchmark, as well as copy headers from the response of one request to use for future requests (mainly implemented to be help me deal with CSRF tokens). This is my first PR for a rust project, so let me know if there's anything that might need changes.

    As far as I can tell, these changes didn't break anything when running either cargo test or the benchmark.yml benchmark. I also added a bit of code to the example server and the headers.yml benchmark to test the new functionality.

    opened by shadowwolf899 1
  • Print a message if a newer version is available

    Print a message if a newer version is available

    Hi there!

    I found this feature very useful in the GitHub CLI application and npm.

    I think it'll be useful for users who install drill using cargo. And this will let them know that a new version is available and it's time to update.

    Ready-made crates to do that:

    • https://github.com/mgrachev/update-informer
    • https://github.com/tarikeshaq/update-notifier
    opened by nobsaibot 0
  • fix: increase maximum bounds of histogram

    fix: increase maximum bounds of histogram

    Currently, the maximum bounds of 60*60*1000 is insufficient for requests that take longer than ~4000ms. Increasing the bounds of this by a factor of 10 should prevent this ever being an issue for long requests.

    opened by Mythral 0
  • RUSTSEC-2021-0139: ansi_term is Unmaintained

    RUSTSEC-2021-0139: ansi_term is Unmaintained

    ansi_term is Unmaintained

    | Details | | | ------------------- | ---------------------------------------------- | | Status | unmaintained | | Package | ansi_term | | Version | 0.12.1 | | URL | https://github.com/ogham/rust-ansi-term/issues/72 | | Date | 2021-08-18 |

    The maintainer has adviced this crate is deprecated and will not receive any maintenance.

    The crate does not seem to have much dependencies and may or may not be ok to use as-is.

    Last release seems to have been three years ago.

    Possible Alternative(s)

    The below list has not been vetted in any way and may or may not contain alternatives;

    See advisory page for additional details.

    opened by github-actions[bot] 0
  • Panic when some requests time out

    Panic when some requests time out

    If a timeout occurs on some requests, the statistics will not be printed out. The program will then panic.

    TimeOut Log

    Error connecting 'xxxxx': reqwest::Error { kind: Request, url: Url { scheme: "https", cannot_be_a_base: false, username: "", password: None, host: Some(Domain("xxxx")), port: None, path: "xxxx", query: Some("xxxx"), fragment: None }, source: TimedOut }
    

    Panic Log

    thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ValueOutOfRangeResizeDisabled', /Users/daoleno/.cargo/registry/src/github.com-1ecc6299db9ec823/hdrhistogram-7.5.1/src/lib.rs:1855:28
    note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
    
    opened by daoleno 0
Releases(0.8.1)
  • 0.8.0(Jul 10, 2022)

    :gift: New features

    • Improved documentation. Thanks to @corrieriluca (https://github.com/fcsonline/drill/pull/118)
    • Integrate High Dynamic Range Histogram. Thanks to @schrieveslaach (https://github.com/fcsonline/drill/pull/120)
    • Read items from file lines. Thanks to @SteVio89 (https://github.com/fcsonline/drill/pull/127)
    • Add step filtering by tags. Thanks to @IvashchenkoSerhii (https://github.com/fcsonline/drill/pull/132)
    • Add response status code into request assignations
    • Convert Travis configuration into Github Actions
    • Updated many outdated dependencies
    Source code(tar.gz)
    Source code(zip)
  • 0.7.2(Sep 3, 2021)

    • Add shuffle feature to with_items
    • Fix body for put and patch verbs
    • Add index variable for loop actions
    • Panic for properties that don't support interpolations
    • Fix Windows console colors code support
    • Fix command-line option to set timeout in seconds
    • New actions: Assert values
    • Add flag for verbose output
    • New Action: Execute OS commands
    Source code(tar.gz)
    Source code(zip)
  • 0.7.0(Nov 27, 2020)

    • Migration Async / Await completed!
    • New concurrency model
    • Interpolate env variables
    • Added Keep-Alive
    • Request headers memory
    • New delay actions
    Source code(tar.gz)
    Source code(zip)
  • 0.6.0(May 23, 2020)

    • Fixed quotes in string fields and panic on HTTP errors
    • Support multiple cookies
    • Fix wrong behavior for 1 iteration
    • Improve general performance
    • Fixed issues with interpolations
    • Relaxed interpolations
    • Add more documentation
    Source code(tar.gz)
    Source code(zip)
  • 0.5.0(Mar 20, 2019)

    • Added rampup option
    • Added HEAD verb support
    • Added new option with_items_range
    • Improved stats
    • New CSV parsing options
    • New no-check-certificate option to ingore SSL certificate validation
    • Formatted code with rustfmt
    Source code(tar.gz)
    Source code(zip)
  • 0.4.0(Nov 8, 2018)

    • Fixed concurrency issue
    • Fixed interpolation issue
    • Added new available interpolations: {{ thread }} and {{ iteration }}
    • Added new server to test low connections
    • More colors in log
    Source code(tar.gz)
    Source code(zip)
  • 0.3.5(Mar 8, 2018)

  • 0.3.2(Mar 8, 2018)

  • 0.3.1(Mar 8, 2018)

Owner
Ferran Basora
We need a tool™
Ferran Basora
A Kubernetes implementation of the Open Application Model specification

Rudr ?? NOTE: Rudr is deprecated in favor of the upcoming open application platform project as its successor. There are no plans to produce future rel

Open Application Model 1.6k Dec 4, 2022
Dragit - Application for intuitive file sharing between devices.

Dragit helps you share files between computers in the same network.

Piotr Gołąb 122 Nov 30, 2022
A genetic algorithm for bechmark problems, written to learn Rust.

Genetic Algorithm A genetic algorithm in Rust for the following benchmark problems: Ackley Griewangk Rastrigin Rosenbrock Schwefel Sphere Usage: Insta

Andrew Schwartzmeyer 71 Jul 11, 2022
interative assembly shell written in rust

Overview this project is inspired by https://github.com/poppycompass/asmshell Preview Build from source git clone https://github.com/keystone-engine/k

Xargin 231 Dec 2, 2022
A purpose-built proxy for the Linkerd service mesh. Written in Rust.

This repo contains the transparent proxy component of Linkerd2. While the Linkerd2 proxy is heavily influenced by the Linkerd 1.X proxy, it comprises

Linkerd 1.6k Nov 25, 2022
Full fake REST API generator written with Rust

Weld Full fake REST API generator. This project is heavily inspired by json-server, written with rust. Synopsis Our first aim is to generate a fake ap

Seray Uzgur 237 Nov 24, 2022
A GPU-accelerated cross-platform terminal emulator and multiplexer written by @wez and implemented in Rust

Wez's Terminal A GPU-accelerated cross-platform terminal emulator and multiplexer written by @wez and implemented in Rust User facing docs and guide a

Wez Furlong 6.5k Dec 1, 2022
pastebin written in pure rust. A rewrite of ptpb/pb.

rspb rust fork of ptpb/pb TL;DR Create a new paste from the output of cmd: cmd | curl -F [email protected] https://pb.mgt.moe/ Usage Creating pastes > echo hi | c

mgt 39 Dec 1, 2022
Distributed compute platform implemented in Rust, and powered by Apache Arrow.

Ballista: Distributed Compute Platform Overview Ballista is a distributed compute platform primarily implemented in Rust, powered by Apache Arrow. It

Ballista 2.3k Nov 30, 2022
Userspace WireGuard® Implementation in Rust

BoringTun BoringTun is an implementation of the WireGuard® protocol designed for portability and speed. BoringTun is successfully deployed on millions

Cloudflare 4.7k Dec 4, 2022
A fast data collector in Rust

Flowgger is a fast, simple and lightweight data collector written in Rust. It reads log entries over a given protocol, extracts them, decodes them usi

Amazon Web Services - Labs 728 Nov 22, 2022
kytan: High Performance Peer-to-Peer VPN in Rust

kytan: High Performance Peer-to-Peer VPN kytan is a high performance peer to peer VPN written in Rust. The goal is to to minimize the hassle of config

Chang Lan 358 Nov 29, 2022
The LibreTranslate API for Rust.

libretranslate-rs A LibreTranslate API for Rust. libretranslate = "0.2.4" libretranslate allows you to use open source machine translation in your pr

Grant Handy 51 Nov 30, 2022
Yet another pager in Rust

rust-pager Yet another pager in Rust Features Vim like keybindings Search substring Mouse wheel support Install cargo install rust-pager Usage <comman

null 20 Oct 10, 2022
A Rust serverless function to retrieve and relay a playlist for Twitch livestreams/VODs.

City17 A Rust serverless function to retrieve and relay a playlist for Twitch livestreams/VODs. By running this in specific countries and using a brow

Malloc Voidstar 5 Dec 15, 2021
Fork of async-raft, the Tokio-based Rust implementation of the Raft protocol.

Agreed Fork of async-raft, the Tokio-based Rust implementation of the Raft distributed consensus protocol. Agreed is an implementation of the Raft con

NLV8 Technologies 8 Jul 5, 2022
Rust runtime for Vercel Functions.

Rust Rust runtime for Vercel Functions. Community-maintained package to support using Rust inside Vercel Functions as a Runtime. Usage First, you'll n

Vercel Community 353 Nov 19, 2022
Drill is an HTTP load testing application written in Rust inspired by Ansible syntax

Drill is an HTTP load testing application written in Rust inspired by Ansible syntax

Ferran Basora 1.4k Nov 25, 2022
An experimental HTTP load testing application written in Rust.

Herd Herd was a small side project in building a HTTP load testing application in Rust with a main focus on being easy to use and low on OS level depe

Jacob Clark 98 Nov 16, 2022
hb is an endpoint focused HTTP load testing / benchmark tool.

hb hb is an endpoint focused HTTP load testing / benchmark tool. Description The goal of hb is to provide a simple, robust tool to apply load against

Mark Pritchard 2 Aug 23, 2022