daikon 0.6.0 → 0.7.0

data/daikon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{daikon}
-  s.version = "0.6.0"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nick Quaranto"]
-  s.date = %q{2011-01-10}
+  s.date = %q{2011-01-29}
   s.default_executable = %q{daikon}
   s.description = %q{daikon, a radishapp.com client}
   s.email = %q{nick@quaran.to}
@@ -40,7 +40,6 @@ Gem::Specification.new do |s|
     "spec/client_spec.rb",
     "spec/configuration_spec.rb",
     "spec/daemon_spec.rb",
-    "spec/daikon_spec.rb",
     "spec/monitor_spec.rb",
     "spec/spec_helper.rb"
   ]
@@ -54,7 +53,6 @@ Gem::Specification.new do |s|
     "spec/client_spec.rb",
     "spec/configuration_spec.rb",
     "spec/daemon_spec.rb",
-    "spec/daikon_spec.rb",
     "spec/monitor_spec.rb",
     "spec/spec_helper.rb"
   ]

data/lib/daikon.rb

@@ -1,10 +1,11 @@
 require 'rubygems'
 
 require 'logger'
-require 'pp'
 require 'shellwords'
+require 'set'
 require 'socket'
 require 'stringio'
+require 'thread'
 
 require 'excon'
 require 'daemons'
@@ -25,5 +26,5 @@ require 'daikon/monitor'
 require 'daikon/redis_hacks'
 
 module Daikon
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/daikon/client.rb

@@ -6,7 +6,8 @@ module Daikon
                   Errno::EINVAL,
                   Errno::ECONNRESET,
                   EOFError,
-                  JSON::ParserError]
+                  JSON::ParserError,
+                  Excon::Errors::SocketError]
 
     attr_accessor :redis, :logger, :config, :http, :monitor
 
@@ -38,7 +39,7 @@ module Daikon
       options[:headers] ||= {}
       options[:headers]['Authorization'] = config.api_key
 
-      log "#{options[:method]} #{config.server_prefix}/#{options[:path]}"
+      log "#{options[:method]} #{config.server_prefix}#{options[:path]}"
       http.request(options)
     end
 
@@ -65,16 +66,19 @@ module Daikon
       log ex.to_s
     end
 
-    def report_info
-      push :post, "/api/v1/info.json", redis.info
+    def rotate_monitor(start, stop)
+      payload = monitor.rotate.merge({
+        "start" => start,
+        "stop"  => stop
+      })
+
+      push :post, "/api/v1/summaries.json", payload
     rescue *EXCEPTIONS => ex
       log ex.to_s
     end
 
-    def rotate_monitor
-      lines = monitor.rotate
-
-      push :post, "/api/v1/monitor.json", {"lines" => lines}
+    def report_info
+       push :post, "/api/v1/infos.json", redis.info
     rescue *EXCEPTIONS => ex
       log ex.to_s
     end

data/lib/daikon/daemon.rb

@@ -1,6 +1,26 @@
 module Daikon
   class Daemon
-    def self.start(argv)
+    INFO_INTERVAL    = ENV["INFO_INTERVAL"] || 5
+    SUMMARY_INTERVAL = ENV["SUMMARY_INTERVAL"] || 60
+
+    def self.sleep_time=(sleep_time)
+      @@sleep_time = sleep_time
+    end
+
+    def self.sleep_time
+      @@sleep_time ||= 1
+    end
+
+    def self.run=(run)
+      @@run = run
+    end
+
+    def self.run
+      @@run
+    end
+
+    def self.start(argv, ontop = false)
+      self.run = true
       config = Daikon::Configuration.new(argv)
 
       if argv.include?("-v") || argv.include?("--version")
@@ -8,31 +28,34 @@ module Daikon
         return
       end
 
-      Daemons.run_proc("daikon", :log_output => true, :backtrace => true) do
+      Daemons.run_proc("daikon", :ARGV => argv, :log_output => true, :backtrace => true, :ontop => ontop) do
         if argv.include?("run")
           logger = Logger.new(STDOUT)
         else
           logger = Logger.new("/tmp/radish.log")
         end
 
