rubyrun 0.9.5-x86-mswin32-60

data/lib/rubyrun/rubyrun_monitor__.rb

@@ -0,0 +1,238 @@
+#---------------------------------------------------------------#
+#                                                               #  
+#  (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)
+    return unless ($rubyrun_thread_local[tid] || is_action?(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)
+      $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

data/lib/rubyrun/rubyrun_tracer__.rb

@@ -0,0 +1,79 @@
+#---------------------------------------------------------------#
+#                                                               #  
+#  (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                                        #  
+#---------------------------------------------------------------#
+#                                                               #  
+#  RubyRunTracer__ is the module for tracing a line of data     #
+#  in the output destination.                                   #
+#                                                               #            
+#  The source of the trace can be data from forward-tracing     #
+#  or data collected from a stack trace.			                  #
+#                                                               #  
+#---------------------------------------------------------------#
+module RubyRunTracer__
+  
+  require 'rubyrun_globals'
+  require 'rubyrun_utils__'
+  require 'rubyrun_html__'
+  include RubyRunGlobals
+  include RubyRunUtils__
+  include RubyRunHTML__
+    
+  # 1. If arguments are required to trace, try using kernel inspect to print it
+  # 2. If obejct is required to trace, try using kernel inspect to print it. 
+  # Otherwise print class name, The inspect can cause recursion and blow up
+  # ruby. Rescue only delays the issue hence not used here.
+  # 3. Show the last caller and line 
+  def enter_trace(tid, type, obj, invoker, klass, mid, *args)
+    @rubyrun_trace_odd_row = true if @rubyrun_trace_odd_row == nil
+    cur_time = Time.now
+    html_content = sprintf("#{@rubyrun_trace_odd_row ? METHOD_TRACE_ODD_ROW : METHOD_TRACE_EVEN_ROW}",
+                           "#{cur_time.strftime("%H:%M:%S")}.#{("%.3f" % cur_time.to_f).split('.')[1]} #{cur_time.strftime("%m/%d/%y")}",
+                           get_thread_id,
+                           "#{type.split(' ').reverse.first}",
+                           "#{type.split(' ').length == 3 ? '#3B9C9C' : (@rubyrun_trace_odd_row ? '#AFDCEC' : 'white')}",
+                           "#{type.split(' ').length == 1 ? '' : (type.split(' ').length == 3 ? '*'+type.split(' ').reverse[1]+'s' : type.split(' ').reverse[1]+'s')}",
+                           klass.to_s,
+                           return_method_name(mid),
+                           "#{args.each {|arg| arg.inspect} if $rubyrun_debug_args || is_in_hash?($rubyrun_adapter_hash, klass, mid)}",
+                           "#{$rubyrun_debug_obj && obj ? obj.inspect : obj.class if obj}",
+                           "#{invoker if invoker}")
+    write_trace(html_content)
+    @rubyrun_trace_odd_row = !@rubyrun_trace_odd_row
+  end
+  
+  # Write a trace entry to the trace destination
+  def write_trace(html_content)
+    begin
+      $rubyrun_tracer.info(html_content)
+    rescue Exception => e
+      $rubyrun_logger.warn(e.to_s)
+    end
+  end
+  
+  # The stack trace global hash is printed out in the rubyrun log in
+  # thread id order, also showing the top stack of all these
+  # threads before they were interrupted.
+  def back_trace_all(th_data_hash)
+    $rubyrun_thread_dump_reporter.info "----- RubyRun Thread Dump STARTS-----"
+    $rubyrun_thread_stack.each {|th, stack|
+      $rubyrun_thread_dump_reporter.info
+      thread_id = get_thread_id(th)
+      $rubyrun_thread_dump_reporter.info "Thread ID = #{thread_id}"
+      $rubyrun_thread_dump_reporter.info "    Last line before interrupt: #{get_top_stack(th_data_hash, thread_id)}"
+      $rubyrun_thread_dump_reporter.info "    Stack trace at interrupt"
+      stack.each {|line|
+        $rubyrun_thread_dump_reporter.info "\t#{line}"
+      }
+    }
+    $rubyrun_thread_dump_reporter.info
+    $rubyrun_thread_dump_reporter.info "----- RubyRun Thread Dump ENDS -----"
+    $rubyrun_thread_stack.clear
+  end    
+end

data/lib/rubyrun/rubyrun_utils__.rb

@@ -0,0 +1,101 @@
+#---------------------------------------------------------------#
+#                                                               #  
+#  (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                                        #  
+#---------------------------------------------------------------#
+#                                                               #  
+# RubyRunUtils__ is a module that owns common methods shared    #
+# by all the other RubyRun modules.                             # 
+#                                                               #  
+#---------------------------------------------------------------#
+module RubyRunUtils__
+
+  require 'rubyrun_globals'
+  include RubyRunGlobals
+  
+  # Return a readable thread ID for the current thread of execution
+  def get_thread_id(th=Thread.current)
+    th.inspect.split(/Thread:0x/)[1].split(/ .*?>/)[0]
+  end
+
+  # Retrieve caller details (filename, line number, method name)
+  def get_caller_detail(n=3)
+    caller(0)[n].gsub("#{RUBYRUN_PREFIX}_", '').gsub('//', '/') 
+  end
+
+  # Environment variable not defined or defined with nil value is deemed to
+  # be non-existent
+  def env_var_exists?(var)
+    ENV[var].nil? || ENV[var] == '' ? false : true
+  end
+
+  # Error exit
+  def fatal_exit(e)
+    $stderr.print e.to_s + "\n" + e.backtrace.join("\n")
+    exit(-1)
+  end
+  
+  # Return true if a Rails Action Controller class 
+  # A module or object has no superclass hence the rescue clause
+  def is_rails_controller?(klass)
+    return true if $rubyrun_controller_classes.include?(klass)
+    $rubyrun_rails_env ||= ENV['RAILS_ENV']
+    begin
+      ($rubyrun_controller_classes << klass; return true) if $rubyrun_rails_env &&
+        klass.to_s[-10, 10] == 'Controller' && is_application_controller(klass)
+    rescue
+    end      
+    false    
+  end
+  
+  # Return true if this is an action method in a controller class
+  def is_action?(klass, mid)
+    !klass.private_instance_methods(false).include?(return_method_name(mid))    
+  end
+  
+  # Given a class, it's deemed to be a Rails Action Controller if one of its
+  # ancestors is ApplicationController
+  def is_application_controller(klass)
+    return false unless klass.superclass
+    if klass.superclass == ApplicationController
+      return true
+    else
+      is_application_controller(klass.superclass)
+    end
+  end
+
+  # Return false if the passed in hash is empty
+  # Return false if the hash doenst even have the class name as a key
+  # Return true if the hash has the key but the method array is empty
+  # Return true if the method array has a case-insensitive matching name,
+  # matching can be exact or 'include'.
+  # Otherwise return false
+  def is_in?(hash, klass, mid, mode='loose')
+    return false if hash.empty?
+    [klass.to_s, klass.class.to_s, '*'].each {|name|
+      if hash.has_key?(name)
+        return true if hash[name].empty? 
+        method_name = return_method_name(mid)
+        hash[name].each {|meth_name|
+        case mode
+          when 'strict'
+            return true if method_name.downcase == meth_name.downcase 
+          when 'loose'
+            return true if method_name.downcase.include?(meth_name.downcase) 
+          end
+        }
+      end
+    }
+    false
+  end 
+  
+  # Return method name since mid can be an method object ID or a string
+  def return_method_name(mid)
+    mid.kind_of?(String) ? mid : mid.id2name
+  end
+end