camayoc 0.1.0 → 0.2.0

data/lib/camayoc/handlers/statsd.rb

@@ -1,6 +1,6 @@
 require 'socket'
 
-# This class is a port of the code in https://github.com/reinh/statsd to fit 
+# This class is a port of the code in https://github.com/reinh/statsd to fit
 # with the Camayoc handler interface.
 module Camayoc
   module Handlers
@@ -9,7 +9,7 @@ module Camayoc
       include ThreadSafety
 
       attr_accessor :namespace
-      
+
       def initialize(options={})
         self.namespace = options[:namespace]
         @host = options[:host]
@@ -18,15 +18,28 @@ module Camayoc
         self.thread_safe = Camayoc.thread_safe?
       end
 
-      def count(event)
-        send(event.ns_stat,event.value,'c',event.options[:sample_rate]||1) 
-      end
-
-      def timing(event)
-        send(event.ns_stat, event.value, 'ms', event.options[:sample_rate]||1) 
+      def event(ev)
+        case ev.type
+          when :timing then timing(ev)
+          when :count  then count(ev)
+          else other(ev)
+        end
       end
 
       private
+        def other(ev)
+          value = Integer(ev.value) rescue 1
+          send(ev.ns_stat,value,'c',ev.options[:sample_rate]||1)
+        end
+
+        def count(ev)
+          send(ev.ns_stat,ev.value,'c',ev.options[:sample_rate]||1)
+        end
+
+        def timing(ev)
+          send(ev.ns_stat,ev.value,'ms',ev.options[:sample_rate]||1)
+        end
+
         def sampled(sample_rate)
           yield unless sample_rate < 1 and rand > sample_rate
         end
@@ -41,7 +54,6 @@ module Camayoc
             end
           end
         end
-
     end
   end
-end
+end

data/lib/camayoc/stat_event.rb

@@ -1,9 +1,16 @@
 module Camayoc
   class StatEvent
 
-    attr_accessor :source, :stat, :value, :options
+    attr_accessor :type, :source, :stat, :value, :options
 
-    def initialize(source,stat,value,options={})
+    # Constructor
+    # * +type+ :: Symbol of stat type: count, timing, or generic
+    # * +source+ :: Source of stat
+    # * +stat+ :: Name of stat
+    # * +value+ :: Value of stat
+    # * +options+ :: Optionals options
+    def initialize(type,source,stat,value,options={})
+      self.type = type
       self.source = source
       self.stat = stat
       self.value = value
@@ -15,4 +22,4 @@ module Camayoc
     end
 
   end
-end
+end

data/lib/camayoc/stats.rb

@@ -3,12 +3,23 @@ module Camayoc
 
     attr_accessor :name, :parent, :handlers
 
+    # Constructor
+    # * +name+ :: Name of stat
+    # * +parent+ :: Optional parent stat (default: nil)
     def initialize(name,parent=nil)
       self.name = name
       self.parent = parent
       self.handlers = []
     end
-    
+
+    def [](descendant_name)
+      Camayoc[Camayoc.join(name,descendant_name)]
+    end
+
+    # Add handler with filter options
+    # * +handler+ :: Handler instance
+    # * +filter_opts+ :: Options for a new Handlers::Filter
+    #                    instance (optional)
     def add(handler,filter_opts={})
       if !filter_opts.empty?
         handler = Handlers::Filter.new(handler,filter_opts)
@@ -17,49 +28,76 @@ module Camayoc
       self
     end
 
+    # Quick alias for adding a handler
     def <<(handler)
       self.add(handler)
     end
 
+    # Timing stat
+    def timing(stat,value,options={})
+      propagate(:timing,stat,value,options)
+    end
+
+    # Generic event
+    def event(stat,value,options={})
+      propagate(:generic,stat,value,options)
+    end
+
+    # Count and incr/decr convenience methods
+    def count(stat,value,options={})
+      propagate(:count,stat,value,options)
+    end
+
     def increment(stat,options={})
-      count(stat,1,options)  
+      count(stat,1,options)
     end
 
     def decrement(stat,options={})
       count(stat,-1,options)
     end
 
-    def count(stat,value,options={})
-      count_event(StatEvent.new(name,stat,value,options))
+    # Executes a block, stores the timing information in the specified stat
+    # and returns the value of the block. Use this to wrap existing code with 
+    # timing information without worrying about return values.
+    def benchmark(stat,options={})
+      result = nil
+      realtime(stat,options) do
+        result = yield
+      end
+      result
     end
 
-    def timing(stat,ms,options={})
-      timing_event(StatEvent.new(name,stat,ms,options))
+    # Executes a block, stores the timing information in the specified stat
+    # and returns the time **in seconds** that the execution took. This is 
+    # basically a drop-in replacement for calls to Benchmark.realtime
+    def realtime(stat,options={})
+      start_time = Time.now
+      yield
+      duration = (Time.now.to_f - start_time.to_f)
+      # Convert to ms for timing call
+      timing(stat,(duration*1000).round,options)
+      duration
     end
