xray 1.1

data/lib/xray/dtrace/rails/enable_tracing.rb

@@ -0,0 +1,25 @@
+# Require this file to enable out the box DTrace tracing 
+# for your Rails application
+#
+# You typically change your environment.rb to require it after config
+# initialization:
+#
+#   Rails::Initializer.run do |config|
+#
+#     ...
+#
+#     config.after_initialize do
+#       require "xray/dtrace/rails/enable_tracing"
+#     end  
+#   end
+
+require File.expand_path(File.dirname(__FILE__) + '/../tracer')
+if Object.const_defined? :ActionController
+  puts "XRay: Enabling Rails Controller Tracing"
+  require File.expand_path(File.dirname(__FILE__) + "/../rails/action_controller_tracing_extension")
+end
+
+if Object.const_defined? :ActiveRecord
+  puts "XRay: Enabling Rails DB Tracing"
+  require File.expand_path(File.dirname(__FILE__) + "/../rails/active_record_connection_tracing_extension")
+end

data/lib/xray/dtrace/tracer.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/tracer/leopard.rb'
+require File.dirname(__FILE__) + '/tracer/joyent.rb'
+
+module XRay
+  module DTrace
+    
+    # Ruby module to fire application-level Dtrace events (using ruby-probe).
+    # 
+    # This module provide a convenient and unified API abstracting 
+    # different tracing implementations in Leopard Ruby VM (by Apple) 
+    # and in the one provided by Joyent (https://dev.joyent.com/projects/ruby-dtrace). 
+    # This module also provides a NOOP implementation for Ruby VMs with 
+    # no DTrace support: So you can use the exact same code while developing
+    # on Linux and deploying on Solaris for instance.
+    module Tracer
+
+      # Fire an application-level probe using ruby-probe.
+      #   
+      # The first argument passed will be passed to the D script as arg0 for
+      # the ruby-probe probe. This is conventionally a probe name.
+      #   
+      # The second argument is optional and can be used to pass additional
+      # data into the D script as arg1.
+      #
+      # Example:
+      #   
+      # XRay::DTrace::Tracer.fire('service-start', "order processing")
+      #
+      # XRay::DTrace::Tracer.fire('service-stop')
+      #
+      def fire(name, data = nil)
+      end
+
+      # Use ruby-probe to fire 2 application-level probes before and after
+      # evaling a block .
+      #    
+      # The first argument passed will be passed to the D script as arg0 for
+      # the ruby-probe probe. The first argument is conventionally a 
+      # probe base name. The probes which fire before and after the block 
+      # runs will have "-start" and "-end" appended to the probe base name, 
+      # respectively.
+      #    
+      # The second argument is optional and can be used to pass additional
+      # data into the D script as arg1.
+      #
+      # Example:
+      #    
+      # XRay::DTrace::Tracer.firing('db-query', "select * from dual;") do
+      #   ActiveRecord::Base.execute("select * from dual;")
+      # 
+      # end
+      #
+      # Will:
+      # 1. Fire a probe with arg0 set to "db-query-start", and arg1 set
+      #    to the sql query.
+      # 
+      # 2. Run the block and execute the SQL.
+      #
+      # 3. Fire a probe with arg0 set to "db-query-start".    
+      def firing(name, data = nil)
+        yield
+      end
+
+      # Returns true if ruby-probe probes are enabled.
+      # (application-level probes for Ruby).
+      def enabled?
+        false
+      end
+    
+    end
+
+    if Object.const_defined?(:DTracer)
+      actual_tracer = Tracer::Leopard
+      send :remove_const, :Tracer
+      Tracer = actual_tracer
+    elsif Object.const_defined?(:Tracer) && Tracer.methods.include?(:fire)
+      actual_tracer = Tracer::Joyent
+      send :remove_const, :Tracer
+      Tracer = actual_tracer
+    else
+      # No DTrace support, keep the NOOP implementation
+    end
+    
+  end
+end
+

data/lib/xray/dtrace/tracer/joyent.rb

