mutalisk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5a04080381afb1c9f0aaa2339636135dda6bbb0
+  data.tar.gz: 3840193f635d2110303b9ff00fa73d408e70f63d
+SHA512:
+  metadata.gz: d3624024cb5aad3a074e039b701c6dfca3733870a36aa0a083560e2fae3fe0ee23f42d796642f4779397776cc671f24f12d6df4720ba94bcea66ae20fff9d5b4
+  data.tar.gz: 5f8a8ced9370289f4761c2c68214ccf5315db92e726c981711443057b00bb52537f6600f1d16b782aaf8d76e431f688b7799425d18cd7ea11f0fc1003972664b

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.byebug_history

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://ruby.taobao.org'
+
+gemspec

data/README.md

@@ -0,0 +1,79 @@
+# Mutalisk
+
+[Mutalisk](http://starcraft.wikia.com/wiki/Mutalisk_(StarCraft)) is a simple yet powerful HTTP API benchmarking tool.
+
+Mutalisk emulates [wrk](https://github.com/wg/wrk), combines the power of multi-threading and IO-multiplexing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mutalisk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mutalisk
+
+## Usage
+
+Do it in [wrk](https://github.com/wg/wrk) style:
+
+    $ mutalisk -d 5 -t 2 -c 50 --latency http://v2.same.com/channel/1070566/senses
+
+Sample output:
+
+```
+Running 5s test @ http://v2.same.com/channel/1070566/senses
+  2 threads and 50 connections
++----------+------------+---------------+--------------------+------------------------------------------------+
+| time     | bytes_read | requests_sent | responses_received | errors                                         |
++----------+------------+---------------+--------------------+------------------------------------------------+
+| 5.012713 | 27876713   | 1225          | 1175               | {:read=>0, :write=>0, :connect=>0, :status=>0} |
++----------+------------+---------------+--------------------+------------------------------------------------+
+  Latency Distribution
+   50%    159.21ms
+   75%    217.85ms
+   90%    280.15ms
+   95%    344.61ms
+   99%    523.09ms
+  1175 requests in 5.01s, 26.58MB read
+Requests/sec:   234.40
+Transfer/sec:     5.30MB
+```
+
+Side by side comparison with `wrk`:
+
+    $ wrk -d 5 -t 2 -c 50 --latency http://v2.same.com/channel/1070566/senses
+
+```
+Running 5s test @ http://v2.same.com/channel/1070566/senses
+  2 threads and 50 connections
+  Thread Stats   Avg      Stdev     Max   +/- Stdev
+    Latency   238.27ms  370.89ms   2.07s    96.00%
+    Req/Sec   131.30      9.78   142.00     70.00%
+  Latency Distribution
+     50%  154.93ms
+     75%  197.59ms
+     90%  321.57ms
+     99%    2.07s
+  1241 requests in 5.01s, 28.00MB read
+Requests/sec:    247.51
+Transfer/sec:      5.58MB
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/forresty/mutalisk.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mutalisk"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/mutalisk

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'mutalisk'
+
+Mutalisk::CLI.start(ARGV)

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mutalisk.rb

@@ -0,0 +1,10 @@
+require_relative 'mutalisk/version'
+require_relative 'mutalisk/errors'
+require_relative 'mutalisk/stats'
+require_relative 'mutalisk/connection'
+require_relative 'mutalisk/ae'
+require_relative 'mutalisk/request'
+require_relative 'mutalisk/response'
+require_relative 'mutalisk/runner_thread'
+require_relative 'mutalisk/runner'
+require_relative 'mutalisk/cli'

data/lib/mutalisk/ae.rb

@@ -0,0 +1,22 @@
+module Mutalisk
+  class AE
+    SELECT_TIMEOUT = 0.01
+
+    def self.readable(connections, pipe)
+      sockets = connections.map(&:socket)
+
+      readable, _ = IO.select(sockets + [pipe], nil, nil, SELECT_TIMEOUT)
+
+      if readable
+        readable.map do |io|
+          if io == pipe
+            pipe
+          else
+            socket = io
+            socket.instance_variable_get(:@_mutalisk_connection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutalisk/cli.rb

@@ -0,0 +1,155 @@
+require 'optparse'
+require 'addressable/uri'
+
+module Mutalisk
+  class CLI
+    def initialize(args)
+      @args = args
+    end
+
+    def start
+      Stats.reset
+      @options = { headers: {} }
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: mutalisk <options> <url>\n  Options:"
+        opts.version = Mutalisk::VERSION
+
+        opts.on("-c", "--connections N", Integer, "<N>  Connections to keep open") do |n|
+          @options[:connections] = n
+        end
+
+        opts.on("-d", "--duration T", Integer, "<T>  Duration of test") do |t|
+          @options[:seconds] = t
+        end
+
+        opts.on("-t", "--threads N", Integer, "<N>  Number of threads to use") do |n|
+          @options[:threads] = n
+        end
+
+        opts.on('-H', '--header H', String, "<H>  Add header to request") do |h|
+          if h =~ /^(.+): (.+)$/
+            @options[:headers][$1] = $2
+          end
+        end
+
+        opts.on("--latency", "     Print latency statistics") do |l|
+          @options[:print_latency] = l
+        end
+
+        opts.on("-v", "--[no-]verbose", "     Run verbosely") do |v|
+          @options[:verbose] = v
+        end
+
+        opts.on("-h", "--help", "     Prints this help") do
+          puts opts
+          exit
+        end
+      end
+      parser.parse!(@args)
+
+      if url = @args.shift
+        uri = Addressable::URI.parse(url)
+        if uri.scheme =~ /^https?/
+          @options[:uri] = uri
+
+          runner = Runner.new(@options)
+          print_header(runner)
+          runner.start
+          print_results(runner)
+        else
+          puts "invalid URL: `#{url}', only HTTP/HTTPS endpoints are supported at the moment"
+        end
+      else
+        puts parser
+      end
+    end
+
+    private
+
+    def print_header(runner)
+      seconds, uri, threads, connections = runner.options.values_at(:seconds, :uri, :threads, :connections)
+
+      puts "Running #{seconds}s test @ #{uri}"
+      puts "  #{threads} threads and #{connections} connections"
+    end
+
+    def print_errors(errors)
+      read, write, connect, status = errors.values_at(:read, :write, :connect, :status)
+
+      if read > 0 || write > 0 || connect > 0
+        puts "  Socket errors: connect #{connect}, read #{read}, write #{write}, timeout UNKNOWN"
+      end
+
+      if status > 0
+        puts "  Non-2xx or 3xx responses: #{status}"
+      end
+    end
+
+    def print_results(runner)
+      require 'ttable'
+      puts Terminal::Table.new(runner.results)
+      completed_requests = runner.results[:responses_received]
+      total_time = runner.results[:time]
+      bytes_read = runner.results[:bytes_read]
+
+      if @options[:print_latency]
+        puts "  Latency Distribution"
+        [50, 75, 90, 95, 99].each do |pc|
+          puts "   #{pc}%  #{pretty_time(Stats.percentile(pc))}"
+        end
+      end
+
+      puts "  #{completed_requests} requests in #{'%.2f' % total_time}s, #{pretty_bytes(bytes_read)} read"
+
+      qps = '%.2f' % (completed_requests.to_f / total_time)
+      bps = pretty_bytes(bytes_read / total_time)
+
+      print_errors(runner.results[:errors])
+
+      puts "Requests/sec: #{qps.rjust(8)}"
+      puts "Transfer/sec: #{bps.rjust(10)}"
+
+      if @options[:verbose]
+        puts "All finished requests:"
+        puts
+        puts Terminal::Table.new(Stats.metrics)
+      end
+
+      @results = {
+        qps: qps,
+        tps: bps,
+        uri: @options[:uri]
+      }
+    end
+
+    def pretty_time(sec)
+      if sec > 1
+        ('%.2fs' % sec).rjust(9)
+      else
+        ('%.2fms' % (sec * 1000)).rjust(10)
+      end
+    end
+
+    def pretty_bytes(bytes)
+      kb, bytes = bytes.divmod(1024)
+
+      if kb > 0
+        mb, kb = kb.divmod(1024)
+
+        if mb > 0
+          "#{'%.2f' % ((mb*1024 + kb)/1024.0)}MB"
+        else
+          "#{'%.2f' % ((kb*1024 + bytes)/1024.0)}KB"
+        end
+
+      else
+        "#{bytes} bytes"
+      end
+    end
+
+    def self.start(args)
+      new(args).start
+    end
+  end
+end

data/lib/mutalisk/connection.rb

@@ -0,0 +1,124 @@
+require 'socket'
+
+module Mutalisk
+  class Connection
+    attr_reader :socket
+    attr_reader :uri
+    attr_reader :connection_id
+    attr_reader :thread
+
+    # stats
+    attr_reader :bytes_read
+    attr_reader :requests_sent
+    attr_reader :responses_received
+    attr_reader :read_errors
+    attr_reader :write_errors
+    attr_reader :connect_errors
+
+    READ_MAXLEN = 100_000
+
+    def initialize(thread, uri, cid)
+      @thread = thread
+      @uri = uri
+      @connection_id = cid
+
+      # stats
+      @bytes_read = 0
+      @requests_sent = 0
+      @responses_received = 0
+      @read_errors = 0
+      @write_errors = 0
+      @connect_errors = 0
+
+      connect
+    end
+
+    def idle?
+      !!@idle
+    end
+
+    def send_request(headers=nil)
+      raise ConnectionBusyError unless idle?
+
+      reset_response
+
+      @request = spawn_request(headers)
+      @request.start
+
+      @idle = false
+      @requests_sent += 1
+
+      @request
+    rescue Errno::EPIPE
+      @write_errors += 1
+      reconnect
+    end
+
+    def receive
+      @response ||= Response.new(@request)
+
+      resp = @socket.readpartial(READ_MAXLEN)
+
+      @bytes_read += resp.bytesize
+
+      @response << resp
+
+      if @response.complete?
+        @idle = true
+        @responses_received += 1
+      end
+
+      @response
+    rescue EOFError
+      @idle = true
+      @response
+    rescue Errno::ECONNRESET => e
+      @read_errors += 1
+      @idle = true
+      reconnect
+
+      @response
+    end
+
+    private
+
+    def spawn_request(headers)
+      @rid ||= 0
+      request = Request.new(self, @rid, headers)
+      @rid += 1
+
+      request
+    end
+
+    def connect
+      reconnect
+    end
+
+    def reconnect
+      if uri.scheme == 'https'
+        sock = TCPSocket.new(uri.host, uri.port || 443)
+
+        require 'openssl'
+        ctx = OpenSSL::SSL::SSLContext.new
+
+        ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
+
+        @socket = OpenSSL::SSL::SSLSocket.new(sock, ctx).tap do |socket|
+          socket.sync_close = true
+          socket.connect
+        end
+      else
+        @socket = TCPSocket.new(uri.host, uri.port || 80)
+      end
+
+      @socket.instance_variable_set(:@_mutalisk_connection, self)
+      @idle = true
+    rescue SocketError
+      @connect_errors += 1
+    end
+
+    def reset_response
+      @response = nil
+    end
+  end
+end

data/lib/mutalisk/errors.rb

@@ -0,0 +1,6 @@
+module Mutalisk
+  class MutaliskError < StandardError; end
+  class NotImplementedYet < MutaliskError; end
+  class ConnectionBusyError < MutaliskError; end
+  class AssertionFailedError < MutaliskError; end
+end

data/lib/mutalisk/request.rb

@@ -0,0 +1,66 @@
+module Mutalisk
+  class Request
+    attr_accessor :uri
+    attr_accessor :connection
+    attr_accessor :request_id
+    attr_accessor :t0
+
+    def initialize(connection, rid, headers=nil)
+      @connection = connection
+      @uri = @connection.uri
+      @socket = @connection.socket
+      @request_id = rid
+      @headers = headers
+      @done = false
+    end
+
+    def start
+      @t0 = Time.now
+      path = @uri.path && !@uri.path.empty? ? @uri.path : '/'
+
+      header_lines = [
+        "GET #{path} HTTP/1.1",
+        # 'Accept: */*',
+        # 'Accept-Encoding: gzip, deflate',
+        # 'Connection: keep-alive',
+        "Host: #{@uri.host}",
+        # "User-Agent: Mutalisk/#{Mutalisk::VERSION}"
+      ]
+
+      if @headers
+        @headers.each do |k, v|
+          header_lines << "#{k}: #{v}"
+        end
+      end
+
+      headers = header_lines.join("\r\n") + "\r\n\r\n"
+
+      bytes_written = @socket.write(headers)
+
+      # assume out-going buffer is large enough
+      assert bytes_written == headers.bytesize
+
+      @done = true
+    rescue IO::EAGAINWaitWritable
+      retry
+    end
+
+    def done?
+      !!@done
+    end
+
+    def req_id
+      tid = connection.thread.thread_id
+      cid = connection.connection_id
+      rid = request_id
+
+      "t#{tid}-c#{cid}-r#{rid}"
+    end
+
+    private
+
+    def assert(condition)
+      raise AssertionFailedError unless condition
+    end
+  end
+end

data/lib/mutalisk/response.rb

@@ -0,0 +1,56 @@
+require 'http/parser'
+
+module Mutalisk
+  class Response
+    attr_reader :code
+    attr_reader :headers
+    attr_reader :body
+    attr_reader :request
+    attr_reader :time_spent
+
+    def initialize(request)
+      @request = request
+
+      @completed = false
+      @code = nil
+      @body = ''
+      @time_spent = nil
+
+      @parser = Http::Parser.new
+
+      @parser.on_headers_complete = proc do
+        @code = @parser.status_code
+      end
+
+      @parser.on_body = proc do |chunk|
+        @body << chunk
+      end
+
+      @parser.on_message_complete = proc do
+        @time_spent = Time.now - @request.t0
+        @completed = true
+      end
+    end
+
+    def <<(data)
+      @parser << data
+    end
+
+    def complete?
+      !!@completed
+    end
+
+    def success?
+      complete? && (@code >= 200 && @code <= 399)
+    end
+
+    def to_h
+      {
+        req_id: @request.req_id,
+        code: @code,
+        body_size: @body.bytesize,
+        time_spent: @time_spent
+      }
+    end
+  end
+end

data/lib/mutalisk/runner.rb

@@ -0,0 +1,75 @@
+module Mutalisk
+  class Runner
+    attr_reader :results
+    attr_reader :options
+
+    DEFAULT_OPTIONS = {
+      connections: 10,
+      seconds: 10,
+      threads: 2
+    }
+
+    def initialize(options={})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @threads = []
+    end
+
+    def start
+      t0 = Time.now
+      options_per_thread = @options.dup
+      options_per_thread.delete(:threads)
+      options_per_thread[:connections] = @options[:connections] / @options[:threads]
+
+      Thread.abort_on_exception = true
+
+      @options[:threads].times do |i|
+        thread = spawn_thread(options_per_thread, i)
+        thread.start
+        @threads << thread
+      end
+
+      trap(:INT) {
+        puts "INT signal caught, stopping threads..."
+        @pipes.each { |writer| writer.write_nonblock('.') }
+      }
+
+      @threads.map(&:join)
+
+      @results = { time: Time.now - t0 }
+      @results = merge_stats(@results, @threads.map(&:results))
+    end
+
+    private
+
+    def spawn_thread(options_per_thread, i)
+      @pipes ||= []
+
+      reader, writer = create_pipe
+
+      # selfpipe to pass signals to threads
+      @pipes << writer
+
+      RunnerThread.new(options_per_thread, reader, i)
+    end
+
+    def create_pipe
+      IO.method(:pipe).arity.zero? ? IO.pipe : IO.pipe("BINARY")
+    end
+
+    def merge_stats(dest, array)
+      array.each do |hash|
+        hash.each do |key, value|
+          if value.is_a? Hash
+            dest[key] ||= {}
+            merge_stats(dest[key], [value])
+          else
+            dest[key] ||= 0
+            dest[key] += value
+          end
+        end
+      end
+
+      dest
+    end
+  end
+end

data/lib/mutalisk/runner_thread.rb

@@ -0,0 +1,94 @@
+module Mutalisk
+  class RunnerThread
+    attr_reader :results
+    attr_reader :thread_id
+
+    def initialize(options, pipe, id)
+      @options = options
+      @connections = []
+      @responses = []
+
+      @pipe = pipe
+      @interrupted = false
+      @thread_id = id
+    end
+
+    def start
+      @t0 = Time.now
+
+      @thread = Thread.new {
+        # slow start
+        until @connections.size == @options[:connections]
+          spawn_connection
+          send_requests
+          check_response
+        end
+
+        # full speed
+        loop do
+          send_requests
+          check_response
+          break if times_up? or @interrupted
+        end
+
+        generate_report
+      }
+    end
+
+    def join
+      @thread.join
+
+      Stats.collect(@responses.map(&:to_h))
+    end
+
+    private
+
+    def spawn_connection
+      @cid ||= 0
+      connection = Connection.new(self, @options[:uri], @cid)
+      @cid += 1
+      @connections << connection
+    end
+
+    def send_requests
+      @connections.each do |c|
+        c.send_request(@options[:headers]) if c.idle?
+      end
+    end
+
+    def check_response
+      if readable = AE.readable(@connections, @pipe)
+        readable.each do |connection|
+          if connection == @pipe
+            @interrupted = true
+          else
+            response = connection.receive
+
+            if response.complete?
+              # done with a request
+              @responses << response
+            end
+          end
+        end
+      end
+    end
+
+    def times_up?
+      Time.now - @t0 > @options[:seconds]
+    end
+
+    def generate_report
+      @results = {
+        bytes_read: @connections.map(&:bytes_read).inject(&:+),
+        requests_sent: @connections.map(&:requests_sent).inject(&:+),
+        responses_received: @connections.map(&:responses_received).inject(&:+),
+        errors: {
+          read: @connections.map(&:read_errors).inject(&:+),
+          write: @connections.map(&:write_errors).inject(&:+),
+          connect: @connections.map(&:connect_errors).inject(&:+),
+          status: @responses.map(&:code).count { |code| code < 200 || code > 399 }
+        }
+      }
+    end
+  end
+end

data/lib/mutalisk/stats.rb

@@ -0,0 +1,22 @@
+module Mutalisk
+  class Stats
+    def self.collect(metrics)
+      @@metrics ||= []
+      @@metrics += metrics
+    end
+
+    def self.reset
+      @@metrics = []
+    end
+
+    def self.metrics
+      @@metrics
+    end
+
+    def self.percentile(pc)
+      metrics = @@metrics.sort { |m1, m2| m1[:time_spent] <=> m2[:time_spent] }.reject { |m| m[:code] > 399 || m[:code] < 200 }
+
+      metrics[pc*metrics.size/100][:time_spent] rescue 0
+    end
+  end
+end

data/lib/mutalisk/version.rb

@@ -0,0 +1,3 @@
+module Mutalisk
+  VERSION = "0.1.0"
+end

data/mutalisk.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mutalisk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mutalisk"
+  spec.version       = Mutalisk::VERSION
+  spec.authors       = ["Forrest Ye"]
+  spec.email         = ["afu@forresty.com"]
+
+  spec.summary       = %q{A simple yet powerful HTTP API benchmarking tool.}
+  spec.homepage      = "https://github.com/forresty/mutalisk"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'ttable', '~> 0.0.10'
+  spec.add_runtime_dependency 'http_parser.rb', '~> 0.6.0'
+  spec.add_runtime_dependency 'addressable', '~> 2.3.8'
+
+  spec.add_development_dependency 'byebug', '~> 8.2.0'
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: mutalisk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Forrest Ye
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ttable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.10
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.8
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- afu@forresty.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/mutalisk
+- bin/setup
+- lib/mutalisk.rb
+- lib/mutalisk/ae.rb
+- lib/mutalisk/cli.rb
+- lib/mutalisk/connection.rb
+- lib/mutalisk/errors.rb
+- lib/mutalisk/request.rb
+- lib/mutalisk/response.rb
+- lib/mutalisk/runner.rb
+- lib/mutalisk/runner_thread.rb
+- lib/mutalisk/stats.rb
+- lib/mutalisk/version.rb
+- mutalisk.gemspec
+homepage: https://github.com/forresty/mutalisk
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A simple yet powerful HTTP API benchmarking tool.
+test_files: []