Refactor reporters to remove duplication

lib/metriks/counter.rb

@@ -1,9 +1,12 @@
 require 'atomic'
+require 'metriks/exportable'
 
 module Metriks
   # Public: Counters are one of the simplest metrics whose only operations
   # are increment and decrement.
   class Counter
+    include Metriks::Exportable
+
     # Public: Initialize a new Counter.
     def initialize
       @count = Atomic.new(0)
@@ -40,5 +43,10 @@ def decrement(decr = 1)
     def count
       @count.value
     end
+
+    private
+    def exportable_metrics
+      [:count]
+    end
   end
-end
+end

lib/metriks/exportable.rb

@@ -0,0 +1,49 @@
+
+module Metriks
+  module Exportable
+
+    # Public: Get the type of this metric
+    #
+    # This key is used by certain reporters such as logger
+    def metric_type
+      self.class.name.split('::').last.gsub(/(.)([A-Z])/, '\1_\2').downcase
+    end
+
+    # Public: Export all of the Metric's computed values as a hash
+    def export_values
+      values = capture_metrics(self, exportable_metrics)
+
+      if respond_to? :snapshot
+        values = values.merge(capture_metrics(snapshot, exportable_snapshots))
+      end
+
+      values
+    end
+
+    private
+    # Private: Array of metrics that this metric object can calculate
+    #
+    # Returns: Array
+    def exportable_metrics
+      raise NotImplementedError, "Metrics must declare a set of exportable values"
+    end
+
+    # Private: Array of metrics that can be calculated from a snapshot
+    # of the data
+    #
+    # Returns: Array
+    def exportable_snapshots
+      []
+    end
+
+    def capture_metrics(source, metric)
+      Array(metric).inject({}) do |values,key|
+        name = String(key).gsub(/^get_/, '').to_sym
+
+        values.tap do |h|
+          h[name] = source.send(key)
+        end
+      end
+    end
+  end
+end

lib/metriks/histogram.rb

@@ -1,9 +1,12 @@
 require 'atomic'
 require 'metriks/uniform_sample'
 require 'metriks/exponentially_decaying_sample'
+require 'metriks/exportable'
 
 module Metriks
   class Histogram
+    include Metriks::Exportable
+
     DEFAULT_SAMPLE_SIZE = 1028
     DEFAULT_ALPHA = 0.015
 
@@ -108,5 +111,14 @@ def update_variance(value)
         new_values
       end
     end
+
+    private
+    def exportable_metrics
+      [:count, :min, :max, :mean, :stddev]
+    end
+
+    def exportable_snapshots
+      [:median, :get_95th_percentile]
+    end
   end
 end

lib/metriks/meter.rb

@@ -1,9 +1,12 @@
 require 'atomic'
 
 require 'metriks/ewma'
+require 'metriks/exportable'
 
 module Metriks
   class Meter
+    include Metriks::Exportable
+
     TICK_INTERVAL = 5.0
 
     def initialize(averager_klass = Metriks::EWMA)
@@ -81,5 +84,14 @@ def mean_rate
 
     def stop
     end
+
+    private
+    def exportable_metrics
+      [
+        :count,
+        :one_minute_rate, :five_minute_rate, :fifteen_minute_rate,
+        :mean_rate
+      ]
+    end
   end
-end
+end

lib/metriks/reporter/graphite.rb

@@ -48,68 +48,21 @@ def restart
 
     def write
       @registry.each do |name, metric|
-        case metric
-        when Metriks::Meter
-          write_metric name, metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate
-          ]
-        when Metriks::Counter
-          write_metric name, metric, [
-            :count
-          ]
-        when Metriks::UtilizationTimer
-          write_metric name, metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate,
-            :min, :max, :mean, :stddev,
-            :one_minute_utilization, :five_minute_utilization,
-            :fifteen_minute_utilization, :mean_utilization,
-          ], [
-            :median, :get_95th_percentile
-          ]
-        when Metriks::Timer
-          write_metric name, metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate,
-            :min, :max, :mean, :stddev
-          ], [
-            :median, :get_95th_percentile
-          ]
-        when Metriks::Histogram
-          write_metric name, metric, [
-            :count, :min, :max, :mean, :stddev
-          ], [
-            :median, :get_95th_percentile
-          ]
-        end
+        write_metrics name, metric.export_values
       end
     end
 
-    def write_metric(base_name, metric, keys, snapshot_keys = [])
+    def write_metrics(base_name, metrics)
       time = Time.now.to_i
 
       base_name = base_name.to_s.gsub(/ +/, '_')
       if @prefix
         base_name = "#{@prefix}.#{base_name}"
       end
 
-      keys.flatten.each do |key|
-        name = key.to_s.gsub(/^get_/, '')
-        value = metric.send(key)
+      metrics.each_pair do |name, value|
         socket.write("#{base_name}.#{name} #{value} #{time}\n")
       end
