camayoc 0.1.0 → 0.2.0

data/test/handlers/memory_test.rb

@@ -1,33 +1,33 @@
 class MemoryTest < Test::Unit::TestCase
-  
+
   def setup
     @handler = Camayoc::Handlers::Memory.new
   end
-  
+
   def test_count_initializes_to_0_and_increments_value
-    @handler.count(Camayoc::StatEvent.new("foo:bar","count",100))
+    @handler.event(Camayoc::StatEvent.new(:count,"foo:bar","count",100))
     assert_equal(100,@handler["foo:bar:count"])
   end
 
   def test_multiple_counts_increments_value
-    @handler.count(Camayoc::StatEvent.new("foo:bar","count",100))
-    @handler.count(Camayoc::StatEvent.new("foo:bar","count",500))
-    @handler.count(Camayoc::StatEvent.new("foo:bar","count",400))
+    @handler.event(Camayoc::StatEvent.new(:count,"foo:bar","count",100))
+    @handler.event(Camayoc::StatEvent.new(:count,"foo:bar","count",500))
+    @handler.event(Camayoc::StatEvent.new(:count,"foo:bar","count",400))
     assert_equal(1000,@handler["foo:bar:count"])
   end
 
   def test_timing_initializes_timing_object_and_adds_data
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",500))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",500))
     timing = @handler["foo:bar:time"]
     assert_not_nil(timing)
     assert_equal(1,timing.count)
   end
 
   def test_timing_increments_timing_object
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",100))
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",600))
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",1000))
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",500))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",600))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",1000))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",500))
     timing = @handler["foo:bar:time"]
     assert_equal(4,timing.count)
     assert_equal(100,timing.min)
@@ -35,4 +35,55 @@ class MemoryTest < Test::Unit::TestCase
     assert_equal(2200,timing.total)
     assert_equal(550,timing.average)
   end
-end
+
+  def test_ignore_unknown_event_type
+    @handler.expects(:count).never
+    @handler.expects(:timing).never
+    @handler.event(Camayoc::StatEvent.new(:throwaway,"foo:bar","time",500))
+  end
+
+  def test_add_generic_event
+    @handler.expects(:generic).once
+    @handler.event(Camayoc::StatEvent.new(:generic,"foo:bar","time",50))
+  end
+
+  def test_safe_defaults_for_max_events_falls_back
+    @handler = Camayoc::Handlers::Memory.new
+    assert_equal(Camayoc::Handlers::Memory::DEFAULT_MAX_EVENTS,
+      @handler.max_events)
+
+    @handler = Camayoc::Handlers::Memory.new(:max_events=>"apple pie")
+    assert_equal(Camayoc::Handlers::Memory::DEFAULT_MAX_EVENTS,
+      @handler.max_events)
+
+    @handler = Camayoc::Handlers::Memory.new(:max_events=>"0")
+    assert_equal(Camayoc::Handlers::Memory::DEFAULT_MAX_EVENTS,
+      @handler.max_events)
+
+    @handler = Camayoc::Handlers::Memory.new(:max_events=>"-1")
+    assert_equal(Camayoc::Handlers::Memory::DEFAULT_MAX_EVENTS,
+      @handler.max_events)
+
+    # valid value for good measure
+    @handler = Camayoc::Handlers::Memory.new(:max_events=>"1")
+    assert_equal(1,@handler.max_events)
+  end
+
+  def test_capped_fifo_generic_events
+    max_events = 10
+    @handler = Camayoc::Handlers::Memory.new(:max_events=>max_events)
+
+    overflow = 3
+    num_events = max_events + overflow
+
+    num_events.times do |idx|
+      @handler.event(Camayoc::StatEvent.new(:generic,
+        "foo:bar","beep",{:idx=>idx}))
+    end
+    beeps = @handler['foo:bar:beep']
+    assert_equal(max_events,beeps.size)
+    assert_equal({:idx=>overflow+max_events-1},beeps[0])
+    assert_equal({:idx=>overflow},beeps[-1])
+  end
+
+end

data/test/handlers/redis_test.rb

@@ -7,7 +7,7 @@ if (begin; require 'camayoc/handlers/redis'; true; rescue LoadError; false end)
 
     def test_count_increments_correct_key_in_redis
       @redis.expects(:incrby).with("foo:bar:baz",500)