@@ -0,0 +1,25 @@
+module XRay
+  module DTrace
+    module Tracer
+    
+      # Wrapper around OS X DTracer exposing a custom API and namespace.
+      module Joyent
+
+        def fire(name, data = nil)    #:nodoc: all      
+          ::Tracer.fire(name, data)
+        end
+
+        def firing(name, data = nil) #:nodoc: all      
+          ::Tracer.fire(name, data)
+        end
+      
+        def enabled?  #:nodoc: all      
+          STDERR.puts "WARNING: XRay::DTrace.Tracer.enabled? does not work with Joyent Tracer"
+          false
+        end
+            
+      end
+      
+    end  
+  end
+end

data/lib/xray/dtrace/tracer/leopard.rb

@@ -0,0 +1,28 @@
+module XRay
+  module DTrace
+    module Tracer
+
+      # Wrapper around OS X DTracer exposing a custom API and namespace.
+      module Leopard
+      
+        def fire(name, data = nil)
+          DTracer.fire(name, data)
+        end
+
+        def firing(name, data = nil)
+          fire(name + "-start", data)
+          result = yield
+          fire(name + "-end", data)
+          result
+        end
+
+        def enabled?
+          DTracer.enabled?
+        end
+      
+      end
+      
+    end
+    
+  end
+end

data/lib/xray/dtrace/usdt/provider_extensions.rb

@@ -0,0 +1,45 @@
+#
+# Extend ruby-dtrace API with a more convenient one to fire custom USDT
+# probes
+#
+
+require "rubygems"
+require 'dtrace/provider'
+
+class Dtrace
+
+  class Provider
+    
+    alias :original_load :load
+    def load
+      provider_module = original_load
+      
+      xray_extension_module = Module.new do
+        @@provider_module = provider_module
+        
+        def firing(function_prefix, *args)
+          @@provider_module.send :"#{function_prefix}_start" do |probe|
+            probe.fire(*args)
+          end
+          result = yield
+          @@provider_module.send :"#{function_prefix}_end" do |probe|
+            probe.fire(*args)
+          end
+          result
+        end
+
+        def fire(function_name, *args)
+          @@provider_module.send function_name do |p|
+            p.fire(*args)
+          end
+        end
+
+      end
+              
+      provider_module.const_set :XRay, xray_extension_module
+      provider_module     
+    end
+    
+  end
+  
+end

data/lib/xray/thread_dump_signal_handler.rb

@@ -0,0 +1,31 @@
+#
+# Install a signal handler to dump backtraces for all threads
+#
+# Trigger it with: kill -QUIT <pid>
+#  
+trap "QUIT" do
+  if Kernel.respond_to? :caller_for_all_threads
+    STDERR.puts "\n=============== XRay - Thread Dump ==============="
+    caller_for_all_threads.each_pair do |thread, stack|
+      thread_description = thread.inspect
+      thread_description << " [main]" if thread == Thread.main
+      thread_description << " [current]" if thread == Thread.current
+      thread_description << " alive=#{thread.alive?}"
+      thread_description << " priority=#{thread.priority}"
+      thread_separator = "-" * 78
+      
+      full_description = "\n#{thread_separator}\n"
+      full_description << thread_description
+      full_description << "\n#{thread_separator}\n"
+      full_description << "    #{stack.join("\n      \\_ ")}\n"
+      
+      # Single puts to avoid interleaved output
+      STDERR.puts full_description
+    end
+  else
+    STDERR.puts "=============== XRay - Current Thread Backtrace ==============="
+    STDERR.puts "Current thread : #{Thread.inspect}"
+    STDERR.puts caller.join("\n    \\_ ")
+  end
+  STDERR.puts "\n=============== XRay - Done ===============\n"
+end

data/patches_for_mri/caller_for_all_threads_patch_for_MRI_1.8.6.diff

