redis-stat 0.1.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis-stat.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Junegunn Choi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# redis-stat
+
+A command-line Redis monitoring tool written in Ruby.
+
+## Installation
+
+```
+gem install redis-stat
+```
+
+## Usage
+
+```
+usage: redis-stat [HOST[:PORT]] [INTERVAL [COUNT]]
+
+        --csv=OUTPUT_CSV_FILE_PATH   Saves the result in CSV format
+    -v, --verbose                    Show more info
+        --version                    Show version
+        --help                       Show this message
+```
+
+## Examples
+
+```
+redis-stat
+
+redis-stat 1
+
+redis-stat localhost:6380
+
+redis-stat localhost:6380 1 10
+
+redis-stat localhost:6380 1 10 --csv=/tmp/output.csv --verbose
+```
+
+## Screenshot
+
+![](https://github.com/junegunn/redis-stat/raw/master/screenshots/redis-stat-0.1.0.png)
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/bin/redis-stat

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'redis-stat'
+
+options = RedisStat::Option.parse ARGV
+rs = RedisStat.new options
+rs.start $stdout

data/lib/redis-stat.rb

@@ -0,0 +1,351 @@
+require "redis-stat/version"
+require "redis-stat/option"
+require 'insensitive_hash'
+require 'redis'
+require 'tabularize'
+require 'ansi'
+require 'csv'
+
+class RedisStat
+  DEFAULT_TERM_WIDTH  = 180
+  DEFAULT_TERM_HEIGHT = 25
+
+  def initialize options = {}
+    @options   = RedisStat::Option::DEFAULT.merge options
+    @redis     = Redis.new(Hash[ @options.select { |k, _| [:host, :port].include? k } ])
+    @max_count = @options[:count]
+    @count     = 0
+    @colors    = @options[:colors] || COLORS
+  end
+
+  def start output_stream
+    @os = output_stream
+    trap('INT') { Thread.main.raise Interrupt }
+
+    @csv = File.open(@options[:csv], 'w') if @options[:csv]
+    update_term_size!
+
+    begin
+      @started_at = Time.now
+      loop do
+        @info = @redis.info.insensitive
+        @info[:at] = Time.now.to_f
+
+        output @info, @prev_info, @csv
+
+        @prev_info = @info
+        @count += 1
+        break if @max_count && @count >= @max_count
+        sleep @options[: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 }
+      exit 1
+    ensure
+      @csv.close if @csv
+    end
+    @os.puts ansi(:blue, :bold) {
+      "Elapsed: #{"%.2f" % (Time.now - @started_at)} sec."
+    }
+  end
+
+private
+  def update_term_size!
+    @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, prev_info, file
+    info_output = process info, prev_info
+
+    init_table info_output unless @table
+
+    movement = nil
+    if @count == 0
+      movement = 0
+      output_static_info info
+
+      if file
+        file.puts CSV.generate_line(info_output.map { |pair|
+          LABELS[pair.first] || pair.first
+        })
+      end
+    elsif @count % @term_height == 0
+      movement = -1
+      update_term_size!
+      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)
+    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
+    data = 
+      {
+        :redis_stat_version => RedisStat::VERSION,
+        :redis_host         => @options[:host],
+        :redis_port         => @options[:port],
+        :csv                => @options[:csv],
+      }.merge(
+        Hash[
+          [
+            :redis_version,
+            :process_id,
+            :uptime_in_seconds,
+            :uptime_in_days,
+            :gcc_version,
+            :role,
+            :connected_slaves, # FIXME: not so static
+            :aof_enabled,
+            :vm_enabled
+          ].map { |k| [k, info[k]] }
+        ]
+      ).reject { |k, v| v.nil? }.to_a
+    @os.puts Tabularize.it(data, :align => :left).map { |pair| 
+      ansi(:bold) { pair.first } + ' : ' + pair.last
+    }
+  end
+
+  def init_table info_output
+    @table = Tabularize.new :unicode => false,
+                       :align => :right,
+                       :hborder => ansi(:black, :bold) { '-' },
+                       :iborder => ansi(:black, :bold) { '+' },
+                       :vborder => ' ',
+                       :pad_left => 0,
+                       :pad_right => 0,
+                       :screen_width => @term_width
+    @table << info_output.map { |pair|
+      ansi(*((@colors[pair.first] || []) + [:underline])) {
+        LABELS[pair.first] || pair.first
+      } 
+    }
+    @table.separator!
+  end
+
+  def process info, prev_info
+    MEASURES[@options[:verbose] ? :verbose : :default].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
+        (info[label].to_f - prev_info[label].to_f) / dur
+      else
+        nil
+      end
+    end
+
+    case key
+    when :at
+      Time.now.strftime('%H:%M:%S')
+    when :used_cpu_user, :used_cpu_sys
+      val = get_diff.call(key)
+      [humanize_number(val), val]
+    when :keys
+      val = Hash[ info.select { |k, v| k =~ /^db[0-9]+$/ } ].values.inject(0) { |sum, v| 
+        sum + Hash[ v.split(',').map { |e| e.split '=' } ]['keys'].to_i
+      }
+      [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 :total_commands_processed, :evicted_keys, :expired_keys, :keyspace_hits, :keyspace_misses
+      [humanize_number(info[key].to_i), info[key]]
+    when :used_memory, :used_memory_rss, :aof_current_size, :aof_base_size
+      [humanize_number(info[key].to_i, 1024, 'B'), info[key]]
+    else
+      info[key]
+    end
+  end
+
+  def format_number num
+    if num.to_i == num
+      num.to_i
+    elsif num < 10
+      "%.2f" % num
+    elsif num < 100
+      "%.1f" % num
+    else
+      num.to_i
+    end.to_s
+  end
+
+  def humanize_number bytes, k = 1000, suffix = ''
+    return '-' if bytes.nil?
+
+    bytes = bytes.to_f
+    if bytes < k
+      format_number(bytes)
+    elsif bytes < k ** 2
+      format_number(bytes / k) + 'K' + suffix
+    elsif bytes < k ** 3
+      format_number(bytes / k ** 2) + 'M' + suffix
+    else
+      format_number(bytes / k ** 3) + 'G' + suffix
+    end
+  end
+
+  def ansi *args, &block
+    if args.empty?
+      block.call
+    else
+      ANSI::Code.ansi *args, &block
+    end
+  end
+
+  MEASURES = {
+    :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/option.rb

@@ -0,0 +1,101 @@
+require 'optparse'
+
+class RedisStat
+module Option
+  DEFAULT = {
+    :host     => '127.0.0.1',
+    :port     => 6379,
+    :interval => 2,
+    :count    => nil,
+    :csv      => nil
+  }
+
+  def self.parse argv
+    argv = argv.dup
+
+    options = DEFAULT.dup
+    opts = ::OptionParser.new { |opts|
+      opts.banner = "usage: redis-stat [HOST[:PORT]] [INTERVAL [COUNT]]"
+      opts.separator ''
+
+      opts.on('--csv=OUTPUT_CSV_FILE_PATH', 'Save the result in CSV format') do |v|
+        options[:csv] = v
+      end
+
+      opts.on('-v', '--verbose', 'Show more info') do |v|
+        options[:verbose] = v
+      end
+
+      opts.on('--version', 'Show version') do
+        puts RedisStat::VERSION
+        exit 0
+      end
+
+      opts.on_tail('--help', 'Show this message') do
+        puts opts
+        exit 0
+      end
+    }
+    
+    begin
+      opts.parse! argv
+
+      is_number   = lambda { |str| str =~ /^([0-9]\.?[0-9]*)$|^([1-9][0-9]*)$/ }
+      set_options = lambda { |host_port, interval, count|
+        if host_port
+          host, port = host_port.split(':')
+          options[:host] = host
+          options[:port] = port.to_i if port
+        end
+
+        options[:interval] = interval.to_f if interval
+        options[:count] = count.to_i if count
+      }
+
+      case argv.length
+      when 1
+        if is_number.call argv.first
+          set_options.call nil, argv.first, nil
+        else
+          set_options.call argv.first, nil, nil
+        end
+      when 2
+        if is_number.call argv.first
+          set_options.call nil, argv.first, argv.last
+        else
+          set_options.call argv.first, argv.last, nil
+        end
+      when 3
+        set_options.call *argv
+      end
+
+      validate options
+
+      return options
+    rescue SystemExit => e
+      exit e.status
+    rescue Exception => e
+      puts e.to_s
+      puts opts
+      exit 1
+    end
+  end
+
+  def self.validate options
+    interval = options[:interval]
+    unless interval.is_a?(Numeric) && interval > 0
+      raise ArgumentError.new("Invalid interval: #{interval}")
+    end
+
+    count = options[:count]
+    unless count.nil? || (count.is_a?(Numeric) && count > 0)
+      raise ArgumentError.new("Invalid count: #{count}")
+    end
+
+    port = options[:port]
+    unless port.is_a?(Fixnum) && port > 0 && port < 65536
+      raise ArgumentError.new("Invalid port: #{port}")
+    end
+  end
+end
+end

data/lib/redis-stat/version.rb

@@ -0,0 +1,3 @@
+class RedisStat
+  VERSION = "0.1.2"
+end

data/redis-stat.gemspec

@@ -0,0 +1,24 @@
+# -*- 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 command-line Redis monitoring tool}
+  gem.summary       = %q{A command-line Redis monitoring tool}
+  gem.homepage      = "https://github.com/junegunn/redis-stat"
+
+  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.4'
+  gem.add_runtime_dependency "insensitive_hash", '~> 0.2.4'
+
+  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,74 @@
+require 'rubygems'
+require 'test/unit'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'redis-stat'
+
+class TestRedisStat < Test::Unit::TestCase
+  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({
+      :host => 'localhost',
+      :port => 1000,
+      :interval => 20,
+      :count => nil,
+      :csv => nil
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[localhost:1000 20 30])
+    assert_equal({
+      :host => 'localhost',
+      :port => 1000,
+      :interval => 20,
+      :count => 30,
+      :csv => nil
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[20])
+    assert_equal({
+      :host => '127.0.0.1',
+      :port => 6379,
+      :interval => 20,
+      :count => nil,
+      :csv => nil
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[20 30])
+    assert_equal({
+      :host => '127.0.0.1',
+      :port => 6379,
+      :interval => 20,
+      :count => 30,
+      :csv => nil
+    }.sort, options.sort)
+
+    options = RedisStat::Option.parse(%w[localhost:8888 10 --csv=/tmp/a.csv])
+    assert_equal({
+      :port => 8888,
+      :host => 'localhost',
+      :interval => 10,
+      :count => nil,
+      :csv => '/tmp/a.csv',
+    }.sort, options.sort)
+  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
+  end
+
+  def test_start
+    rs = RedisStat.new :interval => 0.1, :count => 200, :verbose => true, :csv => '/tmp/redis-stat.csv'
+    rs.start $stdout
+  end
+end
+
+

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: redis-stat
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Junegunn Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ansi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.3
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: tabularize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: insensitive_hash
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A command-line Redis monitoring tool
+email:
+- junegunn.c@gmail.com
+executables:
+- redis-stat
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/redis-stat
+- lib/redis-stat.rb
+- lib/redis-stat/option.rb
+- lib/redis-stat/version.rb
+- redis-stat.gemspec
+- test/bin_helper.rb
+- test/test_redis-stat.rb
+homepage: https://github.com/junegunn/redis-stat
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A command-line Redis monitoring tool
+test_files:
+- test/bin_helper.rb
+- test/test_redis-stat.rb