hey.rb 1.0.0

data/lib/hey/requester.rb

@@ -0,0 +1,533 @@
+# 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/requester.go.
+#
+# Module Hey::Requester provides commands to run load tests and display
+# results. Go's goroutines/channels become Async tasks and queues; net/http
+# becomes async-http.
+
+require "base64"
+require "uri"
+require "socket"
+
+require "async"
+require "async/barrier"
+require "async/queue"
+require "async/http"
+require "async/http/endpoint"
+require "async/http/proxy"
+require "async/http/middleware/location_redirector"
+
+require "io/endpoint/host_endpoint"
+
+require "protocol/http"
+require "protocol/http/accept_encoding"
+require "protocol/http/body/buffered"
+
+# Go selects now() with a build tag; Ruby selects it at require time.
+if RUBY_PLATFORM.match?(/mswin|mingw|cygwin/)
+  require_relative "requester/now_windows"
+else
+  require_relative "requester/now_other"
+end
+
+require_relative "requester/report"
+require_relative "requester/print"
+
+module Hey
+  module Requester
+    # Max size of the buffer of result queue.
+    MAX_RESULT = 1_000_000
+    MAX_IDLE_CONN = 500
+
+    # Go's unexported `result` struct.
+    Result = Struct.new(
+      :err,            # error message, or nil
+      :status_code,
+      :offset,
+      :duration,
+      :conn_duration,  # connection setup(DNS lookup + Dial up) duration
+      :dns_duration,   # dns lookup duration
+      :req_duration,   # request "write" duration
+      :res_duration,   # response "read" duration
+      :delay_duration, # delay between response and request
+      :content_length,
+      keyword_init: true
+    )
+
+    # Trace stands in for Go's httptrace.ClientTrace. net/http exposes
+    # per-phase callbacks; async-http has no equivalent hook, so the phases are
+    # recovered by instrumenting the endpoint (connect/DNS) and the request
+    # body (write completion), with the trace for the request in flight held in
+    # fiber storage.
+    class Trace
+      attr_accessor :dns_duration, :conn_duration, :conn_done_at, :req_done_at
+
+      def initialize
+        @dns_duration = 0.0
+        @conn_duration = 0.0
+        @conn_done_at = nil
+        @req_done_at = nil
+      end
+    end
+
+    # The trace belonging to the request this fiber is performing. Fiber
+    # storage is inherited by child fibers, so the connection pool's resource
+    # block -- which runs on behalf of the acquiring worker -- sees it too.
+    def self.current_trace
+      Fiber[:hey_trace]
+    end
+
+    def self.current_trace=(trace)
+      Fiber[:hey_trace] = trace
+    end
+
+    # A host endpoint that times name resolution, standing in for Go's
+    # DNSStart/DNSDone callbacks. The connect loop mirrors
+    # IO::Endpoint::HostEndpoint#connect; only the timing is added.
+    class TimingHostEndpoint < ::IO::Endpoint::HostEndpoint
+      def connect(wrapper = self.wrapper, &block)
+        trace = Requester.current_trace
+        return super if trace.nil?
+
+        last_error = nil
+        resolved = false
+        dns_start = Requester.now
+
+        ::Addrinfo.foreach(*@specification) do |address|
+          unless resolved
+            resolved = true
+            trace.dns_duration = Requester.now - dns_start
+          end
+
+          begin
+            socket = wrapper.connect(address, **@options)
+          rescue => last_error
+            # Try again if possible, otherwise raise...
+          else
+            return socket unless block_given?
+
+            begin
+              return yield(socket)
+            ensure
+              socket.close
+            end
+          end
+        end
+
+        raise last_error
+      end
+    end
+
+    # An endpoint that times connection establishment, standing in for Go's
+    # GetConn/GotConn callbacks. Timing at this level rather than inside the
+    # host endpoint means the TLS handshake is included, which is what
+    # net/http reports as the connection duration.
+    class TimingEndpoint < Async::HTTP::Endpoint
+      def connect(&block)
+        trace = Requester.current_trace
+        return super if trace.nil?
+
+        conn_start = Requester.now
+        begin
+          super
+        ensure
+          done = Requester.now
+          trace.conn_duration = done - conn_start
+          trace.conn_done_at = done
+        end
+      end
+
+      def tcp_endpoint
+        TimingHostEndpoint.new(
+          [self.hostname, self.port, nil, ::Socket::SOCK_STREAM], **tcp_options
+        )
+      end
+    end
+
+    # A request body that records when the protocol finished writing it,
+    # standing in for Go's WroteRequest callback.
+    class TimingBody < ::Protocol::HTTP::Body::Buffered
+      def initialize(chunks, trace)
+        super(chunks)
+        @trace = trace
+      end
+
+      def read
+        chunk = super
+        if chunk.nil? && @trace && @trace.req_done_at.nil?
+          @trace.req_done_at = Requester.now
+        end
+        chunk
+      end
+    end
+
+    # Request is the template a benchmark run is built from. It mirrors the
+    # parts of net/http.Request that hey actually sets; each request sent is a
+    # fresh Protocol::HTTP::Request cloned from it.
+    class Request
+      attr_accessor :method, :url, :headers, :host, :content_length, :body
+
+      # Go: http.NewRequest(method, url, body)
+      def initialize(method, url, body = nil)
+        @method = method
+        @url = url.is_a?(::URI::Generic) ? url : ::URI.parse(url.to_s)
+        raise ArgumentError, "URL must be absolute (include scheme, host): #{url}" unless @url.absolute?
+
+        @headers = ::Protocol::HTTP::Headers.new
+        @host = nil
+        @content_length = 0
+        @body = body
+      end
+
+      # Go: req.SetBasicAuth(username, password)
+      def set_basic_auth(username, password)
+        credentials = ::Base64.strict_encode64("#{username}:#{password}")
+        @headers["authorization"] = "Basic #{credentials}"
+      end
+
+      # The authority to send, honouring an explicit Host override.
+      def authority
+        return @host if @host && !@host.empty?
+
+        if @url.port && @url.port != @url.default_port
+          "#{@url.hostname}:#{@url.port}"
+        else
+          @url.hostname
+        end
+      end
+
+      def path
+        path = @url.path
+        path = "/" if path.nil? || path.empty?
+        path += "?#{@url.query}" if @url.query
+        path
+      end
+    end
+
+    # cloneRequest returns a clone of the provided request, as a wire-ready
+    # Protocol::HTTP::Request. A fresh one is built per request because a
+    # protocol-http body is consumed as it is written.
+    def self.clone_request(r, body, trace = nil)
+      headers = ::Protocol::HTTP::Headers.new(r.headers.fields.dup)
+
+      request_body =
+        if body && !body.empty?
+          TimingBody.new([body.dup], trace)
+        end
+
+      ::Protocol::HTTP::Request.new(
+        r.url.scheme, r.authority, r.method, r.path, nil, headers, request_body
+      )
+    end
+
+    class Work
+      # Request is the request to be made.
+      attr_accessor :request
+
+      attr_accessor :request_body
+
+      # RequestFunc is a callable to generate requests. If it is nil, then
+      # Request and RequestBody are cloned for each request.
+      attr_accessor :request_func
+
+      # N is the total number of requests to make.
+      attr_accessor :n
+
+      # C is the concurrency level, the number of concurrent workers to run.
+      attr_accessor :c
+
+      # H2 is an option to make HTTP/2 requests
+      attr_accessor :h2
+
+      # Timeout in seconds.
+      attr_accessor :timeout
+
+      # QPS is the rate limit in queries per second.
+      attr_accessor :qps
+
+      # DisableCompression is an option to disable compression in response
+      attr_accessor :disable_compression
+
+      # DisableKeepAlives is an option to prevent re-use of TCP connections
+      # between different HTTP requests
+      attr_accessor :disable_keep_alives
+
+      # DisableRedirects is an option to prevent the following of HTTP
+      # redirects
+      attr_accessor :disable_redirects
+
+      # Output represents the output type. If "csv" is provided, the output
+      # will be dumped as a csv stream.
+      attr_accessor :output
+
+      # ProxyAddr is the address of the HTTP proxy server. Optional.
+      attr_accessor :proxy_addr
+
+      # Writer is where results will be written. If nil, results are written
+      # to stdout.
+      attr_accessor :writer
+
+      def initialize(request: nil, request_body: nil, request_func: nil,
+                     n: 0, c: 0, h2: false, timeout: 0, qps: 0.0,
+                     disable_compression: false, disable_keep_alives: false,
+                     disable_redirects: false, output: "", proxy_addr: nil,
+                     writer: nil)
+        @request = request
+        @request_body = request_body
+        @request_func = request_func
+        @n = n
+        @c = c
+        @h2 = h2
+        @timeout = timeout
+        @qps = qps
+        @disable_compression = disable_compression
+        @disable_keep_alives = disable_keep_alives
+        @disable_redirects = disable_redirects
+        @output = output
+        @proxy_addr = proxy_addr
+        @writer = writer
+
+        @init_once = false
+        @results = nil
+        @stop_queue = nil
+        @start = 0.0
+        @report = nil
+      end
+
+      # Go: b.writer()
+      def writer_io
+        return $stdout if @writer.nil?
+
+        @writer
+      end
+
+      # Init initializes internal data-structures.
+      def init
+        return if @init_once
+
+        @init_once = true
+        @results = Async::LimitedQueue.new([@c * 1000, MAX_RESULT].min)
+        @stop_queue = Async::LimitedQueue.new(@c)
+      end
+
+      # Run makes all the requests, prints the summary. It blocks until all
+      # work is done. It can be called inside or outside a reactor.
+      def run
+        Sync { perform }
+      end
+
+      def perform
+        init
+        @start = Requester.now
+        @report = Reporter.new(writer_io, @results, @output, @n)
+        # Run the reporter first, it polls the result queue until it is closed.
+        reporter = Async { @report.run }
+        run_workers
+        finish
+        reporter.wait
+      end
+
+      def stop
+        # Send stop signal so that workers can stop gracefully.
+        @c.times { @stop_queue.enqueue(nil) }
+      end
+
+      def finish
+        @results.close
+        total = Requester.now - @start
+        # Wait until the reporter is done.
+        @report.done.dequeue
+        @report.finalize(total)
+      end
+
+      def make_request(client)
+        s = Requester.now
+        size = 0
+        code = 0
+        res_start = 0.0
+        err = nil
+
+        trace = Trace.new
+        Requester.current_trace = trace
+
+        req =
+          if @request_func
+            @request_func.call
+          else
+            Requester.clone_request(@request, @request_body, trace)
+          end
+
+        # Go's transport adds this; async-http leaves connection reuse to the
+        # pool, so the header is what turns keep-alive off.
+        req.headers["connection"] = "close" if @disable_keep_alives
+
+        call_start = Requester.now
+        begin
+          with_timeout do
+            response = client.call(req)
+            begin
+              size = response.body&.length || -1
+              code = response.status
+              res_start = Requester.now
+              # Go: io.Copy(io.Discard, resp.Body)
+              response.body&.each { |_chunk| }
+            ensure
+              response.close
+            end
+          end
+        rescue StandardError, Async::TimeoutError => e
+          err = error_message(req, e)
+        end
+
+        t = Requester.now
+        res_duration = t - res_start
+        finish = t - s
+
+        # Go reads reqStart at GotConn and reqDuration at WroteRequest.
+        req_start = trace.conn_done_at || call_start
+        req_done = trace.req_done_at || req_start
+        req_duration = req_done - req_start
+        delay_duration = res_start > 0 ? res_start - req_done : 0.0
+
+        @results.enqueue(Result.new(
+          offset: s,
+          status_code: code,
+          duration: finish,
+          err: err,
+          content_length: size,
+          conn_duration: trace.conn_duration,
+          dns_duration: trace.dns_duration,
+          req_duration: req_duration,
+          res_duration: res_duration,
+          delay_duration: delay_duration
+        ))
+      ensure
+        Requester.current_trace = nil
+      end
+
+      def run_worker(client, n)
+        # Go uses a time.Ticker; the deadline is tracked explicitly here, and
+        # a missed tick is dropped rather than queued, as the ticker does.
+        interval = nil
+        next_tick = nil
+        if @qps > 0
+          interval = (1e6 / @qps).to_i / 1e6
+          next_tick = Requester.now + interval
+        end
+
+        n.times do
+          # Check if application is stopped. Do not send into a closed queue.
+          unless @stop_queue.empty?
+            @stop_queue.dequeue
+            return
+          end
+
+          if interval
+            delay = next_tick - Requester.now
+            if delay > 0
+              sleep(delay)
+              next_tick += interval
+            else
+              next_tick = Requester.now + interval
+            end
+          end
+
+          make_request(client)
+        end
+      end
+
+      def run_workers
+        endpoint = build_endpoint
+        client = Async::HTTP::Client.new(
+          endpoint,
+          protocol: endpoint.protocol,
+          # Go caps idle connections per host at min(C, maxIdleConn); the pool
+          # limit here caps live connections, so it tracks the concurrency.
+          limit: [@c, 1].max
+        )
+        app = wrap(client)
+
+        barrier = Async::Barrier.new
+        # Ignore the case where n % c != 0.
+        @c.times do
+          barrier.async do
+            run_worker(app, @n / @c)
+          end
+        end
+        barrier.wait
+      ensure
+        barrier&.stop
+        client&.close
+        @proxy_client&.close
+      end
+
+      private
+
+      # Go configures http.Transport; the equivalents here are the endpoint
+      # (TLS, protocol) and a middleware stack (redirects, compression).
+      def build_endpoint
+        protocol = @h2 ? Async::HTTP::Protocol::HTTP2 : Async::HTTP::Protocol::HTTP11
+
+        endpoint = TimingEndpoint.new(
+          @request.url,
+          protocol: protocol,
+          # Go: tls.Config{InsecureSkipVerify: true}
+          ssl_context: insecure_ssl_context(protocol)
+        )
+
+        if @proxy_addr
+          @proxy_client = Async::HTTP::Client.new(Async::HTTP::Endpoint[@proxy_addr])
+          # Tunnels via CONNECT; the connection is the proxy's, so the
+          # DNS/connect timings above do not apply to it.
+          endpoint = Async::HTTP::Proxy.endpoint(@proxy_client, endpoint)
+        end
+
+        endpoint
+      end
+
+      def insecure_ssl_context(protocol)
+        context = OpenSSL::SSL::SSLContext.new
+        context.alpn_protocols = protocol.names if protocol.respond_to?(:names)
+        context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        context
+      end
+
+      def wrap(client)
+        app = client
+        # net/http follows up to 10 redirects unless told not to; async-http
+        # follows none unless asked, so the sense of the flag is inverted.
+        app = Async::HTTP::Middleware::LocationRedirector.new(app, 10) unless @disable_redirects
+        # net/http requests gzip by default; async-http does not.
+        app = ::Protocol::HTTP::AcceptEncoding.new(app) unless @disable_compression
+        app
+      end
+
+      # Go: http.Client{Timeout: ...}, where 0 means no timeout.
+      def with_timeout(&block)
+        return block.call unless @timeout.to_i > 0
+
+        Async::Task.current.with_timeout(@timeout, &block)
+      end
+
+      # Shaped after net/http's error strings, e.g.
+      #   Get "http://host/": dial tcp ...: connection refused
+      def error_message(req, error)
+        verb = req.method.to_s.capitalize
+        "#{verb} \"#{@request.url}\": #{error.message}"
+      end
+    end
+  end
+end

