fozzie 0.0.27 → 1.0.0

data/lib/core_ext/hash.rb

@@ -1,16 +0,0 @@
-class Hash
-
-  # Return self as symbolized keys hash
-  def symbolize_keys
-    self.dup.inject({}) do |hsh, (k,v)|
-      hsh[k.to_s.to_sym] = (v.respond_to?(:symbolize_keys) ? v.symbolize_keys : v)
-      hsh
-    end
-  end
-
-  # Replace self with symbolized keys hash
-  def symbolize_keys!
-    self.replace(self.symbolize_keys)
-  end
-
-end

data/lib/fozzie/mill.rb

@@ -1,50 +0,0 @@
-require 'uri'
-
-module Fozzie
-  class Mill
-
-    DELIMETER = ';'
-    METRICS   = %w{ttfb load}
-
-    attr_reader :str, :args
-
-    def initialize(str = "")
-      @str          = str
-      escaped_split = str.split(DELIMETER).map!{|x| URI.unescape(x) }
-      @args         = Hash[*escaped_split]
-    end
-
-    def self.register(str = "")
-      new(str).register
-    end
-
-    def register
-      return self unless self.has_href?
-      METRICS.each do |k|
-        next unless self.respond_to?(k.to_sym)
-        S.timing((namespace << ['page', k]).flatten, self.send(k.to_sym))
-      end
-
-      self
-    end
-
-    def load
-      @load ||= @args['domComplete'].to_i - @args['fetchStart'].to_i
-    end
-
-    def ttfb
-      @ttfb ||= @args['responseStart'].to_i - @args['fetchStart'].to_i
-    end
-
-    def has_href?
-      !@args['href'].nil?
-    end
-
-    def namespace
-      @uri  ||= URI(@args['href'])
-      @path ||= @uri.path.strip.split('/').reject(&:empty?)
-      @path.dup
-    end
-
-  end
-end

data/lib/fozzie/rails/engine.rb

@@ -1,15 +0,0 @@
-require 'json'
-require 'fozzie/mill'
-
-module Fozzie
-  module Rails
-    class Engine < ::Rails::Engine
-
-      endpoint Proc.new { |env|
-        Fozzie::Mill.register(env['QUERY_STRING'].gsub('d=', ''))
-        [201, {"Content-Type" => "text/html"}, [""]]
-      }
-
-    end
-  end
-end

data/lib/fozzie/rails/middleware.rb

@@ -1,39 +0,0 @@
-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']
-        request_method = env['REQUEST_METHOD']
-
-        return nil unless path_str
-
-        begin
-          routing = routing_lookup
-          path    = routing.recognize_path(path_str, :method => request_method)
-          stat    = [path[:controller], path[:action], "render"].join('.')
-          stat
-        rescue => exc
-          S.increment "routing.error"
-          nil
-        end
-      end
-
-      def routing_lookup
-        (rails_version == 3 ? ::Rails.application.routes : ::ActionController::Routing::Routes)
-      end
-
-      def rails_version
-        ::Rails.version.to_i
-      end
-
-    end
-
-  end
-end

data/lib/fozzie/railtie.rb

@@ -1,15 +0,0 @@
-require 'fozzie/rails/engine'
-
-class FozzieRailtie < Rails::Railtie
-  initializer "fozzie_railtie.configure_rails_initialization" do |app|
-
-    # Load up the middleware
-    app.middleware.use Fozzie::Rails::Middleware
-
-    # Add the Mill route
-    app.routes.prepend do
-      mount Fozzie::Rails::Engine => '/mill'
-    end
-
-  end
-end

data/lib/fozzie/socket.rb

@@ -1,53 +0,0 @@
-require 'socket'
-
-module Fozzie
-  module Socket
-
-    RESERVED_CHARS_REGEX = /[\:\|\@\s]/
-    DELIMETER = '.'
-
-    private
-
-    # Send the statistic to the server
-    #
-    # Creates the Statsd key from the given values, and sends to socket (depending on sample rate)
-    #
-    def send(stat, delta, type, sample_rate)
-      stat = [stat].flatten.compact.collect(&:to_s).join(DELIMETER).downcase
-      stat = stat.gsub('::', DELIMETER).gsub(RESERVED_CHARS_REGEX, '_')
-
-      k =  [Fozzie.c.data_prefix, stat].compact.join(DELIMETER)
-      k << ":"
-      k << [delta, type].join('|')
-      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) {
-          res = socket.send(message, 0, Fozzie.c.host, Fozzie.c.port)
-          Fozzie.logger.debug {"Statsd sent: #{res}"} if Fozzie.logger
-          (res.to_i == message.length)
-        }
-      rescue => exc
-        Fozzie.logger.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/spec/lib/core_ext/hash_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'core_ext/hash'
-
-describe Hash do
-
-  it { should respond_to(:symbolize_keys) }
-  it { should respond_to(:symbolize_keys!) }
-
-  it "manipulates keys correctly" do
-    {
-      '1' => 1,
-      '2' => 2,
-      '3' => 3
-    }.symbolize_keys.should == {
-      :"1" => 1,
-      :"2" => 2,
-      :"3" => 3
-    }
-  end
-
-  it "returns copy when bang not provided" do
-    hsh = { '1' => 1, '2' => 2, '3' => 3 }
-    hsh.symbolize_keys
-    hsh.should == { '1' => 1, '2' => 2, '3' => 3 }
-  end
-
-  it "replaces self when bang provided" do
-    hsh = { '1' => 1, '2' => 2, '3' => 3 }
-    hsh.symbolize_keys!
-    hsh.should == { :"1" => 1, :"2" => 2, :"3" => 3 }
-  end
-
-end

