hey.rb 1.0.0

data/exe/hey

@@ -0,0 +1,405 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Translated from hey.go. Command hey is an HTTP load generator.
+
+require "etc"
+require "uri"
+
+require "hey"
+
+module Hey
+  module CLI
+    HEADER_REGEXP = '^([\w-]+):\s*(.+)'
+    AUTH_REGEXP = '^(.+):([^\s].+)'
+    HEY_UA = "hey/0.0.1"
+
+    # Go's math.MaxInt32.
+    MAX_INT32 = 2_147_483_647
+
+    # A stand-in for Go's flag package, covering the forms it accepts for the
+    # flags declared below: -name value, -name=value, --name value, and a bare
+    # -name for booleans. Parsing stops at the first non-flag argument.
+    FLAGS = {
+      "m" => [:string, "GET"],
+      "h" => [:string, ""],
+      "d" => [:string, ""],
+      "D" => [:string, ""],
+      "A" => [:string, ""],
+      "T" => [:string, "text/html"],
+      "a" => [:string, ""],
+      "host" => [:string, ""],
+      "U" => [:string, ""],
+
+      "o" => [:string, ""],
+
+      "c" => [:int, 50],
+      "n" => [:int, 200],
+      "q" => [:float, 0.0],
+      "t" => [:int, 20],
+      "z" => [:duration, 0.0],
+
+      "h2" => [:bool, false],
+      "cpus" => [:int, Etc.nprocessors],
+
+      "disable-compression" => [:bool, false],
+      "disable-keepalive" => [:bool, false],
+      "disable-redirects" => [:bool, false],
+      "x" => [:string, ""],
+
+      # Go: flag.Var(&hs, "H", "") -- a repeatable flag.
+      "H" => [:strings, []]
+    }.freeze
+
+    USAGE = <<~'TEXT'
+      Usage: hey [options...] <url>
+
+      Options:
+        -n  Number of requests to run. Default is 200.
+        -c  Number of workers to run concurrently. Total number of requests cannot
+            be smaller than the concurrency level. Default is 50.
+        -q  Rate limit, in queries per second (QPS) per worker. Default is no rate limit.
+        -z  Duration of application to send requests. When duration is reached,
+            application stops and exits. If duration is specified, n is ignored.
+            Examples: -z 10s -z 3m.
+        -o  Output type. If none provided, a summary is printed.
+            "csv" is the only supported alternative. Dumps the response
+            metrics in comma-separated values format.
+
+        -m  HTTP method, one of GET, POST, PUT, DELETE, HEAD, OPTIONS.
+        -H  Custom HTTP header. You can specify as many as needed by repeating the flag.
+            For example, -H "Accept: text/html" -H "Content-Type: application/xml" .
+        -t  Timeout for each request in seconds. Default is 20, use 0 for infinite.
+        -A  HTTP Accept header.
+        -d  HTTP request body.
+        -D  HTTP request body from file. For example, /home/user/file.txt or ./file.txt.
+        -T  Content-type, defaults to "text/html".
+        -U  User-Agent, defaults to version "hey/0.0.1".
+        -a  Basic authentication, username:password.
+        -x  HTTP Proxy address as host:port.
+        -h2 Enable HTTP/2.
+
+        -host	HTTP Host header.
+
+        -disable-compression  Disable compression.
+        -disable-keepalive    Disable keep-alive, prevents re-use of TCP
+                              connections between different HTTP requests.
+        -disable-redirects    Disable following of HTTP redirects
+        -cpus                 Number of used cpu cores.
+                              (default for current machine is %d cores)
+    TEXT
+
+    # Units accepted by Go's time.ParseDuration.
+    DURATION_UNITS = {
+      "ns" => 1e-9,
+      "us" => 1e-6,
+      "µs" => 1e-6,
+      "ms" => 1e-3,
+      "s" => 1.0,
+      "m" => 60.0,
+      "h" => 3600.0
+    }.freeze
+
+    class << self
+      def usage_text
+        format(USAGE, Etc.nprocessors)
+      end
+
+      # Go: flag.Usage
+      def print_usage
+        $stderr.print(usage_text)
+      end
+
+      def err_and_exit(msg)
+        $stderr.printf("%s", msg)
+        $stderr.printf("\n")
+        exit 1
+      end
+
+      def usage_and_exit(msg)
+        unless msg.nil? || msg.empty?
+          $stderr.printf("%s", msg)
+          $stderr.printf("\n\n")
+        end
+        print_usage
+        $stderr.printf("\n")
+        exit 1
+      end
+
+      def parse_input_with_regexp(input, regx)
+        re = Regexp.new(regx)
+        matches = re.match(input)
+        # Go returns the full match followed by the groups; the array is
+        # shaped the same way here so the indices line up.
+        raise ArgumentError, "could not parse the provided input; input = #{input}" if matches.nil?
+
+        [matches[0], matches[1], matches[2]]
+      end
+
+      # Go: time.ParseDuration
+      def parse_duration(value)
+        raise ArgumentError, "time: invalid duration #{value.inspect}" if value.nil? || value.empty?
+
+        rest = value
+        sign = 1.0
+        if rest.start_with?("-", "+")
+          sign = -1.0 if rest.start_with?("-")
+          rest = rest[1..]
+        end
+        return 0.0 if rest == "0"
+        raise ArgumentError, "time: invalid duration #{value.inspect}" if rest.empty?
+
+        total = 0.0
+        until rest.empty?
+          m = /\A(\d+(?:\.\d*)?|\.\d+)(ns|us|µs|ms|s|m|h)/.match(rest)
+          raise ArgumentError, "time: invalid duration #{value.inspect}" if m.nil?
+
+          total += m[1].to_f * DURATION_UNITS.fetch(m[2])
+          rest = m.post_match
+        end
+
+        sign * total
+      end
+
+      # Go's flag package accepts these spellings for a bool flag's value.
+      def parse_bool(value)
+        case value
+        when "1", "t", "T", "true", "TRUE", "True" then true
+        when "0", "f", "F", "false", "FALSE", "False" then false
+        else raise ArgumentError, "invalid boolean value #{value.inspect}"
+        end
+      end
+
+      def coerce(name, type, value)
+        case type
+        when :string then value
+        when :int then Integer(value, 10)
+        when :float then Float(value)
+        when :duration then parse_duration(value)
+        when :bool then parse_bool(value)
+        end
+      rescue ArgumentError, TypeError => e
+        usage_and_exit("invalid value #{value.inspect} for flag -#{name}: #{e.message}")
+      end
+
+      # Go: flag.Parse(). Returns [values, remaining args].
+      def parse_flags(argv)
+        values = {}
+        # dup so the repeatable -H array is not shared between parses.
+        FLAGS.each { |name, (_type, default)| values[name] = default.dup }
+
+        args = argv.dup
+        until args.empty?
+          arg = args.first
+          break unless arg.start_with?("-") && arg.length > 1
+
+          args.shift
+          break if arg == "--"
+
+          body = arg.sub(/\A--?/, "")
+          name, eq, inline = body.partition("=")
+
+          spec = FLAGS[name]
+          usage_and_exit("flag provided but not defined: -#{name}") if spec.nil?
+
+          type, = spec
+
+          if type == :bool
+            # Go only accepts -name=false, never -name false.
+            value = eq.empty? ? "true" : inline
+          elsif eq.empty?
+            usage_and_exit("flag needs an argument: -#{name}") if args.empty?
+            value = args.shift
+          else
+            value = inline
+          end
+
+          if type == :strings
+            values[name] << value
+          else
+            values[name] = coerce(name, type, value)
+          end
+        end
+
+        [values, args]
+      end
+
+      def main(argv = ARGV)
+        flags, args = parse_flags(argv)
+        usage_and_exit("") if args.length < 1
+
+        hs = flags["H"]
+
+        # Go: runtime.GOMAXPROCS(*cpus). Ruby's async runs on a single thread
+        # per process, so the flag is accepted and has no effect.
+        num = flags["n"]
+        conc = flags["c"]
+        q = flags["q"]
+        dur = flags["z"]
+
+        if dur > 0
+          num = MAX_INT32
+          usage_and_exit("-c cannot be smaller than 1.") if conc <= 0
+        else
+          usage_and_exit("-n and -c cannot be smaller than 1.") if num <= 0 || conc <= 0
+
+          usage_and_exit("-n cannot be less than -c.") if num < conc
+        end
+
+        url = args[0]
+        method = flags["m"].upcase
+
+        # set content-type
+        header = ::Protocol::HTTP::Headers.new
+        header.set("content-type", flags["T"])
+        # set any other additional headers
+        usage_and_exit("Flag '-h' is deprecated, please use '-H' instead.") unless flags["h"].empty?
+        # set any other additional repeatable headers
+        hs.each do |h|
+          begin
+            match = parse_input_with_regexp(h, HEADER_REGEXP)
+          rescue ArgumentError => e
+            usage_and_exit(e.message)
+          end
+          header.set(match[1], match[2])
+        end
+
+        header.set("accept", flags["A"]) unless flags["A"].empty?
+
+        # set basic auth if set
+        username = ""
+        password = ""
+        unless flags["a"].empty?
+          begin
+            match = parse_input_with_regexp(flags["a"], AUTH_REGEXP)
+          rescue ArgumentError => e
+            usage_and_exit(e.message)
+          end
+          username = match[1]
+          password = match[2]
+        end
+
+        body_all = nil
+        body_all = flags["d"].b unless flags["d"].empty?
+        unless flags["D"].empty?
+          begin
+            slurp = File.binread(flags["D"])
+          rescue SystemCallError => e
+            err_and_exit(e.message)
+          end
+          body_all = slurp
+        end
+
+        proxy_url = nil
+        unless flags["x"].empty?
+          begin
+            proxy_url = ::URI.parse(flags["x"])
+          rescue ::URI::Error => e
+            usage_and_exit(e.message)
+          end
+        end
+
+        begin
+          req = Requester::Request.new(method, url)
+        rescue ArgumentError => e
+          usage_and_exit(e.message)
+        end
+        req.content_length = body_all ? body_all.bytesize : 0
+        req.set_basic_auth(username, password) if !username.empty? || !password.empty?
+
+        # set host header if set
+        req.host = flags["host"] unless flags["host"].empty?
+
+        ua = header["user-agent"]
+        if ua.nil? || ua.empty?
+          ua = HEY_UA
+        else
+          ua += " #{HEY_UA}"
+        end
+        header.set("user-agent", ua)
+
+        # set userAgent header if set
+        unless flags["U"].empty?
+          ua = "#{flags['U']} #{HEY_UA}"
+          header.set("user-agent", ua)
+        end
+
+        # NOTE: this mirrors hey.go exactly, including an upstream bug: the
+        # assignment replaces the header set built above, discarding the
+        # Authorization header that SetBasicAuth wrote a few lines earlier. So
+        # -a has no effect, in Go and here alike.
+        req.headers = header
+
+        w = Requester::Work.new(
+          request: req,
+          request_body: body_all,
+          n: num,
+          c: conc,
+          qps: q,
+          timeout: flags["t"],
+          disable_compression: flags["disable-compression"],
+          disable_keep_alives: flags["disable-keepalive"],
+          disable_redirects: flags["disable-redirects"],
+          h2: flags["h2"],
+          proxy_addr: proxy_url,
+          output: flags["o"]
+        )
+        w.init
+
+        # Go: signal.Notify(c, os.Interrupt) plus a goroutine per stop source.
+        # A self-pipe carries the signal into the reactor, because a Ruby trap
+        # handler cannot touch async primitives directly.
+        interrupt_r, interrupt_w = IO.pipe
+        previous = Signal.trap("INT") do
+          begin
+            interrupt_w.write_nonblock("x")
+          rescue StandardError
+            nil
+          end
+        end
+
+        Async do |task|
+          stopper = task.async do
+            interrupt_r.wait_readable
+            w.stop
+          end
+
+          timer =
+            if dur > 0
+              task.async do
+                sleep(dur)
+                w.stop
+              end
+            end
+
+          begin
+            w.perform
+          ensure
+            stopper.stop
+            timer&.stop
+          end
+        end
+      ensure
+        Signal.trap("INT", previous) if previous
+        interrupt_r&.close
+        interrupt_w&.close
+      end
+    end
+  end
+end
+
+Hey::CLI.main if $PROGRAM_NAME == __FILE__

