leafy 0.0.3 → 0.1.0

data/lib/leafy/core/ratio_gauge.rb

@@ -0,0 +1,56 @@
+require_relative 'gauge'
+
+# A gauge which measures the ratio of one value to another.
+#
+# If the denominator is zero, not a number, or infinite, the resulting ratio is not a number.
+module Leafy
+  module Core
+    class RatioGauge < Gauge
+
+      # A ratio of one quantity to another.
+      class Ratio
+        
+        # Creates a new ratio with the given numerator and denominator.
+        #
+        # @param numerator   the numerator of the ratio
+        # @param denominator the denominator of the ratio
+        # @return {@code numerator:denominator}
+        def self.of(numerator, denominator)
+          Ratio.new(numerator, denominator)
+        end
+
+        def initialize(numerator, denominator)
+          @numerator = numerator
+          @denominator = denominator
+        end
+        
+        # Returns the ratio, which is either a {@code double} between 0 and 1 (inclusive) or
+        # {@code NaN}.
+        #
+        # @return the ratio
+        def value
+          if !(@denominator.is_a?(Float)) || @denominator.infinite? || @denominator.nan? || @denominator == 0
+            return Float::NAN
+          end
+          @numerator.to_f / @denominator.to_f
+        end
+
+        def to_s
+          "#{@numerator.to_f}:#{@denominator.to_f}"
+        end
+      end
+    
+      # Returns the {@link Ratio} which is the gauge's current value.
+      #
+      # @return the {@link Ratio} which is the gauge's current value
+      def ratio
+        @block.call
+      end
+      protected :ratio
+
+      def value
+        ratio.value
+      end
+    end
+  end
+end

data/lib/leafy/core/scheduled_reporter.rb

@@ -0,0 +1,170 @@
+require 'concurrent/thread_safe/util/cheap_lockable'
+require 'concurrent'
+require_relative 'metric_registry'
+
+module Leafy
+  module Core
+    class ScheduledReporter
+      include Concurrent::ThreadSafe::Util::CheapLockable
+
+      def self.logger(logger = nil)
+        @logger ||= logger || (require 'logger'; Logger.new(STDERR))
+      end
+
+      def logger
+        self.class.logger
+      end
+
+      #FACTORY_ID = Concurrent::AtomicFixnum.new
+      def self.createDefaultExecutor(_name)
+        Concurrent::SingleThreadExecutor.new
+        #return Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory(name + '-' + FACTORY_ID.incrementAndGet()));
+      end
+
+      def initialize(registry, name, executor = nil, shutdownExecutorOnStop = true)
+        super() # for cheap_lockable
+        @registry  = registry;
+        @executor = executor.nil? ? self.class.createDefaultExecutor(name) : executor
+        @shutdownExecutorOnStop = shutdownExecutorOnStop
+        @rateFactor = 1.0
+        @durationFactor = 1000000.0
+      end
+
+      class ReportedTask
+
+        attr_reader :period
+
+        def initialize(reporter, start, period)
+          @reporter = reporter
+          @start = start
+          @period = period
+        end
+
+        def delay
+          @period - (Concurrent.monotonic_time - @start) % @period
+        end
+
+        def call
+          @reporter.report
+        end
+
+        def task(task = nil)
+          @task ||= task
+        end
+
+        def to_s
+          "start: #{Time.at(@start).utc} period: #{@period}"
+        end
+       end
+
+
+      # obserer callback from scheduled task used to trigger the task for the
+      # next report
+      def update(_time, _value, reason)
+        return if reason.is_a? Concurrent::CancelledOperationError
+        cheap_synchronize do
+          raise ArgumentError.new("Reporter not started started") unless @scheduledFuture
+          task = Concurrent::ScheduledTask.new(@scheduledFuture.delay, executor: @executor, &@scheduledFuture.method(:call))
+          task.add_observer(self)
+          task.execute
+        end
+      end
+
+      # Starts the reporter polling at the given period.
+      #
+      # @param initialDelay the time to delay the first execution
+      # @param period       the amount of time between polls
+      # @param unit         the unit for {@code period}
+      def start(initial_delay, period = initial_delay)
+        cheap_synchronize do
+          raise ArgumentError.new("Reporter already started") if @scheduledFuture
+          start = Concurrent.monotonic_time + initial_delay
+
+          @scheduledFuture = ReportedTask.new(self, start, period)
+          task = Concurrent::ScheduledTask.new(initial_delay, executor: @executor, &@scheduledFuture.method(:call))
+          task.add_observer(self)
+          @scheduledFuture.task(task)
+          task.execute
+        end
+      end
+
+      # Stops the reporter and if shutdownExecutorOnStop is true then shuts down its thread of execution.
+      # <p>
+      # Uses the shutdown pattern from http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorService.html
+      def stop
+        if @shutdownExecutorOnStop
+          @executor.shutdown # Disable new tasks from being submitted
+          # Wait a while for existing tasks to terminate
+          unless @executor.wait_for_termination(1)
+            @executor.shutdown # Cancel currently executing tasks
+            # Wait a while for tasks to respond to being cancelled
+            unless @executor.wait_for_termination(1)
+              logger.warn "#{self.class.name}: ScheduledExecutorService did not terminate"
+            end
+          end
+        else
+          # The external manager(like JEE container) responsible for lifecycle of executor
+          cheap_synchronize do
+            return if @scheduledFuture.nil? # was never started
+            return if @scheduledFuture.task.cancelled? # already cancelled
+            # just cancel the scheduledFuture and exit
+            @scheduledFuture.task.cancel
+          end
+        end
+      end
+
+      # Report the current values of all metrics in the registry.
+      def report
+        cheap_synchronize do
+          do_report(@registry.gauges,
+            @registry.counters,
+            @registry.histograms,
+            @registry.meters,
+            @registry.timers)
+        end
+      rescue => ex
+        logger.error("Exception thrown from #{self.class.name}#report. Exception was suppressed: #{ex.message}", e)
+      end
+
+      # Called periodically by the polling thread. Subclasses should report all the given metrics.
+      #
+      # @param gauges     all of the gauges in the registry
+      # @param counters   all of the counters in the registry
+      # @param histograms all of the histograms in the registry
+      # @param meters     all of the meters in the registry
+      # @param timers     all of the timers in tdhe registry
+      def do_report(_gauges,
+                    _counters,
+                    _histograms,
+                    _meters,
+                    _timers)
+        raise 'not implemented'
+      end
+
+
+      def rate_unit
+        'second'
+      end
+      protected :rate_unit
+
+      def duration_unit
+        'milliseconds'
+      end
+      protected :duration_unit
+
+      def convert_duration(duration)
+        duration / @durationFactor;
+      end
+      protected :convert_duration
+
+      def convert_rate(rate)
+        rate * @rateFactor
+      end
+      protected :convert_rate
+
+      def to_s
+        "#{self.class}: #{@scheduledFuture}"
+      end
+    end
+  end
+end

