fozzie 0.0.15 → 0.0.16

data/lib/fozzie/interface.rb

@@ -0,0 +1,121 @@
+require 'singleton'
+require 'fozzie/socket'
+
+module Fozzie
+  class Interface
+    include Fozzie::Socket, Singleton
+
+    # Increments the given stat by one, with an optional sample rate
+    #
+    # `Stats.increment 'wat'`
+    def increment(stat, sample_rate=1)
+      count(stat, 1, sample_rate)
+    end
+
+    # Decrements the given stat by one, with an optional sample rate
+    #
+    # `Stats.decrement 'wat'`
+    def decrement(stat, sample_rate=1)
+      count(stat, -1, sample_rate)
+    end
+
+    # Registers a count for the given stat, with an optional sample rate
+    #
+    # `Stats.count 'wat', 500`
+    def count(stat, count, sample_rate=1)
+      send(stat, count, 'c', sample_rate)
+    end
+
+    # Registers a timing (in ms) for the given stat, with an optional sample rate
+    #
+    # `Stats.timing 'wat', 500`
+    def timing(stat, ms, sample_rate=1)
+      send(stat, ms, 'ms', sample_rate)
+    end
+
+    # Registers the time taken to complete a given block (in ms), with an optional sample rate
+    #
+    # `Stats.time 'wat' { # Do something... }`
+    def time(stat, sample_rate=1)
+      stat   = stat.flatten.join('.') if stat.kind_of?(Array)
+      start  = Time.now
+      result = yield
+      timing(stat, ((Time.now - start) * 1000).round, sample_rate)
+      result
+    end
+
+    # Registers the time taken to complete a given block (in ms), with an optional sample rate
+    #
+    # `Stats.time_to_do 'wat' { # Do something, again... }`
+    def time_to_do(stat, sample_rate=1, &block)
+      time_for(stat, sample_rate, &block)
+    end
+
+    # Registers the time taken to complete a given block (in ms), with an optional sample rate
+    #
+    # `Stats.time_for 'wat' { # Do something, grrr... }`
+    def time_for(stat, sample_rate=1, &block)
+      time(stat, sample_rate, &block)
+    end
+
+    # Registers a commit
+    #
+    # `Stats.commit`
+    def commit
+      event :commit
+    end
+
+    # Registers a commit
+    #
+    # `Stats.commit`
+    def committed
+      commit
+    end
+
+    # Registers that the app has been built
+    #
+    # `Stats.built`
+    def built
+      event :build
+    end
+
+    # Registers a build for the app
+    #
+    # `Stats.build`
+    def build
+      built
+    end
+
+    # Registers a deployed status for the given app
+    #
+    # `Stats.deployed 'watapp'`
+    def deployed(app = nil)
+      event :deploy, app
+    end
+
+    # Registers a deployment for the given app
+    #
+    # `Stats.deploy 'watapp'`
+    def deploy(app = nil)
+      deployed(app)
+    end
+
+    # Registers an increment on the result of the given boolean
+    #
+    # `Stats.increment_on 'wat', wat.random?`
+    def increment_on(stat, perf, sample_rate=1)
+      key = "#{stat}.%s" % (perf ? "success" : "fail")
+      increment(key, sample_rate)
+      perf
+    end
+
+    # Register an event of any type
+    #
+    # `Stats.event 'wat', 'app'`
+    def event(type, app = nil)
+      stat = ["event", type.to_s, app].compact.join('.')
+      timing stat, Time.now.usec
+    end
+
+  end
+end

data/lib/fozzie/rack/middleware.rb

@@ -1,5 +1,8 @@
 module Fozzie
   module Rack
+
+    # Time and record each request through a given Rack app
+    # This middlewware times server processing for a resource, not view render.
     class Middleware
 
       attr_reader :app

data/lib/fozzie/rails/middleware.rb

@@ -2,8 +2,12 @@ require 'fozzie/rack/middleware'
 
 module Fozzie
   module Rails
+
+    # Time and record each request through a given Rails app
+    # This middlewware times server processing for a resource, not view render.
     class Middleware < Fozzie::Rack::Middleware
 
+      # Generates the statistics key for the current path
       def generate_key(env)
         path_str = env['PATH_INFO']
         return nil unless path_str

data/lib/fozzie/socket.rb