-        count  = 0
-        client = Daikon::Client.new
+        rotated_at  = Time.now
+        reported_at = Time.now
+        client      = Daikon::Client.new
+
         client.setup(config, logger)
         client.start_monitor
 
-        loop do
-          if count % 5 == 0
+        while self.run do
+          now = Time.now
+
+          if now - reported_at >= sleep_time * INFO_INTERVAL.to_i
             client.report_info
+            reported_at = now
           end
 
-          client.fetch_commands
-
-          if count % 10 == 9
-            client.rotate_monitor
+          if now - rotated_at >= sleep_time * SUMMARY_INTERVAL.to_i
+            client.rotate_monitor(rotated_at, now)
+            rotated_at = now
           end
 
-          count += 1
-          sleep 1
+          sleep sleep_time
         end
       end
     end

data/lib/daikon/monitor.rb

@@ -1,15 +1,29 @@
 module Daikon
   class Monitor
-    attr_accessor :queue
+    attr_accessor :data
+
+    NO_ARG_COMMANDS = ["BGREWRITEAOF", "BGSAVE", "CONFIG RESETSTAT", "DBSIZE", "DEBUG SEGFAULT", "DISCARD", "EXEC", "FLUSHALL", "FLUSHDB", "INFO", "LASTSAVE", "MONITOR", "MULTI", "PING", "QUIT", "RANDOMKEY", "SAVE", "SHUTDOWN", "SYNC", "UNWATCH"]
+    READ_COMMANDS   = ["EXISTS", "GET", "GETBIT", "GETRANGE", "HEXISTS", "HGET", "HGETALL", "HKEYS", "HLEN", "HMGET", "HVALS", "KEYS", "LINDEX", "LLEN", "LRANGE", "MGET", "SCARD", "SDIFF", "SINTER", "SISMEMBER", "SMEMBERS", "SORT", "SRANDMEMBER", "STRLEN", "SUNION", "TTL", "TYPE", "ZCARD", "ZCOUNT", "ZRANGE", "ZRANGEBYSCORE", "ZRANK", "ZREVRANGE", "ZREVRANGEBYSCORE", "ZREVRANK", "ZSCORE"].to_set
+    WRITE_COMMANDS  = ["APPEND", "BLPOP", "BRPOP", "BRPOPLPUSH", "DECR", "DECRBY", "DEL", "GETSET", "EXPIRE", "EXPIREAT", "HDEL", "HINCRBY", "HMSET", "HSET", "HSETNX", "INCR", "INCRBY", "LINSERT", "LPOP", "LPUSH", "LPUSHX", "LREM", "LSET", "LTRIM", "MOVE", "MSET", "MSETNX", "PERSIST", "RENAME", "RENAMENX", "RPOP", "RPOPLPUSH", "RPUSH", "RPUSHX", "SADD", "SDIFFSTORE", "SET", "SETBIT", "SETEX", "SETNX", "SETRANGE", "SINTERSTORE", "SMOVE", "SPOP", "SREM", "SUNIONSTORE", "ZADD", "ZINCRBY", "ZINTERSTORE", "ZREM", "ZREMRANGEBYRANK", "ZREMRANGEBYSCORE", "ZUNIONSTORE"].to_set
+    OTHER_COMMANDS  = ["AUTH", "BGREWRITEAOF", "BGSAVE", "CONFIG GET", "CONFIG SET", "CONFIG RESETSTAT", "DBSIZE", "DEBUG OBJECT", "DEBUG SEGFAULT", "DISCARD", "ECHO", "EXEC", "FLUSHALL", "FLUSHDB", "INFO", "LASTSAVE", "MONITOR", "MULTI", "PING", "PSUBSCRIBE", "PUBLISH", "PUNSUBSCRIBE", "QUIT", "RANDOMKEY", "SAVE", "SELECT", "SHUTDOWN", "SUBSCRIBE", "SYNC", "UNSUBSCRIBE", "UNWATCH", "WATCH"].to_set
+    ALL_COMMANDS    = READ_COMMANDS + WRITE_COMMANDS + OTHER_COMMANDS
 
     NEW_FORMAT        = /^\+?(\d+\.\d+)( "[A-Z]+".*)/i
