web_tsunami 0.0.1 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5684946d08e860b309d812707e690d91f45698140d5a22b1d8fe963f85203f25
+  data.tar.gz: dd58e555fc6c6dc89c3e1205299fec88c3879635ea36f4e78baa49a5f00993e5
+SHA512:
+  metadata.gz: 1a29b20791f56ba1e87b4168777fd9a362a6bc06c3548bd5bc1a7a2d44b4d765153fb24ca732fea99172d0a2d2ffbdbad08aec7d0063cc018fa5309e740c647f
+  data.tar.gz: 3991dbf3d1b3d72c2aa40f734a153a8ed40f4bfbc903afdd6f3780c4b81ef918b0ed4033ee5f3521837342987ff16cd1a5f2a5f2d5a68990039c0a2d67356189

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog of Web Tsunami
+
+## 0.2.0 (2024-01-25)
+
+* Add methods post, put, patch and delete
+* Improve README with an advanced example
+
+## 0.1.0 (2024-01-19)
+
+* Fix non compatible changes of Typhoeus
+
+## 0.0.1 (2012-07-13)
+
+* Initial version

data/Gemfile.lock

@@ -1,12 +1,17 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    mime-types (1.18)
-    typhoeus (0.3.3)
-      mime-types
+    ethon (0.16.0)
+      ffi (>= 1.15.0)
+    ffi (1.16.3)
+    typhoeus (1.4.1)
+      ethon (>= 0.9.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   typhoeus
+
+BUNDLED WITH
+   2.2.22

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2024 Alexis Bernard
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,135 @@
+<img align="right" width="120px" src="./web_tsunami.png">
+
+# Web Tsunami
+
+Write tailor-made scenarios for load testing web apps
+
+## Why
+
+Many good tools already exist for a very long time such as ApacheBench and Siege.
+The goal is not to replace them.
+But sometimes, load testing a web app requires to write a custom scenario.
+My initial requirement was to send requests with unique parameters.
+To the best of my knowledge, no tool could do this.
+
+The goal is to focus only on the scenario without thinking about forking, threads and non blocking IOs.
+Fortunately there is [Typhoeus](https://github.com/typhoeus/typhoeus) to send parallel HTTP requests.
+
+## How
+
+Web Tsunami is a tiny class that forks every seconds and sends as many requests as expected.
+It provide the methods `get`, `post`, `put`, `patch` and `delete`.
+They all accept the same arguments : `get(url, options = {}, &block)`.
+The `options` is given to Typhoeus as is.
+It can contain headers and the request body.
+See [Typhoeus usage](https://github.com/typhoeus/typhoeus/#usage) for more details.
+
+## Examples
+
+Let's start with a very trivial scenario and I will show you an advanced one after :
+
+```ruby
+require "web_tsunami"
+
+class SearchTsunami < WebTsunami::Scenario
+  def run
+    get("http://site.example") do
+      # Block is executed once the response has been received
+      sleep(5) # Simulates the time required for a human to visit the next page
+      get("http://site.example/search?query=stress+test") do |response|
+        # Do whatever you need with the response object or ignore it
+        sleep(10)
+        get("http://site.example/search?query=stress+test&page=#{rand(100)}") do
+          sleep(5)
+          get("http://site.example/stress/test")
+        end
+      end
+    end
+  end
+end
+
+# Simulates 100 concurrent visitors every second for 10 minutes
+# It's a total of 60K unique visitors for an average of 23'220 rpm.
+SearchTsunami.start(concurrency: 100, duration: 60 * 10)
+```
+
+In this scenario, a visitor comes on the index page, then search for _stress test_, then go on a random page of the search result, and finally found the stress test page.
+It introduces a unique parameters which is the page number.
+It's nice, but it could have almost be done with Siege.
+Let me show you a more advanced scenario.
+
+```ruby
+require "web_tsunami"
+require "json"
+
+class RegistrationTsunami < WebTsunami::Scenario
+  # Simulate a visitor coming on the index page,
+  # then going to the registration form,
+  # and finally submitting the form.
+  def run
+    get("http://site.example/") do |response|
+      get("http://site.example/account/new") do |response|
+        post("http://site.example/account", post_account_options(response)) do |response|
+          # Then visiting the dashboard, and so on.
+        end
+      end
+    end
+  end
+
+  private
+
+  def post_account_options(response)
+    # In order to not be blocked by the Cross-Site Request Forgery, the request must contain :
+    #   1. Cookie header
+    #   2. authenticity_token form param
+    {
+      headers: build_post_headers(response),
+      body: JSON.generate(
+        authenticity_token: extract_csrf_token(response.body),
+        user: {
+          name: name = rand.to_s[2..-1],
+          email: "#{name}@domain.test",
+          password: name,
+        }
+      ),
+    }
+  end
+
+  def build_post_headers(response)
+    {
+      "Origin" => response.request&.base_url,
+      "Content-Type" => "application/json",
+      "Cookie" => response.headers["Set-Cookie"],
+      # To Simulate a post XmlHttpRequest from JavaScript, you should provide these headers :
+      # "X-CSRF-Token" => extract_csrf_token(response.body),
+      # "X-Requested-With" => "XMLHttpRequest"
+    }
+  end
+
+  CSRF_REGEX = /<meta name="csrf-token" content="([^"]+)"/
+
+  def extract_csrf_token(html)
+    html.match(CSRF_REGEX)[1]
+  end
+end
+
+# Simulates 100 concurrent visitors every second for 10 minutes
+RegistrationTsunami.start(concurrency: 100, duration: 10)
+```
+
+This is more complex because it handles CSRF and every submitted forms are unique.
+Indeed emails must be unique, so it's not possible to send the same data everytime.
+
+## Output and result
+
+Web Tsunami does not measure response time or print any result.
+If you are running a load test, that means you should use an APM (application performance monitoring).
+It already collects and displays all data you need such as throughput, response time and bottlenecks.
+
+So, the only output are errors.
+
+## License
+
+The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+Rails developer? Check out [RoRvsWild](https://rorvswild.com), our Ruby on Rails application monitoring tool.

data/lib/web_tsunami/version.rb

@@ -0,0 +1,3 @@
+module WebTsunami
+  VERSION = "0.2.0"
+end

data/{web_tsunami.rb → lib/web_tsunami.rb}

@@ -13,22 +13,41 @@ module WebTsunami
     end
 
     def initialize(concurrency)
-      @sleeps = {}
       @concurrency = concurrency
     end
 
     def requests
-      (@requests = Typhoeus::Hydra.new).disable_memoization unless @requests
-      @requests
+      @requests ||= Typhoeus::Hydra.new
     end
 
-    def get(url, &block)
-      requests.queue(req = Typhoeus::Request.new(url, request_options))
+    def get(url, options = {}, &block)
+      request(:get, url, options, &block)
+    end
+
+    def post(url, options = {}, &block)
+      request(:post, url, options, &block)
+    end
+
+    def put(url, options = {}, &block)
+      request(:put, url, options, &block)
+    end
+
+    def patch(url, options = {}, &block)
+      request(:patch, url, options, &block)
+    end
+
+    def delete(url, options = {}, &block)
+      request(:delete, url, options, &block)
+    end
+
+    def request(method, url, options, &block)
+      req = Typhoeus::Request.new(url, {method: method}.merge(options))
+      requests.queue(req)
       req.on_complete do |response|
         if response.timed_out?
           puts "Timeout #{url}"
         elsif response.code == 0
-          puts "#{response.curl_error_message} #{url}"
+          puts "#{response.return_message} #{url}"
         elsif !response.success? && response.code != 302
           puts "#{response.code} #{url}"
         end
@@ -37,7 +56,7 @@ module WebTsunami
     end
 
     def start
-      concurrency.times { |i| run }
+      concurrency.times { run }
       requests.run
     end
 
@@ -45,9 +64,5 @@ module WebTsunami
       raise NotImplementedError
     end
 
-    def request_options
-      {}
-    end
-
   end
 end

data/web_tsunami.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require_relative "lib/web_tsunami/version"
+
+Gem::Specification.new do |s|
+  s.name          = "web_tsunami"
+  s.version       = WebTsunami::VERSION
+  s.authors       = ["Alexis Bernard"]
+  s.email         = ["alexis@basesecrete.com"]
+  s.homepage      = "https://github.com/BaseSecrete/web_tsunami"
+  s.summary       = "Tailor-made load testing for web apps"
+  s.description   = "Write realistic scenarios to test the load of a web application."
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.metadata["source_code_uri"] = "https://github.com/BaseSecrete/web_tsunami"
+  s.metadata["changelog_uri"] = "https://github.com/BaseSecrete/web_tsunami/blob/master/CHANGELOG.md"
+
+  s.add_runtime_dependency "typhoeus"
+end

metadata

@@ -1,50 +1,68 @@
 --- !ruby/object:Gem::Specification
 name: web_tsunami
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexis Bernard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-13 00:00:00.000000000Z
-dependencies: []
-description: Benchmark your web application
+date: 2024-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Write realistic scenarios to test the load of a web application.
 email:
-- alexis@official.fm
+- alexis@basesecrete.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
-- README
-- example.rb
-- web_tsunami.rb
-homepage: https://github.com/officialfm/web_tsunami
-licenses: []
+- LICENSE.txt
+- README.md
+- lib/web_tsunami.rb
+- lib/web_tsunami/version.rb
+- web_tsunami.gemspec
+- web_tsunami.png
+homepage: https://github.com/BaseSecrete/web_tsunami
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/BaseSecrete/web_tsunami
+  changelog_uri: https://github.com/BaseSecrete/web_tsunami/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 3.2.22
 signing_key: 
-specification_version: 3
-summary: Benchmark your web application
+specification_version: 4
+summary: Tailor-made load testing for web apps
 test_files: []

data/README

@@ -1,9 +0,0 @@
-Benchmark your web application.
-
-Why not using Apache Benchmark or any similar tool?
-
-Because some times we need to send unique requests and AB doesn't fit for that need.
-
-Check example.rb to see how it's working.
-
-More documentation and gem is coming soon.

data/example.rb

@@ -1,28 +0,0 @@
-$LOAD_PATH << File.dirname(__FILE__)
-
-require 'web_tsunami'
-
-# Triggers the following requests concurently:
-# http://www.google.com
-# http://www.google.com/search?q=ruby
-# http://www.google.com/search?q=ruby&start=10
-
-class GoogleTsunami < WebTsunami::Scenario
-  def run
-    get('http://www.google.com') do
-      puts 'http://www.google.com'
-      get('http://www.google.com/search?q=ruby') do
-        puts 'http://www.google.com/search?q=ruby'
-        get("http://www.google.com/search?q=ruby&start=#{rand(100)*10}") do
-          puts 'http://www.google.com/search?q=ruby&start=10'
-        end
-      end
-    end
-  end
-end
-
-# Set concurrency and duration in seconds and start your script.
-# These numbers are voluntary low because I don't want any trouble with Google.
-# But don't hesitate to set a higher concurrency and a duration of almost 5 minutes
-# in order to get a reliable benchmark.
-GoogleTsunami.start(concurrency: 2, duration: 10)