-      @handler.count(Camayoc::StatEvent.new("foo:bar","baz",500))
+      @handler.event(Camayoc::StatEvent.new(:count,"foo:bar","baz",500))
     end
 
     def test_timing_updates_redis_keys_with_timing_info
@@ -17,12 +17,17 @@ if (begin; require 'camayoc/handlers/redis'; true; rescue LoadError; false end)
       @redis.expects(:incrby).with("foo:bar:time:_total",500).in_sequence(seq)
       @redis.expects(:incrby).with("foo:bar:time:_total",400).in_sequence(seq)
       @redis.expects(:incrby).with("foo:bar:time:_total",200).in_sequence(seq)
-      @handler.timing(Camayoc::StatEvent.new("foo:bar","time",500))
-      @handler.timing(Camayoc::StatEvent.new("foo:bar","time",400))
-      @handler.timing(Camayoc::StatEvent.new("foo:bar","time",200))
+      @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",500))
+      @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",400))
+      @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",200))
+    end
+
+    def test_ignore_unknown_event_type
+      @redis.expects(:set).never
+      @handler.event(Camayoc::StatEvent.new(:throwaway,"foo:bar","time",500))
     end
 
   end
 else
   puts "Warn: Skipping Redis test because redis gem is not installed"
-end
+end

data/test/handlers/statsd_test.rb

@@ -1,17 +1,37 @@
 class StatsdTest < Test::Unit::TestCase
-  
+
   def setup
     @statsd = Camayoc::Handlers::Statsd.new(:host=>"localhost",:port=>1234)
   end
-  
+
   def test_count_sends_correct_statsd_message
     expect_message("foo.bar.baz:500|c")
-    @statsd.count(Camayoc::StatEvent.new("foo:bar","baz",500,{}))
+    @statsd.event(Camayoc::StatEvent.new(:count,"foo:bar","baz",500,{}))
   end
 
   def test_timing_sends_correct_statsd_message
     expect_message("foo.bar.time:100|ms")
-    @statsd.timing(Camayoc::StatEvent.new("foo:bar","time",100,{}))
+    @statsd.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100,{}))
+  end
+
+  def test_generic_sends_count_statsd_message
+    expect_message("foo.bar.beep:1|c")
+    @statsd.event(Camayoc::StatEvent.new(:count,"foo:bar","beep",1,{}))
+  end
+
+  def test_any_other_event_type_is_treated_as_a_count_with_value_if_value_is_integer
+    expect_message("foo.bar.beep:25|c")
+    @statsd.event(Camayoc::StatEvent.new(:foo,"foo:bar","beep",25,{}))
+  end
+
+  def test_any_other_event_type_is_treated_as_a_count_with_value_if_value_is_string_integer_representation
+    expect_message("foo.bar.beep:31|c")
+    @statsd.event(Camayoc::StatEvent.new(:foo,"foo:bar","beep","31",{}))
+  end
+
+  def test_any_other_event_type_is_treated_as_a_count_of_1_if_value_is_not_convertable_to_integer
+    expect_message("foo.bar.beep:1|c")
+    @statsd.event(Camayoc::StatEvent.new(:foo,"foo:bar","beep",{:a=>50},{}))
   end
 
   private
@@ -19,4 +39,8 @@ class StatsdTest < Test::Unit::TestCase
       @statsd.instance_variable_get("@socket").expects(:send).with(message,0,"localhost",1234)
     end
 
-end
+    def never_expect_message
+      @statsd.__send__(:socket).expects(:send).never
+    end
+
+end

data/test/registration_test.rb

@@ -51,6 +51,18 @@ class RegistrationTest < Test::Unit::TestCase
     assert_equal([root,middle,child1,child2],all)
   end
 
+  def test_brackets_on_stats_gets_namespaced_descendant
+    parent = Camayoc["foo:bar"]
+    desc = parent["a:b:c"]
+    assert_equal(Camayoc.join(parent.name,"a:b:c"),desc.name)
+    assert_equal(parent,desc.parent)
+  end
+
+  def test_join_builds_name_with_delimiter
+    assert_equal("a:b:c",Camayoc.join("a","b","c"))
+    assert_equal("foo:bar:baz",Camayoc.join(%w(foo bar:baz)))
+  end
+
   def teardown
     Camayoc.instance_variable_get("@registry").clear
   end