data/spec/lib/fozzie/interface_spec.rb

@@ -1,180 +0,0 @@
-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 "downcases any stat value" do
-    subject.expects(:send_to_socket)
-      .with {|bin| bin.match /\.foo/ }
-
-    subject.increment("FOO")
-  end
-
-  it "replaces invalid stat value chars" do
-    subject.expects(:send_to_socket)
-      .with {|bin| bin.match /\.foo_/ }
-      .times(4)
-
-    subject.increment("FOO:")
-    subject.increment("FOO@")
-    subject.increment("FOO|")
-    subject.increment(["FOO|"])
-  end
-  
-  it "converts any values to strings for stat value, ignoring nil" do
-    subject.expects(:send_to_socket)
-      .with {|bin| bin.match /\.foo.1._.bar/ }
-
-    subject.increment([:foo, 1, nil, "@", "BAR"])
-  end
-
-  it "times a given block" do
-    subject.expects(:timing).with() {|b, val, timing| b == 'data.bin' && (1..11).include?(val) }.twice
-    subject.time_for('data.bin')    { sleep 0.01 }
-    subject.time_to_do('data.bin')  { sleep 0.01 }
-  end
-
-  it "registers a commit" do
-    subject.expects(:gauge).with(['event', 'commit', nil], anything).twice
-    subject.commit
-    subject.committed
-  end
-
-  it "registers a build" do
-    subject.expects(:gauge).with(['event', 'build', nil], anything).twice
-    subject.build
-    subject.built
-  end
-
-  it "registers a deploy" do
-    subject.expects(:gauge).with(['event', 'deploy', nil], 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 0.01 } }.should_not raise_error
-    proc { subject.time_to_do('data.bin') { sleep 0.01 } }.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
-    Fozzie.c.timeout = 0.01
-    UDPSocket.any_instance.stubs(:send).with(any_parameters) { sleep 0.4 }
-    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
-
-  describe "#gauge" do
-    it "registers a gauge measurement" do
-      subject.expects(:send).with("mystat", 99, "g", 1)
-      subject.gauge("mystat", 99)
-    end
-  end
-
-  describe "without prefix" do
-
-    it "registers stats without app, etc" do
-      Fozzie.c.disable_prefix
-      subject.expects(:send_to_socket).with {|bin| bin.match(/^mystat/) }
-
-      subject.gauge("mystat", 99)
-    end
-
-  end
-
-end

data/spec/lib/fozzie/mill_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'fozzie/mill'
-
-module Fozzie
-  describe Mill do
-    let(:str) { "userAgent;Mozilla/5.0%20%28Macintosh%3B%20Intel%20Mac%20OS%20X%2010_7_3%29%20AppleWebKit/535.19%20%28KHTML%2C%20like%20Gecko%29%20Chrome/18.0.1025.165%20Safari/535.19;vendorSub;;vendor;Google%20Inc.;onLine;true;appCodeName;Mozilla;cookieEnabled;true;product;Gecko;language;en-US;appVersion;5.0%20%28Macintosh%3B%20Intel%20Mac%20OS%20X%2010_7_3%29%20AppleWebKit/535.19%20%28KHTML%2C%20like%20Gecko%29%20Chrome/18.0.1025.165%20Safari/535.19;appName;Netscape;productSub;20030107;platform;MacIntel;domainLookupStart;1335538507546;domInteractive;1335538508237;domComplete;1335538508323;loadEventEnd;0;requestStart;1335538507546;connectEnd;1335538507546;domContentLoadedEventEnd;1335538508237;unloadEventStart;1335538508050;domainLookupEnd;1335538507546;fetchStart;1335538507545;unloadEventEnd;1335538508050;connectStart;1335538507546;secureConnectionStart;0;redirectEnd;0;domContentLoadedEventStart;1335538508237;loadEventStart;1335538508323;responseStart;1335538508049;redirectStart;0;domLoading;1335538508182;responseEnd;1335538508050;navigationStart;1335538507545;href;http://localhost:8080/" }
-    subject   { Mill }
-
-    describe "with environment arguments" do
-
-      it "creates args hash from string" do
-        inst = subject.register(str)
-        inst.args['appCodeName'].should eq 'Mozilla'
-        inst.args['cookieEnabled'].should eq 'true'
-      end
-
-      it "handles escaped values" do
-        inst = subject.register(str)
-        inst.args['userAgent'].should eq 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.165 Safari/535.19'
-        inst.args['appVersion'].should eq '5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.165 Safari/535.19'
-      end
-
-      it "skips if not passed" do
-        S.expects(:timing).never
-        subject.register("")
-      end
-
-      describe "registers all mapped metrics" do
-        let!(:expects) {
-          S.expects(:timing).with(["page", "ttfb"], 504)
-          S.expects(:timing).with(["page", "load"], 778)
-        }
-
-        it "dom complete" do
-          subject.register(str)
-        end
-
-      end
-
-    end
-
-  end
-end