@@ -0,0 +1,229 @@
+Index: test/callerforallthreads/test_caller_for_each_thread.rb
+===================================================================
+--- test/callerforallthreads/test_caller_for_each_thread.rb	(revision 0)
++++ test/callerforallthreads/test_caller_for_each_thread.rb	(revision 0)
+@@ -0,0 +1,95 @@
++# -*- ruby-indent-level: 4 -*-
++require 'thread'
++require 'test/unit'
++
++class AClassWithNestedmethods
++  
++  def an_ultra_nested_method(skip)
++    caller_for_all_threads skip
++  end
++
++  def a_nested_method(skip)
++    an_ultra_nested_method skip
++  end
++
++  def a_method(skip=0)
++    a_nested_method skip
++  end
++  
++end
++
++class CallerForEachThreadTest < Test::Unit::TestCase
++  
++  def testCollectMeaningfulBacktraceForASingleThread
++    backtraces = AClassWithNestedmethods.new.a_method
++    backtrace = backtraces[Thread.current]
++    assert_not_nil backtrace
++    assert_equal __FILE__ + ":8:in `an_ultra_nested_method'", backtrace[0]
++    assert_equal __FILE__ + ":12:in `a_nested_method'", backtrace[1]
++    assert_equal __FILE__ + ":16:in `a_method'", backtrace[2]
++    assert_equal __FILE__ + ":24:in `testCollectMeaningfulBacktraceForASingleThread'", 
++                 backtrace[3]
++  end
++
++  def testCanSkipFirstStackEntries
++    backtraces = AClassWithNestedmethods.new.a_method 2
++    backtrace = backtraces[Thread.current]
++    assert_not_nil backtrace
++    assert_equal __FILE__ + ":16:in `a_method'", backtrace[0]
++    assert_equal __FILE__ + ":35:in `testCanSkipFirstStackEntries'", 
++                 backtrace[1]
++  end
++
++  def testCollectMeaningfulBacktraceForMultipleThreads
++    first_thread = Thread.new do
++      loop do
++        Thread.pass
++        sleep 1
++      end
++    end
++
++    second_thread = Thread.new do
++      loop do
++        Thread.pass
++        sleep 1
++      end
++    end
++
++    backtraces = AClassWithNestedmethods.new.a_method
++    
++    backtrace = backtraces[Thread.current]
++    assert_not_nil backtrace
++    assert_match __FILE__ + ":8:in `an_ultra_nested_method'", backtrace[0]
++    assert_match __FILE__ + ":12:in `a_nested_method'", backtrace[1]
++    assert_equal __FILE__ + ":16:in `a_method'", backtrace[2]
++    assert_equal __FILE__ + ":58:in `testCollectMeaningfulBacktraceForMultipleThreads'", 
++                 backtrace[3]
++                 
++    backtrace = backtraces[first_thread]
++    assert_not_nil backtrace
++    assert_equal __FILE__ + ":47:in `testCollectMeaningfulBacktraceForMultipleThreads'", 
++                 backtrace[0]
++    assert_equal __FILE__ + ":45:in `loop'", 
++                 backtrace[1]
++    assert_equal __FILE__ + ":45:in `testCollectMeaningfulBacktraceForMultipleThreads'",
++                 backtrace[2]
++    assert_equal __FILE__ + ":44:in `initialize'",backtrace[3]
++    assert_equal __FILE__ + ":44:in `new'", backtrace[4]
++    assert_equal __FILE__ + ":44:in `testCollectMeaningfulBacktraceForMultipleThreads'",
++                 backtrace[5]
++
++    backtrace = backtraces[second_thread]
++    assert_not_nil backtrace
++    assert_equal __FILE__ + ":53:in `testCollectMeaningfulBacktraceForMultipleThreads'", 
++                 backtrace[0]
++    assert_equal __FILE__ + ":52:in `loop'", backtrace[1]
++    assert_equal __FILE__ + ":52:in `testCollectMeaningfulBacktraceForMultipleThreads'",
++                 backtrace[2]
++    assert_equal __FILE__ + ":51:in `initialize'",backtrace[3]
++    assert_equal __FILE__ + ":51:in `new'", backtrace[4]
++    assert_equal __FILE__ + ":51:in `testCollectMeaningfulBacktraceForMultipleThreads'",
++                 backtrace[5]
++  end
++  
++end
++
+Index: eval.c
+===================================================================
+--- eval.c	(revision 16289)
++++ eval.c	(working copy)
+@@ -7969,6 +7969,17 @@
+     ruby_safe_level = safe;
+ }
+ 
++/* Hash (Thread => Backtrace) used to collect backtrace for each threads. */
++static VALUE backtrace_for_each_thread;
++
++static int backtrace_level_for_each_thread;
++
++static VALUE
++switch_thread_context_to_collect_backtrace(rb_thread_t next);
++
++static VALUE
++rb_f_caller_for_all_threads();
++
+ void
+ Init_eval()
+ {
+@@ -8014,6 +8025,7 @@
+     rb_define_global_function("fail", rb_f_raise, -1);
+ 
+     rb_define_global_function("caller", rb_f_caller, -1);
++    rb_define_global_function("caller_for_all_threads", rb_f_caller_for_all_threads, -1);
+ 
+     rb_define_global_function("exit", rb_f_exit, -1);
+     rb_define_global_function("abort", rb_f_abort, -1);
+@@ -10206,6 +10218,7 @@
+ #define RESTORE_RAISE		5
+ #define RESTORE_SIGNAL		6
+ #define RESTORE_EXIT		7
++#define RESTORE_BACKTRACE	8
+ 
+ extern VALUE *rb_gc_stack_start;
+ #ifdef __ia64
+@@ -10313,6 +10326,15 @@
+ 	}
+ 	rb_exc_raise(th_raise_exception);
+ 	break;
++      case RESTORE_BACKTRACE:
++        rb_hash_aset(backtrace_for_each_thread, curr_thread->thread, 
++                     backtrace(backtrace_level_for_each_thread));
++        if (curr_thread != main_thread) {
++            switch_thread_context_to_collect_backtrace(curr_thread->next);
++        } else { 
++	        /* Circled back to main thread, cycle is complete. */
++        }
++        break;
+       case RESTORE_NORMAL:
+       default:
+ 	break;
+@@ -13240,3 +13262,74 @@
+     argv[1] = val;
+     rb_f_throw(2, argv);
+ }
++
++static VALUE
++switch_thread_context_to_collect_backtrace(rb_thread_t next)
++{
++    if (THREAD_SAVE_CONTEXT(curr_thread)) {
++        return Qnil;
++    }
++    curr_thread = next;
++    rb_thread_restore_context(next, RESTORE_BACKTRACE);
++    return Qnil;
++}
++
++
++/*
++ *  call-seq:
++ *     caller_for_all_threads(start=1)    => array
++ *  
++ *  Returns the current execution stack for all threads 
++ *  ---a hash whose keys are thread instances and values
++ *  the thread caller backtrace.
++ *
++ *  Backtraces are array of hashes indicating location on the 
++ *  stack. Hash keys include ``<em>:line</em>'' or ``<em>:file</em>''
++ *  and ``<em>:method'</em>''. 
++ *
++ *  The optional _start_ parameter
++ *  determines the number of initial stack entries to omit from the
++ *  result.
++ *     
++ *     def a(skip)
++ *       caller_for_all_threads(skip)
++ *     end
++ *     def b(skip)
++ *       a(skip)
++ *     end
++ *     def c(skip)
++ *       b(skip)
++ *     end
++ *     c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10"]
++ *     c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11"]
++ *     c(2)   #=> ["prog:8:in `c'", "prog:12"]
++ *     c(3)   #=> ["prog:13"]
++ */
++static VALUE
++rb_f_caller_for_all_threads(argc, argv)
++    int argc;
++    VALUE *argv;
++{
++    volatile int critical;
++    VALUE level;
++	VALUE result;
++
++    rb_scan_args(argc, argv, "01", &level);
++    backtrace_level_for_each_thread = NIL_P(level) ? 0 : NUM2INT(level);
++	if (backtrace_level_for_each_thread < 0) {
++		rb_raise(rb_eArgError, "negative level (%d)", backtrace_level_for_each_thread);
++	}
++
++	critical = rb_thread_critical;
++	rb_thread_critical = Qtrue;
++
++    backtrace_for_each_thread = rb_hash_new();
++    switch_thread_context_to_collect_backtrace(main_thread->next);
++
++	result = backtrace_for_each_thread;
++	backtrace_for_each_thread = Qnil;
++	backtrace_for_each_thread = 0;
++		
++	rb_thread_critical = critical;
++    return result;
++}