-
-      unless snapshot_keys.empty?
-        snapshot = metric.snapshot
-        snapshot_keys.flatten.each do |key|
-          name = key.to_s.gsub(/^get_/, '')
-          value = snapshot.send(key)
-          socket.write("#{base_name}.#{name} #{value} #{time}\n")
-        end
-      end
-    rescue Errno::EPIPE
-      socket.close
     end
   end
 end

lib/metriks/reporter/librato_metrics.rb

@@ -46,41 +46,7 @@ def restart
     def write
       gauges = []
       @registry.each do |name, metric|
-        gauges << case metric
-        when Metriks::Meter
-          prepare_metric name, metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate
-          ]
-        when Metriks::Counter
-          prepare_metric name, metric, [
-            :count
-          ]
-        when Metriks::UtilizationTimer
-          prepare_metric name, metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate,
-            :min, :max, :mean, :stddev,
-            :one_minute_utilization, :five_minute_utilization,
-            :fifteen_minute_utilization, :mean_utilization,
-          ], [
-            :median, :get_95th_percentile
-          ]
-        when Metriks::Timer
-          prepare_metric name, metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate,
-            :min, :max, :mean, :stddev
-          ], [
-            :median, :get_95th_percentile
-          ]
-        when Metriks::Histogram
-          prepare_metric name, metric, [
-            :count, :min, :max, :mean, :stddev
-          ], [
-            :median, :get_95th_percentile
-          ]
-        end
+        gauges << prepare_metrics(name, metric.export_values)
       end
 
       gauges.flatten!
@@ -137,7 +103,7 @@ def form_data(metrics)
       data
     end
 
-    def prepare_metric(base_name, metric, keys, snapshot_keys = [])
+    def prepare_metrics(base_name, metrics)
       results = []
       time = @time_tracker.now_floored
 
@@ -146,10 +112,7 @@ def prepare_metric(base_name, metric, keys, snapshot_keys = [])
         base_name = "#{@prefix}.#{base_name}"
       end
 
-      keys.flatten.each do |key|
-        name = key.to_s.gsub(/^get_/, '')
-        value = metric.send(key)
-
+      metrics.each_pair do |name, value|
         results << {
           :type => name.to_s == "count" ? "counter" : "gauge",
           :name => "#{base_name}.#{name}",
@@ -159,22 +122,6 @@ def prepare_metric(base_name, metric, keys, snapshot_keys = [])
         }
       end
 
-      unless snapshot_keys.empty?
-        snapshot = metric.snapshot
-        snapshot_keys.flatten.each do |key|
-          name = key.to_s.gsub(/^get_/, '')
-          value = snapshot.send(key)
-
-          results << {
-            :type => name.to_s == "count" ? "counter" : "gauge",
-            :name => "#{base_name}.#{name}",
-            :source => @source,
-            :measure_time => time,
-            :value => value
-          }
-        end
-      end
-
       results
     end
   end

lib/metriks/reporter/logger.rb

@@ -49,65 +49,19 @@ def write
       @last_write = Time.now
 
       @registry.each do |name, metric|
-        case metric
-        when Metriks::Meter
-          log_metric name, 'meter', metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate
-          ]
-        when Metriks::Counter
-          log_metric name, 'counter', metric, [
-            :count
-          ]
-        when Metriks::UtilizationTimer
-          log_metric name, 'utilization_timer', metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate,
-            :min, :max, :mean, :stddev,
-            :one_minute_utilization, :five_minute_utilization,
-            :fifteen_minute_utilization, :mean_utilization,
-          ], [
-            :median, :get_95th_percentile
-          ]
-        when Metriks::Timer
-          log_metric name, 'timer', metric, [
-            :count, :one_minute_rate, :five_minute_rate,
-            :fifteen_minute_rate, :mean_rate,
-            :min, :max, :mean, :stddev
-          ], [
-            :median, :get_95th_percentile
-          ]
-        when Metriks::Histogram
-          log_metric name, 'histogram', metric, [
-            :count, :min, :max, :mean, :stddev
-          ], [
-            :median, :get_95th_percentile
-          ]
-        end
-      end
-    end
-
-    def extract_from_metric(metric, *keys)
-      keys.flatten.collect do |key|
-        name = key.to_s.gsub(/^get_/, '')
-        [ { name => metric.send(key) } ]
+        log_metrics name, metric.metric_type, metric.export_values
       end
     end
 
-    def log_metric(name, type, metric, keys, snapshot_keys = [])
+    def log_metrics(name, type, values)
       message = []
 
       message << @prefix if @prefix
       message << { :time => Time.now.to_i }
 
       message << { :name => name }
       message << { :type => type }
-      message += extract_from_metric(metric, keys)
-
-      unless snapshot_keys.empty?
-        snapshot = metric.snapshot
-        message += extract_from_metric(snapshot, snapshot_keys)
-      end
+      message << values
 
       @logger.add(@log_level, format_message(message))
     end