yam-ruby-metrics 0.8.6

data/lib/ruby-metrics.rb

@@ -0,0 +1,15 @@
+# == Metrics Initialization
+#
+
+require 'logger'
+
+module Metrics
+  class << self
+    attr_writer :logger
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+end
+
+require 'ruby-metrics/agent'

data/lib/ruby-metrics/agent.rb

@@ -0,0 +1,62 @@
+require 'ruby-metrics/logging'
+
+require 'ruby-metrics/time_units'
+
+require 'ruby-metrics/instruments/counter'
+require 'ruby-metrics/instruments/meter'
+require 'ruby-metrics/instruments/gauge'
+require 'ruby-metrics/instruments/histogram'
+require 'ruby-metrics/instruments/timer'
+
+require 'ruby-metrics/integration'
+
+require 'json'
+
+module Metrics
+  class Agent
+    include Logging
+
+    attr_reader :instruments
+
+    def initialize(options = {})
+      @instruments = {}
+    end
+
+    alias_method :registered, :instruments
+
+    def counter(name)
+      @instruments[name] ||= Instruments::Counter.new
+    end
+
+    def meter(name)
+      @instruments[name] ||= Instruments::Meter.new
+    end
+
+    def gauge(name, &block)
+      @instruments[name] ||= Instruments::Gauge.new(&block)
+    end
+
+    def timer(name, options = {})
+      @instruments[name] ||= Instruments::Timer.new(options)
+    end
+
+    def uniform_histogram(name)
+      @instruments[name] ||= Instruments::UniformHistogram.new
+    end
+
+    # For backwards compatibility
+    alias_method :histogram, :uniform_histogram
+
+    def exponential_histogram(name)
+      @instruments[name] ||= Instruments::ExponentialHistogram.new
+    end
+
+    def as_json(*_)
+      @instruments
+    end
+
+    def to_json(*_)
+      as_json.to_json
+    end
+  end
+end

data/lib/ruby-metrics/instruments/counter.rb

@@ -0,0 +1,39 @@
+module Metrics
+  module Instruments
+    class Counter
+      def initialize
+        @value = 0
+      end
+
+      def inc(value = 1)
+        @value += value
+      end
+      alias_method :incr, :inc
+
+      def dec(value = 1)
+        @value -= value
+      end
+      alias_method :decr, :dec
+
+      def clear
+        @value = 0
+      end
+
+      def to_i
+        @value.to_i
+      end
+
+      def to_s
+        @value.to_s
+      end
+
+      def as_json(*_)
+        @value
+      end
+
+      def to_json(*_)
+        as_json.to_json
+      end
+    end
+  end
+end

data/lib/ruby-metrics/instruments/gauge.rb

@@ -0,0 +1,23 @@
+module Metrics
+  module Instruments
+    class Gauge
+      def initialize(&block)
+        raise ArgumentError, "a block is required" unless block_given?
+        @block = block
+      end
+
+      def get
+        instance_exec(&@block)
+      end
+
+      def as_json(*_)
+        value = get
+        value.respond_to?(:as_json) ? value.as_json : value
+      end
+
+      def to_json(*_)
+        as_json.to_json
+      end
+    end
+  end
+end

data/lib/ruby-metrics/instruments/histogram.rb