@@ -0,0 +1,44 @@
+module Fozzie
+  module Socket
+
+    RESERVED_CHARS_REGEX = /[\:\|\@]/
+
+    private
+
+    # Send the statistic to the server
+    def send(stat, delta, type, sample_rate)
+      prefix = "%s." % Fozzie.c.data_prefix unless Fozzie.c.data_prefix.nil?
+      stat   = stat.to_s.gsub('::', '.').gsub(RESERVED_CHARS_REGEX, '_')
+
+      k = "%s%s:%s|%s" % [prefix, stat, delta, type]
+      k << '|@%s' % sample_rate.to_s if sample_rate < 1
+
+      sampled(sample_rate) { send_to_socket(k.strip) }
+    end
+
+    # If the statistic is sampled, generate a condition to check if it's good to send
+    def sampled(sample_rate)
+      yield unless sample_rate < 1 and rand > sample_rate
+    end
+
+    # Send data to the server via the socket
+    def send_to_socket(message)
+      begin
+        Fozzie.logger.debug {"Statsd: #{message}"} if Fozzie.logger
+        Timeout.timeout(Fozzie.c.timeout) {
+          socket.send(message, 0, Fozzie.c.host, Fozzie.c.port)
+          true
+        }
+      rescue => exc
+        Fozzie.ogger.debug {"Statsd Failure: #{exc.message}\n#{exc.backtrace}"} if Fozzie.logger
+        false
+      end
+    end
+
+    # The Socket we want to use to send data
+    def socket
+      @socket ||= UDPSocket.new
+    end
+
+  end
+end

data/lib/fozzie/version.rb

@@ -1,3 +1,3 @@
 module Fozzie
-  VERSION = "0.0.15"
+  VERSION = "0.0.16"
 end

data/spec/lib/fozzie/configuration_spec.rb

@@ -13,32 +13,32 @@ describe Fozzie::Configuration do
 
   it "attempts to load configuration from yaml" do
     c = Fozzie::Configuration.new({:env => 'test', :config_path => 'spec/'})
-    c.stubs(:origin_name).returns("")
-    c.host.should == '1.1.1.1'
-    c.port.should == 9876
-    c.appname.should == 'fozzie'
-    c.data_prefix.should == 'fozzie.test'
+    c.stubs(:origin_name).returns ""
+    c.host.should eq '1.1.1.1'
+    c.port.should eq 9876
+    c.appname.should eq 'fozzie'
+    c.data_prefix.should eq 'fozzie.test'
   end
 
   it "defaults env" do
-    subject.env.should == 'development'
+    subject.env.should eq 'development'
   end
 
   it "creates a data prefix" do
     subject.stubs(:origin_name).returns("")
-    subject.data_prefix.should == 'development'
+    subject.data_prefix.should eq 'development'
   end
 
   it "creates a data prefix with appname when set" do
     subject.stubs(:origin_name).returns("")
     subject.appname = 'astoria'
-    subject.data_prefix.should == 'astoria.development'
+    subject.data_prefix.should eq 'astoria.development'
   end
 
   it "creates a prefix with origin" do
     subject.stubs(:origin_name).returns("app.server.local")
     subject.appname = 'astoria'
-    subject.data_prefix.should == 'astoria.app-server-local.development'
+    subject.data_prefix.should eq 'astoria.app-server-local.development'
   end
 
   it "handles missing configuration namespace" do
@@ -51,37 +51,4 @@ describe Fozzie::Configuration do
     subject.namespaces.should include("S")
   end
 
-  describe "#ip_from_host" do
-
-    it "returns host if host an ip" do
-      c = Fozzie::Configuration.new({:env => 'test', :config_path => nil, :host => '127.0.0.1'})
-      c.ip_from_host.should == '127.0.0.1'
-    end
-
-    it "assigns nil on miss" do
-      Resolv.expects(:getaddresses).with('some.awesome.log.server').returns([])
-      c = Fozzie::Configuration.new({:env => 'test', :config_path => nil, :host => 'some.awesome.log.server'})
-      c.ip_from_host.should == ""
-      c.ip_from_host.should == ""
-    end
-
-    it "looks up ip from host" do
-      c = Fozzie::Configuration.new({:env => 'test', :config_path => nil, :host => 'lonelyplanet.com'})
-      c.ip_from_host.should match(/^(?:\d{1,3}\.){3}\d{1,3}$/)
-    end
-
-    it "caches the ip once it is retrieved" do
-      Resolv.expects(:getaddresses).with('lonelyplanet.com').returns(["1.1.1.1"])
-      c = Fozzie::Configuration.new({:env => 'test', :config_path => nil, :host => 'lonelyplanet.com'})
-      c.ip_from_host.should == "1.1.1.1"
-    end
-
-    it "raises Timeout on slow lookup" do
-      Resolv.stubs(:getaddresses).with('lonelyplanet.com') {|val| sleep 0.6; [] }
-      c = Fozzie::Configuration.new(:env => 'test', :config_path => nil, :host => 'lonelyplanet.com', :timeout => 0.5)
-      c.ip_from_host.should == ""
-    end
-
-  end
-
 end

