leafy 0.0.3 → 0.1.0

data/lib/leafy/core/counter.rb

@@ -0,0 +1,33 @@
+require 'concurrent/thread_safe/util/adder'
+
+# An incrementing and decrementing counter metric.
+module Leafy
+  module Core
+    class Counter
+       def initialize
+         @count = Concurrent::ThreadSafe::Util::Adder.new
+       end
+  
+       # Increment the counter by {@code n}, default by one.
+       #
+       # @param n the amount by which the counter will be increased
+       def inc(n = 1)
+         @count.add(n)
+       end
+
+       # Decrement the counter by {@code n}, default by one.
+       #
+       # @param n the amount by which the counter will be decreased
+       def dec(n = 1)
+         @count.add(-n)
+       end
+
+       # Returns the counter's current value.
+       #
+       # @return the counter's current value
+       def count
+         @count.sum
+       end
+    end
+  end
+end

data/lib/leafy/core/ewma.rb

@@ -0,0 +1,95 @@
+require 'concurrent/thread_safe/util/volatile'
+require_relative 'adder'
+
+# An exponentially-weighted moving average.
+#
+# @see <a href="http://www.teamquest.com/pdfs/whitepaper/ldavg1.pdf">UNIX Load Average Part 1: How
+# It Works</a>
+# @see <a href="http://www.teamquest.com/pdfs/whitepaper/ldavg2.pdf">UNIX Load Average Part 2: Not
+# Your Average Average</a>
+# @see <a href="http://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average">EMA</a>
+module Leafy
+  module Core
+    class EWMA
+      extend Concurrent::ThreadSafe::Util::Volatile
+      
+      INTERVAL = 5 # 5 nanos
+      FIVE_NANOS = INTERVAL * 1000000000.0 # 5 nanos
+      ONE_NANOS = 1000000000.0 # 1 nanos
+      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)
+
+      # Creates a new EWMA which is equivalent to the UNIX one minute load average and which expects
+      # to be ticked every 5 seconds.
+      #
+      # @return a one-minute EWMA
+      def self.oneMinuteEWMA
+        EWMA.new(M1_ALPHA);
+      end
+
+      # Creates a new EWMA which is equivalent to the UNIX five minute load average and which expects
+      # to be ticked every 5 seconds.
+      #
+      # @return a five-minute EWMA
+      def self.fiveMinuteEWMA
+        EWMA.new(M5_ALPHA);
+      end
+
+      # Creates a new EWMA which is equivalent to the UNIX fifteen minute load average and which
+      # expects to be ticked every 5 seconds.
+      #
+      # @return a fifteen-minute EWMA
+      def self.fifteenMinuteEWMA
+        EWMA.new(M15_ALPHA);
+      end
+
+      attr_volatile :initialized, :rate
+
+      # Create a new EWMA with a specific smoothing constant.
+      #
+      # @param alpha        the smoothing constant
+      # @param interval     the expected tick interval
+      # @param intervalUnit the time unit of the tick interval
+      def initialize(alpha)
+        @alpha = alpha;
+        @initialized = false # volatile
+        @rate = 0.0 # volatile
+        @uncounted = Adder.new
+      end
+
+      # Update the moving average with a new value.
+      #
+      # @param n the new value
+      def update(n)
+        @uncounted.add(n)
+      end
+
+      # Mark the passage of time and decay the current rate accordingly.
+      def tick
+        count = @uncounted.sum_then_reset# @uncounted = 0 # uncounted.sumThenReset();
+        instantRate = count / FIVE_NANOS;
+        if @initialized
+          oldRate = @rate
+          @rate = oldRate + (@alpha * (instantRate - oldRate))
+        else 
+          @rate = instantRate
+          @initialized = true
+        end
+        self
+      end
+
+      # Returns the rate in the given units of time.
+      #
+      # @param rateUnit the unit of time
+      # @return the rate
+      def rate
+        @rate * ONE_NANOS
+      end
+    end
+  end
+end

data/lib/leafy/core/gauge.rb

@@ -0,0 +1,26 @@
+# A gauge.
+module Leafy
+  module Core
+    class Gauge
+      include Concurrent::Synchronization::Volatile
+
+      attr_volatile :val
+
+      def initialize(&block)
+        @block = block
+      end
+
+      def value=(v)
+        self.val = v
+      end
+
+      def value
+        if @block
+          @block.call
+        else
+          self.val
+        end
+      end
+    end
+  end
+end

data/lib/leafy/core/histogram.rb

