mmtop 0.9.0

data/bin/mmtop

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+#
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'pp'
+require 'Getopt/Declare'
+
+require 'mysql2'
+require 'lib/mmconfig'
+require 'lib/host'
+require 'lib/process'
+require 'lib/term_printer'
+require 'lib/term_input'
+require 'lib/command'
+require 'lib/pid'
+require 'lib/filter'
+
+
+spec = <<-EOL
+  -c, --config <FILE>         Where to find mmtop_config
+  -p, --password <pass>       The password used to connect to all DBs
+  -u, --user <user>           The user used to connect to all DBs
+  -o, --ops                   David's funky ops mode
+EOL
+
+args = Getopt::Declare.new(spec)
+config = MMTop::Config.new(args)
+
+printer = MMTop::TermPrinter.new
+input = MMTop::TermInput.new
+
+while true
+  MMTop::PID.reset
+  config.get_info
+  printer.print_info(config.info)
+  input.control(config)
+end
+
+
+

data/lib/command.rb

@@ -0,0 +1,45 @@
+module MMTop
+  class Command
+    def matches?(cmd)
+      @regexp.match(cmd)
+    end
+
+    def run(cmd, config)
+      cmd =~ @regexp
+      @command.call(cmd, config)
+    end
+
+    def regexp(r = nil)
+      @regexp = r if r
+      @regexp
+    end
+
+    def usage(u = nil)
+      @usage = u if u
+      @usage
+    end
+
+    def explain(e = nil)
+      @explain = e if e
+      @explain
+    end
+
+    def command(&block)
+      @command = block.to_proc
+    end
+
+    class <<self
+      def register
+        @commands ||= []
+        c = self.new
+        yield c
+        @commands << c
+      end
+
+      attr_accessor :commands
+    end
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), "commands/*")).each { |f| require f }
+

data/lib/commands/basic.rb

@@ -0,0 +1,96 @@
+MMTop::Command.register do |c|
+  c.regexp /^h|help|\?/
+  c.usage "help"
+  c.explain "Display this text"
+  c.command do |cmd, config|
+    MMTop::Command.commands.sort_by(&:usage).each do |c|
+      puts "%-50s %s" % [c.usage, c.explain]
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^q|quit|\?/
+  c.usage "quit"
+  c.explain "Exit"
+  c.command do |cmd, config|
+    exit
+  end
+end
+
+    
+MMTop::Command.register do |c|
+  c.regexp /^[x|(?:examine)]\s+(\d+)/
+  c.usage "x PID"
+  c.explain "Show full query"
+  c.command do |cmd, config|
+    cmd =~ c.regexp
+    pid = $1.to_i
+    ps = config.find_pid(pid)
+    if ps
+      puts "%-20s%-6s%-20s%-20s%-20s" % ["status","time","client", "server", "database"]
+      puts "%-20s%-6s%-20s%-20s%-20s" % [ps.status, ps.time, ps.client, ps.host.name, ps.db]
+      puts ps.sql
+    else
+      puts "No such pid #{p}"
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^(?:ex|explain)\s+(\d+)/
+  c.usage "explain PID"
+  c.explain "Show query plan"
+  c.command do |cmd, config|
+    cmd =~ c.regexp
+    pid = $1.to_i
+    ps = config.find_pid(pid)
+    if ps
+      puts ps.sql
+      explain = ps.explain
+      pp explain
+    else
+      puts "No such pid #{p}"
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^(?:l|list)\s+(\S+)/
+  c.usage "list HOST"
+  c.explain "List hosts and their connections to this server"
+  c.command do |cmd, config|
+    cmd =~ c.regexp
+    host = $1
+
+    server = config.find_server(host)
+    if server
+      cxs = {}
+      server.connections.each do |cx|
+        client = MMTop::ReverseLookup.lookup(cx.client)
+        cxs[client] ||= 0
+        cxs[client] += 1
+      end
+
+      cxs.sort_by { |k, v| [-v, k] }.each { |k, v|
+        puts "#{k}: #{v}"
+      }
+    else
+      puts "No such host: #{server}"
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^sleep\s+([\d\.]+)/
+  c.usage "sleep TIME"
+  c.explain "Set mmtop sleep time"
+  c.command do |cmd, config|
+    cmd =~ c.regexp
+    sleep = $1.to_f
+    if sleep == 0.0
+      puts "sleep must be over 0."
+    end
+    config.options['sleep'] = sleep
+  end
+end

