stella 0.5.4 → 0.5.5

data/lib/stella/test/stats.rb

@@ -0,0 +1,114 @@
+
+
+module Stella::Test
+  
+  # Stella::Test::Stats
+  class Stats < Stella::Storable
+
+    field :elapsed_time_avg => Float
+    field :transaction_rate_avg => Float
+    field :vusers_avg => Float
+    field :response_time_avg => Float
+
+    field :elapsed_time_sdev => Float
+    field :transaction_rate_sdev => Float
+    field :vusers_sdev => Float
+    field :response_time_sdev => Float
+
+
+    field :transactions_total => Float
+    field :successful_total => Float
+    field :failed_total => Float
+
+    field :data_transferred_total => Float
+    field :headers_transferred_total => Float
+
+
+    field :elapsed_time_total => Float
+    field :availability => Float
+    field :throughput_avg => Float
+    field :throughput_sdev => Float
+    
+    def availability
+      return 0 if @successful_total == 0
+      begin
+        (@transactions_total / @successful_total).to_f * 100
+      rescue => ex
+        0.0
+      end
+    end
+    
+    
+    attr_reader :runs
+    
+    def initialize(msg="")
+      @message = msg
+      @runs = []
+    end
+    
+    # Add a TestRun object to the list
+    def add_run(run)
+      raise "I got a #{run.class} but I wanted a Run::Summary" unless run.is_a?(Run::Summary)
+      @runs << run
+      calculate
+    end
+    
+    private 
+    def calculate
+      # We simply keep a running tally of these
+      @transactions_total = 0
+      @headers_transferred_total = 0
+      @data_transferred_total = 0
+      @elapsed_time_total = 0
+      @successful_total = 0
+      @failed_total = 0
+      
+      # We keep a list of the values for averaging and std dev
+      elapsed_times = ::Stats.new
+      transaction_rates = ::Stats.new
+      vusers_list = ::Stats.new
+      response_times = ::Stats.new
+      response_time = ::Stats.new
+      transaction_rate = ::Stats.new
+      throughput = ::Stats.new
+      vusers = ::Stats.new
+      
+      # Each run is the summary of a single run (i.e. run01/SUMMARY.csv)
+      runs.each do |run|
+        # These are totaled
+        @transactions_total += run.transactions || 0
+        @headers_transferred_total += run.headers_transferred || 0
+        @data_transferred_total += run.data_transferred || 0
+        @successful_total += run.successful || 0
+        @failed_total += run.failed || 0
+        @elapsed_time_total += run.elapsed_time || 0
+        
+        # These are used for standard deviation
+        elapsed_times.sample(run.elapsed_time)
+        transaction_rates.sample(run.transaction_rate)
+        vusers_list.sample(run.vusers)
+        response_times.sample(run.response_time)
+        throughput.sample(run.throughput)
+        response_time.sample(run.response_time)
+        transaction_rate.sample(run.transaction_rate)
+        vusers.sample(run.vusers)
+      end
+      
+      # Calculate Averages
+      @elapsed_time_avg = elapsed_times.mean
+      @throughput_avg = throughput.mean
+      @response_time_avg = response_time.mean
+      @transaction_rate_avg = transaction_rate.mean
+      @vusers_avg = vusers.mean 
+      
+      # Calculate Standard Deviations
+      @elapsed_time_sdev = elapsed_times.sd
+      @throughput_sdev= throughput.sd
+      @transaction_rate_sdev = transaction_rates.sd
+      @vusers_sdev = vusers_list.sd
+      @response_time_sdev = response_times.sd
+      
+    end
+  end
+  
+end

data/lib/stella/text/resource.rb

@@ -21,7 +21,7 @@ module Stella
       
       def load_resource
         return @messages unless @messages.empty?
-        Stella::LOGGER.debug("LOADING #{path}")
+        #Stella::LOGGER.debug("LOADING #{path}")
         raise UnsupportedLanguage unless File.exists?(path)
         @messages = YAML.load_file(path)
       end

data/lib/stella.rb

@@ -4,6 +4,10 @@ require 'date'
 require 'time'
 require 'tempfile'
 require 'socket'
+require 'ostruct'
+require 'optparse'
+require 'rubygems'
+
 
 # Common utilities
 require 'utils/domainutil'
@@ -11,6 +15,7 @@ require 'utils/httputil'
 require 'utils/fileutil'
 require 'utils/mathutil'
 require 'utils/escape'
+require 'utils/stats'
 
 # Common dependencies
 $: << File.join(STELLA_HOME, 'vendor', 'useragent', 'lib')
@@ -32,7 +37,7 @@ require 'stella/response'
 require 'stella/sysinfo'
 require 'stella/test/definition'
 require 'stella/test/run/summary'
-require 'stella/test/summary'
+require 'stella/test/stats'
 
 # Commands
 require 'stella/command/base'
@@ -56,14 +61,14 @@ module Stella
     # including OS (unix), implementation (freebsd), and architecture (x64)
   SYSINFO = Stella::SystemInfo.new unless defined? SYSINFO
     # A global logger for info, error, and debug messages. 
-  LOGGER = Stella::Logger.new(:debug=>true) unless defined? LOGGER
+  LOGGER = Stella::Logger.new(:debug=>false) unless defined? LOGGER
     # A global resource for all interface text. 
   TEXT = Stella::Text.new('en') unless defined? TEXT
   
   module VERSION #:nodoc:
     MAJOR = 0.freeze unless defined? MAJOR
     MINOR = 5.freeze unless defined? MINOR
