rubyrun 0.9.0-mswin32

data/lib/rubyrun/rubyrun_instrumentor__.rb

@@ -0,0 +1,226 @@
+#---------------------------------------------------------------#
+#                                                               #  
+#  (C) Copyright Rubysophic Inc. 2007-2008                      #
+#  All rights reserved.                                         #
+#                                                               #  
+#  Use, duplication or disclosure of the code is not permitted  #
+#  unless licensed.                                             #  
+#                                                               #  
+#  Last Updated: 7/09/08                                        #  
+#---------------------------------------------------------------#
+#                                                               #  
+# RubyRunInstrumentor__ module is responsible for performing    #
+# instrumentation on ruby methods via metaprogramming. These    #
+# methods belong to the candidate classes/modules discovered    #
+# earlier in RubyRunInitializer__ plus others which are 	    #
+# explicitly requested in rubyrun_opts via the use of		    # 
+# INCLUDE_HASH.			                                  #
+#                                                               #  
+#---------------------------------------------------------------#
+module RubyRunInstrumentor__
+
+  require 'logger'
+  require 'yaml'
+  require 'rubyrun_globals'
+  require 'rubyrun_utils__'
+  require 'rubyrun_monitor__'
+  require 'rubyrun_tracer__'
+  require 'rubyrun_dad__'
+  require 'rubyrun_html__'
+  require 'rubyrun_html_writer__'
+  include RubyRunGlobals
+  include RubyRunUtils__
+  include RubyRunMonitor__
+  include RubyRunTracer__
+  include RubyRunDad__
+  include RubyRunHTML__
+
+  # Invoked by the traps set up in rubyrun.rb. This indicates that
+  # a file has been required/loaded such that the methods within
+  # are being added to the process. Each method being added will
+  # go through the following process to determine if it should be intrumented.
+  # 
+  # 1. Through APP_PATHS a stream of class names whose methods are 
+  # identified as candiates for instrumnetation in RubyRunIntializer__.
+  # This process forms the initial INCLUDE_HASH which states ALL methods
+  # belonging to these classes/methods should be instrumented
+  # 2. Through additional INCLUDE_HASH in rubyrun_opts a stream of  
+  # class => methods hash entries provide further candidates for instrumentation.
+  # 3. Thru EXCLUDE_HASH the exclusion logic is then applied to reduce the scope
+  # of instrumentation.
+  # 4. Some classes and methods are never instrumented regarldess. These 
+  # are identifed in constants FIREWALL_HASH.
+  def instrument_it?(type, klass, id)
+    get_dad(type, klass, id)
+    instrument_target(type, klass, id) \
+      if !(is_non_negotiably_excluded?(type, klass, id)) &&
+        !is_in?($rubyrun_exclude_hash, klass, id, 'strict') &&
+        is_in?($rubyrun_include_hash, klass, id, 'strict')
+  end
+
+  # Never instrument the following classes/methods to avoid recursion
+  # 1. Exclude classes and methods that the instrumentation code uses
+  # 2. Exclude method=
+  # 3. Exclude method aliased by rubyrun instrumentation code
+  # 4. Exclude method re-defined by rubyrun instrumentation code
+  # 5. Exclude inherited instances, private, protected, and singleton methods.
+  # The way this works is that if m is one of these non-inherited instance
+  # methods or singleton methods then it should NOT be excluded. Otherwise
+  # it is assumed it is an inherited one and hence excluded.  
+  def is_non_negotiably_excluded?(type, klass, id)    
+    return true if is_in?(RUBYRUN_FIREWALL_HASH, klass, id)    
+    return true if id.id2name[-1,1] == '='  
+    if id.id2name[0, RUBYRUN_PREFIX_LENGTH] == RUBYRUN_PREFIX
+      $rubyrun_prev_method = id.id2name
+      return true
+    end
+    if ($rubyrun_prev_method ||="").include?(id.id2name)
+      $rubyrun_prev_method = nil
+      return true
+    end            
+    if type == 'i'
+      klass.instance_methods(false).each {|m|
+        return false if m == id.id2name
+      }
+      klass.private_instance_methods(false).each {|m|
+        return false if m == id.id2name
+      }
+      klass.protected_instance_methods(false).each {|m|
+        return false if m == id.id2name
+      }
+    else
+      klass.singleton_methods.each {|m|
+        return false if m == id.id2name
+      }
+    end
+    true
+  end
+  
+  #  First layer of code performing instrummentation on a class.method
+  #  The injecting code is different depending on whether the
+  #  method is an instance method, or singleton(static method of a class,
+  #  specific method added to an object).
+  #  
+  #  If this class is a Rails active controller class, create a hash
+  #  entry if it does not already exist. This hash is used to keep track
+  #  of performance metrics by action by controller.
+  #  
+  #  If we fail to instrument for whatever reason, log the 
+  #  errors and leave the method alone.
+  #  
+  #  Also, create metrics hash for a RAILS controller class if it doesn't exist
+  def instrument_target(type, klass, id)
+    $rubyrun_logger.info "instrumenting #{klass.to_s}.#{id.id2name}."
+    create_metrics_hash(klass) if is_rails_controller?(klass, id)
+    begin 
+      case type
+        when 'i'
+          insert_code_to_instance_method(klass, id)
+        when 's' 
+          insert_code_to_singleton_method(klass, id)
+        else
+          raise "undefined instrumentation type"
+      end
+      $rubyrun_logger.info "#{klass.to_s}.#{id.id2name} instrumented."
+    rescue Exception => e
+      $rubyrun_logger.info "Class #{klass.to_s}.#{id.id2name} failed to instrument"
+      $rubyrun_logger.info e.to_s + "\n" + e.backtrace.join("\n")
+    end
+  end
+
+  # To instrument an instance method of a class, a method proxy is used:
+  # 
+  # 1. Alias the method to one with a prefix rubyrun_ (i.e., copy the method and
+  # create another one with a new name)
+  # 2. Create a new method with the original name. This is the method proxy.
+  # 3. Preserve the intended visibility of the original method in the proxy
+  # 4. This proxy method essentially adds pre and post wrapper code to 
+  # the original code. This wrapper code is embodied in collect_method_data
+  # 5. All these must be done in the context of the class
+  def insert_code_to_instance_method(klass, mid)
+    klass.class_eval {
+      alias_method "#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}", mid.id2name
+      eval <<-CODE1
+        def #{mid.id2name} (*args, &blk)
+          RubyRunInstrumentor__.collect_method_data(self, #{klass}, '#{mid}', *args) {self.send("#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}", *args, &blk)} 
+        end
+      CODE1
+      if klass.private_instance_methods(false).include?("#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}")
+        private mid
+      elsif klass.protected_instance_methods(false).include?("#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}")
+        protected mid
+      end
+    }
+  end
+  
+  # Same as insert_code_to_instance_method
+  def insert_code_to_singleton_method(klass, mid)
+    (class << klass; self; end).class_eval {
+      alias_method "#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}", mid.id2name      
+      eval <<-EOF2
+        def #{mid.id2name} (*args, &blk)
+          RubyRunInstrumentor__.collect_method_data(self, #{klass}, '#{mid}', *args) {self.send("#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}", *args, &blk)} 
+        end
+      EOF2
+      if self.private_instance_methods(false).include?("#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}")   
+        private mid
+      elsif self.protected_instance_methods(false).include?("#{RubyRunGlobals::RUBYRUN_PREFIX}_#{mid.id2name}")
+        protected mid
+      end
+    }
+  end
+
+  # This is the piece of code that actually executed under the application 
+  # thread during runtime and is not executed during instrumentation time
+  # 
+  # 1. Create a equivalent thread local storage to store request performance 
+  # metrics but only if this class is a Rails Active Controller class
+  # 2. Trace pre and post execution of the original method which has been aliased
+  # The original method is invoked via 'yield'
+  # 3. When a method ends, report the timings to the response time component but
+  # only if a thread local exists 
+  def collect_method_data(obj, klass, mid, *args)
+    tid = get_thread_id    
+    create_thread_local(tid, obj.request, klass, mid) if is_rails_controller?(klass, mid)
+    rubyrun_trace = is_in?($rubyrun_trace_hash, klass, mid)
+    if rubyrun_trace
+      invoker = get_caller_detail
+      enter_trace(tid, "         Entry", obj, invoker, klass, mid, *args)
+    end
+    t1 = Time.new
+    result = yield
+    t2 = Time.new
+    if rubyrun_trace
+      (t2 - t1) >= RUBYRUN_HIGHLIGHT_THRESHOLD ? (type = "* #{sprintf("%6.2f", t2-t1)} Exit ") : (type = "  #{sprintf("%6.2f", t2-t1)} Exit ")
+      enter_trace(tid, type, nil, nil, klass, mid, nil) 
+    end
+    report_rails_timing(klass, mid, t2, t1, tid) if $rubyrun_thread_local[tid] && (t2 - t1) > 0
+    result
+  end
+  
+  # Instrument Thread.new by wrapping target proc with a 
+  # begin-rescue clause around the application block.
+  # When the thread monitor shoot the thread via thr.raise
+  # the rescue clause will catch the interrupt and collect the
+  # stack entries in $@ and store them in a global hash, later
+  # on printed in rubyrun log by thread id. If the thread dies
+  # naturally, print the stack trace on the rubyrun log
+  def instrument_thread_new
+    (class << Thread; self; end).class_eval {
+      alias_method "#{RubyRunGlobals::RUBYRUN_PREFIX}_new", "new"
+      def new(*rubyrun_args, &rubyrun_apps_block)
+        rubyrun_proc = lambda {
+          begin    
+            rubyrun_apps_block.call(*rubyrun_args)
+          rescue Exception => e
+            e.message == RUBYRUN_KILL_3_STRING ? 
+              $@.each {|line| ($rubyrun_thread_stack[Thread.current] ||= []) << line} :
+              $@.each {|line| $rubyrun_logger.info "#{line}"}
+          end
+        }    
+        self.send("#{RubyRunGlobals::RUBYRUN_PREFIX}_new", *rubyrun_args, &rubyrun_proc)
+      end
+    }
+  end
+  
+end

data/lib/rubyrun/rubyrun_monitor__.rb

@@ -0,0 +1,237 @@
+#---------------------------------------------------------------#
+#                                                               #  
+#  (C) Copyright Rubysophic Inc. 2007-2008                      #
+#  All rights reserved.                                         #
+#                                                               #  
+#  Use, duplication or disclosure of the code is not permitted  #
+#  unless licensed.                                             #
+#                                                               #            
+#  Last Updated: 7/09/08                                        #  
+#---------------------------------------------------------------#
+#                                                               #  
+#  RubyRunMonitor__ is responsible for keeping track of         #
+#  the response time of a Rails Request and its decomposition.  #
+#                                                               #  
+#  For instance, a typical WEBrick/RAILS servlet dispatch       #
+#  response time components generally break down look roughly   # 
+#  like this:           						    #
+#                                                               #      
+#  SVS   DI   ACT   DB   DB    DB          VI    VI             #    
+#  -+-----+----+----+--+--+--+--+--+----+--+----+-+--+---+----+ #
+#                     DB'   DB'   DB'  ACT'    VI'  VI' DI' SVS'#            
+#  Legend:                                                      #
+#   SVS = DispatchServlet.service                               #
+#   DI = DispatchServlet.handle_dispatch                        #
+#   ACT = controller.action                                     #    
+#   DB  = ActiveRecord::ConnectionAdapters::*Adapter.execute    #
+#   VI  = ActionView.Base:render_template                       #
+#   All apostrophe means "end of event"                         #
+#                                                               #
+#   Notes:                                                      #  
+#   1. mutex held from SVS to SVS'                              #
+#   2. Total dispatch time with mutex = SVS' - SVS              #
+#   3. Total DBIO time = Sum(DB' - DB)                          #    
+#   4. Action Time = ACT' - ACT                                 #
+#   5. View time = Sum(VI' - VI)                                #
+#   6. View rendering includes template + layout                #
+#                                                               #      
+#  Another key function is to act as a command agent, responding#
+#  to command such as displaying thread status, terminating     #
+#  threads with stack tracke and showing object heap info.      #
+#                                                               #  
+#---------------------------------------------------------------#
+module RubyRunMonitor__
+  
+  require 'rubyrun_globals'
+  require 'rubyrun_utils__'
+  require 'rubyrun_tracer__'
+  require 'rubyrun_rss__'
+  require 'rubyrun_buffer_mgr__'
+  require 'rubyrun_html__'
+  require 'rubyrun_report__'
+  require 'rubyrun_commander__'
+  begin
+    require 'rubyrunnative__'
+    $rubyrun_native = true
+  rescue Exception
+    $rubyrun_native = false
+  end  
+  include RubyRunGlobals
+  include RubyRunUtils__
+  include RubyRunTracer__
+  include RubyRunBufferMgr__
+  include RubyRunHTML__
+  include RubyRunReport__
+  include RubyRunCommander__
+  
+  # In response to the presence of a 'cmd_status', 'cmd_soft_kill', 'cmd_hard_kill'
+  # or 'cmd_object_map' in the work directory, the monitor thread will either
+  # display thread status, interrupt the threads in different manner, or show object instances
+  # in memory
+  def start_thread_monitor
+    $rubyrun_logger.info "----- RubyRun Thread Monitor started -----"
+    monitor_thr = Thread.new {
+      cycle = $rubyrun_report_timer / RUBYRUN_MONITOR_TIMER
+      sleep_count = 0
+      loop do
+        sleep RUBYRUN_MONITOR_TIMER
+        monitor_thr.exit if exit_monitor?
+        Thread.new {
+          begin
+            sleep_count += 1
+            sleep_count == cycle ? (dump_reports(true); sleep_count = 0) : dump_reports
+            dump_thread_status if thread_status?
+            dump_object_map if object_map?
+            kill_threads(monitor_thr) if soft_kill? || hard_kill?
+          rescue Exception => e
+            $stderr.print e.to_s + "\n" + e.backtrace.join("\n")
+            exit(-1)
+          end
+        }
+      end
+    }
+  end
+ 
+  # Simulate a thread local storage by using a private hash keyed on thread id.
+  # Key elements in the hash are, for instance:
+  # {#{tid} => {:req=>request.object_id, :controller=>name, :action=> name,
+  #   :action_t=>t, :dbio=>t, :dispatch_t=>t, :view_t=>t, :uncaptured_t=>t,
+  #   :dispatch_wait_t=>t}}
+  # Thread local is used to store performance metrics of a RAILS request.
+  # When the same thread serves a different request, the current thread local
+  # data needs to be rolled up and re-initialized.
+  def create_thread_local(tid, request, klass, mid)
+    $rubyrun_thread_local[tid] ||= {}  
+    init_thread_local(tid, request, klass, mid) unless $rubyrun_thread_local[tid][:req]
+    if $rubyrun_thread_local[tid][:req] != request.object_id
+      roll_up_metrics(tid)
+      init_thread_local(tid, request, klass, mid)
+    end
+  end
+  
+  # Create a place holding global metrics hash for each RAILS application 
+  # controller class to accumulate performance metrics by action.
+  # Key elements in the hash are, for instance:
+  # {#{controller} => {#{action} => [dispatch_t, action_t, dbio_t, view_t, uncap_t, dispatch_wait_t]}}
+  def create_metrics_hash(klass)
+    $rubyrun_metrics_hash[klass.to_s.downcase[0..-11]] ||= {}
+  end  
+  
+  # Report timings to thread local after decomposing it into the right component.
+  # For each action, there are 5 components of Response Time (RT)
+  #   :dispatch_t, :#{action}_t, :dbio_t, :view_t, :uncaptured_t
+  def report_rails_timing(klass, mid, t2, t1, tid)
+    t = t2 - t1
+    if is_in_hash?($rubyrun_adapter_hash, klass, mid)  
+      $rubyrun_thread_local[tid][:dbio_t] += t
+    elsif is_in_hash?(RUBYRUN_VIEW_HASH, klass, mid)
+      $rubyrun_thread_local[tid][:view_t] << t2 << t1
+    elsif is_in_hash?($rubyrun_outer_dispatch_hash, klass, mid)
+      $rubyrun_thread_local[tid][:outer_dispatch_t] << t      
+    elsif is_in_hash?($rubyrun_inner_dispatch_hash, klass, mid)
+      $rubyrun_thread_local[tid][:inner_dispatch_t] << t
+    elsif is_rails_controller?(klass, mid)
+      $rubyrun_thread_local[tid][:action_t] = t
+      $rubyrun_thread_local[tid][:scafold_style] = $rubyrun_thread_local[tid][:view_t].empty? ? true : false
+    elsif is_in?(RUBYRUN_THREAD_END_HASH, klass, mid, 'strict')
+      roll_up_metrics(tid, true)   
+    end
+  end
+
+  private
+            
+  # Roll up action metrics to controller_metrics_hash 
+  # First, roll up the pieces in thread_local
+  # Then roll up the thread local data to the metrics global hash
+  def roll_up_metrics(tid, thread_end=false)
+    ($rubyrun_thread_local[tid].clear; return) if thread_local_incomplete?(tid)
+    dbio_t = $rubyrun_thread_local[tid][:dbio_t]
+    outer_dispatch_t = $rubyrun_thread_local[tid][:outer_dispatch_t].max
+    inner_dispatch_t = $rubyrun_thread_local[tid][:inner_dispatch_t].max
+    dispatch_wait_t = outer_dispatch_t - inner_dispatch_t
+    view_t = $rubyrun_thread_local[tid][:view_t].empty? ? 0 : $rubyrun_thread_local[tid][:view_t].max - $rubyrun_thread_local[tid][:view_t].min
+    action_t = ($rubyrun_thread_local[tid][:action_t])
+    uncap_t = $rubyrun_thread_local[tid][:scafold_style] ? outer_dispatch_t - view_t - action_t - dispatch_wait_t : outer_dispatch_t - action_t - dispatch_wait_t
+    $rubyrun_thread_local[tid][:uncaptured_t] = uncap_t 
+    $rubyrun_thread_local[tid][:dispatch_wait_t] = dispatch_wait_t 
+    push_current_buffer([tid, Time.now,
+                        $rubyrun_thread_local[tid][:url],
+                        $rubyrun_thread_local[tid][:controller],
+                        $rubyrun_thread_local[tid][:action],
+                        outer_dispatch_t, action_t, dbio_t, view_t, uncap_t, dispatch_wait_t])
+    !thread_end ? $rubyrun_thread_local[tid].clear : $rubyrun_thread_local.delete(tid)
+  end
+      
+  # Initialize the thread_local hash
+  def init_thread_local(tid, request, klass, mid)
+    $rubyrun_thread_local[tid][:req] = request.object_id
+    $rubyrun_thread_local[tid][:controller] = klass.to_s.split('Controller')[0].downcase
+    $rubyrun_thread_local[tid][:action] = return_method_name(mid)
+    $rubyrun_thread_local[tid][:url] = request.protocol + request.host_with_port + request.request_uri
+    $rubyrun_thread_local[tid][:dbio_t] = 0
+    $rubyrun_thread_local[tid][:outer_dispatch_t] = []
+    $rubyrun_thread_local[tid][:inner_dispatch_t] = []
+    $rubyrun_thread_local[tid][:action_t] = 0
+    $rubyrun_thread_local[tid][:uncaptured_t] = 0
+    $rubyrun_thread_local[tid][:view_t] = []
+    $rubyrun_thread_local[tid][:dispatch_wait_t] = 0
+    $rubyrun_thread_local[tid][:scafold_style] = false
+    $rubyrun_host_with_port = request.host_with_port
+  end
+  
+  # Use the data hash returned by the native function to show
+  # the top frame inside the thread struct (node and orig_func)
+  def get_top_stack(th_data_hash, thread_id)
+    th_data_hash.each {|th, top_stack|
+      if th.to_s.include?(thread_id)
+        return "#{top_stack[0].gsub('rubyrun_', '')}"
+        break
+      end
+    }
+  end
+     
+  # If request aborted, thread_local can be corrupted (half filled)
+  # Return true if corrupted else false
+  def thread_local_incomplete? (tid)
+    $rubyrun_thread_local[tid][:controller].nil? || 
+      $rubyrun_thread_local[tid][:action].nil? ||
+      $rubyrun_thread_local[tid][:outer_dispatch_t].empty? ||
+      $rubyrun_thread_local[tid][:inner_dispatch_t].empty?
+  end
+    
+  # Sort $rubyrun_metrics_hash by response time in descending order
+  # An array of the following data structure is returned:
+  # metrics[0] controller/action name
+  # metrics[1] Array of performance data
+  # metrics[1][0] resposne time     metrics[1][1] action time
+  # metrics[1][2] database IO time  metrics[1][3] view time
+  # metrics[1][4] uncaptured time   metrics[1][5] wait time
+  # metrics[1][6] request count 
+  def sort_performance_metrics
+    results = Hash.new
+    $rubyrun_metrics_hash.each {|controller, action_metrics|
+      next if action_metrics.empty?
+      action_metrics.each {|action, metrics|
+        results["#{controller}/#{action}"] = metrics
+      }
+    }
+    results.sort {|a, b| -1*(a[1]<=>b[1])}
+  end
+    
+  # An optimized runtime version of the original is_in? in RubyRunInstrumentor__
+  # This is used during runtime and not instrumentation, hence something of better
+  # performance but less general is required. 
+  def is_in_hash?(hash, klass, mid)
+    return false if hash.empty?
+    name = klass.to_s
+    if hash.has_key?(name)
+      return true if hash[name].empty? 
+      method_name = return_method_name(mid)
+      hash[name].each {|meth_name|
+        return true if method_name.downcase == meth_name.downcase 
+      }
+    end
+    false
+  end
+    
+end  

data/lib/rubyrun/rubyrun_report__.rb

@@ -0,0 +1,109 @@
+#---------------------------------------------------------------#
+#                                                               #  
+#  (C) Copyright Rubysophic Inc. 2007-2008                      #
+#  All rights reserved.                                         #
+#                                                               #  
+#  Use, duplication or disclosure of the code is not permitted  #
+#  unless licensed.                                             #  
+#                                                               #  
+#  Last Updated: 7/7/08                                         #  
+#---------------------------------------------------------------#
+#                                                               #  
+# RubyRunReport__ is responsible for generating report data in  #
+# RSS or CSV format depending on the type of report.            #   
+#                                                               #  
+#---------------------------------------------------------------#
+module RubyRunReport__
+  
+  # Add entries to transaction log CSV file
+  # metrics structure
+  # metrics[0] Thread ID      metrics[1] Timestamp of the request
+  # metrics[2] URL            metrics[3] Controller name
+  # metrics[4] Action name    metrics[5] Response time
+  # metrics[6] Action time    metrics[7] Database IO time
+  # metrics[8] View time      metrics[9] Uncaptured time
+  # metrics[10] Dispatch wait time
+  # CSV format is URL, thread ID, timestamp, response time, action time, 
+  #   database io time, view time, dispatch wait time, uncaptured time
+  def add_txn_log_csv_item(buffer)
+    return if buffer.length == 0
+    $rubyrun_txn_log_reporter.info "\n----- Transaction Log at #{Time.now.ctime} -----"
+    buffer.each { |metrics|
+      $rubyrun_txn_log_reporter.info "#{metrics[2]},#{metrics[0]},#{metrics[1].strftime("%H:%M:%S")}.#{("%.3f" % metrics[1].to_f).split('.')[1]} #{metrics[1].strftime("%m/%d/%y")},#{sprintf("%0.3f", metrics[5])},#{sprintf("%0.3f", metrics[6])},#{sprintf("%0.3f", metrics[7])},#{sprintf("%0.3f", metrics[8])},#{sprintf("%0.3f", metrics[10])},#{sprintf("%0.3f", metrics[9])}"
+    }
+  end
+
+  # Add an item to performance summary RSS channel
+  def add_perf_summary_rss_item(req_count)
+    return unless $rubyrun_host_with_port # Server started but no request yet
+    # First, Throughput Summary
+    $rubyrun_throughput.shift if $rubyrun_throughput.length == $rubyrun_report_shift_age
+    index = $rubyrun_throughput.length
+    $rubyrun_throughput[index] = [Time.now, req_count.to_f/$rubyrun_report_timer*60]
+    bar_content = ''
+    label_content = ''
+    max = ($rubyrun_throughput.max {|a,b| a[1] <=> b[1]})[1]
+    max = 1 if max == 0 # Avoid divided by zero below
+    $rubyrun_throughput.reverse!
+    $rubyrun_report_shift_age.times { |i|
+      if $rubyrun_throughput[i]
+        bar_content += sprintf(THROUGHPUT_BAR_TABLE, sprintf('%0.0f',$rubyrun_throughput[i][1]), ($rubyrun_throughput[i][1]*250/max).to_i)
+        label_content += sprintf(THROUGHPUT_LABEL_TABLE, $rubyrun_throughput[i][0].strftime("%H:%M %b&nbsp;%d"))        
+      else
+        bar_content += sprintf(THROUGHPUT_BAR_TABLE, '', 0)
+        label_content += sprintf(THROUGHPUT_LABEL_TABLE, '')                
+      end
+    }
+    $rubyrun_throughput.reverse!    
+    html_content = THROUGHPUT_HTML.sub(/%THROUGHPUT_BAR_TABLE%/, bar_content)
+    html_content.sub!(/%THROUGHPUT_LABEL_TABLE%/, label_content)
+    html_content.sub!(/%APPS_NAME%/,Rails::Configuration.new.root_path.split('/').last)
+    html_content.sub!(/%TIMESTAMP%/,Time.now.strftime("%H:%M:%S %m/%d/%Y"))  
+    # Second, Top Slowest Requests
+    results = sort_performance_metrics
+    table_content = ''
+    10.times { |i|
+      break unless results[i]
+      table_content += sprintf(TOP_SLOWEST_REQUESTS_TABLE, results[i][0],
+                              (150*results[i][1][0]/results[0][1][0]).round, results[i][1][0])
+    }
+    (html_content << TOP_SLOWEST_REQUESTS_HTML).sub!(/%TOP_SLOWEST_REQUESTS_TABLE%/,table_content)
+    # Third, Request Performance Breakdown
+    odd = true
+    table_content = ''      
+    results.each { |metrics|
+      table_content += sprintf("#{odd ? REQ_PERF_BREAKDOWN_TABLE_ODD : REQ_PERF_BREAKDOWN_TABLE_EVEN}", metrics[0], metrics[1][6], metrics[1][0], metrics[1][1], (metrics[1][1]/metrics[1][0]*100).round, metrics[1][2], (metrics[1][2]/metrics[1][0]*100).round, metrics[1][3], (metrics[1][3]/metrics[1][0]*100).round, metrics[1][5], (metrics[1][5]/metrics[1][0]*100).round, metrics[1][4])
+      odd = odd ? false : true
+    }
+    (html_content << REQ_PERF_BREAKDOWN_HTML).sub!(/%REQ_PERF_BREAKDOWN_TABLE%/,table_content);
+    $rubyrun_perf_summary_rss.add_item(RubyRunRSS::RUBYRUN_RSS_PERF_SUMMARY_ITEM_TITLE,
+                                       RubyRunRSS::RUBYRUN_RSS_PERF_SUMMARY_ITEM_DESCRIPTION, html_content)
+  end
+  
+  # Create the folder for keeping RSS XML file and HTML files
+  # Create the RSS channel
+  def create_rss_channels
+    rss_folder = $rubyrun_config['RSS_PATH'] ? $rubyrun_config['RSS_PATH'] \
+                 : "#{Rails::Configuration.new.root_path}/public/#{RubyRunRSS::RUBYRUN_RSS_FOLDER}"
+    begin
+      Dir.mkdir(rss_folder) unless File.exist?(rss_folder)
+    rescue Exception
+      rss_folder = @rubyrun_report_folder
+    end    
+    $rubyrun_perf_summary_rss = RubyRunRSS.new \
+                                RubyRunRSS::RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_TITLE,
+                                RubyRunRSS::RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_DESCRIPTION,
+                                rss_folder,
+                                RubyRunRSS::RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_FILENAME,
+                                RubyRunRSS::RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_ITEM_FILENAME \
+                                unless $rubyrun_perf_summary_rss
+    $rubyrun_throughput = Array.new
+  end
+
+  # Create the CSV files 
+  def create_csv_files
+    $rubyrun_txn_log_reporter = Logger.new("#{@rubyrun_report_folder}/#{File.basename($0, ".*")}_#{$$.to_s}_txn_log.csv", shift_age = 10, shift_size = 4096000)   
+    $rubyrun_txn_log_reporter.info "#\n# Format: [URL],[thread ID],[timestamp],[response time],[action time],[database IO time],[view time],[dispatch delay time],[uncaptured time]\n#"
+  end
+    
+end

data/lib/rubyrun/rubyrun_rss__.rb

@@ -0,0 +1,97 @@
+#---------------------------------------------------------------#
+#                                                               #  
+#  (C) Copyright Rubysophic Inc. 2007-2008                      #
+#  All rights reserved.                                         #
+#                                                               #  
+#  Use, duplication or disclosure of the code is not permitted  #
+#  unless licensed.                                             #
+#  Dynamic Application Discovery                                #                        
+#                                                               #            
+#  Last Updated: 6/03/08                                        #  
+#---------------------------------------------------------------#
+#                                                               #  
+# RubyRunRSS provides the interfaces for creating RSS channel   #
+# and adding items to it.                                       #
+#                                                               #  
+#---------------------------------------------------------------#
+
+require 'rss/maker'
+
+class RubyRunRSS
+  RUBYRUN_RSS_VERSION                              = '2.0'
+  RUBYRUN_RSS_CHANNEL_URL                          = 'http://www.rubysophic.com'
+  RUBYRUN_RSS_IMAGE_TITLE                          = 'Learn more about RubyRun from Rubysophic'
+  RUBYRUN_RSS_IMAGE_URL                            = 'http://www.rubysophic.com/images/logo.jpg'
+  RUBYRUN_RSS_FOLDER                               = 'rubyrun_rss'
+  RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_TITLE           = 'RubyRun: %s Performance Summary'
+  RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_ITEM_FILENAME   = 'perf_summary_item'
+  RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_DESCRIPTION     = 'RubyRun delivers up-to-the-minute performance summary of your application.'
+  RUBYRUN_RSS_PERF_SUMMARY_CHANNEL_FILENAME        = 'perf_summary.xml'
+  RUBYRUN_RSS_PERF_SUMMARY_ITEM_TITLE              = 'Performance summary at %s'
+  RUBYRUN_RSS_PERF_SUMMARY_ITEM_DESCRIPTION        = 'Performance summary of %s at %s'  
+  
+  # Constructor of the class.
+  # RSS XML file and HTML files will be kept in the directory as specified                
+  def initialize (title, description, directory, rss_filename, html_filename)
+    @title = title
+    @description = description
+    @directory = directory
+    @rss_filename = rss_filename
+    @html_filename = html_filename
+    @apps_name = Rails::Configuration.new.root_path.split('/').last
+    @rss_xml_destination = "#{@directory}/#{@rss_filename}"
+    create_channel_content unless File::exists?(@rss_xml_destination)
+    @rss = load_rss_content
+  end
+
+  # Create the RSS channel
+  def create_channel_content
+    content = RSS::Maker.make(RUBYRUN_RSS_VERSION) do |m|
+      m.channel.title = sprintf(@title, @apps_name)
+      m.channel.link = RUBYRUN_RSS_CHANNEL_URL
+      m.channel.description = @description
+      m.items.do_sort = true # sort items by date
+      m.image.title = RUBYRUN_RSS_IMAGE_TITLE
+      m.image.width = 140
+      m.image.height = 25
+      m.image.url = RUBYRUN_RSS_IMAGE_URL
+    end
+    File.open(@rss_xml_destination,"w") do |f|
+      f.write(content)
+    end
+    content.to_s
+  end
+
+  # Add an item to the RSS channel
+  def add_item (title, description, html_content)
+    filename = "#{@html_filename}_#{Time.now.to_i}#{rand(1000000)}.html"
+    File.open("#{@directory}/#{filename}", 'w') { |file| file.puts html_content }  
+    item = RSS::Rss::Channel::Item.new
+    item.title = sprintf(title, Time.now.strftime("%H:%M:%S"))
+    item.description = sprintf(description, @apps_name, Time.now.strftime("%H:%M:%S"))
+    item.link = "http://#{$rubyrun_host_with_port}/#{RUBYRUN_RSS_FOLDER}/#{filename}"
+    remove_old_item(@rss) if @rss.items.length == $rubyrun_report_shift_age
+    @rss.items << item
+    File.open(@rss_xml_destination,"w") do |f|
+      f.write(@rss)
+    end    
+  end
+  
+  private
+  
+  # Load the existing RSS XML file. Create a new channel if the channel is blank
+  def load_rss_content
+    content = "" # raw content of rss feed will be loaded here
+    open(@rss_xml_destination) do |s| content = s.read end
+    content = create_channel_content if content == ''
+    RSS::Parser.parse(content, false)    
+  end
+  
+  # Remove the last item in the RSS channel
+  def remove_old_item(rss)
+    item = rss.items.shift
+    filename = "#{@directory}/#{item.link.split('/').last}"
+    File.delete(filename) if File.exists?(filename)
+  end  
+  
+end