data/lib/commands/filters.rb

@@ -0,0 +1,73 @@
+MMTop::Command.register do |c|
+  c.regexp /^filter\s+list/
+  c.usage "filter list"
+  c.explain "Show active filters"
+  c.command do |cmd, config|
+    config.filters.each_with_index do |f, i|
+      puts "#{i}: #{f.name}"
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^filter\s+available/
+  c.usage "filter available"
+  c.explain "Show available filters"
+  c.command do |cmd, config|
+    MMTop::Filter.filters.each do |o|
+      puts "#{o.name}"
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^filter\s+add/
+  c.usage "filter add [{ BLOCK } | NAME] [POSITION]"
+  c.explain "Add a new filter into the chain.  For the { BLOCK } form, the block has access to the \'query\' variable.  see docs for more info."
+  c.command do |cmd, config|
+    cmd =~ /filter\s+add(.*)/
+  
+    filter = nil
+    position = nil
+    rest = $1
+    if rest =~ /\{(.*)\}\s*(\d*)/
+      eval_bits = $1.strip
+      position = $2
+      begin 
+        filter = MMTop::Filter.from_string(eval_bits) 
+      #rescue Exception => e
+      #  puts "error evaluating filter block: #{e}"
+      end
+    else
+      name, position = rest.strip.split(/\s+/)
+      filter = MMTop::Filter.filters.detect { |f| f.name == name } 
+      if filter.nil? 
+        puts "No such filter: '#{name}'"
+      end
+    end
+
+    if filter
+      if position && !position.empty?
+        config.filters.insert(position.to_i, filter)
+      else
+        config.filters.push(filter)
+      end
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^filter\s+rm\s+(\d+)/
+  c.usage "filter rm [POSITION]"
+  c.explain "Remove the filter at [POSITION]"
+  c.command do |cmd, config|
+    cmd =~ c.regexp
+    pos = $1.to_i
+    if !config.filters[pos]
+      puts "No filter at #{pos}"
+    else
+      config.filters.slice!(pos)
+    end
+  end
+end
+

data/lib/commands/kill.rb

@@ -0,0 +1,75 @@
+module MMTop
+  class Command
+    def self.kill_prompt(queries)
+      if queries.empty?
+        puts "No queries matched."
+        return
+      end
+  
+      puts "killing: "
+      queries.each_with_index do |q, i|
+        puts "#{i}: #{q.host.name}\t\t#{q.sql[0..80]}"
+      end
+
+      print "Please confirm (y|n)> "
+      if $stdin.readline != "y\n"
+        puts "no, ok."
+      else
+        queries.each(&:kill!)
+        puts "killed."
+      end
+    end
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp /^k(:?ill)?(\s+\d+)/
+  c.usage "kill [PID] [..PID]"
+  c.explain "Kill a number of queries by PID"
+  c.command do |cmd, config|
+    pids = []
+    procs = []
+    cmd.gsub(/\s+\d+/) { |p| pids << p.to_i }
+
+    pids.each { |p|
+      ps = config.find_pid(p)
+      if ps.nil?
+        puts "No such pid: #{p}"
+        next
+      end
+      procs << ps
+    }
+    procs.each { |ps| ps.kill! }
+  end
+end
+
+MMTop::Command.register do |c|
+  c.regexp %r{^k(:?ill)?\s+l(:?ong)?\s+(\d+)}
+  c.usage "kill long TIME"
+  c.explain "Kill any queries over TIME seconds"
+  c.command do |cmd, config|
+    cmd =~ c.regexp
+    time = $3.to_i
+    MMTop::Command.kill_prompt(config.all_processes.select { |p| p.time > time && p.sql =~ /select/i })
+  end
+end
+
+
+
+
+MMTop::Command.register do |c|
+  c.regexp %r{^k(ill)?\s+(/.*/\w*)}
+  c.usage "kill /REGEXP/"
+  c.explain "Kill a number of queries by REGEXP"
+  c.command do |cmd, config|
+    cmd =~ c.regexp
+    r = eval($2) 
+    if !r.is_a?(Regexp)
+      puts "Invalid regexp \"#{$1}\""
+    else
+      MMTop::Command.kill_prompt(config.all_processes.select { |p| r.match(p.sql) })
+    end
+  end
+end
+
+

