counters 1.3.0 → 1.3.1

data/lib/counters/base.rb

@@ -42,7 +42,7 @@ module Counters
         @namespace
       else
         other = self.dup
-        other.namespace = [@namespace.to_s, args.first].join(".")
+        other.namespace = [@namespace.to_s, args.first].reject {|ns| ns.empty?}.join(".")
         other
       end
     end

data/lib/counters/version.rb

@@ -1,3 +1,3 @@
 module Counters
-  VERSION = "1.3.0"
+  VERSION = "1.3.1"
 end

data/spec/file_counter_spec.rb

@@ -89,7 +89,7 @@ describe Counters::File do
     Tempfile.new("counters.log")
   end
 
-  let :counter do
+  subject do
     Counters::File.new(tempfile)
   end
 
@@ -104,60 +104,60 @@ describe Counters::File do
 
   context "given the counter is namespaced" do
     it "should namespace the key from #hit" do
-      counter.namespace = "juice"
-      counter.hit "foxglove"
+      subject.namespace = "juice"
+      subject.hit "foxglove"
       tempfile.rewind
       tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\shit:\sjuice\.foxglove$/
     end
 
     it "should namespace the key from #latency" do
-      counter.namespace = "cocktail"
-      counter.latency "angelica", 200
+      subject.namespace = "cocktail"
+      subject.latency "angelica", 200
       tempfile.rewind
       tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\slatency:\scocktail\.angelica\s200s$/
     end
 
     it "should namespace the key from #magnitude" do
-      counter.namespace = "brew"
-      counter.magnitude "crocus", 100
+      subject.namespace = "brew"
+      subject.magnitude "crocus", 100
       tempfile.rewind
       tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\smagnitude:\sbrew\.crocus 100$/
     end
 
     it "should namespace the key from #ping" do
-      counter.namespace = "beer"
-      counter.ping "tulip"
+      subject.namespace = "beer"
+      subject.ping "tulip"
       tempfile.rewind
       tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\sping:\sbeer\.tulip$/
     end
   end
 
   it "should log a message to the logfile when a hit is recorded" do
-    counter.hit "urls.visited"
+    subject.hit "urls.visited"
     tempfile.rewind
     tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\shit.*urls\.visited$/
   end
 
   it "should log a message to the logfile when a magnitude is recorded" do
-    counter.magnitude "bytes.read", 2_013
+    subject.magnitude "bytes.read", 2_013
     tempfile.rewind
     tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\smagnitude.*bytes\.read.*2013$/
   end
 
   it "should log a message to the logfile when a latency is recorded" do
-    counter.latency "processing", 0.132 # in seconds
+    subject.latency "processing", 0.132 # in seconds
     tempfile.rewind
     tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\slatency.*processing.*0.132s$/
   end
 
   it "should record a message in the logfile when a ping is recorded" do
-    counter.ping "crawler.alive"
+    subject.ping "crawler.alive"
     tempfile.rewind
     tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\sping.*crawler\.alive$/
   end
 
   it "should log a message to the logfile when a latency is recorded using a block" do
-    counter.latency "crawling" do
+    subject.latency "crawling" do
       sleep 0.1
     end
 
@@ -166,7 +166,7 @@ describe Counters::File do
   end
 
   it "should raise an ArgumentError when calling #latency with both a block and a latency" do
-    lambda { counter.latency("processing", 0.123) { sleep 0.1 } }.should raise_error(ArgumentError)
+    lambda { subject.latency("processing", 0.123) { sleep 0.1 } }.should raise_error(ArgumentError)
   end
 
   it "should accept a filename on instantiation" do

data/spec/memory_counter_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 describe Counters::Memory do
-  let :counter do
+  subject do
     Counters::Memory.new
   end
 
@@ -16,67 +16,67 @@ describe Counters::Memory do
 
   context "given the counter is namespaced" do
     it "should namespace the key from #hit" do
-      counter.namespace = "juice"
-      counter.hit "foxglove"
-      counter.hits["juice.foxglove"].should == 1
+      subject.namespace = "juice"
+      subject.hit "foxglove"
+      subject.hits["juice.foxglove"].should == 1
     end
 
     it "should namespace the key from #latency" do
-      counter.namespace = "cocktail"
-      counter.latency "angelica", 200
-      counter.latencies["cocktail.angelica"].should == [200]
+      subject.namespace = "cocktail"
+      subject.latency "angelica", 200
+      subject.latencies["cocktail.angelica"].should == [200]
     end
 
     it "should namespace the key from #magnitude" do
