fozzie 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f6a706877c3f3cb25972e7a703dd4f43dcb2b87
-  data.tar.gz: 7934207e38e7bff3fa862e6193f7a579227f6a42
+  metadata.gz: 62870b7d38427ff5336337c4653e1d9a4baafd42
+  data.tar.gz: a89f19a1490f4b08b9eebe444c01f62b369c6594
 SHA512:
-  metadata.gz: b7f0e0208f540c6c1634a22a5c6d261ff68096195c99ff5c317686720be49e5e65204a2f7259bdb0455dfd7d6ddd814fb4fcc94995bd60eca168d8ba0c9cc203
-  data.tar.gz: 8e9cb0c5e58968702d4aca13ce4580d43507587875ed1c1cd7fecaf824da9ec4957854230059e5274c54cff52e563e8050c0fe3fc3afecf4debe1d39a86f7f3d
+  metadata.gz: cd6195e443aae3ce9a8069cf81522b0a924438cd25fa9ac1b04baf012df7d368cd0140798e08580150ffb63070e9d1af9d3461de8fd3b2f102cbf954b5a24613
+  data.tar.gz: a5037ff3afd5f73f1eb532049f643062849e4f6725297cf9521299cdd704d5b75407500d1938ef7b54120033b76869a9fe40b20fd1977f5e329144d61b039a92

data/lib/fozzie/adapter.rb

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

data/lib/fozzie/adapter/datadog.rb

@@ -0,0 +1,26 @@
+require 'fozzie/adapter/statsd'
+
+module Fozzie
+  module Adapter
+    class Datadog < Statsd
+
+      # stats is a collection of hashes in the following format:
+      # { :bucket => stat, :value => value, :type => type, :sample_rate => sample_rate, tags => ["serviceid:fozzie","country:au"] }
+      def register(*stats)
+        metrics = stats.flatten.map do |stat|
+          next if sampled?(stat[:sample_rate])
+
+          bucket = format_bucket(stat[:bucket])
+          value  = format_value(stat[:value], stat[:type], stat[:sample_rate])
+          tags   = (stat[:tags] || []).map {|tag| tag.gsub(/[,\|]/, RESERVED_CHARS_REPLACEMENT)}
+
+          result = "#{bucket}:#{value}" 
+          result << "|##{tags.join(',')}" if tags.any? 
+          result
+        end.compact.join(BULK_DELIMETER)
+
+        send_to_socket(metrics)
+      end
+    end
+  end
+end

data/lib/fozzie/adapter/statsd.rb

@@ -1,95 +1,94 @@
-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.map do |stat|
+          next if sampled?(stat[:sample_rate])
+
+          bucket = format_bucket(stat[:bucket])
+          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

data/lib/fozzie/bulk_dsl.rb

@@ -1,28 +1,27 @@
-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
+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, extra = {})
+     val = extra.merge({ :bucket => 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

@@ -105,7 +105,5 @@ module Fozzie
     def full_config_path(path)
       File.expand_path('config/fozzie.yml', path)
     end
-
   end
-
 end

data/lib/fozzie/dsl.rb

@@ -1,19 +1,17 @@
-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
+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, extra = {})
+      val = extra.merge(:bucket => stat, :value => value, :type => type, :sample_rate => sample_rate)
+      adapter.register(val)
+    end
+  end
+end

data/lib/fozzie/interface.rb

@@ -1,140 +1,140 @@
-require 'fozzie/adapter/statsd'
-
-module Fozzie
-  module Interface
-
-    # 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, :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, :timing, 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)
-      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(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
-
-    # 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?`
-    def increment_on(stat, perf, sample_rate=1)
-      key = [stat, (perf ? "success" : "fail")]
-      increment(key, sample_rate)
-      perf
-    end
-
-    # Register an arbitrary value
-    #
-    # `Stats.gauge 'wat', 'app'`
-    def gauge(stat, value, sample_rate = 1)
-      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
+require 'fozzie/adapter/statsd'
+require 'fozzie/adapter/datadog'
+
+module Fozzie
+  module Interface
+
+    # Increments the given stat by one, with an optional sample rate
+    #
+    # `Stats.increment 'wat'`
+    def increment(stat, sample_rate=1, extra = {})
+      count(stat, 1, sample_rate, extra)
+    end
+
+    # Decrements the given stat by one, with an optional sample rate
+    #
+    # `Stats.decrement 'wat'`
+    def decrement(stat, sample_rate=1, extra = {})
+      count(stat, -1, sample_rate, extra)
+    end
+
+    # Registers a count for the given stat, with an optional sample rate
+    #
+    # `Stats.count 'wat', 500`
+    def count(stat, count, sample_rate=1, extra = {})
+      send(stat, count, :count, sample_rate, extra)
+    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, extra = {})
+      send(stat, ms, :timing, sample_rate, extra)
+    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, extra = {})
+      start  = Time.now
+      result = yield
+      timing(stat, ((Time.now - start) * 1000).round, sample_rate, extra)
+      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, extra = {}, &block)
+      time(stat, sample_rate, extra, &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, extra = {}, &block)
+      time(stat, sample_rate, extra, &block)
+    end
+
+    # Registers a commit
+    #
+    # `Stats.commit`
+    def commit(extra = {})
+      event(:commit, nil, extra)
+    end
+
+    # Registers a commit
+    #
+    # `Stats.commit`
+    def committed(extra = {})
+      commit(extra)
+    end
+
+    # Registers that the app has been built
+    #
+    # `Stats.built`
+    def built(extra = {})
+      event(:build, nil, extra)
+    end
+
+    # Registers a build for the app
+    #
+    # `Stats.build`
+    def build(extra = {})
+      built(extra)
+    end
+
+    # Registers a deployed status for the given app
+    #
+    # `Stats.deployed 'watapp'`
+    def deployed(app = nil, extra = {})
+      event(:deploy, app, extra)
+    end
+
+    # Registers a deployment for the given app
+    #
+    # `Stats.deploy 'watapp'`
+    def deploy(app = nil, extra = {})
+      deployed(app, extra)
+    end
+
+    # Register an event of any type
+    #
+    # `Stats.event 'wat', 'app'`
+    def event(type, app = nil, extra = {})
+      gauge(["event", type.to_s, app], Time.now.usec, 1, extra)
+    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, extra = {})
+      key = [stat, (perf ? "success" : "fail")]
+      increment(key, sample_rate, extra)
+      perf
+    end
+
+    # Register an arbitrary value
+    #
+    # `Stats.gauge 'wat', 'app'`
+    def gauge(stat, value, sample_rate = 1, extra = {})
+      send(stat, value, :gauge, sample_rate, extra)
+    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