fozzie 0.0.27 → 1.0.0

data/.gitignore

@@ -2,4 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
-coverage/*
+coverage/*
+.DS_Store

data/Guardfile

@@ -1,8 +1,8 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard 'rspec', :version => 2 do
+guard 'rspec', :cli => "--color" do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
-end
+end

data/README.md

@@ -109,12 +109,31 @@ class FooBar
     # my code here...
   end
 
+  _monitor("my.awesome.bucket.name")
+  def quux
+    # something
+  end
+
 end
 ```
 This will register the processing time for this method, everytime it is called, under the Graphite bucket `foo_bar.zar`.
 
 This will work on both Class and Instance methods.
 
+## Bulk
+
+You can send a bulk of metrics using the `bulk` method:
+``` ruby
+Stats.bulk do
+  increment 'wat'
+  decrement 'wot'
+  gauge 'foo', rand
+  time_to_do 'wat_timer' { sleep 4 }
+end
+```
+
+This will send all the given metrics in a single packet to the statistics server.
+
 ## Namespaces
 
 Fozzie supports the following namespaces as default
@@ -185,13 +204,13 @@ Prefixes are cached on first use, therefore any changes to the Fozzie configure
 
 ## Middleware
 
-To time and register the controller actions within your Rails application, Fozzie provides some middleware.
+To time and register the controller actions within your Rack and Rails application, Fozzie provides some middleware.
 
 ### Rack
 
 ``` ruby
 require 'rack'
-require 'fozzie'
+require 'fozzie/rack/middleware'
 
 app = Rack::Builder.new {
   use Fozzie::Rack::Middleware
@@ -201,9 +220,7 @@ app = Rack::Builder.new {
 
 ### Rails
 
-Based on the Rack middleware above, but is more involved in its construction of the bucket value.
-
-Fozzie::Rails::Middleware will automatically be invoked on Rails initialization.
+See [Fozzie Rails](http://github.com/lonelyplanet/fozzie_rails).
 
 ## Bucket name prefixes
 
@@ -242,18 +259,12 @@ Fozzie.logger = Logger.new 'log/fozzie.log'
 
 This may change, depending on feedback and more production experience.
 
-## Rails User Interface Performance Measuring
-
-If you also require UI metrics, you can also include the Mill script in the bottom of any page you would like to measure (see `resources/mill.js` and `resources/mill.min.js`) and you start receiving measurements on page performance.
-
 ## Credits
 
 Currently supported and maintained by [Marc Watts](marc.watts@lonelyplanet.co.uk) @ Lonely Planet Online.
 
 Big thanks and Credits:
 
-* [Mark Barger](mark.barger@lonelyplanet.co.uk) for support in trying to make this Gem useful.
-
 * [Dave Nolan](https://github.com/textgoeshere)
 
 * [Etsy](http://codeascraft.etsy.com/) whose [Statsd](https://github.com/etsy/statsd) product has enabled us to come such a long way in a very short period of time. We love Etsy.

data/Rakefile

@@ -4,4 +4,4 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task :default => :spec

data/fozzie.gemspec

@@ -5,18 +5,18 @@ require "fozzie/version"
 Gem::Specification.new do |s|
   s.name        = "fozzie"
   s.version     = Fozzie::VERSION
-  s.authors     = ["Marc Watts", "Dave Nolan"]
+  s.authors     = ["Marc Watts"]
   s.email       = ["marc.watts@lonelyplanet.co.uk"]
-  s.summary     = %q{Statsd Ruby gem from Lonely Planet Online}
+  s.summary     = %q{Ruby gem from Lonely Planet Online to register statistics. Currently supports Statsd.}
   s.description = %q{
-    Gem to make statistics sending to Statsd from Ruby applications simple and efficient as possible.
-    Inspired by the original ruby-statsd gem by Etsy, currently used by Lonely Planet Online.
+    Gem to make statistics sending from Ruby applications simple and efficient as possible.
+    Currently supports Statsd, and is inspired by the original ruby-statsd gem by Etsy.
   }
 
   s.rubyforge_project = "fozzie"
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
@@ -25,15 +25,9 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'
-  s.add_development_dependency 'mocha'
-  s.add_development_dependency 'syntax'
-  s.add_development_dependency 'simplecov'
-
-  s.add_development_dependency 'sinatra'
-  s.add_development_dependency 'rack-test'
-  s.add_development_dependency 'actionpack', '2.3.14'
-
   s.add_development_dependency 'guard'
   s.add_development_dependency 'guard-rspec'
-
+  s.add_development_dependency 'rb-fsevent'
+  s.add_development_dependency 'sinatra'
+  s.add_development_dependency 'rack-test'
 end

data/lib/core_ext/module/monitor.rb

@@ -2,10 +2,11 @@ require 'fozzie/sniff'
 
 class Module
 
-  def _monitor
+  def _monitor(bucket_name = nil)
     return unless Fozzie.c.sniff?
-    self.class_eval { include Fozzie::Sniff }
+    self.class_eval { extend Fozzie::Sniff }
     @_monitor_flag = true
+    @_bucket_name  = bucket_name
   end
 
-end
+end

data/lib/fozzie.rb

@@ -11,15 +11,14 @@ module Fozzie
 
   require 'core_ext/module/monitor'
 
+  require 'fozzie/adapter'
+
+  require "fozzie/exception"
   require 'fozzie/configuration'
-  require "fozzie/interface"
+  require "fozzie/dsl"
+  require "fozzie/bulk_dsl"
   require "fozzie/version"
 
-  require "fozzie/rack/middleware"
-  require "fozzie/rails/middleware"
-
-  require 'fozzie/railtie' if defined?(::Rails)
-
   class << self
 
     # Shortcut for `Fozzie.config`
@@ -58,7 +57,7 @@ module Fozzie
 
   # Loads each namespace for registering statistics
   self.c.namespaces.each do |klas|
-    Kernel.const_set(klas, Interface.instance) unless const_defined?(klas)
+    Kernel.const_set(klas, Dsl.instance) unless const_defined?(klas)
   end
 
 end

data/lib/fozzie/adapter.rb

@@ -0,0 +1 @@
+%w{statsd}.each {|r| require "fozzie/adapter/#{r}" }

data/lib/fozzie/adapter/statsd.rb

@@ -0,0 +1,86 @@
+require 'socket'
+
+module Fozzie
+  module Adapter
+
+    class Statsd
+
+      RESERVED_CHARS_REGEX       = /[\:\|\@\s]/
+      RESERVED_CHARS_REPLACEMENT = '_'
+      DELIMETER                  = '.'
+      SAFE_SEPARATOR             = '-'
+      TYPES                      = { :gauge => 'g', :count => 'c', :timing => 'ms' }
+      BULK_DELIMETER             = "\n"
+
+      # Send the statistic to the server
+      #
+      # Creates the Statsd key from the given values, and sends to socket (depending on sample rate)
+      def register(*stats)
+        metrics = stats.flatten.collect do |stat|
+          next if sampled?(stat[:sample_rate])
+
+          bucket = format_bucket(stat[:bin])
+          value  = format_value(stat[:value], stat[:type], stat[:sample_rate])
+
+          [bucket, value].join(':')
+        end.compact.join(BULK_DELIMETER)
+
+        send_to_socket(metrics)
+      end
+
+      def format_bucket(stat)
+        bucket = [stat].flatten.compact.collect(&:to_s).join(DELIMETER).downcase
+        bucket = bucket.gsub('::', DELIMETER).gsub(RESERVED_CHARS_REGEX, RESERVED_CHARS_REPLACEMENT)
+        bucket = [Fozzie.c.data_prefix, bucket].compact.join(DELIMETER)
+
+        bucket
+      end
+
+      def format_value(val, type, sample_rate)
+        converted_type = TYPES[type.to_sym]
+        converted_type ||= TYPES[:gauge]
+
+        value = [val, converted_type].join('|')
+        value << '@%s' % sample_rate.to_s if sample_rate < 1
+
+        value
+      end
+
+      # If the statistic is sampled, generate a condition to check if it's good to send
+      def sampled(sample_rate)
+        yield unless sampled?(sample_rate)
+      end
+
+      def sampled?(sample_rate)
+        sample_rate < 1 and rand > sample_rate
+      end
+
+      # Send data to the server via the socket
+      def send_to_socket(message)
+        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
+
+      # The Socket we want to use to send data
+      def socket
+        @socket ||= ::UDPSocket.new
+      end
+
+      def delimeter
+        DELIMETER
+      end
+
+      def safe_separator
+        SAFE_SEPARATOR
+      end
+    end
+
+  end
+end

data/lib/fozzie/bulk_dsl.rb

@@ -0,0 +1,28 @@
+module Fozzie
+  class BulkDsl
+    include Fozzie::Interface
+
+    def initialize(&block)
+      @metrics = []
+      block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
+      send_bulk
+    end
+
+    private
+
+    # Cache the requested metrics for bulk sending
+    #
+    def send(stat, value, type, sample_rate = 1)
+     val = { :bin => stat, :value => value, :type => type, :sample_rate => sample_rate }
+
+     @metrics.push(val)
+    end
+
+    def send_bulk
+      return if @metrics.empty?
+
+      adapter.register(@metrics)
+    end
+
+  end
+end

data/lib/fozzie/configuration.rb

@@ -1,5 +1,5 @@
 require 'yaml'
-require 'core_ext/hash'
+require 'facets/hash/symbolize_keys'
 require 'sys/uname'
 require 'timeout'
 
@@ -7,16 +7,32 @@ module Fozzie
 
   # Fozzie configuration allows assignment of global properties
   # that will be used within the Fozzie codebase.
+
   class Configuration
     include Sys
+    extend Forwardable
+
+    def_delegators :adapter, :delimeter, :safe_separator
 
-    attr_accessor :env, :config_path, :host, :port, :appname, :namespaces, :timeout, :monitor_classes, :sniff_envs, :ignore_prefix, :prefix
+    attr_accessor :env, :config_path, :host, :port, :appname, :namespaces,
+      :timeout, :monitor_classes, :sniff_envs, :ignore_prefix, :prefix
 
     def initialize(args = {})
       merge_and_assign_config(args)
+      self.adapter
       self.origin_name
     end
 
+    def adapter=(adapter)
+      @adapter = eval("Fozzie::Adapter::#{adapter}").new
+    rescue NoMethodError
+      raise AdapterMissing, "Adapter could not be found for given provider #{@provider}"
+    end
+
+    def adapter
+      @adapter || default_configuration[:adapter]
+    end
+
     def disable_prefix
       @ignore_prefix = true
     end
@@ -26,15 +42,17 @@ module Fozzie
       return nil if @ignore_prefix
       return @data_prefix if @data_prefix
 
-      data_prefix = @prefix.collect do |me|
-        (me.kind_of?(Symbol) && self.respond_to?(me.to_sym) ? self.send(me) : me.to_s)
-      end
-
-      data_prefix = data_prefix.collect do |s|
-        s.empty? ? nil : s.gsub(Socket::DELIMETER, '-')
-      end.compact.join(Socket::DELIMETER).strip
-
-      @data_prefix ||= (data_prefix.empty? ? nil : data_prefix)
+      escaped_prefix_with_dynamically_resolved_parts = prefix.map do |part|
+        resolved_part = (part.kind_of?(Symbol) && self.respond_to?(part) ? self.send(part) : part.to_s)
+        escaped_resolved_part = resolved_part.gsub(delimeter, safe_separator)
+        escaped_resolved_part == "" ? nil : escaped_resolved_part
+      end.compact
+
+      @data_prefix = if escaped_prefix_with_dynamically_resolved_parts.any?
+                       escaped_prefix_with_dynamically_resolved_parts.join(delimeter).strip
+                     else
+                       nil
+                     end
     end
 
     # Returns the origin name of the current machine to register the stat against
@@ -70,7 +88,8 @@ module Fozzie
         :timeout         => 0.5,
         :monitor_classes => [],
         :sniff_envs      => [:development, :staging, :production],
-        :ignore_prefix   => false
+        :ignore_prefix   => false,
+        :adapter         => :Statsd
       }.dup
     end
 
@@ -89,4 +108,4 @@ module Fozzie
 
   end
 
-end
+end

data/lib/fozzie/dsl.rb

@@ -0,0 +1,19 @@
+require 'singleton'
+require "fozzie/interface"
+
+module Fozzie
+  class Dsl
+    include Fozzie::Interface, Singleton
+
+    private
+
+    # Send the statistic to the chosen provider
+    #
+    def send(stat, value, type, sample_rate = 1)
+     val = { :bin => stat, :value => value, :type => type, :sample_rate => sample_rate }
+
+     adapter.register(val)
+    end
+
+  end
+end

data/lib/fozzie/exception.rb

@@ -0,0 +1,5 @@
+module Fozzie
+
+  class AdapterMissing < StandardError; end
+
+end

data/lib/fozzie/interface.rb

@@ -1,9 +1,7 @@
-require 'singleton'
-require 'fozzie/socket'
+require 'fozzie/adapter/statsd'
 
 module Fozzie
-  class Interface
-    include Fozzie::Socket, Singleton
+  module Interface
 
     # Increments the given stat by one, with an optional sample rate
     #
@@ -23,14 +21,14 @@ module Fozzie
     #
     # `Stats.count 'wat', 500`
     def count(stat, count, sample_rate=1)
-      send(stat, count, 'c', sample_rate)
+      send(stat, count, :count, 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)
+      send(stat, ms, :timing, sample_rate)
     end
 
     # Registers the time taken to complete a given block (in ms), with an optional sample rate
@@ -47,7 +45,7 @@ module Fozzie
     #
     # `Stats.time_to_do 'wat' { # Do something, again... }`
     def time_to_do(stat, sample_rate=1, &block)
-      time_for(stat, sample_rate, &block)
+      time(stat, sample_rate, &block)
     end
 
     # Registers the time taken to complete a given block (in ms), with an optional sample rate
@@ -99,6 +97,13 @@ module Fozzie
       deployed(app)
     end
 
+    # Register an event of any type
+    #
+    # `Stats.event 'wat', 'app'`
+    def event(type, app = nil)
+      gauge ["event", type.to_s, app], Time.now.usec
+    end
+
     # Registers an increment on the result of the given boolean
     #
     # `Stats.increment_on 'wat', wat.random?`
@@ -108,18 +113,28 @@ module Fozzie
       perf
     end
 
-    # Register an event of any type
-    #
-    # `Stats.event 'wat', 'app'`
-    def event(type, app = nil)
-      gauge ["event", type.to_s, app], Time.now.usec
-    end
-
     # Register an arbitrary value
     #
     # `Stats.gauge 'wat', 'app'`
     def gauge(stat, value, sample_rate = 1)
-      send(stat, value, "g", sample_rate)
+      send(stat, value, :gauge, sample_rate)
     end
+
+    # Register multiple statistics in a single call
+    #
+    # `Stats.bulk do
+    #    increment 'wat'
+    #    decrement 'wot'
+    # end`
+    def bulk(&block)
+      Fozzie::BulkDsl.new(&block)
+    end
+
+    private
+
+    def adapter
+      Fozzie.c.adapter
+    end
+
   end
 end