data/lib/filter.rb

@@ -0,0 +1,43 @@
+module MMTop
+  class Filter
+    class << self
+      attr_accessor :filters
+
+      def add_filter(name, default=true, &block)
+        @filters ||= []
+        @filters.push self.new(name, default, &block)
+      end
+
+      def default_filters
+        @filters.select(&:default)
+      end
+
+      def from_string(string)
+        final = string.sub(/^\s*\{/, '').sub(/\}$/, '')
+        p = eval("Proc.new { |qlist| qlist.reject! { |query| !(#{final}) } }")
+        new(string, false, &p)
+      end
+
+    end
+
+    def initialize(name, default, &block)
+      @name = name
+      @default = default
+      @block = block.to_proc
+    end
+
+    def run(query_list, host, config)
+      case @block.arity
+        when 1
+          @block.call(query_list)
+        when 2
+          @block.call(query_list, host)
+        when 3
+          @block.call(query_list, host, config)
+      end
+    end
+    attr_accessor :name, :default
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), "filters/*")).each { |f| require f }

data/lib/filters/basic.rb

@@ -0,0 +1,31 @@
+module MMTop
+  Filter.add_filter('strip_empty') do |queries|
+    queries.reject! { |q| q.sql.nil? || q.sql.strip.empty? }
+  end
+
+  Filter.add_filter('trim_whitespace') do |queries|
+    queries.each { |q| q.sql.gsub!(/\s+/, ' ') }
+  end
+
+  Filter.add_filter('sort_by_time') do |queries|
+    queries.sort! { |a, b| b.time <=> a.time }
+  end
+
+  WEDGE_THRESHOLD=15
+  Filter.add_filter('wedge_monitor') do |queries, hostinfo, config|
+    if hostinfo.host.wedge_monitor? 
+      if queries.size > WEDGE_THRESHOLD
+        begin 
+          wedge_filename = config.options['wedge_log'] || 'mmtop_wedge_log'
+          File.open(wedge_filename, "a+") { |f|
+            f.puts("Wedge detected on #{hostinfo.host.name}.  Dumping innodb status")
+            q = hostinfo.host.query("show innodb status")
+            f.write(q[0][:Status])
+          }
+        rescue Exception => e
+          $stderr.puts("error writing to wedge log: #{e}:#{e.message}")
+        end 
+      end
+    end
+  end
+end

data/lib/filters/map_topology.rb

