metriks 0.8.1

data/lib/metriks.rb

@@ -0,0 +1,27 @@
+
+module Metriks
+  VERSION = '0.8.1'
+
+  def self.get(name)
+    Metriks::Registry.default.get(name)
+  end
+
+  def self.counter(name)
+    Metriks::Registry.default.counter(name)
+  end
+
+  def self.timer(name)
+    Metriks::Registry.default.timer(name)
+  end
+
+  def self.utilization_timer(name)
+    Metriks::Registry.default.utilization_timer(name)
+  end
+
+  def self.meter(name)
+    Metriks::Registry.default.meter(name)
+  end
+end
+
+require 'metriks/registry'
+require 'metriks/reporter/proc_title'

data/lib/metriks/counter.rb

@@ -0,0 +1,44 @@
+require 'atomic'
+
+module Metriks
+  # Public: Counters are one of the simplest metrics whose only operations
+  # are increment and decrement.
+  class Counter
+    # Public: Initialize a new Counter.
+    def initialize
+      @count = Atomic.new(0)
+    end
+
+    # Public: Reset the counter back to 0
+    #
+    # Returns nothing.
+    def clear
+      @count.value = 0
+    end
+
+    # Public: Increment the counter.
+    #
+    # incr - The value to add to the counter.
+    #
+    # Returns nothing.
+    def increment(incr = 1)
+      @count.update { |v| v + incr }
+    end
+
+    # Public: Decrement the counter.
+    #
+    # decr - The value to subtract from the counter.
+    #
+    # Returns nothing.
+    def decrement(decr = 1)
+      @count.update { |v| v - decr }
+    end
+
+    # Public: The current count.
+    #
+    # Returns the count.
+    def count
+      @count.value
+    end
+  end
+end

data/lib/metriks/ewma.rb

@@ -0,0 +1,63 @@
+require 'atomic'
+
+module Metriks
+  class EWMA
+    INTERVAL = 5.0
+    SECONDS_PER_MINUTE = 60.0
+
+    ONE_MINUTE      = 1
+    FIVE_MINUTES    = 5
+    FIFTEEN_MINUTES = 15
+
+    M1_ALPHA  = 1 - Math.exp(-INTERVAL / SECONDS_PER_MINUTE / ONE_MINUTE)
+    M5_ALPHA  = 1 - Math.exp(-INTERVAL / SECONDS_PER_MINUTE / FIVE_MINUTES)
+    M15_ALPHA = 1 - Math.exp(-INTERVAL / SECONDS_PER_MINUTE / FIFTEEN_MINUTES)
+
+    def self.new_m1
+      new(M1_ALPHA, INTERVAL)
+    end
+
+    def self.new_m5
+      new(M5_ALPHA, INTERVAL)
+    end
+
+    def self.new_m15
+      new(M15_ALPHA, INTERVAL)
+    end
+
+    def initialize(alpha, interval)
+      @alpha    = alpha
+      @interval = interval
+
+      @initialized = false
+      @rate        = Atomic.new(0.0)
+      @uncounted   = Atomic.new(0)
+    end
+
+    def clear
+      @initialized = false
+      @rate.value = 0.0
+      @uncounted.value = 0
+    end
+
+    def update(value)
+      @uncounted.update { |v| v + value }
+    end
+
+    def tick
+      count = @uncounted.swap(0)
+      instant_rate = count / @interval.to_f
+
+      if @initialized
+        @rate.update { |v| v + @alpha * (instant_rate - v) }
+      else
+        @rate.value = instant_rate
+        @initialized = true
+      end
+    end
+
+    def rate
+      @rate.value
+    end
+  end
+end

data/lib/metriks/histogram.rb