data/lib/hey/requester/now_other.rb

@@ -0,0 +1,29 @@
+# Copyright 2018 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Translated from requester/now_other.go (build tag: !windows).
+
+module Hey
+  module Requester
+    # Process start, captured once, against which every measurement is taken.
+    START_TIME = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    # now returns the elapsed duration, in seconds, using the stdlib monotonic
+    # clock. The Go original returns a time.Duration; durations are plain
+    # Floats of seconds throughout this port.
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) - START_TIME
+    end
+  end
+end

data/lib/hey/requester/now_windows.rb

@@ -0,0 +1,46 @@
+# Copyright 2018 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Translated from requester/now_windows.go.
+#
+# The Go original reaches into kernel32.dll for QueryPerformanceCounter and
+# QueryPerformanceFrequency, because Go's time.Now() on Windows used to have
+# only millisecond resolution -- far too coarse for per-request latencies.
+#
+# CRuby does not have that problem: on Windows, Process::CLOCK_MONOTONIC is
+# itself implemented on top of QueryPerformanceCounter, scaled by
+# QueryPerformanceFrequency. So the correct translation of the Go file is to
+# use the monotonic clock directly rather than to re-bind the DLL through
+# Fiddle. The frequency is read here only so the resolution is reportable.
+
+module Hey
+  module Requester
+    # Ticks per second of the underlying performance counter.
+    QPC_FREQUENCY = begin
+      resolution = Process.clock_getres(Process::CLOCK_MONOTONIC)
+      resolution.positive? ? (1.0 / resolution).round : 0
+    rescue StandardError
+      0
+    end
+
+    # Process start, captured once, against which every measurement is taken.
+    START_TIME = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    # now returns the elapsed duration, in seconds, using the
+    # QueryPerformanceCounter-backed monotonic clock.
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) - START_TIME
+    end
+  end
+end

