scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/timed_metric.rb

@@ -0,0 +1,176 @@
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'forwardable'
+module Hitimes
+  #
+  # A TimedMetric holds the metrics on how long it takes to do something.  For
+  # example, measuring how long a method takes to operate.
+  #
+  #   tm = TimedMetric.new( 'my-method' )
+  #
+  #   200.times do 
+  #     my_method_result = tm.measure do 
+  #       my_method( ... )
+  #     end
+  #   end 
+  #
+  #   puts "#{ tm.name } operated at a rate of #{ tm.rate } calls per second"
+  #
+  # Since TimedMetric is a child class of Metric make sure to look at the
+  # Metric API also.
+  #
+  # A TimedMetric measures the execution time of an option with the Interval
+  # class. 
+  # 
+  # A TimedMetric contains a Stats object, therefore TimedMetric has +count+, +max+, 
+  # +mean+, +min+, +rate+, +stddev+, +sum+, +sumsq+ methods that delegate to that Stats
+  # object for convenience.
+  #
+  #
+  class TimedMetric < Metric
+    # holds all the statistics
+    attr_reader :stats
+
+    class << TimedMetric
+      #
+      # :call-seq:
+      #   TimedMetric.now -> TimedMetric
+      #
+      # Return a TimedMetric that has been started
+      #
+      def now( name, additional_data = {} )
+        t = TimedMetric.new( name, additional_data )
+        t.start
+        return t
+      end
+    end
+
+    #
+    # :call-seq:
+    #   TimedMetric.new( 'name') -> TimedMetric
+    #   TimedMetric.new( 'name', 'other' => 'data') -> TimedMetric
+    #
+    # Create a new TimedMetric giving it a name and additional data.
+    # +additional_data+ may be anything that follows the +to_hash+ protocol
+    #
+    def initialize( name, additional_data = {} )
+      super( name, additional_data )
+      @stats            = Stats.new
+      @current_interval = Interval.new
+    end
+
+    #
+    # :call-seq:
+    #   timed_metric.running? -> true or false
+    #
+    # return whether or not the timer is currently running.  
+    #
+    def running?
+      @current_interval.running?
+    end
+
+    # 
+    # :call-seq:
+    #   timed_metric.start -> nil
+    #
+    # Start the current metric, if the current metric is already started, then
+    # this is a noop.  
+    #
+    def start
+      if not @current_interval.running? then
+        @current_interval.start 
+        @sampling_start_time ||= self.utc_microseconds() 
+        @sampling_start_interval ||= Interval.now
+      end
+      nil
+    end
+
+    #
+    # :call-seq:
+    #   timed_metric.stop -> Float or nil
+    #
+    # Stop the current metric.  This updates the stats and removes the current
+    # interval. If the timer was stopped then the duration of the last Interval
+    # is returned.  If the timer was already stopped then false is returned and
+    # no stats are updated.
+    # 
+    def stop
+      if @current_interval.running? then
+        d = @current_interval.stop
+        @stats.update( d )
+        @current_interval = Interval.new
+
+        # update the length of time we have been sampling
+        @sampling_delta = @sampling_start_interval.duration_so_far
+
+        return d
+      end
+      return false
+    end
+
+    #
+    # :call-seq:
+    #   timed_metric.measure {  ... } -> Object
+    #
+    # Measure the execution of a block and add those stats to the running stats.
+    # The return value is the return value of the block
+    #
+    def measure( &block )
+      return_value = nil
+      begin
+        start
+        return_value = yield
+      ensure
+        stop
+      end
+      return return_value
+    end
+
+    #
+    # :call-seq:
+    #   timed_metric.split -> Float
+    #
+    # Split the current TimedMetric.  Essentially, mark a split time. This means
+    # stop the current interval and create a new interval, but make sure
+    # that the new interval lines up exactly, timewise, behind the previous
+    # interval.
+    #
+    # If the timer is running, then split returns the duration of the previous
+    # interval, i.e. the split-time.  If the timer is not running, nothing
+    # happens and false is returned.
+    #
+    def split  
+      if @current_interval.running? then 
+        next_interval = @current_interval.split
+        d = @current_interval.duration
+        @stats.update( d )
+        @current_interval = next_interval 
+        return d
+      end 
+      return false
+    end
+
+    #
+    # :call-seq:
+    #   metric.to_hash -> Hash
+    #   
+    # Convert the metric to a hash
+    #
+    def to_hash
+      h = super
+      Stats::STATS.each do |s|
+        h[s] = self.send( s ) 
+      end
+      return h
+    end
+
+
+    # forward appropriate calls directly to the stats object
+    extend Forwardable
+    def_delegators :@stats, :count, :max, :mean, :min, :rate, :stddev, :sum, :sumsq
+    alias :duration :sum
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/timed_value_metric.rb