-    OLD_SINGLE_FORMAT = /^(QUIT|RANDOMKEY|DBSIZE|EXPIRE|TTL|SAVE|BGSAVE|SHUTDOWN|BGREWRITEAOF|INFO|MONITOR|SLAVEOF)$/i
+    OLD_SINGLE_FORMAT = /^(#{NO_ARG_COMMANDS.join('|')})$/i
     OLD_MORE_FORMAT   = /^[A-Z]+ .*$/i
 
     def initialize(redis = nil, logger = nil)
-      @queue  = []
+      @data   = data_hash
       @redis  = redis
       @logger = logger
+      @mutex  = Mutex.new
+    end
+
+    def data_hash
+      {"commands"   => Hash.new(0),
+       "keys"       => Hash.new(0),
+       "namespaces" => Hash.new(0),
+       "totals"     => Hash.new(0)}
     end
 
     def start
@@ -20,20 +34,74 @@ module Daikon
       end
     end
 
+    def lock(&block)
+      @mutex.synchronize(&block)
+    end
+
     def rotate
-      @queue.shift(@queue.size)
+      this_data = nil
+      lock do
+        this_data = self.data.dup
+        self.data.replace(data_hash)
+      end
+      this_data["keys"] = Hash[*this_data["keys"].sort_by(&:last).reverse[0..99].flatten]
+      this_data
     end
 
     def parse(line)
       if line =~ NEW_FORMAT
-        push(Float($1), $2)
+        push($2)
       elsif line =~ OLD_SINGLE_FORMAT || line =~ OLD_MORE_FORMAT
-        push(Time.now.to_f, line)
+        push(line)
       end
     end
 
-    def push(at, command)
-      @queue.push({:at => at, :command => command.strip})
+    def push(raw_command)
+      command, key, *rest = raw_command.strip.gsub('"', '').split
+      command.upcase!
+      lock do
+        incr_command(command)
+        incr_total(command)
+        if key
+          incr_key(key)
+          incr_namespace(key)
+        else
+          incr_global_namespace
+        end
+      end
+    end
+
+    def incr_namespace(key)
+      namespace, has_namespace = key.split(/(?::|-)/, 2)
+      if has_namespace
+        data["namespaces"][namespace] += 1
+      else
+        incr_global_namespace
+      end
+    end
+
+    def incr_global_namespace
+      data["namespaces"]["global"] += 1
+    end
+
+    def incr_command(command)
+      data["commands"][command] += 1 if ALL_COMMANDS.member?(command)
+    end
+
+    def incr_key(key)
+      data["keys"][key.gsub(".", "{PERIOD}").gsub("$", "{DOLLAR}")] += 1
+    end
+
+    def incr_total(command)
+      data["totals"]["all"] += 1
+
+      if READ_COMMANDS.member?(command)
+        data["totals"]["read"] += 1
+      elsif WRITE_COMMANDS.member?(command)
+        data["totals"]["write"] += 1
+      elsif OTHER_COMMANDS.member?(command)
+        data["totals"]["other"] += 1
+      end
     end
   end
 end

data/spec/client_spec.rb

@@ -134,32 +134,47 @@ describe Daikon::Client, "when it returns bad json" do
   end
 end
 
-shared_examples_for "a info api consumer" do
+shared_examples_for "a summary api consumer" do
   it "shoots the results back to radish" do
     headers = {
       "Authorization"  => api_key,
-      "Content-Length" => results.to_json.size.to_s,
+      "Content-Length" => payload.to_json.size.to_s,
       "Content-Type"   => "application/json"
     }
 
     http.should have_received(:request).with(
       :method  => "POST",
-      :path    => "/api/v1/info.json",
-      :body    => results.to_json,
+      :path    => "/api/v1/summaries.json",
+      :body    => payload.to_json,
       :headers => headers)
   end
 end
 
-describe Daikon::Client, "report info" do
-  subject       { Daikon::Client.new }
-  let(:results) { {"connected_clients"=>"1", "used_cpu_sys_childrens"=>"0.00"} }
-  let(:redis)   { stub("redis instance", :info => results) }
-  let(:http)    { stub("http", :request => Excon::Response.new) }
+describe Daikon::Client, "rotate monitor" do
+  subject     { Daikon::Client.new }
+  let(:http)  { stub("http", :request => Excon::Response.new) }
+  let(:now)   { "2011-01-19T18:23:55-05:00" }
+  let(:past)  { "2011-01-19T18:23:54-05:00" }
+  let(:payload) do
+    data.merge("start" => past, "stop" => now)
+  end
+  let(:data) do
+    {"commands"   => {"GET" => 42},
+     "keys"       => {"foo" => 42},
+     "namespaces" => {"a" => 42, "global" => 42},
+     "totals"     => {"all" => 42, "read" => 42}}
+  end
 
   before do
-    subject.stubs(:redis => redis, :http => http)
+    Timecop.freeze DateTime.parse(now)
+    subject.stubs(:http => http)
     subject.setup(config)
-    subject.report_info
+    subject.monitor = stub("monitor", :rotate => data)
+    subject.rotate_monitor(DateTime.parse(past), DateTime.parse(now))
+  end
+
+  after do
+    Timecop.return
   end
 
   context "with default configuration" do
@@ -167,7 +182,7 @@ describe Daikon::Client, "report info" do
     let(:server)  { "https://radish.heroku.com" }
     let(:config)  { Daikon::Configuration.new }
 
-    it_should_behave_like "a info api consumer"
+    it_should_behave_like "a summary api consumer"
   end
 
   context "with custom settings" do
@@ -175,43 +190,57 @@ describe Daikon::Client, "report info" do
     let(:server)  { "http://localhost:9999" }
     let(:config)  { Daikon::Configuration.new(["-k", api_key, "-s", "http://localhost:9999"]) }
 
-    it_should_behave_like "a info api consumer"
+    it_should_behave_like "a summary api consumer"
   end
 end
 
-shared_examples_for "a monitor api consumer" do
-  it "shoots the results back to radish" do
-    payload = {"lines" => lines}
+describe Daikon::Client, "pretty printing results" do
+  subject      { Daikon::Client.new }
+  let(:body)   { {"13" => "LRANGE foo 0 -1"}.to_json }
+  let(:list)   { %w[apples bananas carrots] }
+  let(:server) { "https://radish.heroku.com" }
+  let(:config) { Daikon::Configuration.new }
+  let(:http)   { stub("http", :request => Excon::Response.new(:body => body)) }
 
+  before do
+    subject.stubs(:evaluate_redis => list, :http => http)
+    subject.setup(config)
+    subject.fetch_commands
+  end
+
+  it "returns pretty printed results" do
+    http.should have_received(:request).with(has_entry(
+      :body => {"response" => "[\"apples\", \"bananas\", \"carrots\"]"}.to_json
+    ))
+  end
+end
+
+shared_examples_for "a info api consumer" do
+  it "shoots the results back to radish" do
     headers = {
       "Authorization"  => api_key,
-      "Content-Length" => payload.to_json.size.to_s,
+      "Content-Length" => results.to_json.size.to_s,
       "Content-Type"   => "application/json"
     }
 
     http.should have_received(:request).with(
       :method  => "POST",
-      :path    => "/api/v1/monitor.json",
-      :body    => payload.to_json,
+      :path    => "/api/v1/infos.json",
+      :body    => results.to_json,
       :headers => headers)
   end
 end
 
-describe Daikon::Client, "rotate monitor" do
+describe Daikon::Client, "report info" do
   subject       { Daikon::Client.new }
-  let(:results) { %{1290289048.96581 "info"\n1290289053.568815 "info"} }
+  let(:results) { {"connected_clients"=>"1", "used_cpu_sys_childrens"=>"0.00"} }
   let(:redis)   { stub("redis instance", :info => results) }
   let(:http)    { stub("http", :request => Excon::Response.new) }
-  let(:lines) do
-    [{"at" => 1290289048.96581,  "command" => "info"},
-     {"at" => 1290289053.568815, "command" => "info"}]
-  end
 
   before do
-    subject.stubs(:http => http)
+    subject.stubs(:redis => redis, :http => http)
     subject.setup(config)
-    subject.monitor = stub("monitor", :rotate => lines)
-    subject.rotate_monitor
+    subject.report_info
   end
 
   context "with default configuration" do
@@ -219,7 +248,7 @@ describe Daikon::Client, "rotate monitor" do
     let(:server)  { "https://radish.heroku.com" }
     let(:config)  { Daikon::Configuration.new }
 
-    it_should_behave_like "a monitor api consumer"
+    it_should_behave_like "a info api consumer"
   end
 
   context "with custom settings" do
@@ -227,27 +256,6 @@ describe Daikon::Client, "rotate monitor" do
     let(:server)  { "http://localhost:9999" }
     let(:config)  { Daikon::Configuration.new(["-k", api_key, "-s", "http://localhost:9999"]) }
 
-    it_should_behave_like "a monitor api consumer"
-  end
-end
-
-describe Daikon::Client, "pretty printing results" do
-  subject      { Daikon::Client.new }
-  let(:body)   { {"13" => "LRANGE foo 0 -1"}.to_json }
-  let(:list)   { %w[apples bananas carrots] }
-  let(:server) { "https://radish.heroku.com" }
-  let(:config) { Daikon::Configuration.new }
-  let(:http)   { stub("http", :request => Excon::Response.new(:body => body)) }
-
-  before do
-    subject.stubs(:evaluate_redis => list, :http => http)
-    subject.setup(config)
-    subject.fetch_commands
-  end
-
-  it "returns pretty printed results" do
-    http.should have_received(:request).with(has_entry(
-      :body => {"response" => "[\"apples\", \"bananas\", \"carrots\"]"}.to_json
-    ))
+    it_should_behave_like "a info api consumer"
   end
 end

data/spec/daemon_spec.rb

@@ -1,6 +1,29 @@
 require 'spec_helper'
 
 describe Daikon::Daemon do
+  let(:client) { stub("client") }
+
+  before do
+    Daikon::Client.stubs(:new => client)
+    Daikon::Daemon.sleep_time = 0.05
+    client.stubs(:setup => true,
+                 :start_monitor => true,
+                 :rotate_monitor => true,
+                 :report_info => true)
+  end
+
+  it "submits the last minute of data" do
+    thread = Thread.new do
+      Daikon::Daemon.start(["run", "--", "-k", "1234"], true)
+    end
+    sleep 3.1
+    Daikon::Daemon.run = false
+    client.should have_received(:rotate_monitor)
+    client.should have_received(:report_info).times(12)
+  end
+end
+
+describe Daikon::Daemon, "flags" do
   %w[-v --version].each do |flag|
     it "shows the daikon version with #{flag}" do
       old_stdout = $stdout

data/spec/monitor_spec.rb

@@ -1,15 +1,52 @@
 require 'spec_helper'
 
 describe Daikon::Monitor, "#rotate" do
-  it "pops off what is on the queue" do
+  before do
     subject.parse("INCR foo")
     subject.parse("DECR foo")
+    subject.parse("DECR baz")
+    subject.parse("HGETALL faz")
+    subject.parse("PING")
+  end
+
+  it "clears out current data" do
+    subject.rotate
+    subject.data["commands"].size.should be_zero
+    subject.data["totals"].size.should be_zero
+    subject.data["keys"].size.should be_zero
+  end
+
+  it "only saves the top 100 key listings" do
+    150.times { |n| subject.parse("INCR foo#{n}") }
+    150.times { |n| subject.parse("DECR foo#{n}") }
+    100.times { |n| subject.parse("DEL foo#{n}") }
+    data = subject.rotate
+    data["keys"].size.should == 100
+    data["keys"].values.all? { |n| n == 3 }.should be_true
+  end
 
+  it "santizes key names" do
+    subject.parse("INCR $foo.zomg")
     data = subject.rotate
-    data.first[:command].should == "INCR foo"
-    data.last[:command].should  == "DECR foo"
-    data.size.should == 2
-    subject.queue.size.should be_zero
+    data["keys"]["$foo.zomg"].should be_nil
+    data["keys"]["{DOLLAR}foo{PERIOD}zomg"].should == 1
+  end
+
+  it "increments each command type" do
+    subject.data["commands"]["INCR"].should == 1
+    subject.data["commands"]["DECR"].should == 2
+  end
+
+  it "keeps track of key accesses" do
+    subject.data["keys"]["foo"].should == 2
+    subject.data["keys"]["baz"].should == 1
+  end
+
+  it "tallies up totals of commands" do
+    subject.data["totals"]["all"].should == 5
+    subject.data["totals"]["read"].should == 1
+    subject.data["totals"]["write"].should == 3
+    subject.data["totals"]["other"].should == 1
   end
 end
 
@@ -19,7 +56,10 @@ describe Daikon::Monitor, "#parse with new format" do
 
   it "parses the log into json" do
     subject.parse(line)
-    subject.queue.should include({:at => 1291699658.994073, :command => '"decrby" "fooz" "2000"'})
+    subject.data["commands"]["DECRBY"].should == 1
+    subject.data["keys"]["fooz"].should == 1
+    subject.data["totals"]["all"].should == 1
+    subject.data["totals"]["write"].should == 1
   end
 end
 
@@ -29,78 +69,94 @@ describe Daikon::Monitor, "#parse with new format that has reply byte" do
 
   it "parses the log into json" do
     subject.parse(line)
-    subject.queue.should include({:at => 1291699658.994073, :command => '"decrby" "fooz" "2000"'})
-  end
-end
-
-describe Daikon::Monitor, "#parse with multiple inputs" do
-  subject { Daikon::Monitor.new }
-  before  { Timecop.freeze }
-  after   { Timecop.return }
-
-  it "queues up multiple lines" do
-    subject.parse("+OK")
-    subject.parse("INCR foo")
-    subject.parse("INCR fooz")
-    subject.parse("info")
-
-    subject.queue.size.should == 3
-    subject.queue.should include({:at => Time.now.to_f, :command => 'INCR foo'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'INCR fooz'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'info'})
+    subject.data["commands"]["DECRBY"].should == 1
+    subject.data["keys"]["fooz"].should == 1
+    subject.data["totals"]["all"].should == 1
+    subject.data["totals"]["write"].should == 1
   end
 end
 
 describe Daikon::Monitor, "#parse with old multi line input" do
   subject { Daikon::Monitor.new }
-  before  { Timecop.freeze }
-  after   { Timecop.return }
 
-  it "parses gzipped logs into raws" do
+  it "parses logs" do
     subject.parse("incr foo")
     subject.parse("sismember project-13897-global-error-classes 17")
     subject.parse("incrApiParameterError")
     subject.parse("decr foo")
 
-    subject.queue.size.should == 3
-    subject.queue.should include({:at => Time.now.to_f, :command => 'incr foo'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'sismember project-13897-global-error-classes 17'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'decr foo'})
+    subject.data["commands"]["DECR"].should == 1
+    subject.data["commands"]["INCR"].should == 1
+    subject.data["commands"]["SISMEMBER"].should == 1
+    subject.data["keys"]["foo"].should == 2
+    subject.data["keys"]["project-13897-global-error-classes"].should == 1
+    subject.data["totals"]["all"].should == 3
+    subject.data["totals"]["write"].should == 2
+    subject.data["totals"]["read"].should == 1
   end
 end
 
-describe Daikon::Monitor, "#parse with multi line input with numbers" do
+describe Daikon::Monitor, "#parse with old input" do
   subject { Daikon::Monitor.new }
-  before  { Timecop.freeze }
-  after   { Timecop.return }
 
-  it "parses gzipped logs into raws" do
-    subject.parse("incr foo")
-    subject.parse("set g:2470920:mrn 9")
-    subject.parse("554079885")
-    subject.parse("decr foo")
+  shared_examples_for "a valid parser" do
+    it "parses the given commands properly" do
+      subject.data["commands"]["DECR"].should == 1
+      subject.data["commands"]["INCR"].should == 1
+      subject.data["commands"]["SET"].should == 1
+      subject.data["keys"]["foo"].should == 2
+      subject.data["keys"]["g:2470920:mrn"].should == 1
+      subject.data["totals"]["all"].should == 3
+      subject.data["totals"]["write"].should == 3
+    end
+  end
 
-    subject.queue.size.should == 3
-    subject.queue.should include({:at => Time.now.to_f, :command => 'incr foo'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'set g:2470920:mrn 9'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'decr foo'})
+  context "with a bulk input that is a number" do
+    before do
+      subject.parse("incr foo")
+      subject.parse("set g:2470920:mrn 9")
+      subject.parse("554079885")
+      subject.parse("decr foo")
+    end
+    it_should_behave_like "a valid parser"
+  end
+
+  context "with a bulk input that is a number" do
+    before do
+      subject.parse("incr foo")
+      subject.parse("set g:2470920:mrn 9")
+      subject.parse("46fdcf77c1bb2108e6191602c2f5f9ae")
+      subject.parse("decr foo")
+    end
+    it_should_behave_like "a valid parser"
   end
 end
 
-describe Daikon::Monitor, "#parse with strings that may to_i to a number" do
-  subject { Daikon::Monitor.new }
-  before  { Timecop.freeze }
-  after   { Timecop.return }
+describe Daikon::Monitor, "#rotate with a bad command name" do
+  before do
+    subject.parse("gmail foo")
+  end
 
-  it "parses gzipped logs into raws" do
-    subject.parse("incr foo")
+  it "clears out current data" do
+    data = subject.rotate
+    data["commands"].size.should be_zero
+  end
+end
+
+describe Daikon::Monitor, "#rotate that collects namespaces" do
+  before do
     subject.parse("set g:2470920:mrn 9")
-    subject.parse("46fdcf77c1bb2108e6191602c2f5f9ae")
-    subject.parse("decr foo")
+    subject.parse("get g:2470914:mrn")
+    subject.parse("incr s3-queue-key")
+    subject.parse("info")
+    subject.parse("decr somehorriblynamespacedkey")
+    subject.parse("flushdb")
+  end
 
-    subject.queue.size.should == 3
-    subject.queue.should include({:at => Time.now.to_f, :command => 'incr foo'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'set g:2470920:mrn 9'})
-    subject.queue.should include({:at => Time.now.to_f, :command => 'decr foo'})
+  it "keeps track of namespace accesses" do
+    data = subject.rotate
+    data["namespaces"]["g"].should == 2
+    data["namespaces"]["global"].should == 3
+    data["namespaces"]["s3"].should == 1
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: daikon
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Nick Quaranto
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-10 00:00:00 -05:00
+date: 2011-01-29 00:00:00 -05:00
 default_executable: daikon
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -183,7 +183,6 @@ files:
 - spec/client_spec.rb
 - spec/configuration_spec.rb
 - spec/daemon_spec.rb
-- spec/daikon_spec.rb
 - spec/monitor_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -226,6 +225,5 @@ test_files:
 - spec/client_spec.rb
 - spec/configuration_spec.rb
 - spec/daemon_spec.rb
-- spec/daikon_spec.rb
 - spec/monitor_spec.rb
 - spec/spec_helper.rb

data/spec/daikon_spec.rb

@@ -1,4 +0,0 @@
-require 'spec_helper'
-
-describe "Daikon" do
-end