@@ -0,0 +1,115 @@
+module MMTop
+  class Topology
+    def initialize(config)
+      @config = config
+    end
+
+    def new_hostlist
+      topology = find_master_slave
+      topology.each { |name, t| fill_chain_info(t, topology) }
+
+      new_top = create_sort_array(topology)
+
+      hosts = @config.hosts.sort_by { |h| new_top.find_index { |t| t[:hostname] == h.name } }
+      hosts.each { |h|
+        top = new_top.find { |t| t[:hostname] == h.name }
+        if top[:levels] > 0 
+          h.display_name = ("  " * top[:levels]) + '\_' + h.name
+        end
+      }
+      hosts
+    end
+
+    def insert_host_into_sort_array(t, host, array)
+      array << host
+      t.select { |k, v| 
+        # find hosts who are our slaves
+        v[:master] == host[:hostname] 
+      }.sort_by { |k, v| 
+        # add those without children of their own first
+        v[:is_master].to_i 
+      }.each { |k, s| 
+        insert_host_into_sort_array(t, s, array)
+      }
+      array
+    end
+
+
+    def create_sort_array(t)
+      array = []
+      t.values.select { |v|
+        v[:levels] == 0 
+      }.sort_by { |v| 
+        v[:hostname]
+      }.each { |v|
+        insert_host_into_sort_array(t, v, array)
+      }
+      array
+    end
+
+    def fill_chain_info(host, topology)
+      levels = 0
+      stack = []
+      master = host
+      while master = topology[master[:master]]
+        # loop detection
+        break if stack.include?(master)
+
+        last_master = master 
+        levels += 1
+        stack.push(master)
+      end
+
+      if last_master
+       host[:final_master] = last_master[:hostname] 
+      else
+       host[:final_master] = host[:hostname]
+      end
+      host[:levels] = levels
+    end
+
+    def find_master_slave
+      topology = @config.hosts.inject({}) { |accum, h|
+        hostname = h.query("show global variables where Variable_name='hostname'")[0][:Value]
+        hostname = hostname.split('.')[0]
+        status = h.slave_status
+
+        if status && status[:Master_User] != 'test'
+          master_host = status[:Master_Host]
+        end
+
+        master_host = short_name_for_host(master_host) if master_host
+
+        accum[hostname] = {:master => master_host, :hostname => hostname}
+        accum
+      }
+
+      # fill in :is_master
+      topology.each { |k, v|
+        master_top = topology[v[:master]]
+        if master_top
+          master_top[:is_master] = 1
+        end 
+      }
+      topology
+    end
+
+    def short_name_for_host(h)
+      if h =~ /\d+.\d+.\d+.\d+/
+        h = ip_to_short_hostname(h)
+      end
+      h.split('.')[0]
+    end
+
+    def ip_to_short_hostname(ip)
+      `grep #{ip} /etc/hosts | awk '{print $2}'`.chomp
+    end
+  end
+
+  Filter.add_filter("discover_topology") do |queries, hostinfo, config|
+    if !config.options['discovered']
+      config.options['discovered'] = true
+      config.hosts = MMTop::Topology.new(config).new_hostlist
+    end 
+  end
+end

data/lib/filters/reverse_lookup.rb

