camayoc 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2011 by Appozite, LLC
+
+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,163 @@
+Overview
+========
+Camayoc is a flexible way to keep track of application stats. Inspired by 
+various logging frameworks (especially Log4r) it makes it easy to send stats 
+information to multiple destinations via the use of Handlers. Right out of the 
+box, it supports sending stats to the following:
+
+* A [statsd daemon](https://github.com/etsy/statsd/) for ridiculously easy [Graphite](http://graphite.wikidot.com/) stats
+* An in-memory hash for in-process stats
+* A logger or IO stream
+* Redis (EXPERIMENTAL - you'll need the [redis gem](https://github.com/ezmobius/redis-rb))
+
+Philosophy
+----------
+Application stats are critical. But even critical things get ignored if they're 
+hard (believe me, we know). Stats should be easy:
+
+* Collecting stats should take just one line of code
+* All stat collection should be fire-and-forget with no error handling required
+* Organizing stats should be easy
+* There should be essentially no performance cost to collecting stats
+
+Examples
+==========
+Here's all it takes to fire stats to statsd. 
+
+    require 'camayoc'
+    # Grab a stats instance
+    stats = Camayoc["my_app"]
+    # Add a handler for statsd
+    stats.add(Camayoc::Handlers::Statsd.new(:host=>"localhost",:port=>1234))
+    
+    # later in your app
+    def do_some_stuff
+      # Do some stuff
+      Camayoc["my_app"].increment("did_stuff")
+    end
+    
+Your stat will be sent to statsd with the name "my_app.did_stuff". See the 
+statsd docs for more information about how that gets translated into Graphite.
+
+Namespaces
+----------
+Many logging frameworks support the concept of namespaced logs that "extend" 
+other logs. This makes it easy to log messages from different areas of your 
+app and stay sane. Camayoc does this as well. 
+
+Let's say you have a service within your app where you want to store some timing 
+data.
+
+    stats = Camayoc["my_app"]
+    stats.add(Camayoc::Handlers::Statsd.new(:host=>"localhost",:port=>1234))
+
+    class AwesomeService
+      def be_awesome
+        start_time = Time.now.to_f
+        # Be, you know, awesome
+        ms = ((Time.now_to_f - start_time) * 1000).round
+        Camayoc["my_app:awesome_service"].timing("awesome_duration",ms)
+      end
+    end
+    
+This will automatically create a timing metric in graphite via statsd called 
+"my_app.awesome_service.awesome_duration". It does this by using the statsd 
+handler already configured for its "my_app" parent. Now, about handlers...
+
+Handlers
+--------
+Just like loggers can have multiple outputters, you might want to send your 
+stats to different places.
+
+    app_stats = Camayoc["my_app"]
+    app_stats.add(Camayoc::Handlers::Statsd.new(:host=>"localhost",:port=>1234))
+    
+    foo_stats = Camayoc["my_app:foo"]
+    foo_stats.add(Camayoc::Handlers::Redis.new(:host=>"localhost"))
+    
+    app_stats.count("bar",1000) # Stats end up in statsd
+    
+    foo_stats.count("baz",150) # Stats go to redis *and* statsd
+    
+Filters
+-------
+Sometimes you may want to send only certain stats to certain places.
+
+    app_stats = Camayoc["my_app"]
+    app_stats.add(Camayoc::Handlers::Statsd.new(:host=>"localhost",:port=>1234))
+    
+    foo_stats = Camayoc["my_app:foo"]
+    foo_stats.add(Camayoc::Handlers::Redis.new(:host=>"localhost"),:when=>/baz/)
+    
+    foo_stats.increment("baz",1000) #Stats go to redis and statsd
+    foo_stats.increment("bar",5)    #Stats only go to statsd, not redis
+    
+There are other options as well like :if and :unless that take Procs that can 
+be executed to determine if a metric should be sent to the specified handler.
+See Camayoc::Handlers::Filter for more.
+
+Available Handlers
+==================
+Statsd
+------
+Class: Camayoc::Handlers::Statsd
+
+This handler sends data to the statd daemon for use in graphite. If you can get 
+graphite and statsd going, then you'll get pretty graphs.
+
+Memory
+------
+Class: Camayoc::Handlers::Memory
+
+Stores counts and timing data in an in-memory hash. This might be handy for 
+storing some temporary in-process stats.
+
+Logger
+------
+Class: Camayoc::Handlers::Logger
+
+Writes out stat values and a timestamp to a logger instance for later analysis.
+The format and method called on the logger can be controlled by constructor 
+arguments. See the class for details.
+
+IO
+--
+Class: Camayoc::Handlers::IO
+
+Writes out stats values and a timestamp to some stream of your choice. See 
+class for configuration details.
+
+Redis (Experimental)
+--------------------
+Class: Camayoc::Handlers::Redis (require "camayoc/handlers/redis" first) 
+
+The redis gem is required to use this handler. This is a very, very simple 
+implementation that stores some data in redis. It is in no way a full-fledged 
+time-based stats system. It does make it easy to collect some simple counts and 
+some timing data. You can easily retrieve the stored data from redis by using 
+the #get method.
+
+
+Implementing a Handler
+======================
+Let's say you want to implement your own handler, pehaps to MongoDB. Handlers 
+just need to respond to a simple interface. See Camayoc::Handlers::StatEvent 
+for info on the argument to the two methods.
+
+    class SomeHandler
+      def count(stat_event)
+        # Do something
+      end
+      
+      def timing(stat_event)
+        # Do something
+      end
+    end
+
+If you write a handler and would like it included in Camayoc, please fork 
+and send a pull request and we'll get it integrated in.
+
+Acknowledgements
+================
+* The basic structure of Camayoc owes a lot of [Log4r](http://log4r.rubyforge.org/)
+* The socket code for the Statsd handler is a modification of [reinh](https://github.com/reinh)'s [statsd](https://github.com/reinh/statsd)

data/lib/camayoc/handlers/filter.rb

@@ -0,0 +1,43 @@
+module Camayoc
+  module Handlers
+    class Filter
+      
+      def initialize(dest,options={},&block)
+        @dest = dest
+        if block_given?
+          @filter = block
+        elsif options[:with]
+          pattern = options[:with]
+          @filter = Proc.new {|type,event| event.ns_stat =~ pattern }
+        elsif options[:if]
+          @filter = options[:if]
+        elsif options[:unless]
+          proc = options[:unless]
+          @filter = Proc.new do |type,event| 
+            !proc.call(type,event)
+          end
+        else
+          @filter = Proc.new {|args| true }
+        end
+      end
+
+      def count(event)
+        if allowed?(:count,event)
+          @dest.count(event)
+        end
+      end
+
+      def timing(event)
+        if allowed?(:timing,event)
+          @dest.timing(event)
+        end
+      end
+
+      private
+        def allowed?(type,event)
+          @filter.call(type,event)
+        end
+
+    end
+  end
+end

data/lib/camayoc/handlers/io.rb

@@ -0,0 +1,25 @@
+module Camayoc
+  module Handlers
+
+    # Write to a raw IO stream with optional thread-safe locking before writing 
+    # to the stream. By default, each stat message is written on a single line 
+    # using puts. See the options in Camayoc::Handlers:Logger for options.
+    class IO < Logger
+
+      include ThreadSafety
+
+      def initialize(io=$stdout,options={})
+        super(io,{:method=>:puts}.merge(options))
+        self.thread_safe = Camayoc.thread_safe?
+      end
+
+      protected
+        def write(type,event)
+          synchronize do
+            super(type,event)
+          end
+        end
+
+    end
+  end
+end

data/lib/camayoc/handlers/logger.rb

@@ -0,0 +1,44 @@
+module Camayoc
+  module Handlers
+    
+    # Write stats to a logger. Specify the method to call on the logger instance 
+    # with :method (usually something like :info). If not :method is specified 
+    # :debug will be called on the logger. You can control the format of the 
+    # message passed to the logger method using the :formatter Proc.
+    class Logger
+
+      attr_accessor :logger, :method, :formatter
+
+      def initialize(logger, options={})
+        self.logger = logger
+        self.method = options[:method]
+        self.formatter = (options[:formatter] || default_formatter)
+      end
+
+      def count(event)
+        write(:count,event)
+      end
+
+      def timing(event)
+        write(:timing,event)
+      end
+
+      def default_formatter
+        Proc.new do |type,event|
+          "#{type} #{event.ns_stat} #{event.value} #{Time.now.utc.to_i}"
+        end
+      end     
+
+      protected
+        def write(type,event)
+          msg = formatter.call(type,event) 
+          if @method
+            @logger.send(@method,msg)
+          else
+            @logger.debug(msg)
+          end
+        end
+
+    end
+  end
+end

data/lib/camayoc/handlers/memory.rb

@@ -0,0 +1,35 @@
+module Camayoc
+  module Handlers
+    class Memory
+      
+      include ThreadSafety
+
+      def initialize(options={})
+        @data = {}
+        self.thread_safe = Camayoc.thread_safe?
+      end
+
+      def count(event)
+        stat = event.ns_stat
+        synchronize do
+          @data[stat] ||= 0
+          @data[stat] += event.value
+        end
+      end
+
+      def timing(event)
+        synchronize do
+          (@data[event.ns_stat] ||= Timing.new) << event.value
+        end
+      end
+
+      def get(stat)
+        synchronize do
+          @data[stat]
+        end
+      end
+      alias_method :[], :get
+
+    end
+  end
+end

data/lib/camayoc/handlers/redis.rb

@@ -0,0 +1,49 @@
+require 'redis'
+
+module Camayoc
+  module Handlers
+
+    # This class is experimental.
+    class Redis
+      
+      def initialize(options={})
+        @namespace = options.delete(:namespace)
+        @redis = (options[:redis] || ::Redis.new(options))
+      end
+
+      def count(event)
+        @redis.incrby(key(event.ns_stat),event.value)
+      end
+
+      def timing(event)
+        stat = event.ns_stat
+        ms = event.value
+        @redis.set(key(stat),"timing")
+        @redis.incrby(key("#{stat}:_count"),1)
+        @redis.incrby(key("#{stat}:_total"),ms)
+      end
+
+      def get(stat)
+        value = @redis.get(key(stat))
+        if value == "timing"
+          Timing.new(
+            @redis.get(key("#{stat}:_total")).to_i, 
+            @redis.get(key("#{stat}:_count")).to_i,
+            nil,nil # Don't support min and max right now in redis
+          )
+        elsif value
+          value.to_i
+        else
+          nil
+        end
+      end
+      alias_method :[], :get
+
+      private
+        def key(stat)
+          @namespace ? "#{@namespace}:#{stat}" : stat
+        end
+
+    end
+  end
+end

data/lib/camayoc/handlers/statsd.rb

@@ -0,0 +1,47 @@
+require 'socket'
+
+# 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
+    class Statsd
+
+      include ThreadSafety
+
+      attr_accessor :namespace
+      
+      def initialize(options={})
+        self.namespace = options[:namespace]
+        @host = options[:host]
+        @port = options[:port]
+        @socket = UDPSocket.new
+        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) 
+      end
+
+      private
+        def sampled(sample_rate)
+          yield unless sample_rate < 1 and rand > sample_rate
+        end
+
+        def send(stat, delta, type, sample_rate)
+          prefix = "#{@namespace}." unless @namespace.nil?
+          sampled(sample_rate) do
+            stat = stat.gsub(Camayoc::DELIMITER,'.')
+            msg = "#{prefix}#{stat}:#{delta}|#{type}#{'|@' << sample_rate.to_s if sample_rate < 1}"
+            synchronize do
+              @socket.send(msg, 0, @host, @port)
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/camayoc/handlers/timing.rb

@@ -0,0 +1,26 @@
+module Camayoc
+  module Handlers
+    class Timing
+      attr_accessor :total, :count, :min, :max
+
+      def initialize(total=0,count=0,min=nil,max=nil)
+        self.total = total
+        self.count = count
+        self.max = max
+        self.min = min
+      end
+
+      def <<(ms)
+        @total += ms
+        @count += 1
+        @max = ms if @max.nil? || ms > @max
+        @min = ms if @min.nil? || ms < @min
+      end
+
+      def average
+        return nil if @count == 0
+        @total/@count
+      end
+    end
+  end
+end

data/lib/camayoc/stat_event.rb

@@ -0,0 +1,18 @@
+module Camayoc
+  class StatEvent
+
+    attr_accessor :source, :stat, :value, :options
+
+    def initialize(source,stat,value,options={})
+      self.source = source
+      self.stat = stat
+      self.value = value
+      self.options = options
+    end
+
+    def ns_stat
+      "#{source}#{Camayoc::DELIMITER}#{stat}"
+    end
+
+  end
+end

data/lib/camayoc/stats.rb

@@ -0,0 +1,77 @@
+module Camayoc
+  class Stats
+
+    attr_accessor :name, :parent, :handlers
+
+    def initialize(name,parent=nil)
+      self.name = name
+      self.parent = parent
+      self.handlers = []
+    end
+    
+    def add(handler,filter_opts={})
+      if !filter_opts.empty?
+        handler = Handlers::Filter.new(handler,filter_opts)
+      end
+      self.handlers << handler
+      self
+    end
+
+    def <<(handler)
+      self.add(handler)
+    end
+
+    def increment(stat,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))
+    end
+
+    def timing(stat,ms,options={})
+      timing_event(StatEvent.new(name,stat,ms,options))
+    end
+    
+    protected
+      def count_event(event)
+        each_handler do |handler|
+          handler.count(event)
+        end
+        if parent
+          parent.count_event(event)
+        end
+        self
+      end
+
+      def timing_event(event)
+        each_handler do |handler|
+          handler.timing(event)
+        end
+        if parent
+          parent.timing_event(event)
+        end
+        self
+      end
+
+    private
+      def each_handler 
+        handlers.each do |handler|
+          begin
+            yield(handler)
+          rescue
+            # Swallow up errors
+          end
+        end
+      end
+
+      def ns_stat(stat,ns=nil)
+        "#{ns || name}#{Camayoc::NAME_DELIMITER}#{stat}"
+      end
+
+  end
+end

data/lib/camayoc/thread_safety.rb

@@ -0,0 +1,31 @@
+module Camayoc
+  module ThreadSafety
+
+    class PlaceboLock
+      def synchronize
+        yield
+      end
+    end
+
+    # Ideally this should be called from your constructor
+    def thread_safe=(value)
+      @lock = value ? Mutex.new : PlaceboLock.new
+    end
+
+    def thread_safe?
+      lock.is_a?(Mutex)
+    end
+
+    def synchronize
+      lock.synchronize { yield }
+    end
+
+    private
+      def lock
+        # If we get here and have to init the lock because it's nil, obviously 
+        # it's not thread safe
+        @lock ||= PlaceboLock.new
+      end
+
+  end
+end

data/lib/camayoc/version.rb

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

data/lib/camayoc.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'camayoc/version'
+require 'camayoc/thread_safety'
+require 'camayoc/stat_event'
+require 'camayoc/handlers/timing'
+require 'camayoc/handlers/filter'
+require 'camayoc/handlers/logger'
+require 'camayoc/handlers/io'
+require 'camayoc/handlers/memory'
+require 'camayoc/handlers/statsd'
+require 'camayoc/stats'
+
+module Camayoc  
+
+  DELIMITER = ":"
+
+  @registry = {}
+  @lock = Mutex.new
+
+  class << self
+    def [](name)
+      @lock.synchronize { @registry[name] ||= _new(name) }  
+    end
+
+    def new(name)
+      @lock.synchronize { _new(name) }
+    end
+
+    def all
+      @lock.synchronize { @registry.values.dup }
+    end
+
+    def thread_safe=(value)
+      @thread_safe = value
+    end
+    
+    def thread_safe?
+      @thread_safe == true
+    end
+
+    private
+      def _new(name)
+        stats = Stats.new(name,ancestor(name))
+        @registry[name] = stats
+        reassign_children(stats)
+        stats
+      end
+
+      def reassign_children(node)
+        @registry.values.each do |other_node|
+          if other_node != node && other_node.name.index(node.name) == 0
+            other_node.parent = node
+          end
+        end
+      end
+
+      def ancestor(name)
+        ancestor = nil
+        path = name.split(DELIMITER)
+        while path.pop && !ancestor
+          ancestor = @registry[path.join(DELIMITER)]
+        end
+        ancestor
+      end
+  end
+
+end

data/test/handlers/filter_test.rb

@@ -0,0 +1,53 @@
+class FilterTest < Test::Unit::TestCase
+  
+  def setup
+    @handler = mock("handler")
+  end
+
+  def test_constructor_block_used_as_filter
+    filter = Camayoc::Handlers::Filter.new(@handler) do |type,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))
+  end
+
+  def test_with_filters_on_namespaced_stat
+    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))
+  end
+
+  def test_constructor_block_used_as_filter
+    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))
+  end
+
+  def test_constructor_block_used_as_filter
+    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))
+  end
+
+  
+end