@@ -0,0 +1,188 @@
+require 'ruby-metrics/statistics/uniform_sample'
+require 'ruby-metrics/statistics/exponential_sample'
+
+module Metrics
+  module Instruments
+    class Histogram
+
+      def initialize(type = :uniform)
+        @count = 0
+        case type
+        when :uniform
+          @sample = Metrics::Statistics::UniformSample.new
+        when :exponential
+          @sample = Metrics::Statistics::ExponentialSample.new
+        end
+        @min = nil
+        @max = nil
+        @sum = 0
+        @variance_s = 0
+        @variance_m = -1
+      end
+
+      def update(value)
+      	@count += 1
+      	@sum += value
+      	@sample.update(value)
+      	update_max(value)
+      	update_min(value)
+        update_variance(value);
+      end
+
+      def clear
+        @sample.clear
+        @min = nil
+        @max = nil
+        @sum = 0
+        @count = 0
+        @variance_m = -1
+        @variance_s = 0
+      end
+
+      def quantiles(percentiles)
+        # Calculated using the same logic as R and Excel use
+        # as outlined by the NIST here: http://www.itl.nist.gov/div898/handbook/prc/section2/prc252.htm
+        count = @count
+        scores = {}
+        values = @sample.values[0..count-1]
+
+        percentiles.each do |pct|
+          scores[pct] = 0.0
+        end
+
+        if count > 0
+          values.sort!
+          percentiles.each do |pct|
+            idx = pct * (values.length - 1) + 1.0
+            if idx <= 1
+              scores[pct] = values[0]
+            elsif idx >= values.length
+              scores[pct] = values[values.length-1]
+            else
+              lower = values[idx.to_i - 1]
+              upper = values[idx.to_i]
+              scores[pct] = lower + (idx - idx.floor) * (upper - lower)
+            end
+          end
+        end
+
+        return scores
+      end
+
+      def update_min(value)
+        if (@min == nil || value < @min)
+          @min = value
+        end
+      end
+
+      def update_max(value)
+        if (@max == nil || value > @max)
+          @max = value
+        end
+      end
+
+      def update_variance(value)
+        count = @count
+        old_m = @variance_m
+        new_m = @variance_m + ((value - old_m) / count)
+        new_s = @variance_s + ((value - old_m) * (value - new_m))
+
+        @variance_m = new_m
+        @variance_s = new_s
+      end
+
+      def variance
+        count = @count
+        variance_s = @variance_s
+
+        if count <= 1
+          return 0.0
+        else
+          return variance_s.to_f / (count - 1).to_i
+        end
+      end
+
+      def count
+        count = @count
+        return count
+      end
+
+
+      def max
+        max = @max
+        if max != nil
+          return max
+        else
+          return 0.0
+        end
+      end
+
+      def min
+        min = @min
+        if min != nil
+          return min
+        else
+          return 0.0
+        end
+      end
+
+      def mean
+        count = @count
+        sum = @sum
+
+        if count > 0
+          return sum / count
+        else
+          return 0.0
+        end
+      end
+
+      def std_dev
+        count = @count
+        variance = self.variance()
+
+        if count > 0
+          return Math.sqrt(variance)
+        else
+          return 0.0
+        end
+      end
+
+      def values
+        @sample.values
+      end
+
+      def as_json(*_)
+        percentiles = self.quantiles([0.5, 0.75, 0.95, 0.98, 0.99, 0.999])
+        {
+          :min => self.min,
+          :max => self.max,
+          :mean => self.mean,
+          :median => percentiles['0.5'],
+          :std_dev => self.std_dev,
+          :p75 => percentiles['0.75'],
+          :p95 => percentiles['0.95'],
+          :p98 => percentiles['0.98'],
+          :p99 => percentiles['0.99'],
+          :p999 => percentiles['0.999']
+        }
+      end
+
+      def to_json(*_)
+        as_json.to_json
+      end
+    end
+
+    class ExponentialHistogram < Histogram
+      def initialize
+        super(:exponential)
+      end
+    end
+
+    class UniformHistogram < Histogram
+      def initialize
+        super(:uniform)
+      end
+    end
+  end
+end

data/lib/ruby-metrics/instruments/meter.rb

@@ -0,0 +1,99 @@
+require 'ruby-metrics/time_units'
+
+module Metrics
+  module Instruments
+    class Meter
+      include Metrics::TimeConversion
+
+      # From http://www.teamquest.com/pdfs/whitepaper/ldavg2.pdf
+      INTERVAL = 5.0
+      INTERVAL_IN_NS = 5000000000.0
+      ONE_MINUTE_FACTOR     = 1 - Math.exp(-INTERVAL / 60.0)
+      FIVE_MINUTE_FACTOR    = 1 - Math.exp(-INTERVAL / (60.0 * 5.0))
+      FIFTEEN_MINUTE_FACTOR = 1 - Math.exp(-INTERVAL / (60.0 * 15.0))
+
+      attr_reader :count
+      alias_method :counted, :count
+
+      def initialize(options = {})
+        @one_minute_rate = @five_minute_rate = @fifteen_minute_rate = 0.0
+        @count  = 0
+        @initialized = false
+        @start_time = Time.now.to_f
+
+        @timer_thread = Thread.new do
+          begin
+            loop do
+              self.tick
+              sleep(INTERVAL)
+            end
+          rescue Exception => e
+            logger.error "Error in timer thread: #{e.class.name}: #{e}\n  #{e.backtrace.join("\n  ")}"
+          end # begin
+        end # thread new
+
+      end
+
+      def clear
+      end
+
+      def mark(count = 1)
+        @count += count
+      end
+
+      def calc_rate(rate, factor, count)
+        rate = rate.to_f + (factor.to_f * (count.to_f - rate.to_f))
+        rate.to_f
+      end
+
+      def tick
+        count = @count.to_f  / Seconds.to_nsec(INTERVAL).to_f
+
+        if (@initialized)
+          @one_minute_rate      = calc_rate(@one_minute_rate,     ONE_MINUTE_FACTOR,     count)
+          @five_minute_rate     = calc_rate(@five_minute_rate,    FIVE_MINUTE_FACTOR,    count)
+          @fifteen_minute_rate  = calc_rate(@fifteen_minute_rate, FIFTEEN_MINUTE_FACTOR, count)
+        else
+          @one_minute_rate = @five_minute_rate = @fifteen_minute_rate  = (count)
+          @initialized = true
+        end
+
+        @count = 0
+      end
+
+      def one_minute_rate(rate_unit = :seconds)
+        convert_to_ns @one_minute_rate, rate_unit
+      end
+
+      def five_minute_rate(rate_unit = :seconds)
+        convert_to_ns @five_minute_rate, rate_unit
+      end
+
+      def fifteen_minute_rate(rate_unit = :seconds)
+        convert_to_ns @fifteen_minute_rate, rate_unit
+      end
+
+      def mean_rate(rate_unit = :seconds)
+        count = @count
+        if count == 0
+          return 0.0;
+        else
+          elapsed = Time.now.to_f - @start_time.to_f
+          convert_to_ns (count.to_f / elapsed.to_f), rate_unit
+        end
+      end
+
+      def as_json(*_)
+        {
+          :one_minute_rate => self.one_minute_rate,
+          :five_minute_rate => self.five_minute_rate,
+          :fifteen_minute_rate => self.fifteen_minute_rate
+        }
+      end
+
+      def to_json(*_)
+        as_json.to_json
+      end
+    end
+  end
+end

