hitimes 1.3.0-x64-mingw32

data/ext/hitimes/java/src/hitimes/HitimesService.java

@@ -0,0 +1,16 @@
+package hitimes;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class HitimesService implements BasicLibraryService {
+    public boolean basicLoad( final Ruby runtime ) throws IOException {
+        Hitimes.createHitimesModule( runtime );
+        return true;
+    }
+}
+
+

data/ext/hitimes/java/src/hitimes/HitimesStats.java

@@ -0,0 +1,112 @@
+package hitimes;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+
+import org.jruby.RubyNumeric;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ObjectAllocator;
+
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass( name = "Hitimes::Stats" )
+public class HitimesStats extends RubyObject {
+
+    private double min   = 0.0;
+    private double max   = 0.0;
+    private double sum   = 0.0;
+    private double sumsq = 0.0;
+    private long   count = 0;
+
+    public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new HitimesStats( runtime, klass );
+        }
+    };
+
+    public HitimesStats( Ruby runtime, RubyClass klass ) {
+        super( runtime, klass );
+    }
+
+    @JRubyMethod( name = "update", required = 1, argTypes = RubyNumeric.class )
+    public IRubyObject update( IRubyObject val ) {
+        double v = RubyNumeric.num2dbl( val );
+
+        if ( 0 == this.count ) {
+            this.min = this.max = v;
+        } else {
+            this.min = ( v < this.min ) ? v : this.min;
+            this.max = ( v > this.max ) ? v : this.max;
+        }
+
+        this.count += 1;
+        this.sum   += v;
+        this.sumsq += (v * v);
+
+        return val;
+    }
+
+    @JRubyMethod( name = "mean" )
+    public IRubyObject mean() {
+        double mean = 0.0;
+
+        if ( this.count > 0 ) {
+            mean = this.sum / this.count;
+        }
+
+        return getRuntime().newFloat( mean );
+    }
+
+
+    @JRubyMethod( name = "rate" )
+    public IRubyObject rate() {
+        double rate = 0.0;
+
+        if ( this.sum > 0.0 ) {
+            rate = this.count / this.sum ;
+        }
+
+        return getRuntime().newFloat( rate );
+    }
+
+    @JRubyMethod( name = "stddev" )
+    public IRubyObject stddev() {
+        double stddev = 0.0;
+
+        if ( this.count > 1 ) {
+            double sq_sum = this.sum * this.sum;
+            stddev = Math.sqrt( ( this.sumsq - ( sq_sum / this.count ) ) / ( this.count - 1 ) );
+        }
+        return getRuntime().newFloat( stddev );
+    }
+
+
+    @JRubyMethod( name = "min" )
+    public IRubyObject min() {
+        return getRuntime().newFloat( this.min );
+    }
+
+    @JRubyMethod( name = "max" )
+    public IRubyObject max() {
+        return getRuntime().newFloat( this.max );
+    }
+
+    @JRubyMethod( name = "sum" )
+    public IRubyObject sum() {
+        return getRuntime().newFloat( this.sum );
+    }
+
+    @JRubyMethod( name = "sumsq" )
+    public IRubyObject sumsq() {
+        return getRuntime().newFloat( this.sumsq );
+    }
+
+    @JRubyMethod( name = "count" )
+    public IRubyObject count() {
+        return getRuntime().newFixnum( this.count );
+    }
+}
+
+

data/lib/hitimes.rb

@@ -0,0 +1,66 @@
+#--
+# 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
+
+attempts = [
+  "hitimes/#{RUBY_VERSION.sub(/\.\d+$/,'')}/hitimes",
+  "hitimes/hitimes"
+]
+loaded = false
+
+path_exceptions = []
+attempts.each do |path|
+  begin
+    require path
+    loaded = true
+    break
+  rescue LoadError => load_error
+    full_path = File.expand_path(path)
+    path_exceptions << [ full_path, load_error.message ]
+  end
+end
+
+if !loaded then
+  msg = ["Unable to find binary extension, was hitimes installed correctly? The following paths were tried."]
+  path_exceptions.each do |path, message|
+    msg << "#{path} : #{message}"
+  end
+  raise LoadError, msg.join("\n")
+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/lib/hitimes/metric.rb