data/lib/leafy/core/sliding_window_reservoir.rb

@@ -0,0 +1,42 @@
+require_relative 'uniform_snapshot'
+require 'concurrent/thread_safe/util/cheap_lockable'
+
+# A {@link Reservoir} implementation backed by a sliding window that stores the last {@code N}
+# measurements.
+module Leafy
+  module Core
+    class SlidingWindowReservoir
+      include Concurrent::ThreadSafe::Util::CheapLockable
+   
+      # Creates a new {@link SlidingWindowReservoir} which stores the last {@code size} measurements.
+      #
+      # @param size the number of measurements to store
+      def initialize(size)
+        super() # for cheap_lockable
+        @measurements = Array.new size
+        @count = 0
+      end
+
+      def size
+        cheap_synchronize do
+          [@count, @measurements.size].min
+        end
+      end
+
+      def update(value)
+        cheap_synchronize do
+          @measurements[(@count % @measurements.size)] = value;
+          @count += 1
+        end
+      end
+
+      def snapshot
+        values = nil
+        cheap_synchronize do
+          values = @measurements.dup
+        end
+        UniformSnapshot.new(*values)
+      end
+    end
+  end
+end

data/lib/leafy/core/snapshot.rb

@@ -0,0 +1,58 @@
+module Leafy
+  module Core
+
+    # A statistical snapshot of a {@link Snapshot}.
+    class Snapshot
+
+      # Returns the value at the given quantile.
+      #
+      # @param quantile a given quantile, in {@code [0..1]}
+      # @return the value in the distribution at {@code quantile}
+      def value(_quantile)
+        raise 'not implemented'
+      end
+
+      # Returns the median value in the distribution.
+      #
+      # @return the median value
+      def median
+        value(0.5)
+      end
+
+      # Returns the value at the 75th percentile in the distribution.
+      #
+      # @the value at the 75th percentile
+      def get_75th_percentile
+        value(0.75)
+      end
+
+      # Returns the value at the 95th percentile in the distribution.
+      #
+      # @the value at the 95th percentile
+      def get_95th_percentile
+        value(0.95)
+      end
+
+      # Returns the value at the 98th percentile in the distribution.
+      #
+      # @the value at the 98th percentile
+      def get_98th_percentile
+        value(0.98)
+      end
+
+      # Returns the value at the 99th percentile in the distribution.
+      #
+      # @the value at the 99th percentile
+      def get_99th_percentile
+        value(0.99)
+      end
+
+      # Returns the value at the 99.9th percentile in the distribution.
+      #
+      # @the value at the 99.9th percentile
+      def get_999th_percentile
+        value(0.999)
+      end
+    end
+  end
+end

data/lib/leafy/core/timer.rb