data/test/handlers/io_test.rb

@@ -0,0 +1,33 @@
+class IOTest < Test::Unit::TestCase
+  
+  def setup
+    # Hack to get around weird Mocha issue with expecting :puts
+    @io = []
+    def @io.puts(msg)
+      self << msg
+    end
+    @handler = Camayoc::Handlers::IO.new(@io)
+  end
+
+  def test_count_sends_correct_log_message
+    expect_message(/count foo:bar:baz 500/)
+    @handler.count(Camayoc::StatEvent.new("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))
+  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))
+  end
+
+  private
+    def expect_message(*messages)
+      assert(@io.zip(messages).all?{ |actual,patt| actual =~ patt })
+    end
+
+end

data/test/handlers/logger_test.rb

@@ -0,0 +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))
+  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))
+  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))
+    expect_message(:info, /count foo:bar:baz 5000/)
+    @handler.count(Camayoc::StatEvent.new("foo:bar","baz",5000))
+  end
+
+  def test_formatter_changes_format_of_message
+    @handler.formatter = Proc.new{|type,event| "#{type}: #{event.ns_stat}"}
+    expect_message(:debug,/timing: foo:bar:time/)
+    @handler.timing(Camayoc::StatEvent.new("foo:bar","time",100))
+  end
+
+  private
+    def expect_message(method,message)
+      @dest_logger.expects(method).with(regexp_matches(message))
+    end
+
+end