data/lib/hey/requester/print.rb

@@ -0,0 +1,151 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Translated from requester/print.go.
+#
+# Hey supports two output formats: summary and CSV
+#
+# The summary output presents a number of statistics about the requests in a
+# human-readable format, including:
+# - general statistics: requests/second, total runtime, and average, fastest,
+#   and slowest requests.
+# - a response time histogram.
+# - a percentile latency distribution.
+# - statistics (average, fastest, slowest) on the stages of the requests.
+#
+# The comma-separated CSV format is proceeded by a header, and consists of the
+# following columns:
+# 1. response-time:  Total time taken for request (in seconds)
+# 2. DNS+dialup:     Time taken to establish the TCP connection (in seconds)
+# 3. DNS:            Time taken to do the DNS lookup (in seconds)
+# 4. Request-write:  Time taken to write full request (in seconds)
+# 5. Response-delay: Time taken to first byte received (in seconds)
+# 6. Response-read:  Time taken to read full response (in seconds)
+# 7. status-code:    HTTP status code of the response (e.g. 200)
+# 8. offset:         The time since the start of the benchmark when the
+#                    request was started. (in seconds)
+
+require "erb"
+require "json"
+
+module Hey
+  module Requester
+    # Go's text/template becomes ERB here. The two built-in templates below are
+    # transliterated from the Go originals, whitespace included, so the output
+    # is byte-identical; ERB happens to treat the newline after a `<% %>` tag
+    # the same way Go templates do for this layout.
+    #
+    # As in Go, an -o value other than "" or "csv" is itself treated as a
+    # user-supplied template.
+    def self.new_template(output)
+      output_tmpl =
+        case output
+        when nil, "" then DEFAULT_TMPL
+        when "csv" then CSV_TMPL
+        else output
+        end
+
+      ERB.new(output_tmpl)
+    end
+
+    # The helper functions exposed to templates; the Go original registers
+    # these in a template.FuncMap.
+    module TemplateFunctions
+      def jsonify(value)
+        JSON.generate(value)
+      rescue JSON::GeneratorError
+        value.to_json
+      end
+
+      def format_number(duration)
+        format("%4.4f", duration)
+      end
+
+      def format_number_int(duration)
+        format("%d", duration)
+      end
+
+      def histogram(buckets)
+        max = 0
+        buckets.each do |b|
+          v = b.count
+          max = v if v > max
+        end
+
+        res = +""
+        buckets.each_index do |i|
+          # Normalize bar lengths.
+          bar_len = 0
+          bar_len = (buckets[i].count * 40 + max / 2) / max if max > 0
+          res << format("  %4.3f [%s]\t|%s\n", buckets[i].mark, buckets[i].count,
+                        BAR_CHAR * bar_len)
+        end
+        res
+      end
+    end
+
+    # The object a template is evaluated against. It exposes the report
+    # snapshot as `r` (Go's dot) alongside the helper functions.
+    class TemplateContext
+      include TemplateFunctions
+
+      attr_reader :r
+
+      def initialize(report)
+        @r = report
+      end
+
+      def render(template)
+        template.result(binding)
+      end
+    end
+
+    DEFAULT_TMPL = <<~'TMPL'
+
+      Summary:
+        Total:	<%= format_number(r.total) %> secs
+        Slowest:	<%= format_number(r.slowest) %> secs
+        Fastest:	<%= format_number(r.fastest) %> secs
+        Average:	<%= format_number(r.average) %> secs
+        Requests/sec:	<%= format_number(r.rps) %>
+        <% if r.size_total > 0 %>
+        Total data:	<%= r.size_total %> bytes
+        Size/request:	<%= r.size_req %> bytes<% end %>
+
+      Response time histogram:
+      <%= histogram(r.histogram) %>
+
+      Latency distribution:<% r.latency_distribution.each do |d| %>
+        <%= d.percentage %>%% in <%= format_number(d.latency) %> secs<% end %>
+
+      Details (average, fastest, slowest):
+        DNS+dialup:	<%= format_number(r.avg_conn) %> secs, <%= format_number(r.conn_max) %> secs, <%= format_number(r.conn_min) %> secs
+        DNS-lookup:	<%= format_number(r.avg_dns) %> secs, <%= format_number(r.dns_max) %> secs, <%= format_number(r.dns_min) %> secs
+        req write:	<%= format_number(r.avg_req) %> secs, <%= format_number(r.req_max) %> secs, <%= format_number(r.req_min) %> secs
+        resp wait:	<%= format_number(r.avg_delay) %> secs, <%= format_number(r.delay_max) %> secs, <%= format_number(r.delay_min) %> secs
+        resp read:	<%= format_number(r.avg_res) %> secs, <%= format_number(r.res_max) %> secs, <%= format_number(r.res_min) %> secs
+
+      Status code distribution:<% r.status_code_dist.sort.each do |code, num| %>
+        [<%= code %>]	<%= num %> responses<% end %>
+
+      <% if r.error_dist.length > 0 %>Error distribution:<% r.error_dist.sort.each do |err, num| %>
+        [<%= num %>]	<%= err %><% end %><% end %>
+    TMPL
+
+    CSV_TMPL = <<~'TMPL'.chomp
+      response-time,DNS+dialup,DNS,Request-write,Response-delay,Response-read,status-code,offset<% r.lats.each_index do |i| %>
+      <%= format_number(r.lats[i]) %>,<%= format_number(r.conn_lats[i]) %>,<%= format_number(r.dns_lats[i]) %>,<%= format_number(r.req_lats[i]) %>,<%= format_number(r.delay_lats[i]) %>,<%= format_number(r.res_lats[i]) %>,<%= format_number_int(r.status_codes[i]) %>,<%= format_number(r.offsets[i]) %><% end %>
+    TMPL
+  end
+end