redis-stat 0.2.7 → 0.3.0

data/README.md

@@ -1,6 +1,14 @@
 # redis-stat
 
-A command-line Redis monitoring tool written in Ruby.
+_redis-stat_ is a simple Redis monitoring tool written in Ruby.
+
+It is based on [INFO](http://redis.io/commands/info) command of Redis,
+and thus generally won't affect the performance of the Redis instance
+unlike the other monitoring tools based on [MONITOR](http://redis.io/commands/monitor) command.
+
+_redis-stat_ allows you to monitor Redis instances
+- either with vmstat-like output from the terminal
+- or with the dashboard page served by its embedded web server.
 
 ## Installation
 
@@ -13,38 +21,59 @@ gem install redis-stat
 ```
 usage: redis-stat [HOST[:PORT] ...] [INTERVAL [COUNT]]
 
-        --auth=PASSWORD              Password
-        --csv=OUTPUT_CSV_FILE_PATH   Save the result in CSV format
+    -a, --auth=PASSWORD              Password
     -v, --verbose                    Show more info
         --style=STYLE                Output style: unicode|ascii
         --no-color                   Suppress ANSI color codes
+        --csv=OUTPUT_CSV_FILE_PATH   Save the result in CSV format
+
+        --server[=PORT]              Launch redis-stat web server (default port: 63790)
+        --daemon                     Daemonize redis-stat. Must be used with --server option.
+
         --version                    Show version
         --help                       Show this message
 ```
 
-## Examples
+## Running redis-stat for command-line monitoring
 
 ```
 redis-stat
-
 redis-stat 1
-
 redis-stat 1 10
-
+redis-stat --verbose
 redis-stat localhost:6380 1 10
-
 redis-stat localhost localhost:6380 localhost:6381 5
-
 redis-stat localhost localhost:6380 1 10 --csv=/tmp/output.csv --verbose
 ```
 
-## Screenshot
+### Screenshot
 
-![](https://github.com/junegunn/redis-stat/raw/master/screenshots/redis-stat-0.2.4.png)
+![Terminal output](https://github.com/junegunn/redis-stat/raw/master/screenshots/redis-stat-0.3.0.png)
 
-## Contributors
+## redis-stat in web browser
+
+When `--server` option is set, redis-stat will open up an embedded web server (default port: 63790)
+in the background so that you can monitor Redis in your browser.
+
+Since _redis-stat_ pushes updates every interval via [Server-sent events](http://www.w3.org/TR/eventsource/),
+modern browsers are required to view the page.
 
+```
+redis-stat --server
+redis-stat --verbose --server=8080 5
+
+# redis-stat server can be daemonized
+redis-stat --server --daemon
+```
+
+### Screenshot
+
+![Dashboard](https://github.com/junegunn/redis-stat/raw/master/screenshots/redis-stat-web.png)
+
+## Author
 - [Junegunn Choi](https://github.com/junegunn)
+
+## Contributors
 - [Chris Meisl](https://github.com/cmeisl)
 
 ## Contributing

data/bin/redis-stat

@@ -5,4 +5,12 @@ require 'redis-stat'
 
 options = RedisStat::Option.parse ARGV
 rs = RedisStat.new options
-rs.start $stdout
+if options[:daemon]
+  require 'daemons'
+  Daemons.daemonize(:app_name => 'redis-stat-daemon')
+end
+begin
+  rs.start $stdout
+rescue Exception
+  raise if options[:verbose]
+end

data/lib/redis-stat.rb

@@ -1,7 +1,9 @@
 # encoding: utf-8
 
-require "redis-stat/version"
-require "redis-stat/option"
+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'
@@ -11,15 +13,14 @@ require 'parallelize'
 require 'si'
 
 class RedisStat
-  DEFAULT_TERM_WIDTH  = 180
-  DEFAULT_TERM_HEIGHT = 25
+  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}.select { |k, v| v } ])
+      Redis.new(Hash[ {:host => host, :port => port, :timeout => DEFAULT_REDIS_TIMEOUT}.select { |k, v| v } ])
     }
     @interval    = options[:interval]
     @max_count   = options[:count]
@@ -28,9 +29,16 @@ class RedisStat
     @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
@@ -50,30 +58,18 @@ class RedisStat
         end
       end
 
-      @started_at = Time.now
-      all_measures = MEASURES.values.inject(:+).uniq - [:at]
-      prev_info = nil
-      loop do
-        info = {}.insensitive
-        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
 
-        output info, prev_info, csv
+      @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
@@ -84,7 +80,7 @@ class RedisStat
       @os.puts ansi(:yellow, :bold) { "Interrupted." }
     rescue Exception => e
       @os.puts ansi(:red, :bold) { e.to_s }
-      exit 1
+      raise
     ensure
       csv.close if csv
     end
@@ -94,14 +90,51 @@ class RedisStat
   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.match(/java/)
+    if RUBY_PLATFORM == 'java'
       require 'java'
       begin
-        @term ||= Java::jline.Terminal.getTerminal
-        @term_width  = (@term.getTerminalWidth rescue DEFAULT_TERM_WIDTH)
-        @term_height = (@term.getTerminalHeight rescue DEFAULT_TERM_HEIGHT) - 4
-        return
+        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
@@ -130,9 +163,7 @@ private
       end)
   end
 
-  def output info, prev_info, file
-    info_output = process info, prev_info
-
+  def output info, info_output, file
     @table ||= init_table info_output
 
     movement = nil
@@ -238,9 +269,11 @@ private
 
     case key
     when :at
-      Time.now.strftime('%H:%M:%S')
+      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| 
@@ -251,14 +284,12 @@ private
          :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 :total_commands_processed, :evicted_keys, :expired_keys, :keyspace_hits, :keyspace_misses
-      val = info.sumf(key)
-      [humanize_number(val.to_i), 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
-      humanize_number info.sumf(key)
+      val = info.sumf(key)
+      [humanize_number(val), val]
     end
   end
 
@@ -280,111 +311,4 @@ private
       ANSI::Code.ansi *args, &block
     end
   end
-
-  MEASURES = {
-    :static => [
-      :redis_version,
-      :process_id,
-      :uptime_in_seconds,
-      :uptime_in_days,
-      :gcc_version,
-      :role,
-      :connected_slaves,
-      :aof_enabled,
-      :vm_enabled
-    ],
-    :default => [
-      :at,
-      :used_cpu_user,
-      :used_cpu_sys,
-      :connected_clients,
-      :blocked_clients,
-      :used_memory,
-      :used_memory_rss,
-      :keys,
-      :total_commands_processed_per_second,
-      :expired_keys_per_second,
-      :evicted_keys_per_second,
-      :keyspace_hits_per_second,
-      :keyspace_misses_per_second,
-      :aof_current_size,
-      :pubsub_channels,
-    ],
-    :verbose => [
-      :at,
-      :used_cpu_user,
-      :used_cpu_sys,
-      :connected_clients,
-      :blocked_clients,
-      :used_memory,
-      :used_memory_rss,
-      :mem_fragmentation_ratio,
-      :keys,
-      :total_commands_processed_per_second,
-      :total_commands_processed,
-      :expired_keys_per_second,
-      :expired_keys,
-      :evicted_keys_per_second,
-      :evicted_keys,
-      :keyspace_hits_per_second,
-      :keyspace_hits,
-      :keyspace_misses_per_second,
-      :keyspace_misses,
-      :aof_current_size,
-      :aof_base_size,
-      :pubsub_channels,
-      :pubsub_patterns,
-    ]
-  }
-
-  COLORS = {
-    :at                                  => [:bold],
-    :used_cpu_user                       => [:yellow, :bold],
-    :used_cpu_sys                        => [:yellow],
-    :connected_clients                   => [:cyan, :bold],
-    :blocked_clients                     => [:cyan, :bold],
-    :used_memory                         => [:green],
-    :used_memory_rss                     => [:green],
-    :mem_fragmentation_ratio             => [:green],
-    :keys                                => [:bold],
-    :total_commands_processed            => [:blue, :bold],
-    :total_commands_processed_per_second => [:blue, :bold],
-    :expired_keys                        => [:red],
-    :expired_keys_per_second             => [:red],
-    :evicted_keys                        => [:red, :bold],
-    :evicted_keys_per_second             => [:red, :bold],
-    :keyspace_hits                       => [:magenta, :bold],
-    :keyspace_hits_per_second            => [:magenta, :bold],
-    :keyspace_misses                     => [:magenta],
-    :keyspace_misses_per_second          => [:magenta],
-    :aof_current_size                    => [:cyan],
-    :aof_base_size                       => [:cyan],
-    :pubsub_channels                     => [:cyan, :bold],
-    :pubsub_patterns                     => [:cyan, :bold],
-  }
-
-  LABELS = {
-    :at                                  => 'time',
-    :used_cpu_user                       => 'us',
-    :used_cpu_sys                        => 'sy',
-    :connected_clients                   => 'cl',
-    :blocked_clients                     => 'bcl',
-    :used_memory                         => 'mem',
-    :used_memory_rss                     => 'rss',
-    :mem_fragmentation_ratio             => 'frag',
-    :total_commands_processed            => 'cmd',
-    :total_commands_processed_per_second => 'cmd/s',
-    :expired_keys                        => 'exp',
-    :expired_keys_per_second             => 'exp/s',
-    :evicted_keys                        => 'evt',
-    :evicted_keys_per_second             => 'evt/s',
-    :keyspace_hits                       => 'hit',
-    :keyspace_hits_per_second            => 'hit/s',
-    :keyspace_misses                     => 'mis',
-    :keyspace_misses_per_second          => 'mis/s',
-    :aof_current_size                    => 'aofcs',
-    :aof_base_size                       => 'aofbs',
-    :pubsub_channels                     => 'psch',
-    :pubsub_patterns                     => 'psp',
-  }
 end

data/lib/redis-stat/constants.rb

@@ -0,0 +1,118 @@
+class RedisStat
+  DEFAULT_TERM_WIDTH    = 180
+  DEFAULT_TERM_HEIGHT   = 25
+  DEFAULT_SERVER_PORT   = 63790
+  DEFAULT_REDIS_TIMEOUT = 30
+
+  MEASURES = {
+    :static => [
+      :redis_version,
+      :process_id,
+      :uptime_in_seconds,
+      :uptime_in_days,
+      :gcc_version,
+      :role,
+      :connected_slaves,
+      :aof_enabled,
+      :vm_enabled
+    ],
+    :default => [
+      :at,
+      :used_cpu_user,
+      :used_cpu_sys,
+      :connected_clients,
+      :blocked_clients,
+      :used_memory,
+      :used_memory_rss,
+      :keys,
+      :total_commands_processed_per_second,
+      :expired_keys_per_second,
+      :evicted_keys_per_second,
+      :keyspace_hits_per_second,
+      :keyspace_misses_per_second,
+      :aof_current_size,
+      :pubsub_channels,
+    ],
+    :verbose => [
+      :at,
+      :used_cpu_user,
+      :used_cpu_sys,
+      :connected_clients,
+      :blocked_clients,
+      :used_memory,
+      :used_memory_rss,
+      :mem_fragmentation_ratio,
+      :keys,
+      :total_commands_processed_per_second,
+      :total_commands_processed,
+      :expired_keys_per_second,
+      :expired_keys,
+      :evicted_keys_per_second,
+      :evicted_keys,
+      :keyspace_hits_per_second,
+      :keyspace_hits,
+      :keyspace_misses_per_second,
+      :keyspace_misses,
+      :aof_current_size,
+      :aof_base_size,
+      :changes_since_last_save,
+      :pubsub_channels,
+      :pubsub_patterns,
+    ]
+  }
+
+  COLORS = {
+    :at                                  => [:bold],
+    :used_cpu_user                       => [:yellow, :bold],
+    :used_cpu_sys                        => [:yellow],
+    :connected_clients                   => [:cyan, :bold],
+    :blocked_clients                     => [:cyan, :bold],
+    :used_memory                         => [:green],
+    :used_memory_rss                     => [:green],
+    :mem_fragmentation_ratio             => [:green],
+    :keys                                => [:bold],
+    :total_commands_processed            => [:blue, :bold],
+    :total_commands_processed_per_second => [:blue, :bold],
+    :expired_keys                        => [:red],
+    :expired_keys_per_second             => [:red],
+    :evicted_keys                        => [:red, :bold],
+    :evicted_keys_per_second             => [:red, :bold],
+    :keyspace_hits                       => [:magenta, :bold],
+    :keyspace_hits_per_second            => [:magenta, :bold],
+    :keyspace_misses                     => [:magenta],
+    :keyspace_misses_per_second          => [:magenta],
+    :aof_current_size                    => [:cyan],
+    :aof_base_size                       => [:cyan],
+    :changes_since_last_save             => [:green, :bold],
+    :pubsub_channels                     => [:cyan, :bold],
+    :pubsub_patterns                     => [:cyan, :bold],
+  }
+
+  LABELS = {
+    :at                                  => 'time',
+    :used_cpu_user                       => 'us',
+    :used_cpu_sys                        => 'sy',
+    :connected_clients                   => 'cl',
+    :blocked_clients                     => 'bcl',
+    :used_memory                         => 'mem',
+    :used_memory_rss                     => 'rss',
+    :mem_fragmentation_ratio             => 'frag',
+    :total_commands_processed            => 'cmd',
+    :total_commands_processed_per_second => 'cmd/s',
+    :expired_keys                        => 'exp',
+    :expired_keys_per_second             => 'exp/s',
+    :evicted_keys                        => 'evt',
+    :evicted_keys_per_second             => 'evt/s',
+    :keys                                => 'keys',
+    :keyspace_hits                       => 'hit',
+    :keyspace_hits_per_second            => 'hit/s',
+    :keyspace_misses                     => 'mis',
+    :keyspace_misses_per_second          => 'mis/s',
+    :aof_current_size                    => 'aofcs',
+    :aof_base_size                       => 'aofbs',
+    :changes_since_last_save             => 'chsv',
+    :pubsub_channels                     => 'psch',
+    :pubsub_patterns                     => 'psp',
+  }
+end
+