redis-stat 0.3.0-java

data/lib/redis-stat.rb

@@ -0,0 +1,314 @@
+# encoding: utf-8
+
+require 'redis-stat/version'
+require 'redis-stat/constants'
+require 'redis-stat/option'
+require 'redis-stat/server' unless RUBY_PLATFORM == 'java'
+require 'insensitive_hash'
+require 'redis'
+require 'tabularize'
+require 'ansi'
+require 'csv'
+require 'parallelize'
+require 'si'
+
+class RedisStat
+  attr_reader :hosts, :measures
+
+  def initialize options = {}
+    options      = RedisStat::Option::DEFAULT.merge options
+    @hosts       = options[:hosts]
+    @redises     = @hosts.map { |e| 
+      host, port = e.split(':')
+      Redis.new(Hash[ {:host => host, :port => port, :timeout => DEFAULT_REDIS_TIMEOUT}.select { |k, v| v } ])
+    }
+    @interval    = options[:interval]
+    @max_count   = options[:count]
+    @mono        = options[:mono]
+    @colors      = options[:colors] || COLORS
+    @csv         = options[:csv]
+    @auth        = options[:auth]
+    @measures    = MEASURES[ options[:verbose] ? :verbose : :default ]
+    @all_measures= MEASURES.values.inject(:+).uniq - [:at]
+    @count       = 0
+    @style       = options[:style]
+    @first_batch = true
+    @server_port = options[:server_port]
+    @daemonized  = options[:daemon]
+  end
+
+  def info
+    collect
+  end
+
+  def start output_stream
+    @os = output_stream
+    trap('INT') { Thread.main.raise Interrupt }
+
+    begin
+      csv = File.open(@csv, 'w') if @csv
+      update_term_size!
+
+      # Warm-up / authenticate only when needed
+      @redises.each do |r|
+        begin
+          r.info
+        rescue Redis::CommandError
+          r.auth @auth if @auth
+        end
+      end
+
+
+      @started_at = Time.now
+      prev_info   = nil
+      server      = start_server if @server_port
+
+      loop do
+        info        = collect
+        info_output = process info, prev_info
+        output info, info_output, csv unless @daemonized
+        server.push info, Hash[info_output] if server
+        prev_info = info
+
+        @count += 1
+        break if @max_count && @count >= @max_count
+        sleep @interval
+      end
+      @os.puts
+    rescue Interrupt
+      @os.puts
+      @os.puts ansi(:yellow, :bold) { "Interrupted." }
+    rescue Exception => e
+      @os.puts ansi(:red, :bold) { e.to_s }
+      raise
+    ensure
+      csv.close if csv
+    end
+    @os.puts ansi(:blue, :bold) {
+      "Elapsed: #{"%.2f" % (Time.now - @started_at)} sec."
+    }
+  end
+
+private
+  def start_server
+    RedisStat::Server.set :port, @server_port
+    RedisStat::Server.set :redis_stat, self
+    Thread.new { RedisStat::Server.run! }
+    RedisStat::Server.wait_until_running
+    trap('INT') { Thread.main.raise Interrupt }
+    RedisStat::Server
+  end
+
+  def collect
+    {}.insensitive.tap do |info|
+      class << info
+        def sumf label
+          (self[label] || []).map(&:to_f).inject(:+)
+        end
+      end
+
+      info[:at] = Time.now.to_f
+      @redises.pmap(@redises.length) { |redis|
+        redis.info.insensitive
+      }.each do |rinfo|
+        (@all_measures + rinfo.keys.select { |k| k =~ /^db[0-9]+$/ }).each do |k|
+          info[k] ||= []
+          info[k] << rinfo[k]
+        end
+      end
+    end
+  end
+
+  def update_term_size!
+    if RUBY_PLATFORM == 'java'
+      require 'java'
+      begin
+        case JRUBY_VERSION
+        when /^1\.7/
+          @term ||= Java::jline.console.ConsoleReader.new.getTerminal
+          @term_width  = (@term.width rescue DEFAULT_TERM_WIDTH)
+          @term_height = (@term.height rescue DEFAULT_TERM_HEIGHT) - 4
+          return
+        when /^1\.6/
+          @term ||= Java::jline.ConsoleReader.new.getTerminal
+          @term_width  = (@term.getTerminalWidth rescue DEFAULT_TERM_WIDTH)
+          @term_height = (@term.getTerminalHeight rescue DEFAULT_TERM_HEIGHT) - 4
+          return
+        end
+      rescue Exception
+        # Fallback to tput (which yields incorrect values as of now)
+      end
+    end
+
+    @term_width  = (`tput cols`  rescue DEFAULT_TERM_WIDTH).to_i
+    @term_height = (`tput lines` rescue DEFAULT_TERM_HEIGHT).to_i - 4
+  end
+
+  def move! lines
+    return if lines == 0
+
+    @os.print(
+      if defined?(Win32::Console)
+        if lines < 0
+          "\e[#{- lines}F"
+        else
+          "\e[#{lines}E"
+        end
+      else
+        if lines < 0
+          "\e[#{- lines}A\e[0G"
+        else
+          "\e[#{lines}B\e[0G"
+        end
+      end)
+  end
+
+  def output info, info_output, file
+    @table ||= init_table info_output
+
+    movement = nil
+    if @count == 0
+      output_static_info info
+
+      movement = 0
+      if file
+        file.puts CSV.generate_line(info_output.map { |pair|
+          LABELS[pair.first] || pair.first
+        })
+      end
+    elsif @count % @term_height == 0
+      @first_batch = false
+      movement = -1
+      update_term_size!
+      @table = init_table info_output
+    end
+
+    # Build output table
+    @table << info_output.map { |pair|
+      ansi(*@colors[pair.first]) { [*pair.last].first }
+    }
+    lines  = @table.to_s.lines.map(&:chomp)
+    lines.delete_at @first_batch ? 1 : 0
+    width  = lines.first.length
+    height = lines.length
+
+    # Calculate the number of lines to go upward
+    if movement.nil?
+      if @prev_width && @prev_width == width
+        lines = lines[-2..-1]
+        movement = -1
+      else
+        movement = -(height - 1)
+      end
+    end
+    @prev_width = width
+
+    move! movement
+    begin
+      @os.print $/ + lines.join($/)
+
+      if file
+        file.puts CSV.generate_line(info_output.map { |pair|
+          [*pair.last].last
+        })
+      end
+    rescue Interrupt
+      move! -movement
+      raise
+    end
+  end
+
+  def output_static_info info
+    tab = Tabularize.new(
+      :unicode => false, :align => :right,
+      :border_style => @style
+    )
+    tab << [nil] + @hosts.map { |h| ansi(:bold, :green) { h } }
+    tab.separator!
+    MEASURES[:static].each do |key|
+      tab << [ansi(:bold) { key }] + info[key] unless info[key].compact.empty?
+    end
+    @os.puts tab
+  end
+
+  def init_table info_output
+    table = Tabularize.new :unicode => false,
+                       :align        => :right,
+                       :border_style => @style,
+                       :border_color => @mono ? nil : ANSI::Code.red,
+                       :vborder      => ' ',
+                       :pad_left     => 0,
+                       :pad_right    => 0,
+                       :screen_width => @term_width
+    table.separator!
+    table << info_output.map { |pair|
+      ansi(*((@colors[pair.first] || []) + [:underline])) {
+        LABELS[pair.first] || pair.first
+      } 
+    }
+    table.separator!
+    table
+  end
+
+  def process info, prev_info
+    @measures.map { |key|
+      [ key, process_how(info, prev_info, key) ]
+    }.select { |pair| pair.last }
+  end
+
+  def process_how info, prev_info, key
+    dur = prev_info && (info[:at] - prev_info[:at])
+
+    get_diff = lambda do |label|
+      if dur && dur > 0
+        (info.sumf(label) - prev_info.sumf(label)) / dur
+      else
+        nil
+      end
+    end
+
+    case key
+    when :at
+      val = Time.now.strftime('%H:%M:%S')
+      [val, val]
+    when :used_cpu_user, :used_cpu_sys
+      val = get_diff.call(key)
+      val &&= (val * 100).round
+      [humanize_number(val), val]
+    when :keys
+      val = Hash[ info.select { |k, v| k =~ /^db[0-9]+$/ } ].values.inject(0) { |sum, vs| 
+        sum + vs.map { |v| Hash[ v.split(',').map { |e| e.split '=' } ]['keys'].to_i }.inject(:+)
+      }
+      [humanize_number(val), val]
+    when :evicted_keys_per_second, :expired_keys_per_second, :keyspace_hits_per_second,
+         :keyspace_misses_per_second, :total_commands_processed_per_second
+      val = get_diff.call(key.to_s.gsub(/_per_second$/, '').to_sym)
+      [humanize_number(val), val]
+    when :used_memory, :used_memory_rss, :aof_current_size, :aof_base_size
+      val = info.sumf(key)
+      [humanize_number(val.to_i, true), val]
+    else
+      val = info.sumf(key)
+      [humanize_number(val), val]
+    end
+  end
+
+  def humanize_number num, byte = false
+    return '-' if num.nil?
+
+    num = num.to_i if num == num.to_i
+    if byte
+      num.si_byte
+    else
+      num.si(:min_exp => 0)
+    end
+  end
+
+  def ansi *args, &block
+    if @mono || args.empty?
+      block.call
+    else
+      ANSI::Code.ansi *args, &block
+    end
+  end
+end