-      counter.namespace = "brew"
-      counter.magnitude "crocus", 100
-      counter.magnitudes["brew.crocus"].should == 100
+      subject.namespace = "brew"
+      subject.magnitude "crocus", 100
+      subject.magnitudes["brew.crocus"].should == 100
     end
 
     it "should namespace the key from #ping" do
-      counter.namespace = "beer"
+      subject.namespace = "beer"
       Timecop.freeze(Time.now.utc) do
-        counter.ping "tulip"
-        counter.pings["beer.tulip"].should == Time.now.utc
+        subject.ping "tulip"
+        subject.pings["beer.tulip"].should == Time.now.utc
       end
     end
   end
 
   it "should record a hit with key 'pages.read'" do
-    counter.hit "pages.read"
-    counter.hits.should have_key("pages.read")
-    counter.hits["pages.read"].should == 1
+    subject.hit "pages.read"
+    subject.hits.should have_key("pages.read")
+    subject.hits["pages.read"].should == 1
 
-    counter.hit "pages.read"
-    counter.hits["pages.read"].should == 2
+    subject.hit "pages.read"
+    subject.hits["pages.read"].should == 2
   end
 
   it "should record a ping with key 'processor.alive'" do
     Timecop.freeze do
-      counter.ping "processor.alive"
-      counter.pings.should have_key("processor.alive")
-      counter.pings["processor.alive"].strftime("%Y-%m-%d %H:%M:%S").should == Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+      subject.ping "processor.alive"
+      subject.pings.should have_key("processor.alive")
+      subject.pings["processor.alive"].strftime("%Y-%m-%d %H:%M:%S").should == Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
     end
 
     target_time = Time.now + 9
     Timecop.travel(target_time) do
-      counter.ping "processor.alive"
-      counter.pings.should have_key("processor.alive")
-      counter.pings["processor.alive"].strftime("%Y-%m-%d %H:%M:%S").should == target_time.utc.strftime("%Y-%m-%d %H:%M:%S")
+      subject.ping "processor.alive"
+      subject.pings.should have_key("processor.alive")
+      subject.pings["processor.alive"].strftime("%Y-%m-%d %H:%M:%S").should == target_time.utc.strftime("%Y-%m-%d %H:%M:%S")
     end
   end
 
   it "should record a latency with a passed value" do
-    counter.latency "processor.enqueue", 0.00012
-    counter.latencies["processor.enqueue"].should == [0.00012]
+    subject.latency "processor.enqueue", 0.00012
+    subject.latencies["processor.enqueue"].should == [0.00012]
 
-    counter.latency "processor.enqueue", 0.00121
-    counter.latencies["processor.enqueue"].should == [0.00012, 0.00121]
+    subject.latency "processor.enqueue", 0.00121
+    subject.latencies["processor.enqueue"].should == [0.00012, 0.00121]
   end
 
   it "should record a magnitude" do
-    counter.magnitude "processor.bytes_compressed", 9_312
-    counter.magnitude "processor.bytes_compressed", 8_271
-    counter.magnitudes["processor.bytes_compressed"].should == 8_271
+    subject.magnitude "processor.bytes_compressed", 9_312
+    subject.magnitude "processor.bytes_compressed", 8_271
+    subject.magnitudes["processor.bytes_compressed"].should == 8_271
   end
 end

data/spec/redis_counter_spec.rb

@@ -6,7 +6,7 @@ describe Counters::Redis, "integration tests" do
     ::Redis.new
   end
 
-  let :counter do
+  subject do
     Counters::Redis.new(redis, :base_key => "counters")
   end
 
@@ -25,40 +25,40 @@ describe Counters::Redis, "integration tests" do
 
   context "given the counter is namespaced" do
     it "should namespace the key from #hit" do
-      counter.namespace = "juice"
-      counter.hit "foxglove"
+      subject.namespace = "juice"
+      subject.hit "foxglove"
       redis.hget("counters", "hits.juice.foxglove").should == "1"
     end
 
     it "should namespace the key from #latency" do
-      counter.namespace = "cocktail"
-      counter.latency "angelica", 200
+      subject.namespace = "cocktail"
+      subject.latency "angelica", 200
       redis.hget("counters", "latencies.cocktail.angelica.nanoseconds").should == (200 * Counters::Redis::SCALING_FACTOR).to_s
     end
 
     it "should namespace the key from #magnitude" do
-      counter.namespace = "brew"
-      counter.magnitude "crocus", 100
+      subject.namespace = "brew"
+      subject.magnitude "crocus", 100
       redis.hget("counters", "magnitudes.brew.crocus.value").should == "100"
     end
 
     it "should namespace the key from #ping" do
-      counter.namespace = "beer"
+      subject.namespace = "beer"
       Timecop.freeze(Time.now.utc) do