data/test/stat_event_test.rb

@@ -1,8 +1,8 @@
 class StatsTest < Test::Unit::TestCase
  
   def test_ns_stat_uses_source_for_namespace
-    event = Camayoc::StatEvent.new("foo:bar:baz","stat",10000,{})
+    event = Camayoc::StatEvent.new(:ignored,"foo:bar:baz","stat",10000,{})
     assert_equal("foo:bar:baz:stat",event.ns_stat)
   end
 
-end
+end

data/test/stats_test.rb

@@ -1,35 +1,37 @@
 class StatsTest < Test::Unit::TestCase
 
+  include EventTestHelper
+
   def setup
     @stats = Camayoc::Stats.new("foo:bar")
     @handler = mock("handler1")
     @stats.add(@handler)
   end
 
-  def test_count_fires_to_all_handlers
+  with_event_types("test_event_fires_to_all_handlers") do
     h2 = mock("handler2")
     @stats.add(h2)
-    
-    @handler.expects(:count).with(kind_of(Camayoc::StatEvent))
-    h2.expects(:count).with(kind_of(Camayoc::StatEvent))
-    @stats.count("count",500)
+
+    @handler.expects(:event).with(kind_of(Camayoc::StatEvent))
+    h2.expects(:event).with(kind_of(Camayoc::StatEvent))
+    @stats.send(@event_method,"beep",500)
   end
-  
-  def test_count_generates_correct_stat_event
-    @handler.expects(:count).with(
-      &stat_event_match("foo:bar","count",500,{:pass_through=>true}))
-    @stats.count("count",500,:pass_through=>true)
+
+  with_event_types("test_generates_correct_stat_event") do
+    @handler.expects(:event).with(
+      &stat_event_match(@event_type,"foo:bar","beep",500,{:pass_through=>true}))
+    @stats.send(@event_method,"beep",500,:pass_through=>true)
   end
 
-  def test_count_propagates_event_to_parent_after_firing_to_handlers
+  with_event_types("test_propagates_event_to_parent_after_firing_to_handlers") do
     @stats.parent = Camayoc::Stats.new("foo")
 
     seq = sequence("firing")
-    evt = stat_event_match("foo:bar","count",100,{:pass_through=>true})
-    @handler.expects(:count).with(&evt).in_sequence(seq)
-    @stats.parent.expects(:count_event).with(&evt).in_sequence(seq)
-    
-    @stats.count("count",100,:pass_through=>true)
+    evt = stat_event_match(@event_type,"foo:bar","beep",100,{:pass_through=>true})
+    @handler.expects(:event).with(&evt).in_sequence(seq)
+    @stats.parent.expects(:propagate_event).with(&evt).in_sequence(seq)
+
+    @stats.send(@event_method,"beep",100,:pass_through=>true)
   end
 
   def test_increment_delegates_to_count
@@ -42,53 +44,46 @@ class StatsTest < Test::Unit::TestCase
     @stats.decrement("count")
   end
 
-  def test_timing_fires_to_all_handlers
-    h2 = mock("handler2")
-    @stats.add(h2)
-    
-    @handler.expects(:timing).with(kind_of(Camayoc::StatEvent))
-    h2.expects(:timing).with(kind_of(Camayoc::StatEvent))
-    @stats.timing("time",500)
-  end
+  def test_realtime_calculates_time_for_block_fires_timing_event_and_returns_time
+    start_time = Time.now
+    end_time = (Time.now + 10.5)
+    duration = end_time.to_f - start_time.to_f
+    duration_ms = (duration*1000).round
+
+    seq = sequence("duration")
+    Time.expects(:now).returns(start_time).in_sequence(seq)
+    Time.expects(:now).returns(end_time).in_sequence(seq)
 
-  def test_timing_generates_correct_stat_event
-    @handler.expects(:timing).with(
-      &stat_event_match("foo:bar","time",1,{:pass_through=>true}))
-    @stats.timing("time",1,:pass_through=>true)
+    @handler.expects(:event).with(
+      &stat_event_match(:timing,"foo:bar","baz",duration_ms,{:pass_through=>true}))
+
+    actual_duration = @stats.realtime("baz",:pass_through=>true) { "no-op" }
+    assert_equal(duration,actual_duration)
   end
 