data/spec/lib/fozzie/interface_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require 'fozzie/interface'
+
+describe Fozzie::Interface do
+
+  subject { Fozzie::Interface.instance }
+
+  it "acts an a singleton" do
+    Fozzie.c.namespaces.each do |k|
+      Kernel.const_get(k).should eq Fozzie::Interface.instance
+    end
+  end
+
+  it "times a given block" do
+    subject.expects(:timing).with() {|b, val, timing| b == 'data.bin' && (1000..1200).include?(val) }.twice
+    subject.time_for('data.bin')    { sleep 1 }
+    subject.time_to_do('data.bin')  { sleep 1 }
+  end
+
+  it "registers a commit" do
+    subject.expects(:timing).with('event.commit', anything).twice
+    subject.commit
+    subject.committed
+  end
+
+  it "registers a build" do
+    subject.expects(:timing).with('event.build', anything).twice
+    subject.build
+    subject.built
+  end
+
+  it "registers a deploy" do
+    subject.expects(:timing).with('event.deploy', anything).twice
+    subject.deploy
+    subject.deployed
+  end
+
+  it "ensures block is called on socket error" do
+    UDPSocket.any_instance.stubs(:send).raises(SocketError)
+    proc { subject.time_for('data.bin') { sleep 1 } }.should_not raise_error
+    proc { subject.time_to_do('data.bin') { sleep 1 } }.should_not raise_error
+  end
+
+  it "raises exception if natural exception from block" do
+    proc { subject.time_for('data.bin') { raise ArgumentError, "testing" } }.should raise_error(ArgumentError)
+  end
+
+  it "only calls the block once on SocketError" do
+    UDPSocket.any_instance.stubs(:send).raises(SocketError)
+    i = 0
+    p = proc {|n| (n + 1) }
+    val = subject.time_for('data.bin') { i+= p.call(i) }
+    val.should == 1
+  end
+
+  it "raises Timeout on slow lookup" do
+    UDPSocket.any_instance.stubs(:send).with(any_parameters) { sleep 0.6 }
+    subject.increment('data.bin').should eq false
+  end
+
+  describe "#increment_on" do
+
+    it "registers success" do
+      subject.expects(:increment).with("event.increment.success", 1)
+      subject.increment_on('event.increment', true).should == true
+    end
+
+    it "registers failure" do
+      subject.expects(:increment).with("event.increment.fail", 1)
+      subject.increment_on('event.increment', false).should == false
+    end
+
+    it "simply questions the passed val with if" do
+      a = mock()
+      a.expects(:save).returns({})
+      subject.expects(:increment).with("event.increment.success", 1)
+      subject.increment_on('event.increment', a.save).should == {}
+    end
+
+    it "registers fail on nil return" do
+      a = mock()
+      a.expects(:save).returns(nil)
+      subject.expects(:increment).with("event.increment.fail", 1)
+      subject.increment_on('event.increment', a.save).should == nil
+    end
+
+    describe "performing actions" do
+
+      it "registers success" do
+        a = mock()
+        a.expects(:save).returns(true)
+        subject.expects(:increment).with("event.increment.success", 1)
+        subject.increment_on('event.increment', a.save).should == true
+      end
+
+      it "registers failure" do
+        a = mock()
+        a.expects(:save).returns(false)
+        subject.expects(:increment).with("event.increment.fail", 1)
+        subject.increment_on('event.increment', a.save).should == false
+      end
+
+      it "registers positive even when nested" do
+        a = mock()
+        a.expects(:save).returns(true)
+        subject.expects(:timing).with('event.run', any_parameters)
+        subject.expects(:increment).with("event.increment.success", 1)
+
+        res = subject.time_to_do "event.run" do
+          subject.increment_on('event.increment', a.save)
+        end
+        res.should == true
+      end
+
+      it "registers negative even when nested" do
+        a = mock()
+        a.expects(:save).returns(false)
+        subject.expects(:timing).with('event.run', any_parameters)
+        subject.expects(:increment).with("event.increment.fail", 1)
+
+        res = subject.time_to_do "event.run" do
+          subject.increment_on('event.increment', a.save)
+        end
+        res.should == false
+      end
+
+      it "allows passing of arrays for stat key" do
+        subject.expects(:timing).with('event.commit', any_parameters)
+        subject.time_to_do %w{event commit} do; end
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/fozzie/rack/middleware_spec.rb

@@ -5,11 +5,9 @@ require 'rack/test'
 describe Fozzie::Rack::Middleware do
 
   subject do
-    RackApp = Class.new do
-      def call(env)
-        env
-      end
-    end unless defined?(RackApp)
+    unless defined?(RackApp)
+      RackApp = Class.new { def call(env); env end } 
+    end
     Fozzie::Rack::Middleware.new RackApp.new
   end
 

data/spec/lib/fozzie/rails/middleware_spec.rb

@@ -2,9 +2,13 @@ require 'spec_helper'
 require 'action_controller'
 
 describe Fozzie::Rails::Middleware do
+  let(:path_info) { '/somewhere/railsy' }
+  let(:fake_env)  { ({ 'PATH_INFO' => path_info }) }
 
   before :each do
-    ActionController::RoutingError = Class.new(StandardError) unless defined?(ActionController::RoutingError)
+    unless defined?(ActionController::RoutingError)
+      ActionController::RoutingError = Class.new(StandardError)
+    end
   end
 
   subject do
@@ -24,55 +28,57 @@ describe Fozzie::Rails::Middleware do
   end
 
   describe "rails 2" do
-
-    before :each do
-      RailsApp.stubs(:version).returns("2.3.1")
-    end
+    let!(:version) { RailsApp.stubs(:version).returns("2.3.1") }
 
     it "#generate_key" do
-      s = '/somewhere/railsy'
-      fake_env = { 'PATH_INFO' => s }
-      ActionController::Routing::Routes.expects(:recognize_path).with(s).returns({:controller => 'somewhere', :action => 'railsy'})
+      ActionController::Routing::Routes.expects(:recognize_path)
+        .with(path_info)
+        .returns({:controller => 'somewhere', :action => 'railsy'})
+
       subject.generate_key(fake_env).should == 'somewhere.railsy.render'
     end
 
     it "returns nil on routing error" do
-      s = '/somewhere/railsy'
-      fake_env = { 'PATH_INFO' => s }
-      ActionController::Routing::Routes.expects(:recognize_path).with(s).raises(ArgumentError)
+      ActionController::Routing::Routes.expects(:recognize_path)
+        .with(path_info)
+        .raises(ArgumentError)
+
       subject.generate_key(fake_env).should == nil
     end
 
   end
 
   describe "rails 3" do
-
-    before :each do
-      RailsApp.stubs(:version).returns("3.1.1")
-      @app, @routing = Class.new, Class.new
-      @app.stubs(:routes).returns(@routing)
-      RailsApp.stubs(:application).returns(@app)
-    end
+    let(:app)       { Class.new }
+    let(:routing)   { Class.new }
+    let!(:rails)    { RailsApp.stubs(:application).returns(app) }
+    let!(:version)  { RailsApp.stubs(:version).returns("3.1.1") }
+    let!(:routes)   { app.stubs(:routes).returns(routing)}
 
     it "#generate_key" do
-      s = '/somewhere/railsy'
-      fake_env = { 'PATH_INFO' => s }
-      @routing.expects(:recognize_path).with(s).returns({:controller => 'somewhere', :action => 'railsy'})
+      routing.expects(:recognize_path)
+        .with(path_info)
+        .returns({:controller => 'somewhere', :action => 'railsy'})
+
       subject.generate_key(fake_env).should == 'somewhere.railsy.render'
     end
 
     it "returns nil on error" do
-      s = '/somewhere/railsy'
-      fake_env = { 'PATH_INFO' => s }
-      @routing.expects(:recognize_path).with(s).raises(ArgumentError)
+      routing.expects(:recognize_path)
+        .with(path_info)
+        .raises(ArgumentError)
+
       subject.generate_key(fake_env).should == nil
     end
-    
+
     it "returns nil on routing error" do
-      s = '/somewhere/railsy'
-      fake_env = { 'PATH_INFO' => s }
-      @routing.expects(:recognize_path).with(s).raises(ActionController::RoutingError)
-      S.expects(:increment).with('routing.error')
+      routing.expects(:recognize_path)
+        .with(path_info)
+        .raises(ActionController::RoutingError)
+
+      S.expects(:increment)
+        .with('routing.error')
+
       subject.generate_key(fake_env).should == nil
     end