data/test/handlers/memory_test.rb

@@ -0,0 +1,38 @@
+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))
+    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))
+    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))
+    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))
+    timing = @handler["foo:bar:time"]
+    assert_equal(4,timing.count)
+    assert_equal(100,timing.min)
+    assert_equal(1000,timing.max)
+    assert_equal(2200,timing.total)
+    assert_equal(550,timing.average)
+  end
+end

data/test/handlers/redis_test.rb

@@ -0,0 +1,28 @@
+if (begin; require 'camayoc/handlers/redis'; true; rescue LoadError; false end)
+  class RedisTest < Test::Unit::TestCase
+    def setup
+      @redis = mock("redis")
+      @handler = Camayoc::Handlers::Redis.new(:redis=>@redis)
+    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))
+    end
+
+    def test_timing_updates_redis_keys_with_timing_info
+      seq = sequence("increments")
+      @redis.expects(:set).with("foo:bar:time","timing").times(3)
+      @redis.expects(:incrby).with("foo:bar:time:_count",1).times(3)
+      @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))
+    end
+
+  end
+else
+  puts "Warn: Skipping Redis test because redis gem is not installed"
+end

data/test/handlers/statsd_test.rb

@@ -0,0 +1,22 @@
+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,{}))
+  end
+
+  def test_timing_sends_correct_statsd_message
+    expect_message("foo.bar.time:100|ms")
+    @statsd.timing(Camayoc::StatEvent.new("foo:bar","time",100,{}))
+  end
+
+  private
+    def expect_message(message)
+      @statsd.instance_variable_get("@socket").expects(:send).with(message,0,"localhost",1234)
+    end
+
+end

