fozzie 1.0.2 → 1.0.3

data/Rakefile

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

data/fozzie.gemspec

@@ -1,29 +1,29 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "fozzie/version"
-
-Gem::Specification.new do |s|
-  s.name        = "fozzie"
-  s.version     = Fozzie::VERSION
-  s.authors     = ["Marc Watts"]
-  s.email       = ["marc.watts@lonelyplanet.co.uk"]
-  s.summary     = %q{Ruby gem from Lonely Planet Online to register statistics. Currently supports Statsd.}
-  s.description = %q{
-    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 -- {spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_dependency 'sys-uname'
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'sinatra'
-  s.add_development_dependency 'rack-test'
-end
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fozzie/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fozzie"
+  s.version     = Fozzie::VERSION
+  s.authors     = ["Marc Watts"]
+  s.email       = ["marc.watts@lonelyplanet.co.uk"]
+  s.summary     = %q{Ruby gem from Lonely Planet Online to register statistics. Currently supports Statsd.}
+  s.description = %q{
+    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 -- {spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'sys-uname'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'sinatra'
+  s.add_development_dependency 'rack-test'
+end

data/fozzie.yml.example

@@ -1,15 +1,15 @@
-generic: &generic
-  appname: fozzie
-  host: '127.0.0.1'
-  port: 8125
-
-development:
-  <<: *generic
-staging:
-  <<: *generic
-test:
-  <<: *generic
-ci:
-  <<: *generic
-production:
+generic: &generic
+  appname: fozzie
+  host: '127.0.0.1'
+  port: 8125
+
+development:
+  <<: *generic
+staging:
+  <<: *generic
+test:
+  <<: *generic
+ci:
+  <<: *generic
+production:
   <<: *generic

data/lib/core_ext/hash/symbolize_keys.rb

@@ -1,22 +1,22 @@
-class Hash
-  def symbolize_keys(&select)
-    dup.symbolize_keys!(&select)
-  end
-
-  def symbolize_keys!(&select)
-    if select
-      keys.each do |key|
-        if select[key]
-          new_key = (key.to_sym rescue key.to_s.to_sym)
-          self[new_key] = delete(key)
-        end
-      end
-    else
-      keys.each do |key|
-        new_key = (key.to_sym rescue key.to_s.to_sym)
-        self[new_key] = delete(key)
-      end
-    end
-    self
-  end
+class Hash
+  def symbolize_keys(&select)
+    dup.symbolize_keys!(&select)
+  end
+
+  def symbolize_keys!(&select)
+    if select
+      keys.each do |key|
+        if select[key]
+          new_key = (key.to_sym rescue key.to_s.to_sym)
+          self[new_key] = delete(key)
+        end
+      end
+    else
+      keys.each do |key|
+        new_key = (key.to_sym rescue key.to_s.to_sym)
+        self[new_key] = delete(key)
+      end
+    end
+    self
+  end
 end

data/lib/core_ext/module/alias_method_chain.rb

@@ -1,20 +1,20 @@
-class Module
-  def alias_method_chain(target, feature)
-    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-    yield(aliased_target, punctuation) if block_given?
-
-    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
-
-    alias_method without_method, target
-    alias_method target, with_method
-
-    case
-      when public_method_defined?(without_method)
-        public target
-      when protected_method_defined?(without_method)
-        protected target
-      when private_method_defined?(without_method)
-        private target
-    end
-  end
+class Module
+  def alias_method_chain(target, feature)
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+    end
+  end
 end

data/lib/core_ext/module/monitor.rb

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

data/lib/core_ext/string/snakecase.rb

@@ -1,10 +1,10 @@
-class String
-  def snakecase
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr('-', '_').
-    gsub(/\s/, '_').
-    gsub(/__+/, '_').
-    downcase
-  end
+class String
+  def snakecase
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr('-', '_').
+    gsub(/\s/, '_').
+    gsub(/__+/, '_').
+    downcase
+  end
 end

data/lib/fozzie.rb

@@ -1,67 +1,67 @@
-# Fozzie is an implementation of the Statsd statistics gathering tool,
-# designed to make gathering stastistics from applications easy, fast, and effective.
-#
-# Configuration can be applied through a block and/or configuration file ('config/fozzie.yml')
-#
-# Fozzie provides automatic namespacing for the current environment, and host.
-#
-# Rack and Rails middleware is avaliable to gather statistics on the processing time of Controller actions.
-#
-
-module Fozzie
-
-  require 'core_ext/module/monitor'
-  require 'core_ext/module/alias_method_chain' unless Module.methods.include?(:alias_method_chain)
-  require 'core_ext/string/snakecase'
-  require 'core_ext/hash/symbolize_keys'
-
-  require 'fozzie/adapter'
-
-  require "fozzie/exception"
-  require 'fozzie/configuration'
-  require "fozzie/dsl"
-  require "fozzie/bulk_dsl"
-  require "fozzie/version"
-
-  class << self
-
-    # Shortcut for `Fozzie.config`
-    def c
-      config
-    end
-
-    # Returns the current configuration. Creates configuration on first-time request
-    def config
-      @config ||= Configuration.new
-    end
-
-    # Allows the setting on valudes against the configuration
-    #
-    # `Fozzie.configure {|config| config.wat = :random }`
-    def configure
-      yield c if block_given?
-    end
-
-    # Set a logger
-    #
-    #
-    # `Fozzie.logger = Logger.new(STDOUT)`
-    def logger=(logger)
-      @logger = logger
-    end
-
-    # Accessor for logger
-    #
-    # `Fozzie.logger.warn 'foo'`
-    def logger
-      @logger
-    end
-
-  end
-
-  # Loads each namespace for registering statistics
-  self.c.namespaces.each do |klas|
-    Kernel.const_set(klas, Dsl.instance) unless const_defined?(klas)
-  end
-
-end
+# Fozzie is an implementation of the Statsd statistics gathering tool,
+# designed to make gathering stastistics from applications easy, fast, and effective.
+#
+# Configuration can be applied through a block and/or configuration file ('config/fozzie.yml')
+#
+# Fozzie provides automatic namespacing for the current environment, and host.
+#
+# Rack and Rails middleware is avaliable to gather statistics on the processing time of Controller actions.
+#
+
+module Fozzie
+
+  require 'core_ext/module/monitor'
+  require 'core_ext/module/alias_method_chain' unless Module.methods.include?(:alias_method_chain)
+  require 'core_ext/string/snakecase'
+  require 'core_ext/hash/symbolize_keys'
+
+  require 'fozzie/adapter'
+
+  require "fozzie/exception"
+  require 'fozzie/configuration'
+  require "fozzie/dsl"
+  require "fozzie/bulk_dsl"
+  require "fozzie/version"
+
+  class << self
+
+    # Shortcut for `Fozzie.config`
+    def c
+      config
+    end
+
+    # Returns the current configuration. Creates configuration on first-time request
+    def config
+      @config ||= Configuration.new
+    end
+
+    # Allows the setting on valudes against the configuration
+    #
+    # `Fozzie.configure {|config| config.wat = :random }`
+    def configure
+      yield c if block_given?
+    end
+
+    # Set a logger
+    #
+    #
+    # `Fozzie.logger = Logger.new(STDOUT)`
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # Accessor for logger
+    #
+    # `Fozzie.logger.warn 'foo'`
+    def logger
+      @logger
+    end
+
+  end
+
+  # Loads each namespace for registering statistics
+  self.c.namespaces.each do |klas|
+    Kernel.const_set(klas, Dsl.instance) unless const_defined?(klas)
+  end
+
+end

data/lib/fozzie/adapter/statsd.rb

@@ -1,95 +1,95 @@
-require 'socket'
-require 'resolv'
-
-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, host_ip, host_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 host_ip
-        @host_ip ||= Resolv.getaddress(Fozzie.c.host)
-      end
-
-      def host_port
-        @host_port ||= Fozzie.c.port
-      end
-
-      def delimeter
-        DELIMETER
-      end
-
-      def safe_separator
-        SAFE_SEPARATOR
-      end
-    end
-
-  end
-end
+require 'socket'
+require 'resolv'
+
+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, host_ip, host_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 host_ip
+        @host_ip ||= Resolv.getaddress(Fozzie.c.host)
+      end
+
+      def host_port
+        @host_port ||= Fozzie.c.port
+      end
+
+      def delimeter
+        DELIMETER
+      end
+
+      def safe_separator
+        SAFE_SEPARATOR
+      end
+    end
+
+  end
+end