-        counter.ping "tulip"
+        subject.ping "tulip"
         redis.hget("counters", "pings.beer.tulip").should == Time.now.utc.to_i.to_s
       end
     end
   end
 
   it "should record 2 hits on 'pages.read'" do
-    2.times { counter.hit "pages.read" }
+    2.times { subject.hit "pages.read" }
     redis.hkeys("counters").should == ["hits.pages.read"]
     redis.hget("counters", "hits.pages.read").to_i.should == 2
   end
 
   it "should record magnitude using a signed 64 bit 'value' and a 'count'" do
-    4.times { counter.magnitude "bytes.in", 2_047 }
+    4.times { subject.magnitude "bytes.in", 2_047 }
     redis.hkeys("counters").sort.should == %w(magnitudes.bytes.in.value magnitudes.bytes.in.count).sort
 
     redis.hget("counters", "magnitudes.bytes.in.count").to_i.should == 4
@@ -66,8 +66,8 @@ describe Counters::Redis, "integration tests" do
   end
 
   it "does not detect 63 bit integer overflow" do
-    counter.magnitude "bytes.in", 2**63 - 20
-    counter.magnitude "bytes.in", 2_047
+    subject.magnitude "bytes.in", 2**63 - 20
+    subject.magnitude "bytes.in", 2_047
 
     target_value = (2**63 - 20) + 2_047
 
@@ -78,29 +78,29 @@ describe Counters::Redis, "integration tests" do
   it "should record a ping on 'crawler' by HSET counters/pings.crawler with today's date/time as an int" do
     now = Time.now
     Timecop.freeze(now) do
-      counter.ping "crawler"
+      subject.ping "crawler"
     end
 
     redis.hget("counters", "pings.crawler").should == now.to_i.to_s
 
     target_time = Time.now + 9
     Timecop.travel(target_time) do
-      counter.ping "crawler"
+      subject.ping "crawler"
     end
 
     redis.hget("counters", "pings.crawler").should == target_time.to_i.to_s
   end
 
   it "should record latency on 'crawler.download' by HINCRBY counters/latencies.crawler.download.count by 1 and counters/latencies.crawler.download.nanoseconds by the latency" do
-    counter.latency "crawler.download", 1.9
-    counter.latency "crawler.download", 2.02
+    subject.latency "crawler.download", 1.9
+    subject.latency "crawler.download", 2.02
 
     redis.hget("counters", "latencies.crawler.download.count").to_i.should == 2
     redis.hget("counters", "latencies.crawler.download.nanoseconds").to_i.should == (2.02 + 1.90) * ONE_NANOSECOND
   end
 
   it "should record a block's latency" do
-    counter.latency "crawler.process" do
+    subject.latency "crawler.process" do
       sleep 0.2
     end
 

data/spec/spec_helper.rb

@@ -9,29 +9,29 @@ end
 
 shared_examples_for "all counters" do
   it "should raise a ArgumentError when the key includes invalid chars" do
-    lambda { counter.hit "hit!"        }.should raise_error(ArgumentError)
-    lambda { counter.hit "hit counter" }.should raise_error(ArgumentError)
-    lambda { counter.hit "boy.hit?"    }.should raise_error(ArgumentError)
-    lambda { counter.hit "hit/a"       }.should raise_error(ArgumentError)
-    lambda { counter.hit "hit-a"       }.should raise_error(ArgumentError)
-    lambda { counter.hit ""            }.should raise_error(ArgumentError)
-    lambda { counter.hit nil           }.should raise_error(ArgumentError)
+    lambda { subject.hit "hit!"        }.should raise_error(ArgumentError)
+    lambda { subject.hit "hit counter" }.should raise_error(ArgumentError)
+    lambda { subject.hit "boy.hit?"    }.should raise_error(ArgumentError)
+    lambda { subject.hit "hit/a"       }.should raise_error(ArgumentError)
+    lambda { subject.hit "hit-a"       }.should raise_error(ArgumentError)
+    lambda { subject.hit ""            }.should raise_error(ArgumentError)
+    lambda { subject.hit nil           }.should raise_error(ArgumentError)
   end
 
   it "should not raise ArgumentError when the key includes a number" do
-    lambda { counter.hit "hit1" }.should_not raise_error(ArgumentError)
+    lambda { subject.hit "hit1" }.should_not raise_error(ArgumentError)
   end
 
   it "should not raise ArgumentError when the key includes a dot / fullstop" do
-    lambda { counter.hit "hit." }.should_not raise_error(ArgumentError)
+    lambda { subject.hit "hit." }.should_not raise_error(ArgumentError)
   end
 
   it "should not raise ArgumentError when the key includes an underscore" do