@@ -0,0 +1,105 @@
+require_relative 'clock'
+require_relative 'meter'
+require_relative 'histogram'
+
+module Leafy
+  module Core
+
+    # A timer metric which aggregates timing durations and provides duration statistics, plus
+    # throughput statistics via {@link Meter}.
+    class Timer
+
+      # A timing context.
+      #
+      # @see Timer#context()
+      class Context
+        def initialize(timer, clock)
+          @timer = timer
+          @clock = clock
+          @startTime = clock.tick
+        end
+
+         # Updates the timer with the difference between current and start time. Call to this method will
+         # not reset the start time. Multiple calls result in multiple updates.
+         #
+         # @return the elapsed time in nanoseconds
+        def stop
+          elapsed = @clock.tick - @startTime
+          @timer.update(elapsed / 1000000000.0)
+          elapsed
+        end
+      end
+
+      # Creates a new {@link Timer} that uses the given {@link Reservoir} and {@link Clock}.
+      #
+      # @param reservoir the {@link Reservoir} implementation the timer should use
+      # @param clock     the {@link Clock} implementation the timer should use
+      def initialize(reservoir = SlidingWindowReservoir, clock = Clock.default_clock)
+        @meter = Meter.new(clock)
+        @clock = clock
+        @histogram = Histogram.new(reservoir)
+      end
+
+      # Adds a recorded duration.
+      #
+      # @param duration the length of the duration in seconds
+      def update(duration)
+        if duration >= 0
+          @histogram.update(duration * 1000000000.0)
+          @meter.mark
+        end
+      end
+
+      # Times and records the duration of event.
+      #
+      # @param event a {@link Runnable} whose {@link Runnable#run()} method implements a process
+      #              whose duration should be timed
+      def time(&block)
+        startTime = @clock.tick
+        begin 
+          block.call
+        ensure
+          update((@clock.tick - startTime) / 1000000000.0)
+        end
+      end
+
+      # Returns a new {@link Context}.
+      #
+      # @return a new {@link Context}
+      # @see Context
+      def context(&block)
+        ctx = Context.new(self, @clock)
+        if block_given?
+          block.call ctx
+          ctx.stop
+        else
+          ctx
+        end
+      end
+
+      def count
+        @histogram.count
+      end
+
+      def fifteen_minute_rate
+        @meter.fifteen_minute_rate
+      end
+
+      def five_minute_rate
+        @meter.five_minute_rate
+      end
+
+      def one_minute_rate
+        @meter.one_minute_rate
+      end
+
+      def mean_rate
+        @meter.mean_rate
+      end
+
+      def snapshot
+        @histogram.snapshot
+      end
+    end
+  end
+end

data/lib/leafy/core/uniform_snapshot.rb

@@ -0,0 +1,114 @@
+require_relative 'snapshot'
+
+# A statistical snapshot of a {@link UniformSnapshot}. 
+module Leafy
+  module Core
+    class UniformSnapshot < Snapshot
+
+      # Create a new {@link Snapshot} with the given values.
+      #
+      # @param values an unordered set of values in the reservoir that can be used by this class directly
+      def initialize(*values)
+        @values = values.dup.compact.sort
+      end
+
+      # Returns the value at the given quantile.
+      #
+      # @param quantile a given quantile, in {@code [0..1]}
+      # @return the value in the distribution at {@code quantile}
+      def value(quantile)
+        if quantile < 0.0 || quantile > 1.0
+            raise ArgumentError.new("#{quantile} is not in [0..1]")
+        end
+
+        return 0.0 if @values.empty?
+        
+        pos = quantile * (values.size + 1)
+        index = pos.to_i
+
+        return @values[0] if index < 1
+        
+        return @values.last if index >= @values.size
+
+        lower = @values[index - 1]
+        upper = @values[index]
+        lower + (pos - pos.floor) * (upper - lower)
+      end
+
+      # Returns the number of values in the snapshot.
+      #
+      # @return the number of values
+      def size
+        @values.size
+      end
+
+      # Returns the entire set of values in the snapshot.
+      #
+      # @return the entire set of values
+      def values
+        @values.dup
+      end
+
+      # Returns the highest value in the snapshot.
+      #
+      # @return the highest value
+      #/
+      def max
+        return 0 if @values.empty?
+        @values.last
+      end
+
+      # Returns the lowest value in the snapshot.
+      #
+      # @return the lowest value
+      def min
+        return 0 if @values.empty?
+        @values.first
+      end
+
+      # Returns the arithmetic mean of the values in the snapshot.
+      #
+      # @return the arithmetic mean
+      def mean
+        return 0 if @values.empty?
+ 
+
+        sum = 0;
+        @values.each do |value|
+          sum += value
+        end
+        sum / @values.size
+      end
+
+      # Returns the standard deviation of the values in the snapshot.
+      #
+      # @return the standard deviation value
+      def std_dev
+        # two-pass algorithm for variance, avoids numeric overflow
+
+        return 0.0 if @values.size <= 1
+        
+        mean = self.mean
+        sum = 0.0
+
+        @values.each do |value|
+          diff = value - mean
+          sum += diff * diff
+        end
+
+        variance = sum / (@values.size - 1)
+        Math.sqrt(variance)
+      end
+
+      # Writes the values of the snapshot to the given stream.
+      #
+      # @param output an output stream
+      def dump(out)
+        @values.each do |value|
+          out.printf("%d\n", value)
+        end
+      end
+    end
+  end
+end
+