data/redis-stat.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/redis-stat/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Junegunn Choi"]
+  gem.email         = ["junegunn.c@gmail.com"]
+  gem.description   = %q{A Redis monitoring tool written in Ruby}
+  gem.summary       = %q{A Redis monitoring tool written in Ruby}
+  gem.homepage      = "https://github.com/junegunn/redis-stat"
+
+  gem.platform      = 'java' if RUBY_PLATFORM == 'java'
+  gem.files         = `git ls-files`.split("\n").reject { |f| f =~ /^screenshots/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "redis-stat"
+  gem.require_paths = ["lib"]
+  gem.version       = RedisStat::VERSION
+
+  gem.add_runtime_dependency "ansi", '~> 1.4.3'
+  gem.add_runtime_dependency "redis", '~> 3.0.1'
+  gem.add_runtime_dependency "tabularize", '~> 0.2.8'
+  gem.add_runtime_dependency "insensitive_hash", '~> 0.3.0'
+  gem.add_runtime_dependency "parallelize", '~> 0.4.0'
+  gem.add_runtime_dependency "si", '~> 0.1.3'
+  unless RUBY_PLATFORM == 'java'
+    gem.add_runtime_dependency "sinatra", '~> 1.3.3'
+    gem.add_runtime_dependency "thin", '~> 1.5.0' 
+    gem.add_runtime_dependency "json", '~> 1.7.5'
+    gem.add_runtime_dependency "daemons", '~> 1.1.9'
+  end
+
+  gem.add_development_dependency 'test-unit'
+end

data/test/bin_helper.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# DISCLAIMER: 
+#   Not a real test!
+#   Just a helper script for running scripts with local source
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+load File.join(File.dirname(__FILE__), '../bin/', File.basename(ARGV.shift))

data/test/test_redis-stat.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rubygems'
+require 'test-unit'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'redis-stat'
+require 'redis'
+require 'stringio'
+
+class TestRedisStat < Test::Unit::TestCase
+  def test_humanize_number
+    rs = RedisStat.new
+    assert_equal '0', rs.send(:humanize_number, 0.00)
+    assert_equal '7', rs.send(:humanize_number, 7)
+    assert_equal '0.01', rs.send(:humanize_number, 0.00751)
+    assert_equal '0.08', rs.send(:humanize_number, 0.0751)
+    assert_equal '0.75', rs.send(:humanize_number, 0.751)
+    assert_equal '7.51', rs.send(:humanize_number,  7.51)
+    assert_equal '75.1', rs.send(:humanize_number,  75.1)
+    assert_equal '7.51k', rs.send(:humanize_number, 7510)
+    assert_equal '75.1k', rs.send(:humanize_number, 75100)
+    assert_equal '751k', rs.send(:humanize_number,  751000)
+    assert_equal '7.51M', rs.send(:humanize_number, 7510000)
+    assert_equal '75.1M', rs.send(:humanize_number, 75100000)
+    assert_equal '751M', rs.send(:humanize_number,  751000000)
+    assert_equal '7.51G', rs.send(:humanize_number, 7510000000)
+    assert_equal '75.1G', rs.send(:humanize_number, 75100000000)
+    assert_equal '751G', rs.send(:humanize_number,  751000000000)
+    assert_equal '7.51T', rs.send(:humanize_number, 7510000000000)
+    assert_equal '75.1T', rs.send(:humanize_number, 75100000000000)
+    assert_equal '751T', rs.send(:humanize_number,  751000000000000)
+    assert_equal '7.51P', rs.send(:humanize_number, 7510000000000000)
+    assert_equal '75.1P', rs.send(:humanize_number, 75100000000000000)
+    assert_equal '751P', rs.send(:humanize_number,  751000000000000000)
+    assert_equal '7.51E', rs.send(:humanize_number, 7510000000000000000)
+    assert_equal '75.1E', rs.send(:humanize_number, 75100000000000000000)
+    assert_equal '751E',  rs.send(:humanize_number, 751000000000000000000)
+    assert_equal '7.51Z', rs.send(:humanize_number, 7510000000000000000000)
+
+    assert_equal '7.51PB', rs.send(:humanize_number, 7.51 * (1024 ** 5), true)
+    assert_equal '-7.51PB', rs.send(:humanize_number, -7.51 * (1024 ** 5), true)
+  end
+
+  def test_option_parse
+    options = RedisStat::Option.parse([])
+    assert_equal RedisStat::Option::DEFAULT.sort, options.sort
+
+    options = RedisStat::Option.parse(%w[localhost:1000 20])
+    assert_equal({
+      :hosts => ['localhost:1000'],
+      :interval => 20,
+      :count => nil,
+      :csv => nil,
+      :style => :unicode
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[localhost:1000 20 30])
+    assert_equal({
+      :hosts => ['localhost:1000'],
+      :interval => 20,
+      :count => 30,
+      :csv => nil,
+      :style => :unicode
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[20])
+    assert_equal({
+      :hosts => ['127.0.0.1:6379'],
+      :interval => 20,
+      :count => nil,
+      :csv => nil,
+      :style => :unicode
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[20 30])
+    assert_equal({
+      :hosts => ['127.0.0.1:6379'],
+      :interval => 20,
+      :count => 30,
+      :csv => nil,
+      :style => :unicode
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[localhost:8888 10 --csv=/tmp/a.csv --style=ascii --auth password])
+    assert_equal({
+      :auth => 'password',
+      :hosts => ['localhost:8888'],
+      :interval => 10,
+      :count => nil,
+      :csv => '/tmp/a.csv',
+      :style => :ascii
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[-h localhost:8888 10 -a password --csv=/tmp/a.csv --style=ascii])
+    assert_equal({
+      :auth => 'password',
+      :hosts => ['localhost:8888'],
+      :interval => 10,
+      :count => nil,
+      :csv => '/tmp/a.csv',
+      :style => :ascii
+    }.sort, options.sort)
+
+    # Server
+    if RUBY_PLATFORM == 'java'
+      assert_raise(SystemExit) {
+        RedisStat::Option.parse(%w[-h localhost:8888 10 -a password --csv=/tmp/a.csv --style=ascii --server=5555])
+      }
+      assert_raise(SystemExit) {
+        RedisStat::Option.parse(%w[-h localhost:8888 10 -a password --csv=/tmp/a.csv --style=ascii --server=5555 --daemon])
+      }
+    else
+      options = RedisStat::Option.parse(%w[-h localhost:8888 10 -a password --csv=/tmp/a.csv --style=ascii --server=5555 --daemon])
+      assert_equal({
+        :auth => 'password',
+        :hosts => ['localhost:8888'],
+        :interval => 10,
+        :count => nil,
+        :csv => '/tmp/a.csv',
+        :server_port => "5555",
+        :style => :ascii,
+        :daemon => true
+      }.sort, options.sort)
+    end
+
+    options = RedisStat::Option.parse(%w[--no-color])
+    assert_equal true, options[:mono]
+  end
+
+  def test_option_parse_invalid
+    [
+      %w[localhost 0],
+      %w[localhost 5 0]
+    ].each do |argv|
+      assert_raise(SystemExit) {
+        options = RedisStat::Option.parse(argv)
+      }
+    end
+
+    assert_raise(SystemExit) {
+      RedisStat::Option.parse(%w[--style=html])
+    }
+
+    assert_raise(SystemExit) {
+      RedisStat::Option.parse(%w[--daemon])
+    }
+  end
+
+  def test_start
+    csv = '/tmp/redis-stat.csv'
+    cnt = 100
+    rs = RedisStat.new :hosts => %w[localhost] * 5, :interval => 0.01, :count => cnt,
+            :verbose => true, :csv => csv, :auth => 'pw'
+    rs.start $stdout
+
+    assert_equal cnt + 1, File.read(csv).lines.to_a.length
+  ensure
+    File.unlink csv
+  end
+
+  def test_mono
+    [true, false].each do |mono|
+      rs = RedisStat.new :hosts => %w[localhost] * 5, :interval => 0.02, :count => 20,
+                         :verbose => true, :auth => 'pw', :mono => mono
+      output = StringIO.new
+      rs.start output
+      puts output.string
+      assert_equal mono, output.string !~ /\e\[\d*(;\d+)*m/
+    end
+  end
+
+  def test_static_info_of_mixed_versions
+    # prerequisite
+    r1 = Redis.new(:host => 'localhost')
+    r2 = Redis.new(:host => 'localhost', :port => 6380)
+
+    if r1.info['redis_version'] =~ /^2\.4/ && r2.info['redis_version'] =~ /^2\.2/
+      rs = RedisStat.new :hosts => %w[localhost:6380 localhost], :interval => 1, :count => 1,
+            :auth => 'pw', :style => :ascii
+      output = StringIO.new
+      rs.start output
+      vline = output.string.lines.select { |line| line =~ /gcc_version/ }.first
+      puts vline.gsub(/ +/, ' ')
+      assert vline.gsub(/ +/, ' ').include?('| | 4.2.1 |')
+    else
+      raise NotImplementedError.new # FIXME
+    end
+  rescue Redis::CannotConnectError, NotImplementedError 
+    pend "redises not ready"
+  end
+end
+