@@ -0,0 +1,233 @@
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Hitimes
+  #
+  # A TimedValueMetric holds the metrics on how long it takes to do a batch of something.
+  # something.  For measuring how long a method takes to operate on N items.
+  #
+  #   tm = TimedValueMetric.new( 'my-batch-method' )
+  #
+  #   42.times do 
+  #     tm.start
+  #     number_of_items_processed = do_something
+  #     tm.stop( number_of_items_processed )
+  #   end
+  #
+  #   puts "#{ tm.name } operated at a rate of #{ tm.rate } calls per second"
+  #
+  # TimedValueMetric combines the usefulness of a ValueMetric and a TimedMetric.
+  # The stats are available for both the time it took to do the operation and
+  # the sizes of the batches that were run.
+  #
+  # A TimedValueMetric keeps track of both the time it took to do an operation
+  # and the size of the batch that was operated on.  These metrics are kept
+  # separately as +timed_stats+ and +value_stats+ accessors.
+  #
+  class TimedValueMetric < Metric
+    # holds all the Timed statistics
+    attr_reader :timed_stats
+
+    # holds all the Value statistics
+    attr_reader :value_stats
+
+    class << TimedValueMetric
+      #
+      # :call-seq:
+      #   TimedValueMetric.now( 'name' ) -> TimedValueMetric
+      #
+      # Return a TimedValueMetric that has been started
+      #
+      def now( name, additional_data = {} )
+        t = TimedValueMetric.new( name, additional_data )
+        t.start
+        return t
+      end
+    end
+
+    #
+    # :call-seq:
+    #   TimedValueMetric.new( 'name') -> TimedValueMetric
+    #   TimedValueMetric.new( 'name', 'other' => 'data') -> TimedValueMetric
+    #
+    # Create a new TimedValueMetric giving it a name and additional data.
+    # +additional_data+ may be anything that follows the +to_hash+ protocol
+    #
+    def initialize( name, additional_data = {} )
+      super( name, additional_data )
+      @timed_stats      = Stats.new
+      @value_stats      = Stats.new
+      @current_interval = Interval.new
+    end
+
+    #
+    # :call-seq:
+    #   timed_value_metric.running? -> true or false
+    #
+    # return whether or not the metric is currently timing something.
+    #
+    def running?
+      @current_interval.running?
+    end
+
+    # 
+    # :call-seq:
+    #   timed_value_metric.start -> nil
+    #
+    # Start the current timer, if the current timer is already started, then
+    # this is a noop.  
+    #
+    def start
+      if not @current_interval.running? then
+        @current_interval.start
+        @sampling_start_time ||= self.utc_microseconds() 
+        @sampling_start_interval ||= Interval.now
+      end
+      nil
+    end
+
+    #
+    # :call-seq:
+    #   timed_value_metric.stop( count ) -> Float or nil
+    #
+    # Stop the current metric.  The +count+ parameter must be a
+    # value to update to the _value_ portion of the TimedValueMetric.  Generally
+    # this is probably the number of things that were operated upon since
+    # +start+ was invoked.
+    #
+    # This updates both the +value_stats+ and +timed_stats+ stats and removes
+    # the current interval. If the metric is stopped then the duration of the
+    # last Interval is returned.  If the metric was already stopped before this
+    # call, then false is returned and no stats are updated.
+    # 
+    #
+    def stop( value )
+      if @current_interval.running? then
+        d = @current_interval.stop
+        @timed_stats.update( d )
+        @current_interval = Interval.new
+        @value_stats.update( value )
+
+        # update the lenght of time we have been sampling
+        @sampling_delta = @sampling_start_interval.duration_so_far
+
+        return d
+      end
+      return false
+    end
+
+    #
+    # :call-seq:
+    #   timed_value_metric.measure( value ) {  ... } -> Object
+    #
+    # Measure the execution of a block and add those stats to the running stats.
+    # The return value is the return value of the block.  A value must be passed
+    # into +measure+ to update the +value_stats+ portion of the TimedValueMetric.
+    #
+    def measure( value, &block )
+      return_value = nil
+      begin
+        start
+        return_value = yield
+      ensure
+        stop( value )
+      end
+      return return_value
+    end
+
+    #
+    # :call-seq:
+    #   timed_value_metric.split( value ) -> Float
+    #
+    # Split the current metric.  Essentially, mark a split time.  This means
+    # stop the current interval, with the givein +value+ and create a new
+    # interval, but make sure that the new interval lines up exactly, timewise,
+    # behind the previous interval.
+    #
+    # If the metric is running, then split returns the duration of the previous
+    # interval, i.e. the split-time.  If the metric is not running, nothing
+    # happens, no stats are updated, and false is returned.  
+    #
+    #
+    def split( value )
+      if @current_interval.running? then 
+        next_interval = @current_interval.split
+        d = @current_interval.duration
+        @timed_stats.update( d )
+        @value_stats.update( value )
+        @current_interval = next_interval 
+        return d
+      end 
+      return false
+    end
+
+    #
+    # :call-seq:
+    #   timed_value_metric.duration -> Float
+    #
+    # The duration of measured time from the metric.
+    #
+    def duration
+      @timed_stats.sum
+    end
+
+    #
+    # :call-seq:
+    #   timed_value_metric.unit_count -> Float
+    #
+    # The sum of all values passed to +stop+ or +skip+ or +measure+
+    #
+    def unit_count
+      @value_stats.sum
+    end
+
+    #
+    # :call-seq:
+    #   timed_value_metric.rate -> Float
+    #
+    # Rate in the context of the TimedValueMetric is different than the
+    # TimedMetric.  In the TimedValueMetric, each measurement of time is
+    # associated with a quantity of things done during that unit of time.  So
+    # the +rate+ for a TimedValueMetric is the (sum of all quantities sampled) /
+    # ( sum of all durations measured )
+    # 
+    # For example, say you were measuring, using a TimedValueMetric batch jobs
+    # that had individual units of work.
+    #
+    #   tvm = TimedValueMetric.new( 'some-batch' )
+    #   tvm.start
+    #   # process a batch of 12 units
+    #   duration1 = tvm.stop( 12 )
+    #
+    #   tvm.start
+    #   # process a larger batch of 42 units
+    #   duration2 = tvm.stop( 42 )
+    #
+    # At this point the rate of units per second is calculated as ( 12 + 42 ) / ( duration1 + duration2 )
+    #
+    #   some_batch_rate = tvm.rate # returns ( 34 / ( duration1+duration2 ) )
+    # 
+    def rate
+      @value_stats.sum / @timed_stats.sum
+    end
+
+    #
+    # :call-seq:
+    #   metric.to_hash -> Hash
+    #   
+    # Convert the metric to a hash
+    #
+    def to_hash
+      h = super
+      h['timed_stats'] = @timed_stats.to_hash
+      h['value_stats'] = @value_stats.to_hash( Stats::STATS - %w[ rate ] )
+      h['rate'] = self.rate
+      h['unit_count'] = self.unit_count
+      return h
+    end
+
+
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/value_metric.rb