data/lib/hey/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Hey
+  VERSION = "1.0.0"
+end

data/lib/hey.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "hey/version"
+require_relative "hey/requester"
+
+# An HTTP load generator: a Ruby port of rakyll/hey, built on async-http.
+module Hey
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: hey.rb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Nathan Kidd
+bindir: exe
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.46'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.46'
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.105'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.105'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: erb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: io-endpoint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.72'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.72'
+- !ruby/object:Gem::Dependency
+  name: gem_kit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: 'hey sends load to a web application and reports a latency histogram,
+  percentile distribution and per-phase timings. A file-by-file Ruby port of rakyll/hey:
+  goroutines and channels become Async tasks and queues, and net/http becomes async-http.
+  The gem is named hey.rb because hey was taken.'
+email:
+- nathankidd@hey.com
+executables:
+- hey
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- NOTICE
+- README.md
+- exe/hey
+- lib/hey.rb
+- lib/hey/requester.rb
+- lib/hey/requester/now_other.rb
+- lib/hey/requester/now_windows.rb
+- lib/hey/requester/print.rb
+- lib/hey/requester/report.rb
+- lib/hey/version.rb
+homepage: https://github.com/n-at-han-k/hey.rb
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://github.com/n-at-han-k/hey.rb
+  changelog_uri: https://github.com/n-at-han-k/hey.rb/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: An HTTP load generator. A Ruby port of rakyll/hey, built on async-http.
+test_files: []