shiba 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b4f464acdc517169589f38206c835a77b160ae7fe5293f3c1c96bef2a736911
-  data.tar.gz: ab4af7bcb0e55e042372c5579f8829f751c76efbb0ac3c0b17ae1fd97547362b
+  metadata.gz: 4c19ddf8bb56062725650ff02bede1ee4863ec0de0c6ab56ca420496eb35cc5b
+  data.tar.gz: 8ddfbc998e013cae6ecb5fc0b3ad05e7e76c2f086317cca14699099ffbdb7064
 SHA512:
-  metadata.gz: 0c2809905f330b3e1e8874297e66d84c24a938fe4c532b29cfe87b88b8983a1d6700a03f60382e190fe171c5f7cc90ad81d0ca4aa2d1770cf2eb0afdd10621f5
-  data.tar.gz: 36e6639d67a0b333c8faac40c45d092c7fe13b5acc0053066e1e68c0b3f9f70377fc19bb2d1fa0e724fd9163ea913b778bdf07ac8fbbd15d073678c31ac28b16
+  metadata.gz: e73819cb77cdc7efdaf521d76a64a2dc0ad3e27d97260cc45c2e4c59ac021fac6d12ad501fac2c299455963e6cd6c7650366e91ec6f067c873a1ff97e8d397c4
+  data.tar.gz: 302a916584abf9fd32c210498639ab63739d953b569d5b57313bcde0baa563d5fbf66bba1dcff28f16282c3fb8f9e18b56d6187d689f77a378bafc13323a7f49

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiba (0.4.0)
+    shiba (0.5.0)
       activesupport
       mysql2
       pg

data/bin/dump_stats

@@ -10,8 +10,10 @@ parser = Shiba::Configure.make_options_parser(options, only_basics: true)
 parser.banner = "Dump database statistics into yaml file."
 parser.parse!
 
-Shiba.configure(options) do |errmsg|
-  $stderr.puts(errmsg)
+begin
+  Shiba.configure(options)
+rescue Shiba::ConfigError => e
+  $stderr.puts(e.message)
   $stderr.puts(parser.help)
   exit 1
 end

data/bin/explain

@@ -25,8 +25,10 @@ end
 file = options.delete("file")
 file = File.open(file, "r") if file
 
-Shiba.configure(options) do |err_msg|
-  $stderr.puts(err_msg)
+begin
+  Shiba.configure(options)
+rescue Shiba::ConfigError => e
+  $stderr.puts(e.message)
   $stderr.puts(parser)
   exit 2
 end
@@ -50,7 +52,7 @@ end
 table_stats = Shiba::TableStats.new(Shiba.index_config, Shiba.connection, {})
 queries = Shiba::Analyzer.analyze(file, json, table_stats, options)
 
-problems = queries.select { |q| q[:cost] && q[:cost] > 100 }
+problems = queries.select { |q| q[:severity] && q[:severity] != 'none' }
 
 if problems.any?
   query_word = problems.size == 1 ? 'query' : 'queries'

data/lib/shiba.rb

@@ -7,16 +7,17 @@ require "byebug" if ENV['SHIBA_DEBUG']
 
 module Shiba
   class Error < StandardError; end
+  class ConfigError < StandardError; end
 
-  def self.configure(options, &block)
-    configure_mysql_defaults(options, &block)
+  def self.configure(options)
+    configure_mysql_defaults(options)
 
     @connection_hash = options.select { |k, v| [ 'default_file', 'default_group', 'server', 'username', 'database', 'host', 'password', 'port'].include?(k) }
     @main_config = Configure.read_config_file(options['config'], "config/shiba.yml")
     @index_config = Configure.read_config_file(options['index'], "config/shiba_index.yml")
   end
 
-  def self.configure_mysql_defaults(options, &block)
+  def self.configure_mysql_defaults(options)
     option_path = Shiba::Configure.mysql_config_path
 
     if option_path
@@ -40,11 +41,11 @@ module Shiba
     end
 
     if !options["username"] && !option_file.include?('user')
-      yield('Required: --username')
+      raise Shiba::ConfigError.new('Required: --username')
     end
 
     if !options["database"] && !option_file.include?('database')