@@ -0,0 +1,40 @@
+require 'concurrent/thread_safe/util/adder'
+
+module Leafy
+  module Core
+
+    # A metric which calculates the distribution of a value.
+    #
+    # @see <a href="http://www.johndcook.com/standard_deviation.html">Accurately computing running
+    # variance</a>
+    class Histogram
+
+      # Creates a new {@link Histogram} with the given reservoir.
+      #
+      # @param reservoir the reservoir to create a histogram from
+      def initialize(reservoir)
+        @reservoir = reservoir
+        @count = Concurrent::ThreadSafe::Util::Adder.new
+      end
+
+      # Adds a recorded value.
+      #
+      # @param value the length of the value
+      def update(value)
+        @count.increment
+        @reservoir.update(value)
+      end
+
+      # Returns the number of values recorded.
+      #
+      # @return the number of values recorded
+      def count
+        @count.sum
+      end
+
+      def snapshot
+        @reservoir.snapshot
+      end
+    end
+  end
+end

data/lib/leafy/core/meter.rb

@@ -0,0 +1,92 @@
+require_relative 'clock'
+require_relative 'ewma'
+require 'concurrent/thread_safe/util/adder'
+require 'concurrent/atomic/atomic_fixnum'
+
+# A meter metric which measures mean throughput and one-, five-, and fifteen-minute
+# exponentially-weighted moving average throughputs.
+#
+# @see EWMA
+module Leafy
+  module Core
+    class Meter
+
+      TICK_INTERVAL = 5 * 1000 * 1000 * 1000 # 5 Nano-Seconds
+
+      # Creates a new {@link Meter}.
+      # @param clock the clock to use for the meter ticks
+      def initialize(clock = Clock.default_clock)
+        @clock = clock;
+        @startTime = clock.tick
+        @lastTick = Concurrent::AtomicFixnum.new(@startTime)#AtomicLong.new(startTime)
+        @count = Adder.new
+
+        @m1Rate = EWMA.oneMinuteEWMA
+        @m5Rate = EWMA.fiveMinuteEWMA
+        @m15Rate = EWMA.fifteenMinuteEWMA
+      end
+
+      # Mark the occurrence of an event.
+      def mark(n = 1)
+        tickIfNecessary
+        @count.add(n)
+        @m1Rate.update(n)
+        @m5Rate.update(n)
+        @m15Rate.update(n)
+        n
+      end
+
+
+      def count
+        @count.sum
+      end
+
+
+      def fifteen_minute_rate
+        tickIfNecessary
+        @m15Rate.rate
+      end
+
+
+      def five_minute_rate
+        tickIfNecessary
+        @m5Rate.rate
+      end
+
+
+      def one_minute_rate
+        tickIfNecessary
+        @m1Rate.rate
+      end
+
+
+      def mean_rate
+        if count == 0
+          0.0
+        else
+          elapsed = @clock.tick - @startTime
+          count * 1000000000.0 / elapsed
+        end
+      end
+
+      private
+
+      def tickIfNecessary
+        oldTick = @lastTick.value #.get
+        newTick = @clock.tick
+        age = newTick - oldTick
+        if age > TICK_INTERVAL
+          newIntervalStartTick = newTick - age % TICK_INTERVAL
+          if (@lastTick.compare_and_set(oldTick, newIntervalStartTick))
+            requiredTicks = age / TICK_INTERVAL
+            requiredTicks.to_i.times do
+              @m1Rate.tick
+              @m5Rate.tick
+              @m15Rate.tick
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leafy/core/metric_registry.rb