data/test/registration_test.rb

@@ -0,0 +1,57 @@
+class RegistrationTest < Test::Unit::TestCase
+  
+  def test_accessing_stats_creates_it
+    stats = Camayoc["foo:bar"]
+    assert_equal(Camayoc::Stats,stats.class)
+  end
+
+  def test_accessing_stats_returns_same_instance
+    stats1 = Camayoc["foo:bar"]
+    stats2 = Camayoc["foo:bar"]
+    assert_same(stats1,stats2)
+  end
+
+  def test_accessing_path_with_no_ancestor_leaves_parent_nil
+    stats1 = Camayoc["foo:bar"]
+    assert_nil(stats1.parent)
+  end
+
+  def test_accessing_path_with_already_existing_ancestor_sets_parent
+    parent = Camayoc["foo"]
+    child = Camayoc["foo:bar"]
+    assert_same(parent,child.parent)
+  end
+  
+  def test_accessing_path_with_intermediate_steps_gets_closest_existing_ancestor_as_parent
+    parent = Camayoc["foo"]
+    child = Camayoc["foo:a:b:c:baz"]
+    assert_same(parent,child.parent)
+  end
+
+  def test_accessing_path_in_middle_of_existing_hierarchy_reassociates_children
+    root = Camayoc["foo"]
+    child1 = Camayoc["foo:a:b:c:1"]
+    child2 = Camayoc["foo:a:b:c:2"]
+    middle = Camayoc["foo:a:b"]
+    
+    assert_same(root,middle.parent)
+    assert_same(middle,child1.parent)
+    assert_same(middle,child2.parent)
+  end
+  
+  def test_all_lists_all_existing_instances
+    root = Camayoc["foo"]
+    child1 = Camayoc["foo:a:b:c:1"]
+    child2 = Camayoc["foo:a:b:c:2"]
+    middle = Camayoc["foo:a:b"]
+    
+    all = Camayoc.all
+    all = all.sort_by{|stats| stats.name}
+
+    assert_equal([root,middle,child1,child2],all)
+  end
+
+  def teardown
+    Camayoc.instance_variable_get("@registry").clear
+  end
+end

