benelux 0.2.0.001 → 0.3.0

data/CHANGES.txt

@@ -1,4 +1,8 @@
 BENELUX, CHANGES
 
 
-#### 0.2.0 (2009-09-??) ###############################
+#### 0.3.0 (2009-09-30) ###############################
+
+Initial public release
+
+

data/README.rdoc

@@ -1,10 +1,12 @@
-= Benelux v0.1
+= Benelux v0.3 (IN PROGRESS)
 
-<b></b>
+<b>A madhouse of timers for your Ruby codes</b>
 
 
 == Features
 
+* Create timers for any Ruby method
+* Granular statistics
 
 
 == Installation
@@ -21,6 +23,7 @@ Get it in one of the following ways:
 * Codes[http://github.com/delano/benelux]
 * RDocs[http://delano.github.com/benelux]
 
+
 == Credits
 
 * Delano Mandelbaum (http://solutious.com)
@@ -29,6 +32,7 @@ Get it in one of the following ways:
 == Thanks 
 
 * Alexis Sellier for fielding my Ruby questions
+* Tara Dougans for the motivational speaches
 
 
 == License

data/benelux.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "benelux"
   s.rubyforge_project = 'benelux'
-  s.version = "0.2.0.001"
+  s.version = "0.3.0"
   s.summary = "Benelux: Little freakin' timers for your Ruby codes"
   s.description = s.summary
   s.author = "Delano Mandelbaum"
@@ -26,8 +26,16 @@
   lib/benelux.rb
   lib/benelux/mark.rb
   lib/benelux/mixins/thread.rb
+  lib/benelux/range.rb
+  lib/benelux/stats.rb
+  lib/benelux/tags.rb
   lib/benelux/timeline.rb
-  tryouts/basic_tryouts.rb
+  tryouts/10_stats_tryouts.rb
+  tryouts/11_tags_tryouts.rb
+  tryouts/20_class_methods_tryouts.rb
+  tryouts/30_timeline_tryouts.rb
+  tryouts/proofs/alias_performance.rb
+  tryouts/proofs/timer_threading.rb
   )
 
   

data/lib/benelux.rb

@@ -1,66 +1,110 @@
 require 'attic'
-require 'thread'
 require 'hexoid'
+require 'thread'
 
 module Benelux
+  VERSION = "0.3.0"
   NOTSUPPORTED = [Class, Object, Kernel]
-  SUFFIX_START = :a.freeze
-  SUFFIX_END   = :z.freeze
   
-  require 'benelux/timeline'
+  class BeneluxError < RuntimeError; end
+  class NotSupported < BeneluxError; end
+  class NoTrack < BeneluxError; end
+  
+  require 'benelux/tags'
   require 'benelux/mark'
+  require 'benelux/range'
+  require 'benelux/stats'
+  require 'benelux/timeline'
   require 'benelux/mixins/thread'
   
   @@timed_methods = {}
-  @@thread_timelines = []
-  @@timeline = Benelux::Timeline.new
+  @@known_threads = []
+  @@timelines = {}
   @@mutex = Mutex.new
+  @@debug = true
   
-  class BeneluxError < RuntimeError; end
-  class NotSupported < BeneluxError; end
+  def Benelux.enable_debug; @@debug = true; end
+  def Benelux.disable_debug; @@debug = false; end
+  def Benelux.debug?; @@debug; end
   
+  # Returns an Array of method names for the current class that
+  # are timed by Benelux. 
+  #
+  # This is an instance method for objects which have Benelux 
+  # modified methods. 
   def benelux_timers
     Benelux.timed_methods[self.class]
   end
   
-  def Benelux.supported?(klass)
-    !NOTSUPPORTED.member?(klass)
+  def Benelux.timeline(track=nil)
+    if track.nil?
+      if Benelux.timelines.empty?
+        tl = known_threads.collect { |t| t.timeline}
+      else
+        tl = Benelux.timelines.values
+      end
+      Benelux.merge_timelines *tl
+    else
+      Benelux.timelines[track]
+    end
   end
   
-  def Benelux.store_thread_reference
-    return if Benelux.thread_timelines.member? Thread.current
+  # Must be run in single-threaded mode (after all track threads
+  # have finished).
+  #
+  def Benelux.update_all_track_timelines
+    Benelux.timelines.keys.each { |track| Benelux.update_track_timeline(track) }
+  end
+  
+  # Must be run from the master thread in the current track. The master
+  # thread is either the first thread in a track or the one which creates
+  # additional threads for the track. 
+  #
+  def Benelux.update_track_timeline(track=nil)
+    track = Thread.current.track if track.nil?
+    threads = Benelux.known_threads.select { |t| t.track == track }
+    Benelux.timelines[track] = Benelux.merge_timelines(*threads.collect { |t| t.timeline })
+    threads.each { |t| t.timeline.clear }
+    Benelux.timelines[track]
+  end
+  
+  # If +track+ is specified, this will associate the current
+  # thread with that +track+. 
+  #
+  # If +track+ is nil, it returns the timeline for the
+  # track associated to the current thread. 
+  #
+  def Benelux.current_track(track=nil)
+    if track.nil? 
+      raise NoTrack if Benelux.timelines[Thread.current.track].nil?
+      return Benelux.timelines[Thread.current.track] 
+    end
+    Benelux.store_thread_reference
     @@mutex.synchronize do
-      Benelux.thread_timelines << Thread.current
+      # QUESTION: Is it okay for multiple threads to write to
+      # different elements in the same hash?
+      Benelux.timelines[track] ||= Benelux::Timeline.new
+      Benelux.add_thread_tags :track => track
+      Thread.current.track = track
     end
   end
   
-  def Benelux.timed_methods
-    @@timed_methods
-  end
-  
-  def Benelux.thread_timelines
-    @@thread_timelines
-  end
-  
-  def Benelux.timeline
-    @@timeline = Benelux.generate_timeline if @@timeline.empty?
-    @@timeline
-  end
-  
-  def Benelux.generate_timeline
-    @@mutex.synchronize do
-      timeline = Benelux::Timeline.new
-      Benelux.thread_timelines.each { |t| timeline << t.benelux }
-      timeline.flatten.sort
+  # Combine two or more timelines into a new, single Benelux::Timeline.
+  #
+  def Benelux.merge_timelines(*timelines)
+    tl, stats, ranges = Benelux::Timeline.new, Benelux::Stats.new, []
+    timelines.each do |t|
+      tl += t
     end
+    tl
   end
   
-  def Benelux.thread_timeline(thread_id=nil)
-    Thread.current.benelux ||= Benelux::Timeline.new
-    Thread.current.benelux
+  def Benelux.thread_timeline
+    Thread.current.timeline ||= Benelux::Timeline.new
+    Thread.current.timeline
   end
   
-  
+  # Make note of the class which included Benelux. 
   def Benelux.included(klass)
     timed_methods[klass] = [] unless timed_methods.has_key? klass
   end
@@ -75,7 +119,7 @@ module Benelux
     prepare_object klass
     meth_alias = rename_method klass, meth
     timed_methods[klass] << meth
-    klass.module_eval generate_timer_str(meth_alias, meth)
+    klass.module_eval generate_timer_str(meth_alias, meth), __FILE__, 215
   end
   
   def Benelux.add_tally obj, meth
@@ -85,15 +129,75 @@ module Benelux
     names.flatten.collect { |n| n.to_s }.join('_')
   end
   
-  private
+  
   def Benelux.prepare_object obj
     obj.extend Attic  unless obj.kind_of?(Attic)
     unless obj.kind_of?(Benelux)
-      obj.attic :benelux
+      obj.attic :timeline
       obj.send :include, Benelux
     end
   end
+
+  # Benelux keeps track of the threads which have timed
+  # objects so it can process the timelines after all is
+  # said and done. 
+  def Benelux.store_thread_reference
+    return if Benelux.known_threads.member? Thread.current
+    @@mutex.synchronize do
+      Thread.current.timeline ||= Benelux::Timeline.new
+      Benelux.known_threads << Thread.current
+      Benelux.known_threads.uniq!
+    end
+  end
+  
+  # Thread tags become the default for any new Mark or Range. 
+  def Benelux.add_thread_tags(args=Benelux::Tags.new)
+    Benelux.thread_timeline.add_default_tags args
+  end
+  def Benelux.add_thread_tag(*args) add_thread_tags *args end
+  
+  def Benelux.remove_thread_tags(*args)
+    Benelux.thread_timeline.remove_default_tags *args
+  end
+  def Benelux.remove_thread_tag(*args) remove_thread_tags *args end
+  
+  def Benelux.tracks
+    Benelux.timelines.keys
+  end
+  
+  def Benelux.inspect
+    str = ["Benelux"]
+    str << "threads:" << Benelux.known_threads.inspect
+    str << "tracks:" << Benelux.tracks.inspect
+    str << "timers:" << Benelux.timed_methods.inspect
+    str << "timeline:" << Benelux.timeline.inspect
+    str.join $/
+  end
+  
+  def Benelux.supported?(klass)
+    !NOTSUPPORTED.member?(klass)
+  end
+  
+  def Benelux.timed_methods
+    @@timed_methods
+  end
+  
+  def Benelux.known_threads
+    @@known_threads
+  end
   
+  def Benelux.timelines
+    @@timelines
+  end
+  
+  # Rename the method +meth+ in the object +obj+ and return
+  # the new alias. 
+  # 
+  # e.g.
+  #
+  #     Benelux.renamed(SomeClass, :execute) 
+  #       # => __benelux_execute_2151884308_2165479316
+  # 
   def Benelux.rename_method(obj, meth)
     ## NOTE: This is commented out so we can include  
     ## Benelux definitions before all classes are loaded. 
@@ -107,20 +211,29 @@ module Benelux
     end
     meth_alias
   end
-  
+
+  # Creates a method definition (for an `eval` that) for a method
+  # named +meth+ which times a call to +meth_alias+. 
   def Benelux.generate_timer_str(meth_alias, meth)
     %Q{
     def #{meth}(*args, &block)
+      call_id = "" << self.object_id.abs.to_s << args.object_id.abs.to_s
       # We only need to do these things once.
-      if self.benelux.nil?
-        self.benelux = Benelux::Timeline.new
+      if self.timeline.nil?
+        self.timeline = Benelux::Timeline.new
         Benelux.store_thread_reference
       end
-      ref = self.object_id.abs.to_s << args.object_id.abs.to_s
-      self.benelux.add_mark_open ref, :'#{meth}'
+      mark_a = self.timeline.add_mark :'#{meth}_a'
+      mark_a.add_tag :call_id => call_id
+      tags = mark_a.tags
       ret = #{meth_alias}(*args, &block)
-      self.benelux.add_mark_close ref, :'#{meth}'
-      ret
+    rescue => ex
+      raise ex
+    ensure
+      mark_z = self.timeline.add_mark :'#{meth}_z'
+      mark_z.tags = tags # In case tags were added between these marks
+      range = self.timeline.add_range :'#{meth}', mark_a, mark_z
+      range.exception = ex if defined?(ex) && !ex.nil?
     end
     }
   end
@@ -128,3 +241,6 @@ module Benelux
 end
 
 
+
+
+

data/lib/benelux/mark.rb

@@ -1,37 +1,40 @@
 module Benelux
   class Mark < Time
+    include Benelux::TagHelpers
     attr_accessor :name
-    attr_accessor :thread_id
-    attr_accessor :call_id
-    def self.now(n=nil,c=nil,t=nil)
+    def self.now(n=nil)
       v = super()
-      v.name, v.call_id, v.thread_id = n, c, t
+      v.tags = Benelux::Tags.new
+      v.name = n 
       v
     end
+    def track 
+      @tags[:track]
+    end
+    def add_tags(tags=Benelux::Tags.new)
+      @tags.merge! tags
+    end
+    alias_method :add_tag, :add_tags
+    def remove_tags(*tags)
+      @tags.delete_if { |n,v| tags.member?(n) }
+    end
+    alias_method :remove_tag, :remove_tags
     def inspect(reftime=nil)
-      val = reftime.nil? ? self.to_f : (self.to_f - reftime.to_f)
-      args = [self.class, self.hexoid, self.name, val, thread_id, call_id]
-      "#<%s:%s name=%s at=%f thread_id=%s call_id=%s>" % args
+      val = reftime.nil? ? self : (reftime - self)
+      "#<%s:%s at=%f name=%s %s>" % [self.class, hexoid, to_f, name, tags]
     end
     def to_s(reftime=nil)
-      val = reftime.nil? ? self.to_f : (self.to_f - reftime.to_f)
-      val.to_s
+      val = reftime.nil? ? self : (reftime - self)
+      val.to_f.to_s
+    end
+    def distance(time)
+      self - time
     end
     def ==(other)
       return false unless other.respond_to? :call_id
       self.name == other.name &&
-      self.thread_id == other.thread_id &&
-      self.call_id == other.call_id &&
+      self.tags == other.tags &&
       self.to_f == self.to_f
     end
-    def same_timeline?(other)
-      return false unless other.respond_to? :thread_id
-      self.thread_id == other.thread_id
-    end
-    def same_call?(other)
-      return false unless other.respond_to? :call_id
-      self.thread_id == other.thread_id &&
-      self.call_id == other.call_id
-    end
   end
 end

data/lib/benelux/mixins/thread.rb

@@ -2,5 +2,6 @@
 
 class Thread
   extend Attic
-  attic :benelux
+  attic :timeline
+  attic :track
 end

data/lib/benelux/range.rb

@@ -0,0 +1,50 @@
+
+module Benelux
+  class Range
+    include Benelux::TagHelpers
+    
+    attr_accessor :name
+    attr_accessor :from
+    attr_accessor :to
+    attr_accessor :exception
+    def initialize(name,from,to)
+      @name, @from, @to = name, from, to
+      @tags = Benelux::Tags.new
+    end
+    def to_s
+      "%s:%.4f" % [name, duration]
+    end
+    def inspect
+      args = [self.class, hexoid, duration, from, to, name, tags]
+      "#<%s:%s duration=%0.4f from=%s to=%s name=%s %s>" % args
+    end
+
+    def track 
+      @from.nil? ? :unknown : @from.track
+    end
+    def thread_id
+      @from.nil? ? :unknown : @from.thread_id
+    end
+    def call_id
+      @from.nil? ? :unknown : @from.call_id
+    end
+    def successful?
+      @exception.nil?
+    end
+    def failed?
+      !successful?
+    end
+    def duration
+      to - from
+    end
+    def <=>(other)
+      from <=> other.from
+    end
+    def <(other)
+      from < other
+    end
+    def >(other)
+      from > other
+    end
+  end
+end

data/lib/benelux/stats.rb

@@ -0,0 +1,193 @@
+
+module Benelux
+  class Stats
+    attr_reader :names
+    def initialize(*names)
+      @names = []
+      add_keepers names
+    end
+    def get_keeper(name)
+      self.send name
+    end
+    # Each keeper
+    def each(&blk)
+      @names.each { |name| blk.call(get_keeper(name)) }
+    end
+    # Each keeper name, keeper
+    def each_pair(&blk)
+      @names.each { |name| blk.call(name, get_keeper(name)) }
+    end
+    def add_keepers(*args)
+      args.flatten.each do |meth|
+        next if has_keeper? meth
+        @names << meth
+        self.class.send :attr_reader, meth
+        instance_variable_set("@#{meth}", Benelux::Stats::Group.new(meth))
+      end
+    end
+    alias_method :add_keeper, :add_keepers
+    def has_keeper?(name)
+      @names.member? name
+    end
+    def +(other)
+      if !other.is_a?(Benelux::Stats)
+        raise TypeError, "can't convert #{other.class} into Stats" 
+      end
+      other.names.each do |name|
+        add_keeper name
+        a = self.send(name) 
+        a += other.send(name)
+        a
+      end
+      self
+    end
+    
+    class Group < Array
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+      
+      def +(other)
+        unless @name == other.name
+          raise BeneluxError, "Cannot add #{other.name} to #{@name}"
+        end
+        other.each do |newcalc|
+          calcs = self.select { |calc| calc.tags == newcalc.tags }
+          self << newcalc and next if calcs.empty?
+          # This should only ever contain one b/c we should
+          # not have several calculators with the same tags. 
+          calcs.each do |calc|
+            calc += newcalc
+          end
+        end
+        self
+      end
+      
+      def sample(s, tags={})
+        raise BeneluxError, "tags must be a Hash" unless tags.kind_of?(Hash)
+        calcs = self.select { |c| c.tags == tags }
+        if calcs.empty?
+          (c = Calculator.new).add_tags tags
+          self << c
+          calcs = [c]
+        end
+        calcs.each { |c| c.sample(s) }
+        nil
+      end
+      
+      def mean()    merge.mean   end
+      def min()     merge.min    end
+      def max()     merge.max    end
+      def sd()      merge.sd     end
+      def n()       merge.n      end
+      
+      def merge(*tags)
+        tags = Benelux::TagHelpers.normalize tags
+        mc = Calculator.new
+        all = tags.empty? ? self : self.filter(tags)
+        all.each { |calc| 
+          mc.samples calc
+          mc.add_tags calc.tags
+        }
+        mc
+      end
+      
+      def [](*tags)
+        tags = Benelux::TagHelpers.normalize tags
+        g = Benelux::Stats::Group.new @name
+        g << self.select { |c| c.tags >= tags }
+        g.flatten!(1)  # only 1 level deep
+        g
+      end
+      alias_method :filter, :[]
+      
+    end
+    
+    # Based on Mongrel::Stats, Copyright (c) 2005 Zed A. Shaw
+    class Calculator < Array
+      include Benelux::TagHelpers
+      
+      attr_reader :sum, :sumsq, :n, :min, :max
+
+      def initialize
+        reset
+      end
+  
+      def +(other)
+        super(other)
+        self.recalculate
+        self
+      end
+  
+      # Resets the internal counters so you can start sampling again.
+      def reset
+        self.clear
+        @n, @sum, @sumsq = 0.0, 0.0, 0.0
+        @last_time = 0.0
+        @min, @max = 0.0, 0.0
+      end
+      
+      def samples(*args)
+        args.flatten.each { |s| sample(s) }
+      end
+      
+      # Adds a sampling to the calculations.
+      def sample(s)
+        self << s
+        update s
+      end
+  
+      def update(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
+      end
+  
+      # Dump this Stats object with an optional additional message.
+      def dump(msg = "", out=STDERR)
+        out.puts "#{msg}: #{self.inspect}"
+      end
+
+      # Returns a common display (used by dump)
+      def inspect
+        v = [mean, @n, @sum, @sumsq, sd, @min, @max]
+        t = %q'%8d(N) %10.4f(SUM) %8.4f(SUMSQ) %8.4f(SD) %8.4f(MIN) %8.4f(MAX)'
+        ('%0.4f: ' << t) % v
+      end
+
+      def to_s; mean.to_s; end
+      def to_f; mean.to_f; end
+      def to_i; mean.to_i; end
+  
+      # Calculates and returns the mean for the data passed so far.
+      def mean; return 0.0 unless @n > 0; @sum / @n; end
+
+      # Calculates the standard deviation of the data so far.
+      def sd
+        return 0.0 if @n <= 1
+        # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
+        begin
+          return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) )
+        rescue Errno::EDOM
+          return 0.0
+        end
+      end
+  
+      def recalculate
+        samples = self.clone
+        reset
+        samples.each { |s| sample(s) }
+      end
+  
+    end
+    
+    
+  end
+end

data/lib/benelux/tags.rb

@@ -0,0 +1,110 @@
+
+
+module Benelux
+  
+  # Helper methods for objects with a @tags instance var
+  #
+  # e.g. 
+  #
+  #     class Something
+  #       include Benelux::TagHelpers
+  #     end
+  #
+  module TagHelpers
+    attr_accessor :tags
+    def add_tags(tags)
+      @tags ||= Benelux::Tags.new
+      @tags.merge! tags
+    end
+    alias_method :add_tag, :add_tags
+    def remove_tags(*tags)
+      tags.flatten!
+      @tags ||= Benelux::Tags.new
+      @tags.delete_if { |n,v| tags.member?(n) }
+    end
+    alias_method :remove_tag, :remove_tags
+    def tag_values(*tags)
+      tags.flatten!
+      @tags ||= Benelux::Tags.new
+      ret = @tags.collect { |n,v| 
+        p [:n, v]
+        v if tags.empty? || tags.member?(n) 
+      }.compact
+      ret
+    end
+    def self.normalize(tags={})
+      tags = tags.first if tags.kind_of?(Array) && tags.first.kind_of?(Hash)
+      tags = [tags].flatten unless tags.kind_of?(Hash)
+      tags
+    end
+  end
+  
+  # An example of filtering an Array of tagged objects based
+  # on a provided Hash of tags or Array of tag values. +obj+
+  # in this case would be an object that includes TagHelpers.
+  #
+  #     class Something
+  #       def [](tags={})
+  #         tags = [tags].flatten unless tags.is_a?(Hash)
+  #         self.select do |obj|
+  #           obj.tags >= tags
+  #         end
+  #       end
+  #     end
+  #
+  class Tags < ::Hash
+    
+    def to_s
+      tagstr = []
+      self.each_pair do |n,v|
+        tagstr << "%s=%s" % [n,v]
+      end
+      tagstr.join ' '
+    end
+    
+    def inspect
+      to_s
+    end
+    
+    def ==(*other)
+      other = Benelux::TagHelpers.normalize other
+      if other.is_a?(Array)
+        (self.values & other).sort == other.sort
+      else
+        super(other)
+      end
+    end
+    
+    # Comparison between other Hash and Array objects.
+    #
+    # e.g.
+    #
+    #     a = {:a => 1, :b => 2}
+    #     a > {:a => 1, :b => 2, :c => 3}    # => false
+    #     a > {:a => 1}                      # => true
+    #     a < {:a => 1, :b => 2, :c => 3}    # => true
+    #     a >= [2, 1]                        # => true
+    #     a > [2, 1]                         # => false
+    #
+    def <=>(*other)
+      other = Benelux::TagHelpers.normalize other
+      return 0 if self == other
+      if other.is_a?(Array)
+        return -1 unless (self.values & other).size >= other.size
+      else
+        return -1 unless (self.keys & other.keys).size >= other.keys.size
+        other.each_pair { |n,v| 
+          return -1 unless self.has_key?(n) && self[n] == v
+        }
+      end
+      1
+    end
+    
+    def >(other)  (self <=> other) > 0  end
+    def <(other)  (self <=> other) < 0  end
+    
+    def <=(other) (self <=> other) <= 0 end
+    def >=(other) (self <=> other) >= 0 end
+      
+  end
+end

data/lib/benelux/timeline.rb

@@ -1,10 +1,49 @@
 
 module Benelux
   # 
-  # |------+----+--+----+----|
-  #        |
-  #       0.02  
+  #     |------+----+--+----+----|
+  #            |
+  #           0.02  
+  #
+  # Usage examples::
+  #
+  #    Benelux.timeline['9dbd521de4dfd6257135649d78a9c0aa2dd58cfe'].each do |mark|
+  #      p [mark.track, mark.name, mark.tags[:usecase], mark.tags[:call_id]]
+  #    end
+  #
+  #    Benelux.timeline.ranges(:do_request).each do |range|
+  #      puts "Client%s: %s: %s: %f" % [range.track, range.thread_id, range.name, range.duration]
+  #    end
+  #
+  #    regions = Benelux.timeline(track_id).regions(:execute)
+  #
   class Timeline < Array
+    attr_accessor :ranges
+    attr_accessor :stats
+    attr_accessor :default_tags
+    attr_reader :caller
+    def initialize(*args)
+      @caller = Kernel.caller
+      @ranges, @default_tags = [], Benelux::Tags.new
+      @stats = Benelux::Stats.new
+      add_default_tag :thread_id => Thread.current.object_id.abs
+      super
+    end
+    def add_default_tags(tags=Benelux::Tags.new)
+      @default_tags.merge! tags
+    end
+    alias_method :add_default_tag, :add_default_tags
+    def remove_default_tags(*tags)
+      @default_tags.delete_if { |n,v| tags.member?(n) }
+    end
+    alias_method :add_default_tag, :add_default_tags
+    def track 
+      @default_tags[:track]
+    end
+    
+    def duration
+      self.last - self.first
+    end
     
     def each(*args, &blk)
       if args.empty? 
@@ -14,58 +53,105 @@ module Benelux
       end
     end
     
-    ##def between(*names)
-    ##  name_s, name_e = *names.collect { |n| Benelux.name n }
-    ##  time_s, time_e = at(name_s), at(name_e)
-    ##  time_e.first.to_f - time_s.first.to_f
-    ##end
-    ##def duration(*names)
-    ##  name = Benelux.name *names
-    ##  name_s, name_e = "#{name}_a", "#{name}_z"
-    ##  between(name_s, name_e)
-    ##end
-    
-    #
-    #     obj.region(:execute) =>
-    #         [[:execute_a, :execute_z], [:execute_a, :execute_z]]
-    #
-    def regions(*names)
-      
-    end
-    
     #
     #      obj.marks(:execute_a, :execute_z, :do_request_a) => 
     #          [:execute_a, :do_request_a, :do_request_a, :execute_z]
     #
     def marks(*names)
+      return self if names.empty?
       names = names.flatten.collect { |n| n.to_s }
-      self.benelux.select do |mark| 
+      self.select do |mark| 
         names.member? mark.name.to_s
       end
     end
     
-    def duration(name)
-      name_s = Benelux.name name, SUFFIX_START 
-      name_e = Benelux.name name, SUFFIX_END
+    def [](tags={})
+      tags = Benelux::TagHelpers.normalize tags
+      marks = self.select do |mark|
+        mark.tags >= tags
+      end
+      tl = Benelux::Timeline.new marks
+      tl.ranges = @ranges.select do |region|
+        region.tags >= tags
+      end
+      stats = Benelux::Stats.new
+      @stats.each do |stat|
+        next unless stat.tags >= tags
+        stats += stat
+      end
+      tl.stats = stats
+      tl
+    end
+    
+    #
+    #     obj.ranges(:do_request) =>
+    #         [[:do_request_a, :do_request_z], [:do_request_a, ...]]
+    #    
+    def ranges(name=nil, tags=Benelux::Tags.new)
+      return @ranges if name.nil?
+      @ranges.select do |range| 
+        ret = name.to_s == range.name.to_s &&
+        (tags.nil? || range.tags >= tags)
+        ret
+      end
+    end
+    
+    #
+    #     obj.ranges(:do_request) =>
+    #         [[:do_request_a, :get_body, :do_request_z], [:do_request_a, ...]]
+    #
+    def regions(name=nil, tags=Benelux::Tags.new)
+      return self if name.nil?
+      self.ranges(name, tags).collect do |base_range|
+        marks = self.sort.select do |mark|
+          mark >= base_range.from && 
+          mark <= base_range.to &&
+          mark.tags >= base_range.tags
+        end
+        ranges = self.ranges.select do |range|
+          range.from >= base_range.from &&
+          range.to <= base_range.to &&
+          range.tags >= base_range.tags
+        end
+        tl = Benelux::Timeline.new(marks)
+        tl.ranges = ranges.sort
+        tl
+      end
+    end
+    
+    def clear
+      @ranges.clear
+      super
     end
     
-    def add_mark(call_id, name)
-      thread_id = Thread.current.object_id.abs
-      mark = Benelux::Mark.now(name, call_id, thread_id)
+    def add_mark(name)
+      mark = Benelux::Mark.now(name)
+      mark.add_tags Benelux.thread_timeline.default_tags
+      mark.add_tags self.default_tags
       Benelux.thread_timeline << mark
       self << mark
+      mark
     end
-
-    def add_mark_open(call_id, name)
-      add_mark call_id, Benelux.name(name, SUFFIX_START)
-    end
-
-    def add_mark_close(call_id, name)
-      add_mark call_id, Benelux.name(name, SUFFIX_END)
+    
+    def add_range(name, from, to)
+      range = Benelux::Range.new(name, from, to)
+      range.add_tags Benelux.thread_timeline.default_tags
+      range.add_tags self.default_tags
+      @stats.add_keeper(name)
+      @stats.send(name).sample(range.duration, range.tags)
+      @ranges << range
+      Benelux.thread_timeline.ranges << range
+      Benelux.thread_timeline.stats.add_keeper(name)
+      Benelux.thread_timeline.stats.send(name).sample(range.duration, range.tags)
+      range
     end
-
+    
     def to_line
       marks = self.sort
+    end
+    
+    def to_line2
+      marks = self.sort
       str, prev = [], marks.first
       marks.each do |mark|
         str << "%s(%s):%.4f" % [mark.name, mark.thread_id, mark.to_s(prev)]
@@ -75,7 +161,10 @@ module Benelux
     end
     def +(other)
       self << other
-      self.flatten
+      self.ranges += other.ranges
+      self.stats += other.stats
+      self.flatten!
+      self
     end
     # Needs to compare thread id and call id. 
     #def <=>(other)

data/tryouts/10_stats_tryouts.rb

@@ -0,0 +1,49 @@
+
+group "Benelux"
+
+library :benelux, 'lib'
+tryouts "Calculator" do
+  
+  dream :class, Benelux::Stats::Calculator
+  dream :n, 10
+  drill "can keep stats" do
+    keeper = Benelux::Stats::Calculator.new
+    10.times { keeper.sample(rand) }
+    keeper
+  end
+  
+end
+
+tryouts "Stats" do
+  set :stat_names, [:execute, :request, :first_byte]
+  
+  dream stat_names
+  drill "knows stats names" do
+    stats = Benelux::Stats.new(stat_names)
+    stats.names
+  end
+  
+  drill "can keep multiple stats", true do
+    stats = Benelux::Stats.new(stat_names)
+    stats.execute.sample(rand)
+    stats.request.sample(rand*-1)
+    stats.execute != stats.request
+  end
+  
+  dream [true, true, true]
+  drill "can keep stats with tags" do
+    stats = Benelux::Stats.new(stat_names)
+    3.times { |i|
+      stats.execute.sample(rand, :usecase => '11')
+      stats.execute.sample(rand, :usecase => '11', :request => '22')
+      stats.execute.sample(rand, :request => '22')
+    }
+    stash :execute_stats, stats.execute
+    [
+      stats.execute['11'] == stats.execute[:usecase => '11'],
+      stats.execute['22'] == stats.execute[:request => '22'],
+      stats.execute['22','11'] == stats.execute[:usecase => '11', :request => '22']
+    ]
+  end
+  
+end

data/tryouts/11_tags_tryouts.rb

@@ -0,0 +1,60 @@
+
+group "Benelux"
+
+library :benelux, 'lib'
+tryouts "Tags" do
+  set :base, Benelux::Tags[:a => 1, :b => 2]
+  
+  drill "Can equal a Hash with the same keys/values", true do
+    base == {:a => 1, :b => 2}
+  end
+  
+  drill "Implements a comparison operator", true do
+    base.respond_to? :'<=>'
+  end
+  
+  drill "Comparison operator returns 0 for same values", 0 do
+    base <=> {:a => 1, :b => 2}
+  end
+  
+  drill "Comparison operator returns 1 when it's a superset of other", 1 do
+    base <=> {:a => 1}
+  end
+
+  drill "Comparison operator returns -1 when it's a subset of other", -1 do
+    base <=> {:a => 1, :b => 2, :c => 3}
+  end
+  
+  drill "> returns false when compared to a hash with more key value pairs", false do
+    base > {:a => 1, :b => 2, :c => 3}
+  end
+  
+  drill "> returns true when compared to a hash with fewer key value pairs", true do
+    base > {:b => 2}
+  end
+  
+  drill "< returns true when compared to a hash with more key value pairs", true do
+    base < {:a => 1, :b => 2, :c => 3}
+  end
+  
+  drill "< returns false when compared to a hash with fewer key value pairs", false do
+    base < {:b => 2}
+  end
+  
+  drill "< returns false when compared to a hash with same values", false do
+    base < {:a => 1, :b => 2}
+  end
+
+  drill "<= returns true when compared to a hash with same values", true do
+    base <= {:b => 2, :a => 1}
+  end
+  
+  drill "< returns false when compared to an array with same values", false do
+    base < [1, 2]
+  end
+  
+  drill "<= returns true when compared to an array with same values", true do
+    base <= [2, 1]
+  end
+  
+end

data/tryouts/{basic_tryouts.rb → 20_class_methods_tryouts.rb}

@@ -13,13 +13,13 @@ tryouts "Basics" do
   
   drill "Add timers to existing objects", true do
     Benelux.add_timer Sleeper, :do_something
-    Sleeper.new.respond_to? :benelux
+    Sleeper.new.respond_to? :timeline
   end
   
   dream :class, Hash
   dream { Hash[ Sleeper => [:do_something] ] }
   drill "Benelux keeps track of timed objects" do
-    Benelux.timed_objects
+    Benelux.timed_methods
   end
   
   dream [:do_something]
@@ -32,7 +32,7 @@ tryouts "Basics" do
   drill "Creates a timeline" do
     sleeper = Sleeper.new
     5.times { sleeper.do_something }
-    sleeper.benelux
+    sleeper.timeline
   end
   
   dream :size, 4
@@ -41,7 +41,7 @@ tryouts "Basics" do
     Thread.new do
       2.times { sleeper.do_something }
     end.join
-    sleeper.benelux
+    sleeper.timeline
   end
   
   dream :class, Benelux::Timeline

data/tryouts/30_timeline_tryouts.rb

@@ -0,0 +1,25 @@
+
+group "Benelux"
+
+library :benelux, 'lib'
+tryouts "Timelines" do
+  set :tl, Benelux::Timeline.new
+  
+  dream :class, Benelux::Timeline
+  dream :size, 3
+  drill "create timeline with marks" do
+    tl.add_default_tags :a => :frog
+    tl.add_mark(:one) and sleep rand
+    tl.add_default_tags :b => :rest
+    tl.add_mark(:two) and sleep rand
+    tl.add_default_tags :c => :tilt
+    tl.add_mark(:three) and sleep rand
+    tl.marks
+  end
+  
+  dream :size, 2
+  drill "select marks based on tags" do
+    tl[:frog][:b => :rest]
+  end
+
+end

data/tryouts/proofs/alias_performance.rb

@@ -0,0 +1,33 @@
+
+
+tryouts "Alias method speed", :benchmark do
+  set :runcount, 1_000
+  
+  setup do
+    module A;
+      extend self
+      def meth1; end
+      def meth2; end
+      alias_method :meth2_orig, :meth2
+      def meth2; end
+      def meth2_with_call; meth2_orig; end
+    end
+  end
+  
+  [10, 100].each do |mult|
+    count = runcount * mult
+    
+    drill "Natural method (#{count})", count do
+      A.meth1
+    end
+    
+    drill "Aliased method (#{count})", count do
+      A.meth2
+    end
+    
+    drill "Aliased method w/ call (#{count})", count do
+      A.meth2_with_call
+    end
+  end  
+  
+end

data/tryouts/proofs/timer_threading.rb

@@ -0,0 +1,30 @@
+group "Benelux Concept Proofs"
+
+xtryouts "Time benchmarks", :benchmark do
+  set :runcount, 100000
+  
+  drill "Create Array", 1 do
+    @@timers = []
+  end
+  
+  drill "Time.now overhead", 5 do
+    runcount.times { Time.now.to_f }
+  end
+  
+  drill "[] << Time.now overhead", 5 do
+    runcount.times { @@timers << Time.now.to_f }
+  end
+  
+end
+
+require 'date'
+tryouts "Time proofs", :api do
+  set :runcount, 100000
+  
+  drill "All calls to Time.now.to_f are unique (will fail)", 0 do
+    timers = []
+    runcount.times { timers << Time.now.to_f; sleep 0.00000001 }
+    timers.size - timers.uniq.size
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: benelux
 version: !ruby/object:Gem::Version 
-  version: 0.2.0.001
+  version: 0.3.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-21 00:00:00 -04:00
+date: 2009-10-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,8 +41,16 @@ files:
 - lib/benelux.rb
 - lib/benelux/mark.rb
 - lib/benelux/mixins/thread.rb
+- lib/benelux/range.rb
+- lib/benelux/stats.rb
+- lib/benelux/tags.rb
 - lib/benelux/timeline.rb
-- tryouts/basic_tryouts.rb
+- tryouts/10_stats_tryouts.rb
+- tryouts/11_tags_tryouts.rb
+- tryouts/20_class_methods_tryouts.rb
+- tryouts/30_timeline_tryouts.rb
+- tryouts/proofs/alias_performance.rb
+- tryouts/proofs/timer_threading.rb
 has_rdoc: true
 homepage: http://github.com/delano/benelux
 licenses: []