-  def test_timing_propagates_event_to_parent_after_firing_to_handlers
-    @stats.parent = Camayoc::Stats.new("foo")
+  def test_benchmark_calls_realtime_and_returns_value_of_block
+    @stats.expects(:realtime).with("baz",:pass_through=>true).yields
 
-    seq = sequence("firing")
-    evt = stat_event_match("foo:bar","time",100,{:pass_through=>true})
-    @handler.expects(:timing).with(&evt).in_sequence(seq)
-    @stats.parent.expects(:timing_event).with(&evt).in_sequence(seq)
-    
-    @stats.timing("time",100,:pass_through=>true)
+    block_value = rand(10000)
+    result = @stats.benchmark("baz",:pass_through=>true) do
+      block_value
+    end
+
+    assert_equal(block_value,result)
   end
 
+
   def test_handler_errors_are_swallowed_and_firing_continues
     h2 = mock("handler2")
     @stats.add(h2)
 
     seq = sequence("firing")
-    @handler.expects(:count).raises("FAIL").in_sequence(seq)
-    h2.expects(:count).in_sequence(seq)
+    @handler.expects(:event).raises("FAIL").in_sequence(seq)
+    h2.expects(:event).in_sequence(seq)
 
     assert_nothing_raised do
       @stats.count("baz",100)
     end
   end
 
-  private
-    def stat_event_match(*args)
-      template = Camayoc::StatEvent.new(*args)
-      Proc.new do |event|
-        event.source == template.source &&
-          event.stat == template.stat &&
-          event.value == template.value &&
-          event.options == template.options
-      end
-    end
-end
+end

data/test/test_helper.rb

@@ -3,4 +3,42 @@ require 'test/unit'
 require 'mocha'
 
 $: << File.join(File.dirname(__FILE__),"..","lib")
-require 'camayoc'
+require 'camayoc'
+
+module EventTestHelper
+
+  def self.included(test)
+    test.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # Generates methods and populates:
+    # * +@event_type+ :: +:count+, +:timing+ or +:generic+
+    # * +@event_method+ :: method for Stats:
+    #                      +:count+, +:timing+, or +:event+
+    def with_event_types(name,event_types=[:count,:timing,:generic],&block)
+      Array(event_types).each do |event_type|
+        define_method("#{name}_with_#{event_type}") do
+          @event_type = event_type
+          @event_method = case event_type
+            when :count, :timing then event_type
+            else :event
+          end
+          instance_eval(&block)
+        end
+      end
+    end
+  end
+
+  def stat_event_match(*args)
+    template = Camayoc::StatEvent.new(*args)
+    Proc.new do |event|
+      event.type == template.type &&
+        event.source == template.source &&
+        event.stat == template.stat &&
+        event.value == template.value &&
+        event.options == template.options
+    end
+  end
+
+end

metadata

@@ -1,21 +1,22 @@
 --- !ruby/object:Gem::Specification 
 name: camayoc
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Hayes Davis
+- Jerry Chen
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-06-02 00:00:00 -07:00
+date: 2011-11-19 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +33,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id001
-description: "    Inspired by logging frameworks, Camayoc makes it easy send stats and metrics \n    from your application to collectors like Graphite (via statsd) or Redis. \n    Extensible handlers mean you can use whatever storage system you like \n    with the same interface.\n"
+description: "    Inspired by logging frameworks, Camayoc makes it easy to track events and \n    send stats from your application to collectors like Graphite (via statsd). \n    It has an extensible handler system that allows you to use whatever storage \n    system you like with the same interface.\n"
 email: hayes@appozite.com
 executables: []
 
@@ -41,6 +42,7 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.md
+- HISTORY.md
 files: 
 - README.md
 - LICENSE
@@ -54,6 +56,7 @@ files:
 - lib/camayoc/stat_event.rb
 - lib/camayoc/stats.rb
 - lib/camayoc/thread_safety.rb
+- lib/camayoc/timer.rb
 - lib/camayoc/version.rb
 - lib/camayoc.rb
 - test/handlers/filter_test.rb
@@ -67,6 +70,7 @@ files:
 - test/stats_test.rb
 - test/test_helper.rb
 - test/thread_safety_test.rb
+- HISTORY.md
 has_rdoc: true
 homepage: http://github.com/appozite/camayoc
 licenses: []