stella 0.8.1.002 → 0.8.2.001

data/.gitignore

@@ -0,0 +1,2 @@
+.stella
+tmp

data/.gitmodules

@@ -0,0 +1,4 @@
+[submodule "vendor/useragent"]
+	path = vendor/useragent
+	url = git://github.com/delano/useragent.git
+

data/CHANGES.txt

@@ -3,7 +3,6 @@ STELLA, CHANGES
 #### 0.8.X (XXXX-XX-XX) ###############################
 
 * TODO: Force response block content type. 
-* TODO: Add assert methods to response blocks (reconsider)
 * TODO: Add option to dump full request/response output to a file by client
 * TODO: review cookie handling. Not always sent automatically. 
 * TODO: review :variables in URI elements
@@ -11,6 +10,21 @@ STELLA, CHANGES
 * TODO: request block conditions. 
 * TODO: process templates for calls to set in get blocks
 
+
+#### 0.8.2 (2010-03-05) ###############################
+
+* FIXED: Misc issues with usage via module (Stella::Engine.load)
+* CHANGE: Remove all logs except summary and exceptions
+* CHANGE: Renamed .stella/logs/latest/request-exceptions to .stella/logs/latest/exceptions
+* CHANGE: Removed unused Load implementations and renamed LoadQueue to Load
+* CHANGE: Added proper names for statistics (response_time instead of do_request)
+* CHANGE: Benelux 0.5.8 dependency
+* CHANGE: Cleaned up generate mode CLI output
+* CHANGE: Removed no-logging option
+* CHANGE: Renamed Testrun#summary to Testrun#stats
+* ADDED: JSON statistics log (.stella/logs/latest/stats)
+
+
 #### 0.8.1.002 (2010-02-20) ###############################
 
 * FIXED: fail on connection error

data/Rakefile

@@ -1,46 +1,48 @@
+require "rubygems"
+require "rake"
+require "rake/rdoctask"
+require "rake/clean"
+require 'yaml'
 
-require 'rake/clean'
-require 'rake/gempackagetask'
-require 'rake/testtask'
-require 'rake/runtest'
-require 'fileutils'
-include FileUtils
- 
-task :default => :test
+config = YAML.load_file("VERSION.yml")
+task :default => ["build"]
+CLEAN.include [ 'pkg', 'doc', 'rdoc', 'coverage*' ]
 
 begin
-  require 'hanna/rdoctask'
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}.#{config[:BUILD]}"
+    gem.name = "stella"
+    gem.rubyforge_project = gem.name
+    gem.summary = "Blame Stella for breaking your web application!"
+    gem.description = "Blame Stella for breaking your web application!"
+    gem.email = "delano@solutious.com"
+    gem.homepage = "http://blamestella.com/"
+    gem.authors = ["Delano Mandelbaum"]
+    gem.add_dependency("gibbler",    ">= 0.7.4")
+    gem.add_dependency("drydock",    ">= 0.6.9")
+    gem.add_dependency("benelux",    ">= 0.5.8")
+    gem.add_dependency('sysinfo',    '>= 0.7.3')
+    gem.add_dependency('storable',   '>= 0.6.3')
+    gem.add_dependency("nokogiri")
+
+    #gem.add_development_dependency("rspec", ">= 1.2.9")
+    #gem.add_development_dependency("mocha", ">= 0.9.8")
+  end
+  Jeweler::GemcutterTasks.new
 rescue LoadError