@@ -0,0 +1,103 @@
+require 'atomic'
+require 'metriks/uniform_sample'
+
+module Metriks
+  class Histogram
+    DEFAULT_SAMPLE_SIZE = 1028
+    DEFAULT_ALPHA = 0.015
+
+    def self.new_uniform
+      new(Metriks::UniformSample.new(DEFAULT_SAMPLE_SIZE))
+    end
+
+    def initialize(sample)
+      @sample   = sample
+      @count    = Atomic.new(0)
+      @min      = Atomic.new(nil)
+      @max      = Atomic.new(nil)
+      @sum      = Atomic.new(0)
+      @variance = Atomic.new([ -1, 0 ])
+    end
+
+    def clear
+      @sample.clear
+      @count.value = 0
+      @min.value = nil
+      @max.value = nil
+      @sum.value = 0
+      @variance.value = [ -1, 0 ]
+    end
+
+    def update(value)
+      @count.update { |v| v + 1 }
+      @sample.update(value)
+      self.max = value
+      self.min = value
+      @sum.update { |v| v + value }
+      update_variance(value)
+    end
+
+    def count
+      @count.value
+    end
+
+    def max
+      count > 0 ? @max.value : 0.0
+    end
+
+    def min
+      count > 0 ? @min.value : 0.0
+    end
+
+    def mean
+      count > 0 ? @sum.value / count : 0.0
+    end
+
+    def stddev
+      count > 0 ? variance : 0.0
+    end
+
+    def variance
+      count <= 1 ? 0.0 : @variance.value[1] / (count - 1)
+    end
+
+    def max=(potential_max)
+      done = false
+
+      while !done
+        current_max = @max.value
+        done = (!current_max.nil? && current_max >= potential_max) || @max.compare_and_swap(current_max, potential_max)
+      end
+    end
+
+    def min=(potential_min)
+      done = false
+
+      while !done
+        current_min = @min.value
+        done = (!current_min.nil? && current_min <= potential_min) || @min.compare_and_swap(current_min, potential_min)
+      end
+    end
+
+    def update_variance(value)
+      @variance.update do |old_values|
+        new_values = Array.new(2)
+        if old_values[0] == -1
+          new_values[0] = value
+          new_values[1] = 0
+        else
+          old_m = old_values[0]
+          old_s = old_values[1]
+
+          new_m = old_m + ((value - old_m) / count)
+          new_s = old_s + ((value - old_m) * (value - new_m))
+
+          new_values[0] = new_m
+          new_values[1] = new_s
+        end
+
+        new_values
+      end
+    end
+  end
+end

data/lib/metriks/meter.rb

@@ -0,0 +1,73 @@
+require 'atomic'
+
+require 'metriks/ewma'
+
+module Metriks
+  class Meter
+    def initialize(averager_klass = Metriks::EWMA)
+      @count = Atomic.new(0)
+      @start_time = Time.now
+
+      @m1_rate  = averager_klass.new_m1
+      @m5_rate  = averager_klass.new_m5
+      @m15_rate = averager_klass.new_m15
+
+      @thread = Thread.new do
+        loop do
+          sleep averager_klass::INTERVAL
+          tick
+        end
+      end
+    end
+
+    def clear
+      @count.value = 0
+      @start_time = Time.now
+      @m1_rate.clear
+      @m5_rate.clear
+      @m15_rate.clear
+    end
+
+    def tick
+      @m1_rate.tick
+      @m5_rate.tick
+      @m15_rate.tick
+    end
+
+    def mark(val = 1)
+      @count.update { |v| v + val }
+      @m1_rate.update(val)
+      @m5_rate.update(val)
+      @m15_rate.update(val)
+    end
+
+    def count
+      @count.value
+    end
+
+    def one_minute_rate
+      @m1_rate.rate
+    end
+
+    def five_minute_rate
+      @m5_rate.rate
+    end
+
+    def fifteen_minute_rate
+      @m15_rate.rate
+    end
+
+    def mean_rate
+      if count == 0
+        return 0.0
+      else
+        elapsed = Time.now - @start_time
+        count / elapsed
+      end
+    end
+
+    def stop
+      @thread.kill
+    end
+  end
+end

data/lib/metriks/registry.rb