@@ -0,0 +1,24 @@
+module MMTop
+  class ReverseLookup
+    def self.lookup(client)
+      return client if client.nil? or client.empty?
+      return client unless client =~ /\d+\.\d+\.\d+\.\d+/
+
+      @@lookups ||= {}
+
+      return @@lookups[client] if @@lookups[client]
+
+      hostline = %x{dig -x #{client} +short}.chomp
+      hostline.gsub!(/([^\.]+)\..*/, '\1')
+      @@lookups[client] = hostline
+      @@lookups[client] 
+    end
+  end
+
+  Filter.add_filter("reverse_lookup") do |queries|
+    queries.each do |q|
+      q.client = MMTop::ReverseLookup.lookup(q.client)
+    end
+  end
+end
+

data/lib/host.rb

@@ -0,0 +1,88 @@
+module MMTop
+  class Host
+    def initialize(hostname, user, password, options)
+      m2opts = {}
+      m2opts[:host] = hostname
+      m2opts[:username] = user
+      m2opts[:password] = password
+      m2opts[:socket] = options['socket'] if options['socket']
+      m2opts[:port] = options['port'] if options['port']
+      m2opts[:reconnect] = true
+      @mysql = Mysql2::Client.new(m2opts)
+      # rescue connection errors or sumpin
+      @options = options
+      @name = hostname
+      @display_name = @name
+      @comment = options['comment']
+      @last_queries = nil
+    end
+
+    attr_accessor :display_name, :name, :comment, :options
+
+    def query(q)
+      res = []
+      ret = @mysql.query(q)
+      return nil unless ret
+      ret.each(:symbolize_keys => true) do |r|
+        res << r
+      end
+      res
+    end
+
+    def slave_status
+      return nil if @options['expect_slave'] == false
+      res = query("show slave status")[0]
+      return nil if res && res[:Master_User] == 'test'
+      res
+    end
+
+    def wedge_monitor?
+      @options['wedge_monitor']
+    end
+
+    def stats
+      stats = {}
+      queries = query("show global status like 'Questions'")[0][:Value].to_i
+
+      if @last_queries
+        elapsed = Time.now.to_i - @last_queries[:time]
+        if elapsed > 0 
+          qps = (queries - @last_queries[:count]) / elapsed
+        else 
+          qps = queries - @last_queries[:count]
+        end
+        stats[:qps] = qps
+      end
+      @last_queries = {}
+      @last_queries[:count] = queries
+      @last_queries[:time] = Time.now.to_i
+      stats
+    end
+
+    def processlist
+      processlist = query("show full processlist")
+
+      processlist.map { |r| Process.new(r, self) }
+    end
+
+    def hostinfo
+      HostInfo.new(self, processlist, slave_status, stats)
+    end
+  end
+
+  class HostInfo
+    def initialize(host, processlist, slave_status, stats)
+      @host = host
+      @processlist = processlist
+      @connections = processlist.clone
+      @slave_status = slave_status
+      @stats = stats
+    end
+
+    attr_reader :host, :processlist, :slave_status, :stats
+
+    def connections
+      @connections
+    end
+  end
+end

data/lib/mmconfig.rb

@@ -0,0 +1,68 @@
+module MMTop
+  class Config
+    def initialize(cmdline)
+      config_file = cmdline["-c"] || File.join(ENV["HOME"], ".mmtop_config")
+      raise "No file found: #{config_file}" unless File.exist?(config_file)
+      config = YAML.load_file(config_file)
+
+      if config['hosts'].nil? || config['hosts'].empty?
+        raise "Please configure the 'hosts' section of mmtop_config"
+      end
+
+      user = cmdline['-u']
+      pass = cmdline['-p']
+      @hosts = config['hosts'].map do |h|
+        h['user'] ||= (user || config['user'])
+        h['password'] ||= (pass || config['password'])
+        h['wedge_monitor'] ||= config['wedge_monitor']
+
+        begin
+          Host.new(h['host'], h['user'], h['password'], h)
+        rescue Mysql2::Error => e
+          puts e
+          nil
+        end
+      end.compact
+
+      @filters = MMTop::Filter.default_filters
+      config['sleep'] ||= 5
+      @options = config
+    end
+
+    attr_accessor :hosts
+    attr_accessor :info
+    attr_accessor :filters
+    attr_accessor :options
+
+    def find_pid(pid)
+      ret = info.map { |i|
+        i.processlist.detect { |p|
+          p.id == pid
+        }
+      }.flatten.compact
+
+      ret[0]
+    end
+
+    def find_server(name)
+      @info.detect { |i| i.host.name.downcase == name }
+    end
+
+    def run_filters
+      @info.each do |i|
+        @filters.each do |f|
+          f.run(i.processlist, i, self)
+        end
+      end
+    end
+
+    def all_processes
+      @info.map(&:processlist).flatten
+    end
+
+    def get_info
+      @info = hosts.map { |h| h.hostinfo }
+      run_filters
+    end
+  end
+end

data/lib/pid.rb

@@ -0,0 +1,11 @@
+module MMTop
+  class PID
+    def self.get
+      @id += 1
+    end
+    def self.reset
+      @id = 0
+    end
+  end
+end
+

data/lib/process.rb

@@ -0,0 +1,34 @@
+module MMTop
+  class Process
+    def initialize(result, host)
+      @real_id = result[:Id]
+      @query = result[:Info]
+      @status = result[:State]
+      @time = result[:Time]
+      @client, @client_port = result[:Host] && result[:Host].split(":") 
+      @client ||= "(slave)"
+      @client_port ||= ""
+      @db = result[:db]
+      @host = host
+    end
+
+    attr_accessor :query, :status, :time, :client, :host, :db
+
+    def id
+      @id ||= MMTop::PID.get
+    end
+
+    def kill!
+      @host.query("KILL #{@real_id}")
+    end
+
+    def sql
+      @query
+    end
+
+    def explain
+      @host.query("use #{db}")
+      @host.query("explain #{sql}")
+    end
+  end
+end

data/lib/string_colorize.rb

@@ -0,0 +1,53 @@
+class String
+  CODES = {
+    :off       => "\e[0m",
+    :bright    => "\e[1m",
+    :underline => "\e[4m",
+    :blink     => "\e[5m",
+    :swap      => "\e[7m",
+    :hide      => "\e[8m",
+
+    :black     => "\e[30m",
+    :dark_gray => "\e[1;30m",
+    :red       => "\e[31m",
+    :green     => "\e[32m",
+    :yellow    => "\e[33m",
+    :blue      => "\e[34m",
+    :magenta   => "\e[35m",
+    :cyan      => "\e[36m",
+    :white     => "\e[37m",
+    :default   => "\e[39m",
+
+    :black_background     => "\e[40m",
+    :red_background       => "\e[41m",
+    :green_background     => "\e[42m",
+    :yellow_background    => "\e[43m",
+    :blue_background      => "\e[44m",
+    :magenta_background   => "\e[45m",
+    :cyan_background      => "\e[46m",
+    :white_background     => "\e[47m",
+    :default_background   => "\e[49m"
+  }
+
+  OFF = CODES[:off]
+
+  def colorize(*args)
+    color = args.map { |color| CODES[color] if color.is_a?(Symbol) }.join("")
+    "#{color}#{self}#{OFF}"
+  end
+  def colourise(*args); colorize(*args); end
+
+  def red; colorize(:red); end
+  def green; colorize(:green); end
+  def bold; colorize(:bright); end
+  def black; colorize(:black); end
+  def white; colorize(:white); end
+  def dark_gray; colorize(:dark_gray); end
+
+  def size_uncolorized
+    self.gsub(/\e.*?m/, '').size_raw
+  end
+
+  alias :size_raw :size
+  alias :size :size_uncolorized
+end

data/lib/term_input.rb

@@ -0,0 +1,59 @@
+require 'timeout'
+require 'readline' 
+
+module MMTop
+  class TermInput
+    def raw(bool)
+      if bool
+        %x{stty -echo raw}
+      else
+        %x{stty echo -raw}
+      end
+    end
+
+    def initialize()
+    end
+
+    def find_command(cmd)
+      MMTop::Command.commands.detect { |c| c.matches?(cmd) }
+    end
+
+    def control_mode(config)
+      raw(false)
+      while true
+        cmdline = Readline::readline('> ')
+        exit if cmdline.nil?
+        Readline::HISTORY.push(cmdline) 
+        return if cmdline.empty?
+        c = find_command(cmdline)
+        if c.nil?
+          c = find_command("help")
+        end
+        c.run(cmdline, config)
+      end
+    end
+
+    def control(config)
+      raw(true)
+      char = nil
+      begin
+        Timeout::timeout(config.options['sleep']) do
+          char = $stdin.read(1)
+        end
+      rescue Timeout::Error
+        return
+      end
+
+      case char
+        when "\n"
+          return
+        when "p"
+          control_mode(config)
+        when "q"
+          exit(0)
+      end
+      ensure
+        raw(false)
+    end
+  end
+end

data/lib/term_printer.rb

@@ -0,0 +1,181 @@
+require 'lib/string_colorize'
+
+module MMTop
+  class TermPrinter
+    def initialize
+      $stdout.sync = true
+    end
+
+    def reset!
+      @header_columns = nil
+      get_dim
+    end
+
+    def get_dim
+      @y, @x = %x{stty size}.split.collect { |x| x.to_i }
+    end
+
+    def corner
+      "+".dark_gray
+    end
+
+    def edge
+      "-".dark_gray
+    end
+
+    def pipe
+      "|".dark_gray
+    end
+
+    def sep
+      " | ".dark_gray
+    end
+
+    def info_sep
+      " | ".dark_gray
+    end
+
+    def fill
+      "-".dark_gray
+    end
+
+    def print_header
+      puts corner + edge * (@x - 2) + corner
+    end
+
+    def print_footer
+      puts corner + edge * (@x - 2) + corner
+    end
+
+    def table_header_columns
+      @header_columns ||= ["hostname        ", "pid  ", "time", "#cx", "slave  ", "delay", "qps   ", "comment", Time.now.to_s]
+    end
+
+    def column_fill(index)
+      fill * table_header_columns[index].size
+    end
+
+    def sep_fill
+      fill * sep.size
+    end
+
+    def column_value(index, str, fill=" ")
+      if str.size < table_header_columns[index].size
+        str + (fill * (table_header_columns[index].size - str.size))
+      else
+        str[0..table_header_columns[index].size - 1]
+      end
+    end
+
+    def format_slave_status(status)
+      if status.nil? || status.keys.empty?
+        ""
+      else
+        if status[:Slave_IO_Running] == 'Yes' && status[:Slave_SQL_Running] == 'Yes'
+          "OK"
+        elsif status[:Slave_IO_Running] == 'No' && status[:Slave_SQL_Running] == 'No'
+          "STOPPED"
+        elsif status[:Slave_IO_Running] == 'Yes'
+          "!SQL"
+        else
+          "!IO"
+        end
+      end
+    end
+
+    def format_slave_delay(status)
+      return "" unless status
+      if status[:Seconds_Behind_Master].nil?
+        "N/A"
+      else
+        format_time(status[:Seconds_Behind_Master])
+      end
+    end
+
+    def format_time(x)
+      case x
+        when 0..100
+          x.to_s
+        when 100..3599
+          (x / 60).to_s + "m"
+        else
+          (x / 3600).to_s + "h"
+      end
+    end
+
+    def format_process(process, sz)
+      query = process.sql ? process.sql[0..sz-2] : ''
+      case process.time
+        when 0..2:
+          query
+        when 2..10:
+          query.white.bold
+        else
+          query.red
+      end 
+    end
+
+    def clear_screen
+      print "\033[H\033[2J"
+    end
+
+    def print_process(p)
+      return if p.status.nil? || p.status.empty?
+      str = pipe + " " + column_value(0, "  " + p.client)
+      str += info_sep + column_value(1, p.id ? p.id.to_s : '')
+      str += info_sep + column_value(2, format_time(p.time))
+      str += info_sep 
+      str += format_process(p, @x - str.size - 1)
+      str += " " * (@x - str.size - 1) + pipe
+      puts str
+    end
+
+    def print_host(info)
+      str = pipe + " " + column_value(0, info.host.display_name + " " + (info.host.comment || ""), "-".dark_gray)
+      str += sep_fill + column_fill(1) + sep_fill + column_fill(2)
+      str += info_sep + column_value(3, info.connections.size.to_s)
+      str += info_sep + column_value(4, format_slave_status(info.slave_status))
+      str += info_sep + column_value(5, format_slave_delay(info.slave_status))
+      str += info_sep + column_value(6, info.stats[:qps].to_s)
+      #str += info_sep + column_value(7, info.host.comment || '')
+      str += info_sep
+      str += "-".dark_gray * (@x - str.size - 1)
+      str += pipe
+      puts str
+      info.processlist.each do |p|
+        print_process p
+      end
+    end
+
+    def print_table_header
+      if table_header_columns.join(sep).size + 4 > @x
+        table_header_columns[-1] = ''
+      end
+
+      str = pipe + " " + table_header_columns.join(sep) 
+      fill_len = (@x - str.size) - 1
+     
+      print str
+      print ' ' * fill_len if fill_len > 0 
+      puts pipe
+    end
+
+    def print_info(host_infos)
+      #max_comment_size = host_infos.map { |i| (i.host.comment && i.host.comment.size).to_i }.max
+      #comment_index = 7
+      #table_header_columns[comment_index] += (' ' * (max_comment_size - table_header_columns[comment_index].size)) if max_comment_size > table_header_columns[comment_index].size
+
+      clear_screen
+      reset!
+      print_header
+      print_table_header
+      print_header
+
+
+      host_infos.each do |info|
+        print_host(info)
+      end
+      print_footer
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: mmtop
+version: !ruby/object:Gem::Version 
+  hash: 59
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- Ben Osheroff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-09 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+- ben@gimbo.net
+executables: 
+- mmtop
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/command.rb
+- lib/commands/basic.rb
+- lib/commands/filters.rb
+- lib/commands/kill.rb
+- lib/filter.rb
+- lib/filters/basic.rb
+- lib/filters/map_topology.rb
+- lib/filters/reverse_lookup.rb
+- lib/host.rb
+- lib/mmconfig.rb
+- lib/pid.rb
+- lib/process.rb
+- lib/string_colorize.rb
+- lib/term_input.rb
+- lib/term_printer.rb
+- bin/mmtop
+has_rdoc: true
+homepage: http://github.com/osheroff/mmtop
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: A mytop-ish variant that can watch many mysql servers
+test_files: []
+