@@ -0,0 +1,71 @@
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'forwardable'
+module Hitimes
+  #
+  # A ValueMetric holds the data from measuring a single value over a period of
+  # time.  In most cases this may be a single measurement at a single point in
+  # time.
+  #
+  # A good example of a ValueMetric is measuring the number of items in a queue.
+  #
+  # A ValueMetric contains a Stats object, therefore ValueMetric has +count+, +max+, 
+  # +mean+, +min+, +stddev+, +sum+, +sumsq+ methods that delegate to that Stats
+  # object for convenience.
+  #
+  class ValueMetric < Metric
+
+    # holds all the statistics
+    attr_reader :stats
+    
+    #
+    # :call-seq:
+    #   ValueMetric.new( 'my_metric' ) -> ValueMetric
+    #   ValueMetric.new( 'my_metric', 'foo' => 'bar', 'this' => 42 ) -> ValueMetric
+    #
+    # Create a new ValueMetric giving it a name and additional data.
+    # +additional_data+ may be anything that follows the +to_hash+ protocol.
+    #
+    def initialize( name, additional_data = {} )
+      super( name, additional_data )
+      @stats = Stats.new
+    end
+
+    #
+    # :call-seq:
+    #   metric.measure( value ) -> Float
+    #
+    # Give the +value+ as the measurement to the metric.  The value is returned
+    #
+    def measure( value )
+      @sampling_start_time ||= self.utc_microseconds()
+      @sampling_start_interval ||= Interval.now
+
+      @stats.update( value )
+      
+      # update the length of time we have been sampling
+      @sampling_delta = @sampling_start_interval.duration_so_far
+    end
+
+    #
+    # :call-seq:
+    #   metric.to_hash -> Hash
+    #   
+    # Convert the metric to a hash
+    #
+    def to_hash
+      h = super
+      (Stats::STATS - %w[ rate ]).each do |s|
+        h[s] = self.send( s ) 
+      end
+      return h
+    end
+
+    # forward appropriate calls directly to the stats object
+    extend Forwardable
+    def_delegators :@stats, :count, :max, :mean, :min, :stddev, :sum, :sumsq
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/version.rb

