rubycut-metriks 0.9.9.4

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/exponentially_decaying_sample.rb

@@ -0,0 +1,102 @@
+require 'atomic'
+require 'red_black_tree'
+require 'metriks/snapshot'
+
+module Metriks
+  class ExponentiallyDecayingSample
+    RESCALE_THRESHOLD = 60 * 60 # 1 hour
+
+    def initialize(reservoir_size, alpha, values = nil)
+      @values = values || RedBlackTree.new
+      @count = Atomic.new(0)
+      @next_scale_time = Atomic.new(0)
+      @alpha = alpha
+      @reservoir_size = reservoir_size
+      @mutex = Mutex.new
+      clear
+    end
+
+    def clear
+      @mutex.synchronize do
+        @values.clear
+        @count.value = 0
+        @next_scale_time.value = Time.now + RESCALE_THRESHOLD
+        @start_time = Time.now
+      end
+    end
+
+    def size
+      count = @count.value
+      count < @reservoir_size ? count : @reservoir_size
+    end
+
+    def snapshot
+      @mutex.synchronize do
+        Snapshot.new(@values.values)
+      end
+    end
+
+    def update(value, timestamp = Time.now)
+      @mutex.synchronize do
+        priority = weight(timestamp - @start_time) / rand
+        priority = Float::MAX if priority.infinite?
+        new_count = @count.update { |v| v + 1 }
+
+        if priority.nan?
+          warn "ExponentiallyDecayingSample found priority of NaN. timestamp: #{timestamp.to_f} start_time: #{@start_time.to_f}"
+          return
+        end
+
+        if new_count <= @reservoir_size
+          @values[priority] = value
+        else
+          first_priority = @values.first[0]
+          if first_priority < priority
+            unless @values[priority]
+              @values[priority] = value
+
+              until @values.delete(first_priority)
+                first_priority = @values.first[0]
+              end
+            end
+          end
+        end
+      end
+
+      now = Time.new
+      next_time = @next_scale_time.value
+      if now >= next_time
+        rescale(now, next_time)
+      end
+    end
+
+    def weight(time)
+      Math.exp(@alpha * time)
+    end
+
+    def rescale(now, next_time)
+      if @next_scale_time.compare_and_swap(next_time, now + RESCALE_THRESHOLD)
+        @mutex.synchronize do
+          old_start_time = @start_time
+          @start_time = Time.now
+          @values.keys.each do |key|
+            value = @values.delete(key)
+            new_key = key * Math.exp(-@alpha * (@start_time - old_start_time))
+
+            if key.nan?
+              warn "ExponentiallyDecayingSample found a key of NaN. old_start_time: #{old_start_time.to_f} start_time: #{@start_time.to_f}"
+              next
+            end
+
+            if new_key.nan?
+              warn "ExponentiallyDecayingSample found a new_key of NaN. key: #{key} old_start_time: #{old_start_time.to_f} start_time: #{@start_time.to_f}"
+              next
+            end
+
+            @values[new_key] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metriks/histogram.rb

@@ -0,0 +1,112 @@
+require 'atomic'
+require 'metriks/uniform_sample'
+require 'metriks/exponentially_decaying_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 self.new_exponentially_decaying
+      new(Metriks::ExponentiallyDecayingSample.new(DEFAULT_SAMPLE_SIZE, DEFAULT_ALPHA))
+    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 snapshot
+      @sample.snapshot
+    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.5 : 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,85 @@
+require 'atomic'
+
+require 'metriks/ewma'
+
+module Metriks
+  class Meter
+    TICK_INTERVAL = 5.0
+
+    def initialize(averager_klass = Metriks::EWMA)
+      @count = Atomic.new(0)
+      @start_time = Time.now.to_f
+      @last_tick = Atomic.new(@start_time)
+
+      @m1_rate  = averager_klass.new_m1
+      @m5_rate  = averager_klass.new_m5
+      @m15_rate = averager_klass.new_m15
+    end
+
+    def clear
+      @count.value = 0
+      @start_time = Time.now.to_f
+      @last_tick.value = @start_time
+      @m1_rate.clear
+      @m5_rate.clear
+      @m15_rate.clear
+    end
+
+    def tick
+      @m1_rate.tick
+      @m5_rate.tick
+      @m15_rate.tick
+    end
+
+    def tick_if_nessesary
+      old_tick = @last_tick.value
+      new_tick = Time.new.to_f
+      age = new_tick - old_tick
+      if age > TICK_INTERVAL && @last_tick.compare_and_swap(old_tick, new_tick)
+        required_ticks = age / TICK_INTERVAL
+        required_ticks.to_i.times do
+          tick
+        end
+      end
+    end
+
+    def mark(val = 1)
+      tick_if_nessesary
+      @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
+      tick_if_nessesary
+      @m1_rate.rate
+    end
+
+    def five_minute_rate
+      tick_if_nessesary
+      @m5_rate.rate
+    end
+
+    def fifteen_minute_rate
+      tick_if_nessesary
+      @m15_rate.rate
+    end
+
+    def mean_rate
+      if count == 0
+        return 0.0
+      else
+        elapsed = Time.now.to_f - @start_time
+        count / elapsed
+      end
+    end
+
+    def stop
+    end
+  end
+end

data/lib/metriks/registry.rb

@@ -0,0 +1,207 @@
+require 'metriks/counter'
+require 'metriks/timer'
+require 'metriks/utilization_timer'
+require 'metriks/meter'
+require 'metriks/gauge'
+
+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 Metriks::Counter identified by the name.
+    def counter(name)
+      add_or_get(name, Metriks::Counter)
+    end
+
+    # Public: Fetch or create a new gauge metric.
+    #
+    # name - The String name of the metric to define or fetch
+    #
+    # Examples
+    #
+    #   registry.gauge('disk_space.used') { 1 }
+    #
+    # Returns the Metriks::Gauge identified by the name.
+    def gauge(name, callable = nil, &block)
+      add_or_get(name, Metriks::Gauge) do
+        Metriks::Gauge.new(callable, &block)
+      end
+    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 Metriks::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 Metriks::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 Metriks::UtilizationTimer identified by the name.
+    def utilization_timer(name)
+      add_or_get(name, Metriks::UtilizationTimer)
+    end
+
+    # Public: Fetch or create a new histogram metric. Histograms record values
+    # and expose statistics about the distribution of the data like median and
+    # 95th percentile.
+    #
+    # name - The String name of the metric to define or fetch
+    #
+    # Examples
+    #
+    #   registry.histogram('backlog.wait')
+    #
+    # Returns the Metriks::Histogram identified by the name.
+    def histogram(name)
+      add_or_get(name, Metriks::Histogram) do
+        Metriks::Histogram.new_exponentially_decaying
+      end
+    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, &create_metric)
+      @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] = create_metric ? create_metric.call : klass.new
+        end
+      end
+    end
+  end
+end