@@ -0,0 +1,213 @@
+require 'concurrent/map'
+require_relative 'ratio_gauge'
+require_relative 'counter'
+require_relative 'meter'
+require_relative 'histogram'
+require_relative 'timer'
+
+module Leafy
+  module Core
+
+    # A registry of metric instances.
+    class MetricRegistry
+
+      # Creates a new {@link MetricRegistry}.
+      def initialize
+        @metrics = build_map
+      end
+
+      # Creates a new {@link ConcurrentMap} implementation for use inside the registry. Override this
+      # to create a {@link MetricRegistry} with space- or time-bounded metric lifecycles, for
+      # example.
+      #
+      # @return a new {@link ConcurrentMap}
+      def build_map
+        Concurrent::Map.new
+      end
+
+      # Given a {@link Metric}, registers it under the given name.
+      #
+      # @param name   the name of the metric
+      # @param metric the metric
+      # @param <T>    the type of the metric
+      # @return {@code metric}
+      # @throws IllegalArgumentException if the name is already registered
+      def register(name, metric)
+        existing = @metrics.put_if_absent(name, metric)
+        if existing
+          raise ArgumentError.new("A metric named #{name} already exists")
+        end
+        metric
+      end
+
+      # Return the {@link Gauge} registered under this name or create and register
+      # a new {@link Gauge} if none is registered.
+      #
+      # @param name the name of the metric
+      # @param supplier a Builder that can be used to manufacture a Gauge
+      # @return a new or pre-existing {@link Gauge}
+      def gauge(name, builder)
+        getOrAdd(name, builder)
+      end
+
+      # Return the {@link Counter} registered under this name or create and register
+      # a new {@link Counter} if none is registered.
+      #
+      # @param name the name of the metric
+      # @return a new or pre-existing {@link Counter}
+      def counter(name)
+        getOrAdd(name, Builder.counters)
+      end
+
+      # Return the {@link Histogram} registered under this name or create and register
+      # a new {@link Histogram} if none is registered.
+      #
+      # @param name the name of the metric
+      # @return a new or pre-existing {@link Histogram}
+      def histogram(name)
+        getOrAdd(name, Builder.histograms)
+      end
+
+      # Return the {@link Meter} registered under this name or create and register
+      # a new {@link Meter} if none is registered.
+      #
+      # @param name the name of the metric
+      # @return a new or pre-existing {@link Meter}
+      def meter(name)
+        getOrAdd(name, Builder.meters)
+      end
+
+      # Return the {@link Timer} registered under this name or create and register
+      # a new {@link Timer} if none is registered.
+      #
+      # @param name the name of the metric
+      # @return a new or pre-existing {@link Timer}
+      def timer(name)
+        getOrAdd(name, Builder.timers)
+      end
+
+      # Removes the metric with the given name.
+      #
+      # @param name the name of the metric
+      # @return whether or not the metric was removed
+      #/
+      def remove(name)
+        metric = @metrics.delete(name)
+        metric != nil
+      end
+
+      # Returns a set of the names of all the metrics in the registry.
+      #
+      # @return the names of all the metrics
+      def names
+        @metrics.keys.dup.freeze
+      end
+
+      # Returns a map of all the gauges in the registry and their names.
+      #
+      # @return all the gauges in the registry
+      def gauges
+        metrics(Gauge)
+      end
+
+      # Returns a map of all the counters in the registry and their names.
+      #
+      # @return all the counters in the registry
+      def counters
+        metrics(Counter)
+      end
+
+      # Returns a map of all the histograms in the registry and their names.
+      #
+      # @return all the histograms in the registry
+      def histograms
+        metrics(Histogram)
+      end
+
+      # Returns a map of all the meters in the registry and their names.
+      #
+      # @return all the meters in the registry
+      def meters 
+        metrics(Meter)
+      end
+
+      # Returns a map of all the timers in the registry and their names.
+      #
+      # @return all the timers in the registry
+      def timers
+        metrics(Timer)
+      end
+
+      def metrics(klass = nil)
+        if klass
+          result = {}
+          @metrics.each do |k,v|
+            result[k] = v if v.is_a?(klass)
+          end
+          result.freeze
+        else
+          Hash[@metrics.keys.zip(@metrics.values)].freeze
+        end
+      end
+      
+      def getOrAdd(name, builder)
+        metric = @metrics[name]
+        if builder.instance?(metric)
+          return metric
+        elsif metric.nil?
+          begin
+            return register(name, builder.new_metric)
+          rescue ArgumentError
+            added = @metrics[name]
+            return added if builder.instance?(added)  
+          end
+        end
+        raise ArgumentError.new("#{name} is already used for a different type of metric")
+      end
+      private :getOrAdd
+      
+      # A quick and easy way of capturing the notion of default metrics.
+      class Builder
+        def initialize(klass, &block)
+          @klass = klass
+          @block = (block || klass.method(:new))
+        end
+
+        def new_metric
+          @block.call
+        end
+
+        def instance?(metric)
+          metric.is_a?(@klass)
+        end
+
+        class << self
+
+          def counters
+            @counters ||= Builder.new(Counter)
+          end
+          
+          def histograms
+            @histograms ||= begin
+                              builder = Builder.new(Histogram)
+                              def builder.new_metric
+                                Histogram.new(SlidingWindowReservoir.new(16))
+                              end
+                              builder
+                            end
+          end
+
+          def meters
+            @meters ||= Builder.new(Meter)
+          end
+      
+          def timers
+            @timers ||= Builder.new(Timer)
+          end
+        end
+      end
+      
+    end
+  end
+end
+