@@ -0,0 +1,8 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details
+#++
+
+module Hitimes
+  VERSION = "1.2.2"
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes.rb

@@ -0,0 +1,47 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+#
+# The top level module containing the contents of the hitimes library
+#
+# use the library with:
+#
+#   require 'hitimes'
+#
+module Hitimes
+  #
+  # Base class of all errors in Hitimes
+  #
+  class Error < ::StandardError; end
+
+  # Hitimes.measure { } -> Float
+  #
+  # Times the execution of the block, returning the number of seconds it took
+  def self.measure(&block)
+    Hitimes::Interval.measure(&block)
+  end
+end
+require 'hitimes/paths'
+require 'hitimes/version'
+
+# Load the binary extension, try loading one for the specific version of ruby
+# and if that fails, then fall back to one in the top of the library.
+# this is the method recommended by rake-compiler
+begin
+  # this will be for windows
+  require "hitimes/#{RUBY_VERSION.sub(/\.\d$/,'')}/hitimes"
+rescue LoadError
+  # everyone else.
+  require 'hitimes/hitimes'
+end
+
+require 'hitimes/stats'
+require 'hitimes/mutexed_stats'
+
+require 'hitimes/metric'
+require 'hitimes/value_metric'
+require 'hitimes/timed_metric'
+require 'hitimes/timed_value_metric'
+

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/hitimes_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Hitimes do
+  it "can time a block of code" do
+    d = Hitimes.measure do
+      sleep 0.2
+    end
+    d.must_be_close_to(0.2, 0.002)
+  end
+
+  it "raises an error if measure is called with no block" do
+    lambda{ Hitimes.measure }.must_raise( Hitimes::Error )
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/interval_spec.rb

