hey.rb 1.0.0

data/lib/hey/requester/report.rb

@@ -0,0 +1,312 @@
+# 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/report.go.
+
+require "async/queue"
+
+module Hey
+  module Requester
+    BAR_CHAR = "■"
+
+    # We report for max 1M results.
+    MAX_RES = 1_000_000
+
+    # Go's exported LatencyDistribution struct.
+    LatencyDistribution = Struct.new(:percentage, :latency)
+
+    # Go's exported Bucket struct.
+    Bucket = Struct.new(:mark, :count, :frequency)
+
+    # Report is the snapshot handed to a template. It corresponds to Go's
+    # exported `Report` struct; the unexported `report` is `Reporter` below,
+    # since Ruby cannot distinguish the two by case alone.
+    class Report
+      attr_accessor :avg_total, :fastest, :slowest, :average, :rps,
+                    :avg_conn, :avg_dns, :avg_req, :avg_res, :avg_delay,
+                    :conn_max, :conn_min, :dns_max, :dns_min,
+                    :req_max, :req_min, :res_max, :res_min,
+                    :delay_max, :delay_min,
+                    :lats, :conn_lats, :dns_lats, :req_lats, :res_lats,
+                    :delay_lats, :offsets, :status_codes,
+                    :total, :error_dist, :status_code_dist,
+                    :size_total, :size_req, :num_res,
+                    :latency_distribution, :histogram
+
+      # Mirrors Go's zero values, so a snapshot taken when nothing succeeded
+      # still renders rather than blowing up on nil.
+      def initialize
+        @avg_total = 0.0
+        @fastest = 0.0
+        @slowest = 0.0
+        @average = 0.0
+        @rps = 0.0
+
+        @avg_conn = 0.0
+        @avg_dns = 0.0
+        @avg_req = 0.0
+        @avg_res = 0.0
+        @avg_delay = 0.0
+        @conn_max = 0.0
+        @conn_min = 0.0
+        @dns_max = 0.0
+        @dns_min = 0.0
+        @req_max = 0.0
+        @req_min = 0.0
+        @res_max = 0.0
+        @res_min = 0.0
+        @delay_max = 0.0
+        @delay_min = 0.0
+
+        @lats = []
+        @conn_lats = []
+        @dns_lats = []
+        @req_lats = []
+        @res_lats = []
+        @delay_lats = []
+        @offsets = []
+        @status_codes = []
+
+        @total = 0.0
+
+        @error_dist = {}
+        @status_code_dist = {}
+        @size_total = 0
+        @size_req = 0
+        @num_res = 0
+
+        @latency_distribution = []
+        @histogram = []
+      end
+    end
+
+    # Reporter is Go's unexported `report`: it drains the result queue while
+    # the workers run, then renders the summary.
+    class Reporter
+      attr_reader :done
+
+      def initialize(writer, results, output, n)
+        # Go preallocates the slices to min(n, maxRes); Ruby arrays grow on
+        # demand, so the capacity is recorded only for parity.
+        @cap = [n, MAX_RES].min
+
+        @output = output
+        @results = results
+        @done = Async::LimitedQueue.new(1)
+        @error_dist = {}
+        @w = writer
+
+        @avg_total = 0.0
+        @fastest = 0.0
+        @slowest = 0.0
+        @average = 0.0
+        @rps = 0.0
+
+        @avg_conn = 0.0
+        @avg_dns = 0.0
+        @avg_req = 0.0
+        @avg_res = 0.0
+        @avg_delay = 0.0
+
+        @conn_lats = []
+        @dns_lats = []
+        @req_lats = []
+        @res_lats = []
+        @delay_lats = []
+        @offsets = []
+        @status_codes = []
+        @lats = []
+
+        @total = 0.0
+        @size_total = 0
+        @num_res = 0
+      end
+
+      # Go: runReporter(r). Loops until the queue is closed.
+      def run
+        @results.each do |res|
+          @num_res += 1
+          if res.err
+            key = res.err
+            @error_dist[key] = @error_dist.fetch(key, 0) + 1
+          else
+            @avg_total += res.duration
+            @avg_conn += res.conn_duration
+            @avg_delay += res.delay_duration
+            @avg_dns += res.dns_duration
+            @avg_req += res.req_duration
+            @avg_res += res.res_duration
+            if @res_lats.length < MAX_RES
+              @lats << res.duration
+              @conn_lats << res.conn_duration
+              @dns_lats << res.dns_duration
+              @req_lats << res.req_duration
+              @delay_lats << res.delay_duration
+              @res_lats << res.res_duration
+              @status_codes << res.status_code
+              @offsets << res.offset
+            end
+            @size_total += res.content_length if res.content_length > 0
+          end
+        end
+
+        # Signal reporter is done.
+        @done.enqueue(true)
+      end
+
+      def finalize(total)
+        @total = total
+        @rps = @num_res / @total
+        @average = @avg_total / @lats.length
+        @avg_conn = @avg_conn / @lats.length
+        @avg_delay = @avg_delay / @lats.length
+        @avg_dns = @avg_dns / @lats.length
+        @avg_req = @avg_req / @lats.length
+        @avg_res = @avg_res / @lats.length
+        print_report
+      end
+
+      def print_report
+        begin
+          buf = TemplateContext.new(snapshot).render(Requester.new_template(@output))
+        rescue StandardError => e
+          # Go logs and returns without printing anything further.
+          $stderr.puts("error: #{e.message}")
+          return
+        end
+        printf("%s", buf)
+
+        printf("\n")
+      end
+
+      def printf(fmt, *args)
+        @w.write(format(fmt, *args))
+      end
+
+      def snapshot
+        snapshot = Report.new
+        snapshot.avg_total = @avg_total
+        snapshot.average = @average
+        snapshot.rps = @rps
+        snapshot.size_total = @size_total
+        snapshot.avg_conn = @avg_conn
+        snapshot.avg_dns = @avg_dns
+        snapshot.avg_req = @avg_req
+        snapshot.avg_res = @avg_res
+        snapshot.avg_delay = @avg_delay
+        snapshot.total = @total
+        snapshot.error_dist = @error_dist
+        snapshot.num_res = @num_res
+
+        return snapshot if @lats.empty?
+
+        snapshot.size_req = @size_total / @lats.length
+
+        # Copy before sorting: the snapshot's series must stay in the order
+        # the requests completed (the CSV output depends on it), while the
+        # percentile and histogram maths below sort in place, as Go does.
+        snapshot.lats = @lats.dup
+        snapshot.conn_lats = @conn_lats.dup
+        snapshot.dns_lats = @dns_lats.dup
+        snapshot.req_lats = @req_lats.dup
+        snapshot.res_lats = @res_lats.dup
+        snapshot.delay_lats = @delay_lats.dup
+        snapshot.status_codes = @status_codes.dup
+        snapshot.offsets = @offsets.dup
+
+        @lats.sort!
+        @fastest = @lats[0]
+        @slowest = @lats[@lats.length - 1]
+
+        @conn_lats.sort!
+        @dns_lats.sort!
+        @req_lats.sort!
+        @res_lats.sort!
+        @delay_lats.sort!
+
+        snapshot.histogram = histogram
+        snapshot.latency_distribution = latencies
+
+        snapshot.fastest = @fastest
+        snapshot.slowest = @slowest
+        snapshot.conn_max = @conn_lats[0]
+        snapshot.conn_min = @conn_lats[@conn_lats.length - 1]
+        snapshot.dns_max = @dns_lats[0]
+        snapshot.dns_min = @dns_lats[@dns_lats.length - 1]
+        snapshot.req_max = @req_lats[0]
+        snapshot.req_min = @req_lats[@req_lats.length - 1]
+        snapshot.delay_max = @delay_lats[0]
+        snapshot.delay_min = @delay_lats[@delay_lats.length - 1]
+        snapshot.res_max = @res_lats[0]
+        snapshot.res_min = @res_lats[@res_lats.length - 1]
+
+        status_code_dist = {}
+        snapshot.status_codes.each do |status_code|
+          status_code_dist[status_code] = status_code_dist.fetch(status_code, 0) + 1
+        end
+        snapshot.status_code_dist = status_code_dist
+
+        snapshot
+      end
+
+      def latencies
+        pctls = [10, 25, 50, 75, 90, 95, 99]
+        data = Array.new(pctls.length, 0.0)
+        j = 0
+        i = 0
+        while i < @lats.length && j < pctls.length
+          current = i * 100 / @lats.length
+          if current >= pctls[j]
+            data[j] = @lats[i]
+            j += 1
+          end
+          i += 1
+        end
+        res = Array.new(pctls.length) { LatencyDistribution.new(0, 0.0) }
+        pctls.each_index do |k|
+          res[k] = LatencyDistribution.new(pctls[k], data[k]) if data[k] > 0
+        end
+        res
+      end
+
+      def histogram
+        bc = 10
+        buckets = Array.new(bc + 1, 0.0)
+        counts = Array.new(bc + 1, 0)
+        bs = (@slowest - @fastest) / bc
+        bc.times do |i|
+          buckets[i] = @fastest + bs * i
+        end
+        buckets[bc] = @slowest
+        bi = 0
+        max = 0
+        i = 0
+        while i < @lats.length
+          if @lats[i] <= buckets[bi]
+            i += 1
+            counts[bi] += 1
+            max = counts[bi] if max < counts[bi]
+          elsif bi < buckets.length - 1
+            bi += 1
+          end
+        end
+        res = Array.new(buckets.length)
+        buckets.each_index do |k|
+          res[k] = Bucket.new(buckets[k], counts[k], counts[k].to_f / @lats.length)
+        end
+        res
+      end
+    end
+  end
+end