data/test/stat_event_test.rb

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

data/test/stats_test.rb

@@ -0,0 +1,94 @@
+class StatsTest < Test::Unit::TestCase
+
+  def setup
+    @stats = Camayoc::Stats.new("foo:bar")
+    @handler = mock("handler1")
+    @stats.add(@handler)
+  end
+
+  def test_count_fires_to_all_handlers
+    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)
+  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)
+  end
+
+  def test_count_propagates_event_to_parent_after_firing_to_handlers
+    @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)
+  end
+
+  def test_increment_delegates_to_count
+    @stats.expects(:count).with("count",1,{})
+    @stats.increment("count")
+  end
+
+  def test_decrement_delegates_to_count
+    @stats.expects(:count).with("count",-1,{})
+    @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_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)
+  end
+
+  def test_timing_propagates_event_to_parent_after_firing_to_handlers
+    @stats.parent = Camayoc::Stats.new("foo")
+
+    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)
+  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)
+
+    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

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+
+$: << File.join(File.dirname(__FILE__),"..","lib")
+require 'camayoc'

data/test/thread_safety_test.rb

@@ -0,0 +1,33 @@
+class ThreadSafetyTest < Test::Unit::TestCase
+
+  class SafeThing
+    include Camayoc::ThreadSafety
+  end
+
+  def setup
+    @thing = SafeThing.new
+  end
+
+  def test_thread_safe_turns_on_lock
+    @thing.thread_safe = true
+    assert_equal(Mutex,@thing.__send__(:lock).class)
+  end
+
+  def test_lock_is_placebo_by_default
+    assert_equal(Camayoc::ThreadSafety::PlaceboLock,
+      @thing.__send__(:lock).class)
+  end
+
+  def test_synchronize_yields_whether_safe_or_not
+    yielded = false
+    @thing.thread_safe = true
+    @thing.synchronize { yielded = true }
+    assert(yielded)
+    
+    yielded = false
+    @thing.thread_safe = false
+    @thing.synchronize {yielded = true}
+    assert(yielded)
+  end
+
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: camayoc
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Hayes Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        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"
+email: hayes@appozite.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- README.md
+- LICENSE
+- lib/camayoc/handlers/filter.rb
+- lib/camayoc/handlers/io.rb
+- lib/camayoc/handlers/logger.rb
+- lib/camayoc/handlers/memory.rb
+- lib/camayoc/handlers/redis.rb
+- lib/camayoc/handlers/statsd.rb
+- lib/camayoc/handlers/timing.rb
+- lib/camayoc/stat_event.rb
+- lib/camayoc/stats.rb
+- lib/camayoc/thread_safety.rb
+- lib/camayoc/version.rb
+- lib/camayoc.rb
+- test/handlers/filter_test.rb
+- test/handlers/io_test.rb
+- test/handlers/logger_test.rb
+- test/handlers/memory_test.rb
+- test/handlers/redis_test.rb
+- test/handlers/statsd_test.rb
+- test/registration_test.rb
+- test/stat_event_test.rb
+- test/stats_test.rb
+- test/test_helper.rb
+- test/thread_safety_test.rb
+has_rdoc: true
+homepage: http://github.com/appozite/camayoc
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Camayoc makes it easy to send stats anywhere.
+test_files: []
+