@@ -0,0 +1,118 @@
+
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Hitimes
+  #
+  # Metric hold the common meta information for all derived metric classes
+  #
+  # All metrics hold the meta information of:
+  #
+  # * The name of the metric
+  # * The time of day the first measurement is taken
+  # * The time of day the last measurement is taken
+  # * additional data 
+  #
+  # Each derived class is assumed to set the sampling_start_time and
+  # sampling_stop_time appropriately.
+  # 
+  # Metric itself should generally not be used.  Only use the derived classes.
+  #
+  class Metric
+
+    # the number of seconds as a float since the sampling_start_time
+    attr_reader :sampling_delta
+
+    # An additional hash of data to associate with the metric
+    attr_reader :additional_data
+
+    # The 'name' to associate with the metric
+    attr_reader :name
+
+    #
+    # :call-seq:
+    #   Metric.new( 'my_metric' ) -> Metric
+    #   Metric.new( 'my_metric', 'foo' => 'bar', 'this' => 42 ) -> Metric
+    #
+    # Create a new ValueMetric giving it a name and additional data.
+    #
+    # +additional_data+ may be anything that follows the +to_hash+ protocol.
+    # +name+ may be anything that follows the +to_s+ protocol.
+    #
+    def initialize( name, additional_data = {} )
+      @sampling_start_time     = nil
+      @sampling_start_interval = nil
+      @sampling_delta          = 0
+
+      @name                = name.to_s
+      @additional_data     = additional_data.to_hash
+    end
+
+    #
+    # :call-seq: 
+    #   metric.sampling_start_time -> Float or nil
+    #
+    # The time at which the first sample was taken.
+    # This is the number of microseconds since UNIX epoch UTC as a Float
+    #
+    # If the metric has not started measuring then the start time is nil.
+    #
+    def sampling_start_time
+      if @sampling_start_interval then
+        @sampling_start_time ||= self.utc_microseconds()
+      else
+        nil
+      end
+    end
+
+    #
+    # :call-seq:
+    #   metric.sampling_stop_time -> Float or nil
+    #
+    # The time at which the last sample was taken
+    # This is the number of microseconds since UNIX epoch UTC as a Float
+    # 
+    # If the metric has not completely measured at least one thing then 
+    # stop time is nil.
+    #
+    # Because accessing the actual 'time of day' is an expesive operation, we
+    # only get the time of day at the beginning of the first measurement and we
+    # keep track of the offset from that point in @sampling_delta.
+    #
+    # When sampling_stop_time is called, the actual time of day is caculated.
+    #
+    def sampling_stop_time
+      if @sampling_delta > 0 then
+        (self.sampling_start_time + (@sampling_delta * 1_000_000))
+      else 
+        nil
+      end
+    end
+
+    #
+    # :call-seq:
+    #    metric.to_hash -> Hash
+    #    metric.to_hash
+    #
+    # Convert the metric to a Hash.  
+    #
+    def to_hash
+      { 'sampling_start_time' => self.sampling_start_time,
+        'sampling_stop_time'  => self.sampling_stop_time,
+        'additional_data'     => self.additional_data,
+        'name'                => self.name }
+    end
+
+    #
+    # :call-seq:
+    #   metric.utc_microseconds -> Float
+    #
+    # The current time in microseconds from the UNIX Epoch in the UTC
+    #
+    def utc_microseconds
+      Time.now.gmtime.to_f * 1_000_000
+    end
+  end
+end

data/lib/hitimes/mutexed_stats.rb

@@ -0,0 +1,32 @@
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'thread'
+
+module Hitimes
+  #
+  # MutexedStats is the start of a threadsafe Stats class.  Currently, on MRI
+  # Ruby the Stats object is already threadsafe, so there is no need to use
+  # MutexedStats.
+  #
+  class MutexedStats < Stats
+    def initialize
+      @mutex = Mutex.new
+    end
+
+    # call-seq:
+    #   mutex_stat.update( val ) -> nil
+    # 
+    # Update the running stats with the new value in a threadsafe manner.
+    #
+    def update( value )
+      @mutex.synchronize do
+        super( value )
+      end
+    end
+  end
+end
+
+

data/lib/hitimes/paths.rb

@@ -0,0 +1,53 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+#
+module Hitimes
+  #
+  # Access to various paths inside the project programatically
+  #
+  module Paths
+    #   
+    # :call-seq:
+    #    Hitimes::Paths.root_dir -> String
+    #
+    # Returns The full expanded path of the parent directory of +lib+
+    # going up the path from the current file.  A trailing File::SEPARATOR 
+    # is guaranteed.
+    #   
+    def self.root_dir
+      @root_dir ||=(
+        path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
+        lib_index  = path_parts.rindex("lib")
+        @root_dir = path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
+      )
+    end 
+
+    # 
+    # :call-seq:
+    #   Hitimes::Paths.lib_path( *args ) -> String
+    #
+    # Returns The full expanded path of the +lib+ directory below
+    # _root_dir_.  All parameters passed in are joined onto the 
+    # result. A trailing File::SEPARATOR is guaranteed if 
+    # _args_ are *not* present.
+    #   
+    def self.lib_path(*args)
+      self.sub_path("lib", *args)
+    end 
+
+    #
+    # :call-seq:
+    #   Hitimes::Paths.sub_path( sub, *args ) -> String
+    #
+    # Returns the full expanded path of the +sub+ directory below _root_dir.  All
+    # _arg_ parameters passed in are joined onto the result.  A trailing
+    # File::SEPARATOR is guaranteed if _args_ are *not* present.
+    #
+    def self.sub_path(sub,*args)
+      sp = ::File.join(root_dir, sub) + File::SEPARATOR
+      sp = ::File.join(sp, *args) if args
+    end
+  end
+end

data/lib/hitimes/stats.rb

@@ -0,0 +1,58 @@
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'stringio'
+module Hitimes
+  class Stats
+    # A list of the available stats
+    STATS = %w[ count max mean min rate stddev sum sumsq ]
+
+    # 
+    # call-seq:
+    #   stat.to_hash   -> Hash
+    #   stat.to_hash( %w[ count max mean ]) -> Hash
+    #
+    # return a hash of the stats.  By default this returns a hash of all stats
+    # but passing in an array of items will limit the stats returned to only
+    # those in the Array. 
+    #
+    # If passed in an empty array or nil to to_hash then STATS is assumed to be
+    # the list of stats to return in the hash.
+    #
+    def to_hash( *args )
+      h = {}
+      args = [ args ].flatten
+      args = STATS if args.empty?
+      args.each do |meth|
+        h[meth] = self.send( meth )
+      end
+      return h
+    end
+
+    #
+    # call-seq:
+    #   stat.to_json  -> String
+    #   stat.to_json( *args ) -> String
+    #
+    # return a json string of the stats.  By default this returns a json string
+    # of all the stats.  If an array of items is passed in, those that match the
+    # known stats will be all that is included in the json output.
+    #
+    def to_json( *args )
+      h = to_hash( *args )
+      a = []
+      s = StringIO.new
+
+      s.print "{ "
+      h.each_pair do |k,v|
+        a << "\"#{k}\": #{v}"
+      end
+      s.print a.join(", ")
+      s.print "}"
+      return s.string
+    end
+
+  end
+end