-  require 'rake/rdoctask'
-end
-
-# PACKAGE =============================================================
-
-name = "stella"
-load "#{name}.gemspec"
-
-version = @spec.version
-
-Rake::GemPackageTask.new(@spec) do |p|
-  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
-end
-
-task :test do
-  puts "Success!"
-end
-
-task :release => [ "publish:gem", :clean, "publish:rdoc" ] do
-  $: << File.join(File.dirname(__FILE__), 'lib')
-  require "rudy"
-  abort if Drydock.debug?
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-task :install => [ :rdoc, :package ] do
-	sh %{sudo gem install pkg/#{name}-#{version}.gem}
-end
 
-task :uninstall => [ :clean ] do
-	sh %{sudo gem uninstall #{name}}
+Rake::RDocTask.new do |rdoc|
+  version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}.#{config[:BUILD]}"
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "stella #{version}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("LICENSE.txt")
+  rdoc.rdoc_files.include("bin/*.rb")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
 
@@ -60,20 +62,5 @@ task 'publish:gem' => [:package] do |t|
 end
 
 
-Rake::RDocTask.new do |t|
-	t.rdoc_dir = 'doc'
-	t.title    = @spec.summary
-	t.options << '--line-numbers' <<  '-A cattr_accessor=object'
-	t.options << '--charset' << 'utf-8'
-	t.rdoc_files.include('LICENSE.txt')
-	t.rdoc_files.include('README.md')
-	t.rdoc_files.include('CHANGES.txt')
-	#t.rdoc_files.include('Rudyfile')  # why is the formatting f'd?
-	t.rdoc_files.include('bin/*')
-	t.rdoc_files.include('lib/**/*.rb')
-end
-
-CLEAN.include [ 'pkg', '*.gem', '.config', 'doc', 'coverage*' ]
-
 
 

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:MAJOR: 0
+:MINOR: 8
+:PATCH: 2
+:BUILD: '001'

data/bin/stella

@@ -46,7 +46,6 @@ class Stella::CLI::Definition
   global :'with-header', "Include X-Stella-ID request header" 
   global :'with-param', "Include __stella query parameter header"
   global :R, :remote
-  global :E, :engine, String, "Specify a load engine (experimental)"
   global :o, :output, String, "Write output to the given file" do |v|
     String.disable_color
     Stella.log.output = v
@@ -65,9 +64,6 @@ class Stella::CLI::Definition
   global :'no-stats', "Disable stat collection" do
     true
   end
-  global :'no-logging', "Disable all logging" do
-    Stella::Logger.disable!
-  end
   global :'no-templates', "Disable template parsing" do
     true
   end

data/lib/stella.rb

@@ -19,19 +19,21 @@ require 'proc_source'
 
 module Stella
   module VERSION
-    unless defined?(MAJOR)
-      MAJOR = 0.freeze
-      MINOR = 8.freeze
-      TINY  = 1.freeze
-      PATCH = '002'.freeze 
+    def self.to_s
+      load_config
+      [@version[:MAJOR], @version[:MINOR], @version[:PATCH]].join('.')
+    end
+    def self.inspect
+      load_config
+      [@version[:MAJOR], @version[:MINOR], @version[:PATCH], @version[:BUILD]].join('.')
+    end
+    def self.load_config
+      require 'yaml'
+      @version ||= YAML.load_file(File.join(STELLA_LIB_HOME, '..', 'VERSION.yml'))
     end
-    def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
-    def self.to_f; self.to_s.to_f; end
-    def self.patch; PATCH; end
   end
 end
 
-
 module Stella
   class Error < RuntimeError
     def initialize(obj=nil); @obj = obj; end
@@ -79,7 +81,7 @@ module Stella
     attr_accessor :log, :stdout
   end
   
-  def le(*msg); stdout.info "  " << msg.join("#{$/}  ").color(:red); end
+  def le(*msg); stdout.info "  " << msg.join("#{$/}  ").colour(:red); end
   def ld(*msg)
     return unless Stella.debug?
     prefix = "D(#{Thread.current.object_id}):  "
@@ -99,8 +101,8 @@ module Stella
   def abort!()        @abort =  true  end
   
   def quiet?()        @quiet == true  end
-  def enable_quiet()  @quiet = true   end
-  def disable_quiet() @quiet = false  end
+  def enable_quiet()  @quiet = true; @stdout.disable!;  end
+  def disable_quiet() @quiet = false; @stdout.enable!;  end
   
   def add_global(n,v)
     Stella.ld "SETGLOBAL: #{n}=#{v}"
@@ -120,6 +122,7 @@ module Stella
   autoload :Config, 'stella/config'
   autoload :Data, 'stella/data'
   autoload :Testplan, 'stella/testplan'
+  autoload :Testrun, 'stella/engine'
   autoload :Engine, 'stella/engine'
   autoload :Client, 'stella/client'
   autoload :Service, 'stella/service'

data/lib/stella/cli.rb

@@ -47,16 +47,8 @@ class Stella::CLI < Drydock::Command
     
     connect_service if @global.remote
     
-    case @global.engine
-    when "package"
-      ret = Stella::Engine::LoadPackage.run @testplan, opts
-    when "create" 
-      ret = Stella::Engine::LoadCreate.run @testplan, opts
-    when "em" 
-      ret = Stella::Engine::LoadEventMachine.run @testplan, opts
-    else 
-      ret = Stella::Engine::LoadQueue.run @testplan, opts
-    end
+    ret = Stella::Engine::Load.run @testplan, opts
+    
     Stella.ld "ENGINE: #{@global.engine}: #{ret.class}"
     
     @exit_code = (ret ? 0 : 1)
@@ -122,11 +114,10 @@ class Stella::CLI < Drydock::Command
     else
       opts = {}
       opts[:wait] = @option.wait if @option.wait
-      @testplan = Stella::Testplan.new(@argv, opts)
+      @testplan = Stella::Testplan.new(@argv)
     end
     @testplan.check!  # raise errors, update usecase ratios
     @testplan.freeze  # cascades through usecases and requests
-    Stella.stdout.info2 " #{@option.testplan || @testplan.desc} (#{@testplan.digest})" 
     true
   end
   

data/lib/stella/client.rb

@@ -100,7 +100,6 @@ module Stella
           ret, asset_duration = nil, 0
         rescue => ex
           update(:request_unhandled_exception, usecase, uri, req, params, ex)
-          update(:usecase_error, ex.message, uri, container)
           Benelux.remove_thread_tags :status, :retry, :request, :stella_id
           break
         end

data/lib/stella/common.rb

@@ -7,6 +7,22 @@ $KCODE = "u" if RUBY_VERSION =~ /^1.8/
 
 class String
   
+  def colour(*args)
+    self
+  end
+  
+  def color(*args)
+    self
+  end
+  
+  def att(*args)
+    self
+  end
+  
+  def bright(*args)
+    self
+  end
+  
   def in_seconds
     # "60m" => ["60", "m"]
     q,u = self.scan(/([\d\.]+)([s,m,h])?/).flatten

data/lib/stella/engine.rb

@@ -58,6 +58,9 @@ module Stella::Engine
     end
     
     def process_options!(plan, opts={})
+      # Plan must be frozen before running (see freeze methods)
+      plan.frozen? || plan.freeze  
+      
       opts = {
         :hosts          => [],
         :clients        => 1,
@@ -67,7 +70,19 @@ module Stella::Engine
         :repetitions    => 1
       }.merge! opts
       
-      Stella.stdout.info2 " Options: #{opts.inspect}"
+      Stella.ld " Options: #{opts.inspect}"
+      
+      unless Array === opts[:hosts]
+        opts[:hosts] = [opts[:hosts]]
+      end
+      
+      opts[:hosts].collect! do |host|
+        if URI::Generic === host
+          host
+        else
+          URI.parse host
+        end
+      end
       
       opts[:clients] = plan.usecases.size if opts[:clients] < plan.usecases.size
       
@@ -104,22 +119,18 @@ module Stella::Engine
   end
   
   autoload :Functional, 'stella/engine/functional'
-  autoload :Load, 'stella/engine/loadbase'
-  autoload :LoadPackage, 'stella/engine/load_package'
-  autoload :LoadCreate, 'stella/engine/load_create'
-  autoload :LoadQueue, 'stella/engine/load_queue'
-  autoload :LoadEventMachine, 'stella/engine/load_em'
+  autoload :Load, 'stella/engine/load'
   
   # These timers are interesting from a reporting perspective.
   Benelux.add_counter    Stella::Client, :execute_response_handler
-  Benelux.add_timer          HTTPClient, :do_request
+  Benelux.add_timer          HTTPClient, :do_request, :response_time
   ## These are contained in connect
   #Benelux.add_timer HTTPClient::Session, :create_socket
   #Benelux.add_timer HTTPClient::Session, :create_ssl_socket
-  Benelux.add_timer HTTPClient::Session, :connect
-  Benelux.add_timer HTTPClient::Session, :query
-  Benelux.add_timer HTTPClient::Session, :socket_gets_first_byte
-  Benelux.add_timer HTTPClient::Session, :get_body
+  Benelux.add_timer HTTPClient::Session, :connect, :socket_connect
+  Benelux.add_timer HTTPClient::Session, :query, :send_request
+  Benelux.add_timer HTTPClient::Session, :socket_gets_first_byte, :first_byte
+  Benelux.add_timer HTTPClient::Session, :get_body, :receive_response
 
 end
 
@@ -128,7 +139,7 @@ class Stella::Testrun < Storable
   attic :remote_digest
   field :samples => Array
   field :plan
-  field :summary
+  field :stats
   field :hosts
   field :events
   field :mode  # (f)unctional or (l)oad
@@ -139,24 +150,28 @@ class Stella::Testrun < Storable
   field :nowait => Integer
   def initialize(plan, events, opts={})
     @plan, @events = plan, events
-    @samples, @summary = nil, nil
+    @samples, @stats = nil, nil
     opts.each_pair do |n,v|
       self.send("#{n}=", v) if has_field? n
     end
     reset
   end
   
+  def save(path)
+    Stella::Utils.write_to_file(path, self.to_json, 'w', 0644) 
+  end
+  
   def reset
     @samples = []
-    @summary = { :summary => {} }
+    @stats = { :summary => {} }
     @plan.usecases.each do |uc|
       @events.each do |event|
-        @summary[:summary][event] = Benelux::Stats::Calculator.new
-        @summary[uc.digest] ||= { :summary => {} }
-        @summary[uc.digest][:summary][event] = Benelux::Stats::Calculator.new
+        @stats[:summary][event] = Benelux::Stats::Calculator.new
+        @stats[uc.digest] ||= { :summary => {} }
+        @stats[uc.digest][:summary][event] = Benelux::Stats::Calculator.new
         uc.requests.each do |req|
-          @summary[uc.digest][req.digest] ||= {}
-          @summary[uc.digest][req.digest][event] = Benelux::Stats::Calculator.new
+          @stats[uc.digest][req.digest] ||= {}
+          @stats[uc.digest][req.digest][event] = Benelux::Stats::Calculator.new
         end
       end
     end
@@ -182,9 +197,9 @@ class Stella::Testrun < Storable
           stats = tl.stats.group(event)[filter].merge
           sam.stats[uc.digest][req.digest][event] = stats
           # Tally request, usecase and total summaries at the same time. 
-          @summary[uc.digest][req.digest][event] += stats
-          @summary[uc.digest][:summary][event] += stats
-          @summary[:summary][event] += stats
+          @stats[uc.digest][req.digest][event] += stats
+          @stats[uc.digest][:summary][event] += stats
+          @stats[:summary][event] += stats
         end
       end
     end
@@ -193,13 +208,14 @@ class Stella::Testrun < Storable
     
     begin
       if Stella::Engine.service
-        Stella::Engine.service.testrun_stats @summary, @samples
+        Stella::Engine.service.testrun_stats @stats, @samples
       end
     rescue => ex
       Stella.stdout.info "Error syncing to #{Stella::Engine.service.source}"
       Stella.stdout.info ex.message, ex.backtrace if Stella.debug?
     end
     
+    sam
   end
   
   

data/lib/stella/engine/functional.rb

@@ -7,7 +7,6 @@ module Stella::Engine
     def run(plan, opts={})
       opts = process_options! plan, opts
       
-      Stella.ld "OPTIONS: #{opts.inspect}"
       Stella.stdout.info2 "Hosts: " << opts[:hosts].join(', ') if !opts[:hosts].empty?
       
       client = Stella::Client.new opts[:hosts].first, 1, opts
@@ -15,7 +14,7 @@ module Stella::Engine
             
       client.enable_nowait_mode if opts[:nowait]
       
-      @testrun = Stella::Testrun.new plan, [:do_request, :failed], opts
+      @testrun = Stella::Testrun.new plan, [:response_time, :failed], opts
       @testrun.mode = 'f'      
       
       if Stella::Engine.service
@@ -60,7 +59,7 @@ module Stella::Engine
         @testrun.add_sample 1, 1, tt
       end
       
-      @testrun.summary[:summary][:failed].n == 0 
+      @testrun.stats[:summary][:failed].n == 0 
     end