-    lambda { counter.hit "hit_" }.should_not raise_error(ArgumentError)
+    lambda { subject.hit "hit_" }.should_not raise_error(ArgumentError)
   end
 
   it "should return the latency block's value" do
-    value = counter.latency "process" do
+    value = subject.latency "process" do
       "the returned value"
     end
 
@@ -39,11 +39,32 @@ shared_examples_for "all counters" do
   end
 
   it "should allow hitting with a specific value increment" do
-    lambda { counter.hit "tada", 17 }.should_not raise_error
+    lambda { subject.hit "tada", 17 }.should_not raise_error
   end
 
-  it "should return a sub-namespaced counter on-demand" do
-    other = counter.namespace("sub")
-    other.namespace.should == "#{counter.namespace}.sub"
+  context "given a non-namespaced counter" do
+    before(:each) do
+      subject.namespace = nil
+    end
+
+    it "should return a sub-namespaced counter on-demand" do
+      subject.namespace.to_s.should be_empty
+
+      other = subject.namespace("sub")
+      other.namespace.should == "sub"
+    end
+  end
+
+  context "when the counter is namespaced" do
+    before(:each) do
+      subject.namespace = "origin"
+    end
+
+    it "should return a namespaced counter on-demand" do
+      subject.namespace.to_s.should_not be_empty
+
+      other = subject.namespace("sub")
+      other.namespace.should == "#{subject.namespace}.sub"
+    end
   end
 end

data/spec/statsd_counter_spec.rb

@@ -27,7 +27,7 @@ describe Counters::StatsD do
     8125
   end
 
-  let :counter do
+  subject do
     Counters::StatsD.new(host, port, :socket => socket)
   end
 
@@ -41,22 +41,22 @@ describe Counters::StatsD do
 
   it "should record a hit as an increment of the key" do
     socket.should_receive(:send).with("hits.tweets_received:1|c", 0, host, port)
-    counter.hit "tweets_received"
+    subject.hit "tweets_received"
   end
 
   it "should record a magnitude as a timer" do
     socket.should_receive(:send).with("magnitudes.bytes_in:381|ms", 0, host, port)
-    counter.magnitude "bytes_in", 381
+    subject.magnitude "bytes_in", 381
   end
 
   it "should record a latency as a timer" do
     socket.should_receive(:send).with("latencies.json_parsing:9|ms", 0, host, port)
-    counter.latency "json_parsing", 0.009
+    subject.latency "json_parsing", 0.009
   end
 
   it "should record a ping as a counter" do
     socket.should_receive(:send).with("pings.tweet_processor:1|c", 0, host, port)
-    counter.ping "tweet_processor"
+    subject.ping "tweet_processor"
   end
 
   context "#initialize" do
@@ -68,33 +68,33 @@ describe Counters::StatsD do
 
   context "given the counter is namespaced" do
     it "should namespace the key from #hit" do
-      counter.namespace = "juice"
+      subject.namespace = "juice"
       socket.should_receive(:send).with(/^hits\.juice\.foxglove\b/, anything, anything, anything)
-      counter.hit "foxglove"
+      subject.hit "foxglove"
     end
 
     it "should namespace the key from #latency" do
-      counter.namespace = "cocktail"
+      subject.namespace = "cocktail"
       socket.should_receive(:send).with(/^latencies\.cocktail\.angelica\b/, anything, anything, anything)
-      counter.latency "angelica", 200
+      subject.latency "angelica", 200
     end
 
     it "should namespace the key from #magnitude" do
-      counter.namespace = "brew"
+      subject.namespace = "brew"
       socket.should_receive(:send).with(/^magnitudes\.brew\.crocus\b/, anything, anything, anything)
-      counter.magnitude "crocus", 100
+      subject.magnitude "crocus", 100
     end
 
     it "should namespace the key from #ping" do
-      counter.namespace = "beer"
+      subject.namespace = "beer"
       socket.should_receive(:send).with(/^pings\.beer\.tulip\b/, anything, anything, anything)
-      counter.ping "tulip"
+      subject.ping "tulip"
     end
 
     it "should increment with the #hit value" do
-      counter.namespace = "pow"
+      subject.namespace = "pow"
       socket.should_receive(:send).with(/^hits\.pow\.loudness:17\b/, anything, anything, anything)
-      counter.hit "loudness", 17
+      subject.hit "loudness", 17
     end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: counters
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors: 
 - "Fran\xC3\xA7ois Beausoleil"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-01 00:00:00 -04:00
+date: 2011-06-03 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency