fozzie 0.0.27 → 1.0.0

data/lib/fozzie/rack/middleware.rb

@@ -1,8 +1,10 @@
+require 'fozzie'
+
 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.
+    # This middleware times server processing for a resource, not view render.
     class Middleware
 
       attr_reader :app

data/lib/fozzie/sniff.rb

@@ -5,53 +5,48 @@ require 'facets/string/snakecase'
 module Fozzie
   module Sniff
 
-    def self.included(klass)
-      return if klass.include?(ClassMethods)
-
-      klass.class_eval { extend ClassMethods }
+    def _monitor(bucket_name = nil)
+      @_monitor_flag = true
+      @_bucket_name  = bucket_name
     end
 
-    module ClassMethods
-
-      def _monitor
-        @_monitor_flag = true
-      end
+    def _monitor_meth(target, &blk)
+      return if @_monitor_flag.nil? || !@_monitor_flag
 
-      def _monitor_meth(target, &blk)
-        return if @_monitor_flag.nil? || !@_monitor_flag
+      @_monitor_flag = false
+      bin            = @_bucket_name || [self.name.snakecase, target.to_s.snakecase]
+      feature        = :monitor
+      aliased_target = target.to_s.sub(/([?!=])$/, '')
+      punctuation    = $1
 
-        @_monitor_flag, feature, bin = false, :monitor, [self.name.snakecase, target.to_s.snakecase]
-        aliased_target, punctuation  = target.to_s.sub(/([?!=])$/, ''), $1
+      with    = "#{aliased_target}_with_#{feature}#{punctuation}"
+      without = "#{aliased_target}_without_#{feature}#{punctuation}"
 
-        with    = "#{aliased_target}_with_#{feature}#{punctuation}"
-        without = "#{aliased_target}_without_#{feature}#{punctuation}"
-
-        blk.call(with, without, feature, bin)
-      end
+      blk.call(with, without, feature, bin)
+    end
 
-      def method_added(target)
-        _monitor_meth(target) do |with, without, feature, bin|
-          define_method(with) do |*args, &blk|
-            S.time_for(bin) do
-              args.empty? ? self.send(without, &blk) : self.send(without, *args, &blk)
-            end
+    def method_added(target)
+      _monitor_meth(target) do |with, without, feature, bin|
+        define_method(with) do |*args, &blk|
+          S.time_for(bin) do
+            args.empty? ? self.send(without, &blk) : self.send(without, *args, &blk)
           end
-          self.alias_method_chain(target, feature)
         end
+        self.alias_method_chain(target, feature)
       end
+    end
 
-      def singleton_method_added(target)
-        _monitor_meth(target) do |with, without, feature, bin|
-          define_singleton_method(with) do |*args, &blk|
-            S.time_for(bin) do
-              args.empty? ? send(without, &blk) : send(without, *args, &blk)
-            end
+    def singleton_method_added(target)
+      _monitor_meth(target) do |with, without, feature, bin|
+        define_singleton_method(with) do |*args, &blk|
+          S.time_for(bin) do
+            args.empty? ? send(without, &blk) : send(without, *args, &blk)
           end
-          self.singleton_class.class_eval { alias_method_chain target, feature }
         end
+        self.singleton_class.class_eval { alias_method_chain target, feature }
       end
-
     end
 
   end
+
 end

data/lib/fozzie/version.rb

@@ -1,3 +1,3 @@
 module Fozzie
-  VERSION = "0.0.27"
+  VERSION = "1.0.0"
 end

data/spec/config/fozzie.yml

@@ -2,4 +2,5 @@
 test:
   appname: 'fozzie'
   host: '1.1.1.1'
-  port: 9876
+  port: 9876
+  enable_rails_middleware: false

data/spec/lib/core_ext/module/monitor_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Module do
+
+  it "includes _monitor method when required" do
+    Module.should respond_to(:_monitor)
+  end
+
+end

data/spec/lib/fozzie/adapter/statsd_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'fozzie/adapter/statsd'
+
+module Fozzie::Adapter
+  describe Statsd do
+    it_behaves_like "fozzie adapter"
+
+    # Switch to Statsd adapter for the duration of this test
+    before(:all) do
+      Fozzie.c.adapter = :Statsd
+    end
+
+    after(:all) do
+      Fozzie.c.adapter = :TestAdapter
+    end
+    
+    it "downcases any stat value" do
+      subject.should_receive(:send_to_socket).with {|bin| bin.match /\.foo/ }
+
+      subject.register(:bin => "FOO", :value => 1, :type => :gauge, :sample_rate => 1)
+    end
+
+    describe "#format_bucket" do
+      it "accepts arrays" do
+        subject.format_bucket([:foo, '2']).should match /foo.2$/
+        subject.format_bucket([:foo, '2']).should match /foo.2$/
+        subject.format_bucket(%w{foo bar}).should match /foo.bar$/
+      end
+
+      it "converts any values to strings for stat value, ignoring nil" do
+        subject.format_bucket([:foo, 1, nil, "@", "BAR"]).should =~ /foo.1._.bar/
+      end
+
+      it "replaces invalid chracters" do
+        subject.format_bucket([:foo, ':']).should match /foo.#{subject.class::RESERVED_CHARS_REPLACEMENT}$/
+        subject.format_bucket([:foo, '@']).should match /foo.#{subject.class::RESERVED_CHARS_REPLACEMENT}$/
+        subject.format_bucket('foo.bar.|').should match /foo.bar.#{subject.class::RESERVED_CHARS_REPLACEMENT}$/
+      end
+    end
+
+    describe "#format_value" do
+      it "defaults type to gauge when type is not mapped" do
+        subject.format_value(1, :foo, 1).should eq '1|g'
+      end
+
+      it "converts basic values to string" do
+        subject.format_value(1, :count, 1).should eq '1|c'
+      end
+    end
+
+    it "ensures block is called on socket error" do
+      subject.socket.stub(:send) { raise SocketError }
+
+      proc { subject.register(:bin => 'data.bin', :value => 1, :type => :gauge, :sample_rate => 1) { sleep 0.01 } }.should_not raise_error
+      proc { subject.register(:bin => 'data.bin', :value => 1, :type => :gauge, :sample_rate => 1) { sleep 0.01 } }.should_not raise_error
+    end
+
+    it "raises Timeout on slow lookup" do
+      Fozzie.c.timeout = 0.01
+      subject.socket.stub(:send).with(any_args) { sleep 0.4 }
+
+      subject.register(:bin => 'data.bin', :value => 1, :type => :gauge, :sample_rate => 1).should eq false
+    end
+
+    describe "multiple stats in a single call" do
+
+      it "collects stats together with delimeter" do
+        Fozzie.c.disable_prefix
+
+        stats = [
+          { :bin => 'foo', :value => 1, :type => :count, :sample_rate => 1 },
+          { :bin => 'bar', :value => 1, :type => :gauge, :sample_rate => 1 },
+          { :bin => %w{foo bar}, :value => 100, :type => :timing, :sample_rate => 1 }
+        ]
+
+        subject.should_receive(:send_to_socket).with "foo:1|c\nbar:1|g\nfoo.bar:100|ms"
+
+        subject.register(stats)
+      end
+    end
+  end
+end

data/spec/lib/fozzie/bulk_dsl_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Fozzie
+  describe BulkDsl do
+
+    it_behaves_like "interface"
+
+    describe "#initialize" do
+
+      it "accepts and performs block" do
+        BulkDsl.any_instance.should_receive(:foo)
+
+        BulkDsl.new { foo }
+      end
+
+    end
+
+    it "sends statistics in one call" do
+      Fozzie.c.adapter.should_receive(:register).once
+
+      BulkDsl.new do
+        increment :foo
+        decrement :bar
+      end
+    end
+
+    it "scopes given block when arity provided" do
+      Fozzie.c.adapter.should_receive(:register).once
+
+      class Foo
+
+        def send_stats
+          BulkDsl.new do |s|
+            s.increment random_value
+            s.decrement random_value
+          end
+        end
+
+        def random_value; rand end
+
+      end
+
+      Foo.new.send_stats
+    end
+
+  end
+end

data/spec/lib/fozzie/configuration_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'resolv'
 
 describe Fozzie::Configuration do
-
   it "#host" do
     subject.host.should be_kind_of(String)
   end
@@ -12,27 +11,47 @@ describe Fozzie::Configuration do
   end
 
   it "attempts to load configuration from yaml" do
-    c = Fozzie::Configuration.new({:env => 'test', :config_path => 'spec/'})
-    c.stubs(:origin_name).returns ""
+    c = Fozzie::Configuration.new({
+                                    env:         'test',
+                                    config_path: 'spec/',
+                                    adapter:     :TestAdapter
+                                  })
+    c.stub(:origin_name => "")
     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'
+    c.data_prefix.should eq "fozzie#{c.safe_separator}test"
   end
 
   it "defaults env" do
     subject.env.should eq 'test'
   end
 
-  describe "#prefix and #data_prefix" do
+  describe "#adapter" do
+    it "throw error on incorrect assignment" do
+      -> { Fozzie::Configuration.new({:env => 'test', :adapter => 'foo'}) }.should raise_error(Fozzie::AdapterMissing)
+    end
+
+    it "defaults adapter to Statsd" do
+      subject.adapter.should be_kind_of(Fozzie::Adapter::Statsd)
+    end
+  end
+
+  describe "#disable_prefix" do
+    it "sets the data_prefix to nil" do
+      subject.disable_prefix
+      subject.data_prefix.should be_nil
+    end
+  end
 
+  describe "#prefix and #data_prefix" do
     it "creates a #data_prefix" do
-      subject.stubs(:origin_name).returns("")
+      subject.stub(:origin_name => "")
       subject.data_prefix.should eq 'test'
     end
 
     it "creates a #data_prefix with appname when set" do
-      subject.stubs(:origin_name).returns("")
+      subject.stub(:origin_name => "")
       subject.appname = 'astoria'
       subject.data_prefix.should eq 'astoria.test'
     end
@@ -48,11 +67,10 @@ describe Fozzie::Configuration do
     end
 
     it "allows dynamic injection of value to prefix" do
-      subject.stubs(:origin_name).returns("")
+      subject.stub(:origin_name => "")
       subject.prefix << 'git-sha-1234'
       subject.data_prefix.should eq 'test.git-sha-1234'
     end
-
   end
 
   it "handles missing configuration namespace" do
@@ -66,46 +84,42 @@ describe Fozzie::Configuration do
   end
 
   describe "#sniff?" do
-
     it "defaults to false for testing" do
-      subject.stubs(:env).returns('test')
+      subject.stub(:env => "test")
       subject.sniff?.should be_false
     end
 
     it "defaults true when in development" do
-      subject.stubs(:env).returns('development')
+      subject.stub(:env => "development")
       subject.sniff?.should be_true
     end
 
     it "defaults true when in production" do
-      subject.stubs(:env).returns('production')
+      subject.stub(:env => "production")
       subject.sniff?.should be_true
     end
-
   end
 
   describe "#sniff_envs allows configuration for #sniff?" do
-    let!(:sniff_envs) { subject.stubs(:sniff_envs).returns(['test']) }
+    let!(:sniff_envs) { subject.stub(:sniff_envs => ['test']) }
 
     it "scopes to return false" do
-      subject.stubs(:env).returns('development')
+      subject.stub(:env => "development")
       subject.sniff?.should be_false
     end
 
     it "scopes to return true" do
-      subject.stubs(:env).returns('test')
+      subject.stub(:env => "test")
       subject.sniff?.should be_true
     end
 
   end
 
   describe "ignoring prefix" do
-
     it "does not use prefix when set to ignore" do
       subject.disable_prefix
       subject.ignore_prefix.should eq(true)
     end
-
   end
 
-end
+end

data/spec/lib/fozzie/dsl_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'fozzie/interface'
+
+describe Fozzie::Dsl do
+
+  subject { Fozzie::Dsl.instance }
+
+  it_behaves_like "interface"
+
+  it "acts an a singleton" do
+    Fozzie.c.namespaces.each do |k|
+      Kernel.const_get(k).should eq Fozzie::Dsl.instance
+    end
+  end
+
+end

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

@@ -1,12 +1,11 @@
 require 'spec_helper'
-require 'sinatra/base'
-require 'rack/test'
+require 'fozzie/rack/middleware'
 
 describe Fozzie::Rack::Middleware do
 
   subject do
     unless defined?(RackApp)
-      RackApp = Class.new { def call(env); env end } 
+      RackApp = Class.new { def call(env); env end }
     end
     Fozzie::Rack::Middleware.new RackApp.new
   end
@@ -24,30 +23,29 @@ describe Fozzie::Rack::Middleware do
 
     it "ignored stats request when path not valid" do
       fake_env = { 'PATH_INFO' => '' }
-      subject.expects(:call_without_timer).with(fake_env)
+      subject.should_receive(:call_without_timer).with(fake_env)
       subject.call(fake_env)
     end
 
     it "passes request with timer on index" do
       fake_env = { 'PATH_INFO' => '/' }
-      subject.expects(:call_with_timer).with('index.render', fake_env)
+      subject.should_receive(:call_with_timer).with('index.render', fake_env)
       subject.call(fake_env)
     end
 
     it "passes request with timer on full path" do
       fake_env = { 'PATH_INFO' => '/somewhere/nice' }
-      subject.expects(:call_with_timer).with('somewhere.nice.render', fake_env)
+      subject.should_receive(:call_with_timer).with('somewhere.nice.render', fake_env)
       subject.call(fake_env)
     end
 
     it "passes request onto app" do
       envs = ['', '/', '/somewhere/nice'].each do |p|
         fake_env = { 'PATH_INFO' => p }
-        subject.app.expects(:call).with(fake_env)
+        subject.app.should_receive(:call).with(fake_env)
         subject.call(fake_env)
       end
     end
-
   end
 
   describe "#generate_key" do
@@ -69,32 +67,4 @@ describe Fozzie::Rack::Middleware do
 
   end
 
-end
-
-describe "Sinatra Server with Middleware" do
-  include Rack::Test::Methods
-
-  def app
-    Sinatra.new do
-      set :environment, :test
-      use Fozzie::Rack::Middleware
-      get('/') { "echo" }
-      get('/somewhere/nice') { "echo" }
-    end
-  end
-
-  it "sends stats request on root" do
-    S.expects(:timing).with('index.render', any_parameters)
-    get '/'
-    last_response.should be_ok
-    last_response.body.should == 'echo'
-  end
-
-  it "sends stats request on nested path" do
-    S.expects(:timing).with('somewhere.nice.render', any_parameters)
-    get '/somewhere/nice'
-    last_response.should be_ok
-    last_response.body.should == 'echo'
-  end
-
 end