-      yield('Required: --database')
+      raise Shiba::ConfigError.new('Required: --database')
     end
   end
 

data/lib/shiba/checker.rb

@@ -8,8 +8,6 @@ module Shiba
   # Given an explain log and a diff, returns any explain logs
   # that appear to be caused by the diff.
   class Checker
-    MAGIC_COST = 100
-
     Result = Struct.new(:status, :message, :problems)
 
     attr_reader :options
@@ -35,7 +33,7 @@ module Shiba
       end
 
       explains = select_lines_with_changed_files(log)
-      problems = explains.select { |explain| explain["cost"] && explain["cost"] > MAGIC_COST }
+      problems = explains.select { |explain| explain["severity"] && explain["severity"] != 'none' }
 
 
       if options["verbose"]
@@ -164,4 +162,4 @@ module Shiba
       end
     end
   end
-end
+end

data/lib/shiba/explain.rb

@@ -8,14 +8,21 @@ require 'shiba/explain/postgres_explain'
 
 module Shiba
   class Explain
+    COST_PER_ROW_READ = 2.5e-07 # TBD; data size would be better
+    COST_PER_ROW_SORT = 1.0e-07
+    COST_PER_ROW_RETURNED = 3.0e-05
+
     include CheckSupport
     extend CheckSupport::ClassMethods
-    def initialize(sql, stats, backtrace, options = {})
-      @sql = sql
-      @backtrace = backtrace
+
+    def initialize(query, stats, options = {})
+      @query = query
+      @sql = query.sql
+
+      @backtrace = query.backtrace
 
       if options[:force_key]
-         @sql = @sql.sub(/(FROM\s*\S+)/i, '\1' + " FORCE INDEX(`#{options[:force_key]}`)")
+        @sql = @sql.sub(/(FROM\s*\S+)/i, '\1' + " FORCE INDEX(`#{options[:force_key]}`)")
       end
 
       @options = options