-    TINY  = 4.freeze unless defined? TINY
+    TINY  = 5.freeze unless defined? TINY
     def self.to_s
       [MAJOR, MINOR, TINY].join('.')
     end
@@ -71,6 +76,26 @@ module Stella
       self.to_s.to_f
     end
   end
-
+  
+  def self.debug=(enable=false)
+    Stella::LOGGER.debug_level = enable
+  end
+  
+  def self.text(*args)
+    TEXT.msg(*args)
+  end
+  
+  def self.sysinfo
+    SYSINFO
+  end
+  
+  def self.info(*args)
+    LOGGER.info(*args)
+  end
+  
+  def self.error(*args)
+    LOGGER.error(*args)
+  end
+  
 end
 

data/lib/utils/mathutil.rb

@@ -2,30 +2,6 @@
 
 module MathUtil
   
-  def self.variance(population)
-    n = 0
-    mean = 0.0
-    s = 0.0
-    
-    population.each { |x|
-      n = n + 1
-      delta = (x - mean).to_f
-      mean = (mean + (delta / n)).to_f
-      s = (s + delta * (x - mean)).to_f
-    }
-    
-    s / n
-  rescue => ex
-    0.0
-  end
-
-  # calculate the standard deviation of a population
-  # accepts: an array, the population
-  # returns: the standard deviation
-  def self.standard_deviation(population)
-    Math.sqrt(variance(population))
-  end
-  
   # enforce_limit
   #
   # Enforce a minimum and maximum value 
@@ -37,55 +13,3 @@ module MathUtil
   
 end
 
-
-
-
-module Enumerable
-
-    ##
-    # Sum of all the elements of the Enumerable
-
-    def sum
-        return 0 if !self || self.empty?
-        self.inject(0) { |acc, i| acc.to_f + i.to_f }
-    end
-
-    ##
-    # Average of all the elements of the Enumerable
-    #
-    # The Enumerable must respond to #length
-
-    def average
-      return 0 unless self
-      self.sum / self.length.to_f
-    rescue => ex
-      0.0
-    end
-
-    ##
-    # Sample variance of all the elements of the Enumerable
-    #
-    # The Enumerable must respond to #length
-
-    def sample_variance
-      return 0 unless self
-      avg = self.average
-      sum = self.sum
-      (1 / self.length.to_f * sum)
-    rescue => ex
-      0.0
-    end
-
-    ##
-    # Standard deviation of all the elements of the Enumerable
-    #
-    # The Enumerable must respond to #length
-
-    def standard_deviation
-      return 0 unless self
-      Math.sqrt(self.sample_variance)
-    rescue => ex
-      0.0
-    end
-
-end

data/lib/utils/stats.rb

@@ -0,0 +1,88 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+# A very simple little class for doing some basic fast statistics sampling.
+# You feed it either samples of numeric data you want measured or you call
+# Stats.tick to get it to add a time delta between the last time you called it.
+# When you're done either call sum, sumsq, n, min, max, mean or sd to get 
+# the information.  The other option is to just call dump and see everything.
+#
+# It does all of this very fast and doesn't take up any memory since the samples
+# are not stored but instead all the values are calculated on the fly.
+
+class Stats
+  attr_reader :sum, :sumsq, :n, :min, :max
+
+  def initialize(name=:unknown)
+    @name = name
+    reset
+  end
+
+  # Resets the internal counters so you can start sampling again.
+  def reset
+    @sum = 0.0
+    @sumsq = 0.0
+    @last_time = Time.new
+    @n = 0.0
+    @min = 0.0
+    @max = 0.0
+  end
+
+  # Adds a sampling to the calculations.
+  def sample(s)
+    @sum += s
+    @sumsq += s * s
+    if @n == 0
+      @min = @max = s
+    else
+      @min = s if @min > s
+      @max = s if @max < s
+    end
+    (@n+=1).to_f
+  end
+
+  # Dump this Stats object with an optional additional message.
+  def dump(msg = "", out=STDERR)
+    out.puts "#{msg}: #{self.to_s}"
+  end
+
+  # Returns a common display (used by dump)
+  def to_s  
+  "[#{@name}]: SUM=%0.4f, SUMSQ=%0.4f, N=%0.4f, MEAN=%0.4f, SD=%0.4f, MIN=%0.4f, MAX=%0.4f" % [@sum, @sumsq, @n, mean, sd, @min, @max]
+  end
+
+
+  # Calculates and returns the mean for the data passed so far.
+  def mean
+    @sum / @n
+  end
+
+  # Calculates the standard deviation of the data so far.
+  def sd
+    # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
+    begin
+      return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) ).to_f
+    rescue Errno::EDOM
+      return 0.0
+    end
+  end
+
+
+  # Adds a time delta between now and the last time you called this.  This
+  # will give you the average time between two activities.
+  # 
+  # An example is:
+  #
+  #  t = Stats.new("do_stuff")
+  #  10000.times { do_stuff(); t.tick }
+  #  t.dump("time")
+  #
+  def tick
+    now = Time.now
+    sample(now - @last_time)
+    @last_time = now
+  end
+end