@@ -0,0 +1,136 @@
+require "spec_helper"
+
+describe Hitimes::Interval do
+  it "raises an error if duration is called on a non-started interval" do
+    i = Hitimes::Interval.new
+    lambda{ i.duration }.must_raise( Hitimes::Error, /\AAttempt to report a duration on an interval that has not started\Z/ )
+  end
+
+  it "raises an error if stop is called on a non-started interval" do
+    i = Hitimes::Interval.new
+    lambda { i.stop }.must_raise( Hitimes::Error, /\AAttempt to stop an interval that has not started\Z/ )
+  end
+
+  it "knows if it has been started" do
+    i = Hitimes::Interval.new
+    i.started?.must_equal false
+
+    i.start
+    i.started?.must_equal true
+  end
+
+  it "knows if it has been stopped" do
+    i = Hitimes::Interval.new
+    i.start
+    i.stopped?.must_equal false
+    i.stop
+    i.stopped?.must_equal true
+  end
+
+  it "knows if it is currently running" do
+    i = Hitimes::Interval.new
+    i.running?.must_equal false
+    i.start
+    i.running?.must_equal true
+    i.stop
+    i.running?.must_equal false
+  end
+
+  it "can time a block of code" do
+    d = Hitimes::Interval.measure do
+      sleep 0.2
+    end
+    d.must_be_close_to(0.2, 0.002)
+  end
+
+  it "raises an error if measure is called with no block" do
+    lambda{ Hitimes::Interval.measure }.must_raise( Hitimes::Error, /\ANo block given to Interval.measure\Z/ )
+  end
+
+  it "creates an interval via #now" do
+    i = Hitimes::Interval.now
+    i.started?.must_equal true
+    i.stopped?.must_equal false
+  end
+
+  it "calling duration multiple times returns successivly grater durations" do
+    i = Hitimes::Interval.new
+    i.start
+    y = i.duration
+    z = i.duration
+    z.must_be :>, y
+  end
+
+  it "calling start multiple times on has no effect after the first call" do
+    i = Hitimes::Interval.new
+    i.start.must_equal true
+    x = i.start_instant
+    i.start_instant.must_be :>, 0
+    i.start.must_equal false
+    x.must_equal i.start_instant
+  end
+
+  it "returns the duration on the first call to stop" do
+    i = Hitimes::Interval.now
+    d = i.stop
+    d.must_be_instance_of( Float )
+  end
+
+  it "calling stop multiple times on has no effect after the first call" do
+    i = Hitimes::Interval.new
+    i.start.must_equal true
+    i.stop
+
+    x = i.stop_instant
+    i.stop_instant.must_be :>, 0
+    i.stop.must_equal false
+    x.must_equal i.stop_instant
+
+  end
+
+  it "duration does not change after stop is calledd" do
+    i = Hitimes::Interval.new
+    i.start
+    x = i.stop
+    y = i.duration
+    i.stop.must_equal false
+
+    z = i.duration
+
+    x.must_equal y
+    x.must_equal z
+
+    y.must_equal z
+  end
+
+  it "can return how much time has elapsed from the start without stopping the interval" do
+    i = Hitimes::Interval.new
+    i.start
+    x = i.duration_so_far
+    i.running?.must_equal true
+    y = i.duration_so_far
+    i.stop
+    x.must_be :<, y
+    x.must_be :<, i.duration
+    y.must_be :<, i.duration
+  end
+
+  describe "#split" do
+
+    it "creates a new Interval object" do
+      i = Hitimes::Interval.new
+      i.start
+      i2 = i.split
+      i.object_id.wont_equal i2.object_id
+    end
+
+    it "with the stop instant equivialent to the previous Interval's start instant" do
+      i = Hitimes::Interval.new
+      i.start
+      i2 = i.split
+      i.stop_instant.must_equal i2.start_instant
+    end
+  end
+
+end
+