@@ -35,7 +42,8 @@ module Shiba
     def as_json
       {
         sql: @sql,
-        table: get_table,
+        table: @query.from_table,
+        md5: @query.md5,
         messages: @result.messages,
         cost: @result.cost,
         severity: severity,
@@ -52,17 +60,6 @@ module Shiba
       @result.cost
     end
 
-    def get_table
-      @sql =~ /\s+from\s*([^\s,]+)/i
-      table = $1
-      return nil unless table
-
-      table = table.downcase
-      table.gsub!('`', '')
-      table.gsub!(/.*\.(.*)/, '\1')
-      table
-    end
-
     def first
       @rows.first
     end
@@ -77,30 +74,17 @@ module Shiba
 
     def severity
       case @result.cost
-      when 0..100
+      when 0..0.01
+        "none"
+      when 0.01..0.10
         "low"
-      when 100..1000
+      when 0.1..1.0
         "medium"
-      when 1000..1_000_000_000
-        "high"
-      end
-    end
-
-    def limit
-      if @sql =~ /limit\s*(\d+)\s*(offset \d+)?$/i
-        $1.to_i
       else
-        nil
+        "high"
       end
     end
 
-    def aggregation?
-      @sql =~ /select\s*(.*?)from/i
-      select_fields = $1
-      select_fields =~ /(min|max|avg|count|sum|group_concat)\s*\(.*?\)/i
-    end
-
-
     def ignore?
       !!ignore_line_and_backtrace_line
     end
@@ -124,16 +108,16 @@ module Shiba
     def check_query_is_ignored
       if ignore?
         @result.messages << { tag: "ignored" }
-        @cost = 0
+        @result.cost = 0
       end
     end
 
     check :check_no_matching_row_in_const_table
     def check_no_matching_row_in_const_table
       if no_matching_row_in_const_table?
-        @result.messages << { tag: "access_type_const", table:  get_table }
+        @result.messages << { tag: "access_type_const", table: @query.from_table }
         first['key'] = 'PRIMARY'
-        @cost = 1
+        @result.cost = 0
       end
     end
 
@@ -147,25 +131,7 @@ module Shiba
     check :check_query_shortcircuits
     def check_query_shortcircuits
       if first_extra && IGNORE_PATTERNS.any? { |p| first_extra =~ p }
-        @cost = 0
-      end
-    end
-
-    # TODO: need to parse SQL here I think
-    def simple_table_scan?
-      @rows.size == 1 &&  (@sql !~ /order by/i) &&
-        (@rows.first['using_index'] || !(@sql =~ /\s+WHERE\s+/i))
-    end
-
-    # TODO: we don't catch some cases like SELECT * from foo where index_col = 1 limit 1
-    # bcs we really just need to parse the SQL.
-    check :check_simple_table_scan
-    def check_simple_table_scan
-      if simple_table_scan?
-        if limit
-          @result.messages << { tag: 'limited_scan', cost: limit, table: @rows.first['table'] }
-          @cost = limit
-        end
+        @result.cost = 0
       end
     end
 
@@ -184,36 +150,32 @@ module Shiba
     end
 
     def check_return_size
-      if limit
-        return_size = limit
-      elsif aggregation?
+      if @query.limit
+        return_size = [@query.limit, @result.result_size].min
+      elsif @query.aggregation?
         return_size = 1
       else
         return_size = @result.result_size
       end
 
-      if return_size && return_size > 100
-        @result.messages << { tag: "retsize_bad", result_size: return_size }
-      else
-        @result.messages << { tag: "retsize_good", result_size: return_size }
-      end
+      cost = COST_PER_ROW_RETURNED * return_size
+      @result.cost += cost
+      @result.messages << { tag: "retsize", result_size: return_size, cost: cost }
     end
 
     def run_checks!
       # first run top-level checks
       _run_checks! do
-        :stop if @cost
+        :stop if @result.cost
       end
 
-      if @cost
-        # we've decided to stop further analysis at the query level
-        @result.cost = @cost
-      else
-        # run per-table checks
-        0.upto(@rows.size - 1) do |i|
-          check = Checks.new(@rows, i, @stats, @options, @result)
-          check.run_checks!
-        end
+      return if @result.cost
+
+      @result.cost = 0
+      # run per-table checks
+      0.upto(@rows.size - 1) do |i|
+        check = Checks.new(@rows, i, @stats, @options, @query, @result)
+        check.run_checks!
       end
 
       check_return_size
@@ -232,7 +194,7 @@ module Shiba
           next [] unless r['possible_keys'] && r['key'].nil?
           possible = r['possible_keys'] - [r['key']]
           possible.map do |p|
-            Explain.new(@sql, @stats, @backtrace, force_key: p) rescue nil
+            Explain.new(@query, @stats, force_key: p) rescue nil
           end.compact
         end.flatten
       else

data/lib/shiba/explain/checks.rb

@@ -6,12 +6,13 @@ module Shiba
       include CheckSupport
       extend CheckSupport::ClassMethods
 
-      def initialize(rows, index, stats, options, result)
+      def initialize(rows, index, stats, options, query, result)
         @rows = rows
         @row = rows[index]
         @index = index
         @stats = stats
         @options = options
+        @query = query
         @result = result
         @tbl_message = {}
       end
@@ -30,6 +31,26 @@ module Shiba
         @result.messages << { tag: tag, table_size: table_size, table: table }.merge(extra)
       end
 
+      # TODO: need to parse SQL here I think
+      def simple_table_scan?
+        @rows.size == 1 &&
+          (@row['using_index'] || !(@query.sql =~ /\s+WHERE\s+/i)) &&
+          (@row['access_type'] == "index" || (@query.sql !~ /order by/i)) &&
+          @query.limit
+      end
+
+      # TODO: we don't catch some cases like SELECT * from foo where index_col = 1 limit 1
+      # bcs we really just need to parse the SQL.
+      check :check_simple_table_scan
+      def check_simple_table_scan
+        if simple_table_scan?
+          rows_read = [@query.limit, table_size].min
+          @cost = @result.cost = rows_read * Shiba::Explain::COST_PER_ROW_READ
+          @result.messages << { tag: 'limited_scan', cost: @result.cost, table: table, rows_read: rows_read }
+        end
+      end
+
+
       check :check_derived
       def check_derived
         if table =~ /<derived.*?>/
@@ -75,54 +96,48 @@ module Shiba
 
       check :check_key_size
       def check_key_size
-        if @row['key']
-          rows_read = @stats.estimate_key(table, @row['key'], @row['used_key_parts'])
+        if @access_type == "access_type_index"
+          # access-type index means a table-scan as performed on an index... all rows.
+          key_size = table_size
+        elsif @row['key']
+          key_size = @stats.estimate_key(table, @row['key'], @row['used_key_parts'])
         else
-          rows_read = table_size
+          key_size = table_size
         end
 
         # TBD: this appears to come from a couple of bugs.
         # one is we're not handling mysql index-merges, the other is that
         # we're not handling mysql table aliasing.
-        if rows_read.nil?
-          rows_read = 1
+        if key_size.nil?
+          key_size = 1
         end
 
         if @row['join_ref']
-          # when joining, we'll say we read "@cost" rows -- but up to
+          # when joining, we'll say we read "key_size * (previous result size)" rows -- but up to
           # a max of the table size.  I'm not sure this assumption is *exactly*
           # true but it feels good enough to start; a decent hash join should
           # nullify the cost of re-reading rows.  I think.
-          @cost = [@result.result_size * rows_read, table_size || 2**32].min
+          rows_read = [@result.result_size * key_size, table_size || 2**32].min
 
           # poke holes in this.  Is this even remotely accurate?
           # We're saying that if we join to a a table with 100 rows per item
           # in the index, for each row we'll be joining in 100 more rows.  Is that true?
-          @result.result_size *= rows_read
+          @result.result_size *= key_size
         else
-          @cost = rows_read
-          @result.result_size += rows_read
+          rows_read = key_size
+          @result.result_size += key_size
         end
 
+        @cost = Shiba::Explain::COST_PER_ROW_READ * rows_read
         @result.cost += @cost
 
         @tbl_message['cost'] = @cost
+        @tbl_message['rows_read'] = rows_read
         @tbl_message['index'] = @row['key']
         @tbl_message['index_used'] = @row['used_key_parts']
         add_message(@access_type, @tbl_message)
       end
 
-      def estimate_row_count_with_key(key)
-        explain = Explain.new(@sql, @stats, @backtrace, force_key: key)
-        explain.run_checks!
-      rescue Mysql2::Error => e
-        if /Key .+? doesn't exist in table/ =~ e.message
-          return nil
-        end
-
-        raise e
-      end
-
       def run_checks!
         _run_checks! do
           :stop if @cost

data/lib/shiba/explain/result.rb

@@ -7,11 +7,12 @@ module Shiba
 
       def initialize
         @messages = []
-        @cost = 0
+        @cost = nil
         @result_size = 0
+        @rows_read = 0
       end
 
-      attr_accessor :messages, :cost, :result_size
+      attr_accessor :messages, :cost, :result_size, :rows_read
     end
   end
 end

data/lib/shiba/fuzzer.rb

@@ -40,8 +40,8 @@ module Shiba
 
     private
 
-    BIG_FUZZ_SIZE   = 5_000
-    SMALL_FUZZ_SIZE = 100
+    BIG_FUZZ_SIZE   = 100_000
+    SMALL_FUZZ_SIZE = 1000
 
 
     # Create fake table sizes based on the table's index count.
@@ -63,11 +63,9 @@ module Shiba
         end
 
         size = sizes[table_name]
-        # Big
         if size >= large_table_index_count
           sizes[table_name] = BIG_FUZZ_SIZE
         else
-        #small
           sizes[table_name] = SMALL_FUZZ_SIZE
         end
       end

data/lib/shiba/index_stats.rb

@@ -13,7 +13,7 @@ module Shiba
       @tables.any?
     end
 
-    Table = Struct.new(:name, :count, :indexes) do
+    Table = Struct.new(:name, :count, :indexes, :average_row_size) do
       def encode_with(coder)
         coder.map = self.to_h.stringify_keys
         coder.map.delete('name')

data/lib/shiba/output/tags.yaml

@@ -13,28 +13,23 @@ possible_key_check:
     MySQL reported that it had keys it could have used, but elected not to use them.
     Shiba checked each of the possible keys and returned the results from the best
     key possible.  Sometimes "possible_keys" will be inaccurate and no keys were possible.
-  level: info
 access_type_const:
   title: One row
   summary: The database only needs to read a single row from <b>{{table}}</b>.
   description: |
     This query selects at *most* one row, which is about as good as things get.
-  level: success
 access_type_ref:
   title: Index Scan
   summary: The database reads {{ formatted_cost }} rows in <b>{{ table }}</b> via the <i>{{ index }}</i> index ({{ key_parts }}).
   description: |
     This query uses an index to find rows that match a single value.  Often this
     has very good performance, but it depends on how many rows match that value.
-  level: success
 join_type_eq_ref:
   title: Indexed Join
-  summary: <b>{{ table }}</b> is joined to <b>{{ join_to }}</b> via the <i>{{ index }}</i> index, reading 1 row per joined item.
-  level: success
+  summary: <b>{{ table }}</b> is joined to <b>{{ join_to }}</b> via <i>{{ index }}</i>, reading 1 row per joined item.
 join_type_ref:
   title: Indexed Join
-  summary: <b>{{ table }}</b> is joined to <b>{{ join_to }}</b> via the <i>{{ index }}</i> index, reading {{ formatted_cost }} rows per joined item.
-  level: success
+  summary: <b>{{ table }}</b> is joined to <b>{{ join_to }}</b> via <i>{{ index }}</i>, reading {{ formatted_cost }} rows per joined item.
 access_type_range:
   title: Indexed
   summary: The database uses a "range scan" to read more than {{ formatted_cost }} rows in {{ table }} via the <b>{{ index }}</b> index ({{ key_parts }})
@@ -43,7 +38,9 @@ access_type_range:
     `WHERE indexed_value in (1,2,5,6)` or `WHERE indexed_value >= 5 AND indexed_value <= 15`.
     It's very hard to estimate how many rows this query will consider in production, so we've
     upped the formatted_cost of this query.
-  level: info
+access_type_index:
+  title: Index Scan
+  summary: The database reads {{ formatted_cost }} of the rows in <b>{{ table }}</b> via <i>{{ index }}</i>
 access_type_tablescan:
   title: Table Scan
   summary: The database reads {{ formatted_cost }} of the rows in <b>{{ table }}</b>, skipping any indexes.
@@ -54,14 +51,12 @@ access_type_tablescan:
     This *can* be fine if, say, you're querying a tiny table (less than ~500 rows),
     but be aware that if this table is not effectively tiny or constant-sized you're entering
     a world of pain.
-  level: danger
 limited_scan:
   title: Limited Scan
   summary: The database reads {{ formatted_cost }} rows from {{ table }}.
   description: |
     This query doesn't use any indexes to find data, but since it doesn't care about
     ordering and it doesn't have any conditions, it only ever reads {{ formatted_cost }} rows.
-  level: info
 ignored:
   title: Ignored
   summary: This query matched an "ignore" rule in shiba.yml.  Any further analysis was skipped.
@@ -74,11 +69,6 @@ index_walk:
     can read the index and simply pluck {LIMIT} rows out of the index.  It's a very
     fast way to look up stuff by index.
   level: success
-retsize_bad:
-  title: Big Results
-  summary: The database returns {{ result_size }} rows to the client.
-  level: danger
-retsize_good:
-  title: Small Results
+retsize:
+  title: Results
   summary: The database returns {{ result_size }} row(s) to the client.
-  level: success

data/lib/shiba/query.rb

@@ -1,17 +1,29 @@
 require 'open3'
 require 'shiba/explain'
+require 'timeout'
+require 'thread'
+require 'digest'
 
 module Shiba
   class Query
     @@index = 0
     FINGERPRINTER = Shiba.root + "/bin/fingerprint"
 
+    @@fingerprinter_mutex = Mutex.new
     def self.get_fingerprint(query)
-      if !@stdin
-        @stdin, @stdout, _ = Open3.popen2(FINGERPRINTER)
+      @@fingerprinter_mutex.synchronize do
+        if !@stdin
+          @stdin, @stdout, _ = Open3.popen2(FINGERPRINTER)
+        end
+        @stdin.puts(query.gsub(/\n/, ' '))
+        begin
+          Timeout.timeout(2) do
+            @stdout.readline.chomp
+          end
+        rescue StandardError => e
+          $stderr.puts("shiba: timed out waiting for fingerprinter on #{query}...")
+        end
       end
-      @stdin.puts(query.gsub(/\n/, ' '))
-      @stdout.readline.chomp
     end
 
     def initialize(sql, stats)
@@ -29,19 +41,43 @@ module Shiba
       @index = @@index
     end
 
-    attr_reader :sql, :index
-
+    attr_reader :sql, :index, :backtrace
 
     def fingerprint
       @fingerprint ||= self.class.get_fingerprint(@sql)
     end
 
+    def md5
+      Digest::MD5.hexdigest(fingerprint)
+    end
+
     def explain
-      Explain.new(@sql, @stats, @backtrace)
+      Explain.new(self, @stats)
+    end
+
+    def from_table
+      @sql =~ /\s+from\s*([^\s,]+)/i
+      table = $1
+      return nil unless table
+
+      table = table.downcase
+      table.gsub!('`', '')
+      table.gsub!(/.*\.(.*)/, '\1')
+      table
+    end
+
+    def limit
+      if @sql =~ /limit\s*(\d+)\s*(offset \d+)?$/i
+        $1.to_i
+      else
+        nil
+      end
     end
 
-    def backtrace
-      @backtrace
+    def aggregation?
+      @sql =~ /select\s*(.*?)from/i
+      select_fields = $1
+      select_fields =~ /(min|max|avg|count|sum|group_concat)\s*\(.*?\)/i
     end
   end
 end

data/lib/shiba/review/comment_renderer.rb

@@ -22,6 +22,7 @@ module Shiba
           body << "\n"
         end
 
+        body << "Estimated query time: %.2fs" % explain['cost']
         body
       end
 
@@ -44,6 +45,7 @@ module Shiba
           "table_size"      => message["table_size"],
           "result_size"     => message["result_size"],
           "index"           => message["index"],
+          "join_to"         => message["join_to"],
           "key_parts"       => (message["index_used"] || []).join(','),
           "size"            => message["size"],
           "formatted_cost"  => formatted_cost(message)
@@ -51,13 +53,13 @@ module Shiba
       end
 
       def formatted_cost(explain)
-        return nil unless explain["cost"] && explain["table_size"]
-        percentage = (explain["cost"] / explain["table_size"]) * 100.0;
+        return nil unless explain["rows_read"] && explain["table_size"]
+        percentage = (explain["rows_read"] / explain["table_size"]) * 100.0;
 
-        if explain["cost"] > 100 && percentage > 1
-          "#{percentage.floor}% (#{explain["cost"]}) of the"
+        if explain["rows_read"] > 100 && percentage > 1
+          "#{percentage.floor}% (#{explain["rows_read"]}) of the"
         else
-          explain["cost"]
+          explain["rows_read"]
         end
       end
 

data/lib/shiba/reviewer.rb

@@ -11,6 +11,7 @@ module Shiba
   # is semi-corrected but still a problem
   class Reviewer
     TEMPLATE_FILE = File.join(Shiba.root, 'lib/shiba/output/tags.yaml')
+    MESSAGE_FILTER_THRESHOLD = 0.005
 
     attr_reader :repo_url, :problems, :options
 
@@ -34,9 +35,7 @@ module Shiba
 
         position = diff.find_position(file, line_number.to_i)
 
-        if options["submit"]
-          explain = keep_only_dangerous_messages(explain)
-        end
+        explain = keep_only_dangerous_messages(explain)
 
         { body: renderer.render(explain),
           commit_id: @commit_id,
@@ -93,8 +92,7 @@ module Shiba
     def keep_only_dangerous_messages(explain)
       explain_b = explain.dup
       explain_b["messages"] = explain_b["messages"].select do |message|
-        tag = message['tag']
-        tags[tag]["level"] == "danger"
+        message['cost'] && message['cost'] > MESSAGE_FILTER_THRESHOLD
       end
       explain_b
     end

data/lib/shiba/version.rb

@@ -1,3 +1,3 @@
 module Shiba
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/web/results.html.erb

@@ -25,7 +25,7 @@
       var queriesByTable = [];
       var queriesByTableLow = [];
       var queriesHaveFuzzed = false;
-      var severityIndexes = { high: 1, medium: 2, low: 3 };
+      var severityIndexes = { high: 1, medium: 2, low: 3, none: 4 };
 
       function sortByFunc(fields) {
         return function(a, b) {
@@ -76,7 +76,7 @@
       data.queries.forEach(function(query) {
         var q = new Query(query);
 
-        if ( q.cost < 100 ) {
+        if ( q.severity == "none" ) {
           queriesByTableLow.push(q);
         } else {
           queriesByTable.push(q);
@@ -89,11 +89,11 @@
 
         var rCost = 0;
         q.messages.forEach(function(m) {
-          if ( m.cost ) {
+          if ( m.cost && m.cost != 0) {
             rCost += m.cost;
             m.running_cost = rCost;
           } else {
-            m.running_cost = '';
+            m.running_cost = undefined;
           }
         });
       });
@@ -129,6 +129,9 @@
               <table class="shiba-messages">
                 <component v-for="message in query.messages" v-bind:is="'tag-' + message.tag" v-bind="message"></component>
               </table>
+              <% if ENV['SHIBA_DEBUG'] %>
+              <div style="font-size: 10px">md5: {{ query.md5 }}</div>
+              <% end %>
               <div v-if="!rawExpanded">
                 <a href="#" v-on:click.prevent="rawExpanded = !rawExpanded">See full EXPLAIN</a>
               </div>
@@ -178,24 +181,31 @@
           return str;
         },
         formatted_cost: function() {
-          var costPercentage = (this.cost / this.table_size) * 100.0;
-          if ( this.cost > 100 && costPercentage > 1 ) // todo: make better
-            return `${costPercentage.toFixed()}% (${this.cost.toLocaleString()}) of the`;
+          var readPercentage = (this.rows_read / this.table_size) * 100.0;
+          if ( this.rows_read > 100 && readPercentage > 1 ) // todo: make better
+            return `${readPercentage.toFixed()}% (${this.rows_read.toLocaleString()}) of the`;
           else
-            return this.cost.toLocaleString();
+            return this.rows_read.toLocaleString();
         },
         costToColor: function() {
           var goodColor = [34, 160, 60];
           var endColor = [255, 0, 0];
-          var costScale = this.cost ? this.cost / 5000 : 0;
+          var costScale = this.cost ? this.cost / 0.5 : 0;
 
           if ( costScale > 1 )
             costScale = 1;
 
           var pos =  (costScale * (greenToRedGradient.length - 1)).toFixed();
 
-          debugger;
           return "border-color: " + greenToRedGradient[pos];
+        },
+        formattedRunningCost: function() {
+          if ( this.running_cost === undefined )
+            return "-";
+          else if ( this.running_cost < 1.0 )
+            return (this.running_cost * 100).toFixed() + "ms";
+          else
+            return this.running_cost.toFixed(1) + "s";
         }
       }
     </script>
@@ -209,15 +219,18 @@
           <%= h['summary'] %>
         </td>
         <td class="running-totals">
-          {{ running_cost.toLocaleString() }}
+          {{ formattedRunningCost }}
         </td>
         </tr>
     </script>
     <script>
       Vue.component('tag-<%= tag %>', {
         template: '#tag-<%= tag %>-template',
-        props: [ 'table_size', 'result_size', 'table', 'cost', 'index', 'join_to', 'index_used', 'running_cost', 'tables' ],
-        computed: templateComputedFunctions
+        props: [ 'table_size', 'result_size', 'table', 'cost', 'index', 'join_to', 'index_used', 'running_cost', 'tables', 'rows_read' ],
+        computed: templateComputedFunctions,
+        data: function () {
+          return { lastRunnningCost: undefined };
+        }
       });
     </script>
     <% end %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shiba
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Ben Osheroff
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-27 00:00:00.000000000 Z
+date: 2019-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -177,8 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: A gem that attempts to find bad queries before you shoot self in foot