-    
+
     protected
-      def count_event(event)
-        each_handler do |handler|
-          handler.count(event)
-        end
-        if parent
-          parent.count_event(event)
-        end
-        self
+      # Creates new StatEvent and passes to +#propagate_event+
+      def propagate(type,stat,value,options)
+        propagate_event(StatEvent.new(type,name,stat,value,options))
       end
 
-      def timing_event(event)
+      # Propagates event to all handlers and parent Stat
+      def propagate_event(ev)
         each_handler do |handler|
-          handler.timing(event)
+          handler.event(ev)
         end
         if parent
-          parent.timing_event(event)
+          parent.propagate_event(ev)
         end
         self
       end
 
     private
-      def each_handler 
+      def each_handler
         handlers.each do |handler|
           begin
             yield(handler)
@@ -74,4 +112,4 @@ module Camayoc
       end
 
   end
-end
+end

data/lib/camayoc/timer.rb

@@ -0,0 +1,41 @@
+module Camayoc
+  class Timer
+
+    attr_accessor :stats, :name, :start_time, :stop_time
+
+    def initialize(stats,name)
+      self.stats = stats
+      self.name = name
+    end
+
+    def start
+      self.start_time = Time.now.to_f
+    end
+
+    def stop
+      self.stop_time = Time.now.to_f
+      duration
+    end
+
+    def duration
+      (duration_seconds*1000).round
+    end
+
+    def duration_seconds
+      stop_time - start_time
+    end
+
+    def save(options={})
+      stats.timing(name,duration,options)
+    end
+
+    def realtime
+      start
+      yield
+      stop
+      save
+      duration_seconds
+    end
+
+  end
+end

data/lib/camayoc/version.rb

@@ -1,3 +1,3 @@
 module Camayoc
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/handlers/filter_test.rb

@@ -1,53 +1,57 @@
 class FilterTest < Test::Unit::TestCase
-  
+
+  include EventTestHelper
+
   def setup
     @handler = mock("handler")
   end
 
-  def test_constructor_block_used_as_filter
-    filter = Camayoc::Handlers::Filter.new(@handler) do |type,event|
+  with_event_types("test_constructor_block_used_as_filter") do
+    filter = Camayoc::Handlers::Filter.new(@handler) do |event|
       event.stat.length > 5
     end
-    @handler.expects(:count).once
-    @handler.expects(:timing).once
-    filter.count(Camayoc::StatEvent.new("foo:bar","short",500))
-    filter.count(Camayoc::StatEvent.new("foo:bar","very_long",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","short",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","very_long",500))
+
+    @handler.expects(:event).once
+    filter.event(Camayoc::StatEvent.new(@event_type,"foo:bar","short",500))
+    filter.event(Camayoc::StatEvent.new(@event_type,"foo:bar","very_long",500))
   end
 
-  def test_with_filters_on_namespaced_stat
+  with_event_types("test_with_filters_on_namespaced_stat") do
     filter = Camayoc::Handlers::Filter.new(@handler,:with=>/a{2}/)
-    @handler.expects(:count).once
-    @handler.expects(:timing).once
-    filter.count(Camayoc::StatEvent.new("foo:bar","aa_blah",500))
-    filter.count(Camayoc::StatEvent.new("foo:bar","bb_blah",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","aa_blah",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","bb_blah",500))
+
+    evt = stat_event_match(@event_type,"foo:bar","aa_blah",500)
+    @handler.expects(:event).with(&evt).once
+    filter.event(Camayoc::StatEvent.new(@event_type,"foo:bar","aa_blah",500))
+    filter.event(Camayoc::StatEvent.new(@event_type,"foo:bar","bb_blah",500))
   end
 
-  def test_constructor_block_used_as_filter
+  def test_constructor_block_used_as_filter_with_if_condition
     filter = Camayoc::Handlers::Filter.new(@handler,
-      :if=>Proc.new{|type,event| type == :timing && event.value > 1000 })
-    
-    @handler.expects(:count).never
-    @handler.expects(:timing).once
-    filter.count(Camayoc::StatEvent.new("foo:bar","short",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","short",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","very_long",1500))
+      :if=>Proc.new{|event| event.type == :timing && event.value > 1000 })
+
+    evt = stat_event_match(:timing,"foo:bar","very_long",1500)
+    @handler.expects(:event).with(&evt).once
+    filter.event(Camayoc::StatEvent.new(:count,"foo:bar","short",500))
+    filter.event(Camayoc::StatEvent.new(:timing,"foo:bar","short",500))
+    filter.event(Camayoc::StatEvent.new(:timing,"foo:bar","very_long",1500))
   end
 