@@ -0,0 +1,174 @@
+require 'metriks/counter'
+require 'metriks/timer'
+require 'metriks/utilization_timer'
+require 'metriks/meter'
+
+module Metriks
+  # Public: A collection of metrics
+  class Registry
+    # Public: The default registry for the process.
+    #
+    # Returns the default Registry for the process.
+    def self.default
+      @default ||= new
+    end
+
+    # Public: Initializes a new Registry.
+    def initialize
+      @mutex = Mutex.new
+      @metrics = {}
+    end
+
+    # Public: Clear all of the metrics in the Registry. This ensures all
+    # metrics that have been added are stopped.
+    #
+    # Returns nothing.
+    def clear
+      @mutex.synchronize do
+        @metrics.each do |key, metric|
+          metric.stop if metric.respond_to?(:stop)
+        end
+
+        @metrics = {}
+      end
+    end
+
+    # Public: Clear all of the metrics in the Registry. This has the same
+    # effect as calling #clear.
+    #
+    # Returns nothing.
+    def stop
+      clear
+    end
+
+    # Public: Iterate over all of the counters.
+    #
+    # Examples
+    #
+    #   registry.each do |name, metric|
+    #     puts name
+    #   end
+    #
+    # Returns nothing.
+    def each(&block)
+      metrics = @mutex.synchronize do
+        @metrics.dup
+      end
+
+      metrics.each(&block)
+    end
+
+    # Public: Fetch or create a new counter metric. Counters are one of the
+    # simplest metrics whose only operations are increment and decrement.
+    #
+    # name - The String name of the metric to define or fetch
+    #
+    # Examples
+    #
+    #   registry.counter('method.calls')
+    #
+    # Returns the Metricks::Counter identified by the name.
+    def counter(name)
+      add_or_get(name, Metriks::Counter)
+    end
+
+    # Public: Fetch or create a new meter metric. Meters are a counter that
+    # tracks throughput along with the count.
+    #
+    # name - The String name of the metric to define or fetch
+    #
+    # Examples
+    #
+    #   registry.meter('resque.calls')
+    #
+    # Returns the Metricks::Meter identified by the name.
+    def meter(name)
+      add_or_get(name, Metriks::Meter)
+    end
+
+    # Public: Fetch or create a new timer metric. Timers provide the means to
+    # time the execution of a method including statistics on the number of
+    # invocations, average length of time, throughput.
+    #
+    # name - The String name of the metric to define or fetch
+    #
+    # Examples
+    #
+    #   registry.timer('resque.worker')
+    #
+    # Returns the Metricks::Timer identified by the name.
+    def timer(name)
+      add_or_get(name, Metriks::Timer)
+    end
+
+    # Public: Fetch or create a new utilization timer metric.
+    #
+    # Utilization timers are a specialized version of a timer that calculate
+    # the percentage of wall-clock time (between 0 and 1) that was spent in
+    # the method. This metric is most valuable in a single-threaded
+    # environment where a processes is waiting on an external resource like a
+    # message queue or HTTP server.
+    #
+    # name - The String name of the metric to define or fetch
+    #
+    # Examples
+    #
+    #   registry.utilization_timer('rack.utilization')
+    #
+    # Returns the Metricks::UtilizationTimer identified by the name.
+    def utilization_timer(name)
+      add_or_get(name, Metriks::UtilizationTimer)
+    end
+
+    # Public: Fetch an existing metric.
+    #
+    # name - The String name of the metric to fetch
+    #
+    # Examples
+    #
+    #   registry.get('rack.utilization')
+    #
+    # Returns the metric or nil.
+    def get(name)
+      @mutex.synchronize do
+        @metrics[name]
+      end
+    end
+
+    # Public: Add a new metric.
+    #
+    # name - The String name of the metric to add
+    # metric - The metric instance to add
+    #
+    # Examples
+    #
+    #   registry.add('method.calls', Metriks::Counter.new)
+    #
+    # Returns nothing.
+    # Raises RuntimeError if the metric name is already defined
+    def add(name, metric)
+      @mutex.synchronize do
+        if @metrics[name]
+          raise "Metric '#{name}' already defined"
+        else
+          @metrics[name] = metric
+        end
+      end
+    end
+
+    protected
+    def add_or_get(name, klass)
+      @mutex.synchronize do
+        if metric = @metrics[name]
+          if !metric.is_a?(klass)
+            raise "Metric already defined as '#{metric.class}'"
+          else
+            return metric
+          end
+        else
+          @metrics[name] = klass.new
+        end
+      end
+    end
+  end
+end