data/lib/ruby-metrics/instruments/timer.rb

@@ -0,0 +1,138 @@
+require File.join(File.dirname(__FILE__), '..', 'time_units')
+
+module Metrics
+  module Instruments
+    class Timer
+      include Metrics::TimeConversion
+
+      attr_reader :duration_unit, :rate_unit
+
+      def initialize(options = {})
+        @meter          = Meter.new
+        @histogram      = ExponentialHistogram.new
+
+        @duration_unit  = options[:duration_unit] || :seconds
+        @rate_unit      = options[:rate_unit] || :seconds
+
+        clear
+      end
+
+      def clear
+        @histogram.clear
+      end
+
+      def update(duration, unit)
+        mult = convert_to_ns(1, unit)
+        self.update_timer(duration * mult)
+      end
+
+      def time(&block)
+        start_time = Time.now.to_f
+        result = block.call
+        time_diff = Time.now.to_f - start_time
+        time_in_ns = convert_to_ns time_diff, :seconds
+        update_timer(time_in_ns)
+        result
+      end
+
+      def count
+        @histogram.count
+      end
+
+      def fifteen_minute_rate
+        @meter.fifteen_minute_rate(@rate_unit)
+      end
+
+      def five_minute_rate
+        @meter.five_minute_rate(@rate_unit)
+      end
+
+      def one_minute_rate
+        @meter.one_minute_rate(@rate_unit)
+      end
+
+      def mean_rate
+        @meter.mean_rate(@rate_unit)
+      end
+
+      def max
+        scale_duration_to_ns @histogram.max, @duration_unit
+      end
+
+      def min
+        scale_duration_to_ns @histogram.min, @duration_unit
+      end
+
+      def mean
+        scale_duration_to_ns @histogram.mean, @duration_unit
+      end
+
+      def std_dev
+        scale_duration_to_ns @histogram.std_dev, @duration_unit
+      end
+
+      def quantiles(percentiles = [0.99,0.97,0.95,0.75,0.5,0.25])
+        result = {}
+
+        @histogram.quantiles(percentiles).each do |k,v|
+          result[k] = scale_duration_to_ns v, @duration_unit
+        end
+
+        result
+      end
+
+      def values
+        result = []
+
+        @histogram.values.each do |value|
+          result << (scale_duration_to_ns value, @duration_unit)
+        end
+
+        result
+      end
+
+      def update_timer(duration)
+        if duration >= 0
+          @histogram.update(duration)
+          @meter.mark
+        end
+      end
+
+      def as_json(*_)
+        percentiles = self.quantiles([0.5, 0.75, 0.95, 0.98, 0.99, 0.999])
+        {
+          :rates => {
+            :count => count,
+            :m1 => one_minute_rate,
+            :m5 => five_minute_rate,
+            :m15 => fifteen_minute_rate,
+            :mean => mean_rate,
+            :unit => @rate_unit
+          },
+          :duration => {
+            :min => self.min,
+            :max => self.max,
+            :mean => self.mean,
+            :median => percentiles['0.5'],
+            :std_dev => self.std_dev,
+            :p75 => percentiles['0.75'],
+            :p95 => percentiles['0.95'],
+            :p98 => percentiles['0.98'],
+            :p99 => percentiles['0.99'],
+            :p999 => percentiles['0.999'],
+            :unit => @duration_unit
+          }
+        }
+      end
+
+      def to_json(*_)
+        as_json.to_json
+      end
+
+      private
+      def scale_duration_to_ns(value, unit)
+        value.to_f / convert_to_ns(1, unit).to_f
+      end
+    end
+  end
+end