-  def test_constructor_block_used_as_filter
+  def test_constructor_block_used_as_filter_with_unless_condition
     filter = Camayoc::Handlers::Filter.new(@handler,
-      :unless=>Proc.new{|type,event| type == :count })
-    
-    @handler.expects(:count).never
-    @handler.expects(:timing).twice
-    filter.count(Camayoc::StatEvent.new("foo:bar","short",500))
-    filter.count(Camayoc::StatEvent.new("foo:bar","very_long",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","short",500))
-    filter.timing(Camayoc::StatEvent.new("foo:bar","very_long",1500))
+      :unless=>Proc.new{|event| event.type == :count })
+
+    evt = stat_event_match(:timing,"foo:bar","short",500)
+    @handler.expects(:event).with(&evt).once
+    filter.event(Camayoc::StatEvent.new(:timing,"foo:bar","short",500))
+    filter.event(Camayoc::StatEvent.new(:count,"foo:bar","short",500))
+    filter.event(Camayoc::StatEvent.new(:count,"foo:bar","very_long",500))
+  end
+
+  def test_default_filter_is_always_true
+    filter = Camayoc::Handlers::Filter.new(@handler)
+
+    @handler.expects(:event).once
+    filter.event(Camayoc::StatEvent.new(:counting,"foo:bar","short",500))
   end
 
-  
-end
+end

data/test/handlers/io_test.rb

@@ -1,5 +1,5 @@
 class IOTest < Test::Unit::TestCase
-  
+
   def setup
     # Hack to get around weird Mocha issue with expecting :puts
     @io = []
@@ -10,24 +10,38 @@ class IOTest < Test::Unit::TestCase
   end
 
   def test_count_sends_correct_log_message
-    expect_message(/count foo:bar:baz 500/)
-    @handler.count(Camayoc::StatEvent.new("foo:bar","baz",500))
+    @handler.event(Camayoc::StatEvent.new(:count,"foo:bar","baz",500))
+    assert_message(/count foo:bar:baz 500/)
   end
 
   def test_timing_sends_correct_log_message
-    expect_message(/timing foo:bar:time 100/)
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",100))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100))
+    assert_message(/timing foo:bar:time 100/)
   end
 
   def test_formatter_changes_format_of_message
-    @handler.formatter = Proc.new{|type,event| "#{type}: #{event.ns_stat}"}
-    expect_message(/timing: foo:bar:time/)
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",100))
+    @handler.formatter = Proc.new{|event| "#{event.type}: #{event.ns_stat}"}
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100))
+    assert_message(/timing: foo:bar:time/)
+  end
+
+  def test_formatter_can_be_set_with_constructor_block
+    @handler = Camayoc::Handlers::IO.new(@io) do |event|
+      "#{event.type}: #{event.ns_stat} #{event.value}"
+    end
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100))
+    assert_message(/timing: foo:bar:time 100/)
+  end
+
+  def test_logs_any_event_type
+    @handler.event(Camayoc::StatEvent.new(:baz,"foo:bar","time",500))
+    assert_message(/baz foo:bar:time 500/)
   end
 
   private
-    def expect_message(*messages)
-      assert(@io.zip(messages).all?{ |actual,patt| actual =~ patt })
+    def assert_message(*messages)
+      pairs = messages.zip(@io)
+      assert(pairs.all?{ |actual,patt| actual =~ patt },pairs.join("\n"))
     end
 
-end
+end

data/test/handlers/logger_test.rb

@@ -1,32 +1,37 @@
 class LoggerTest < Test::Unit::TestCase
-  
+
   def setup
     @dest_logger = mock("logger")
     @handler = Camayoc::Handlers::Logger.new(@dest_logger)
   end
-  
+
   def test_count_sends_correct_log_message
     expect_message(:debug, /count 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_sends_correct_log_message
     expect_message(:debug,/timing foo:bar:time 100/)
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",100))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100))
   end
 
   def test_method_option_changes_method_called_on_logger
     @handler.method = :info
     expect_message(:info,/timing foo:bar:time 100/)
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",100))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100))
     expect_message(:info, /count foo:bar:baz 5000/)
-    @handler.count(Camayoc::StatEvent.new("foo:bar","baz",5000))
+    @handler.event(Camayoc::StatEvent.new(:count,"foo:bar","baz",5000))
   end
 
   def test_formatter_changes_format_of_message
-    @handler.formatter = Proc.new{|type,event| "#{type}: #{event.ns_stat}"}
+    @handler.formatter = Proc.new{|event| "#{event.type}: #{event.ns_stat}"}
     expect_message(:debug,/timing: foo:bar:time/)
-    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",100))
+    @handler.event(Camayoc::StatEvent.new(:timing,"foo:bar","time",100))
+  end
+
+  def test_logs_unknown_event_type
+    expect_message(:debug,/throwaway foo:bar:time 500/)
+    @handler.event(Camayoc::StatEvent.new(:throwaway,"foo:bar","time",500))
   end
 
   private
@@ -34,4 +39,4 @@ class LoggerTest < Test::Unit::TestCase
       @dest_logger.expects(method).with(regexp_matches(message))
     end
 
-end
+end