request_profiler 0.0.1 → 0.0.2

data/lib/rack/request_profiler.rb

@@ -5,8 +5,7 @@ module Rack
     def initialize(app, options = {})
       @app = app
       @printer = options[:printer] || ::RubyProf::GraphHtmlPrinter
-      @mode = options[:mode] || ::RubyProf::PROCESS_TIME
-      @eliminations = options[:eliminations]
+      @exclusions = options[:exclude]
 
       @path = options[:path]
       @path ||= Rails.root + 'tmp/performance' if defined?(Rails)
@@ -16,15 +15,15 @@ module Rack
 
     def call(env)
       request = Rack::Request.new(env)
-      profile_request = request.params.delete("profile_request") == "true"
-
-      if profile_request
-        ::RubyProf.measure_mode = @mode
+      mode = profile_mode(request)
+      
+      if mode
+        ::RubyProf.measure_mode = mode
         ::RubyProf.start
       end
       status, headers, body = @app.call(env)
 
-      if profile_request
+      if mode
         result = ::RubyProf.stop
         write_result(result, request)
       end
@@ -32,6 +31,17 @@ module Rack
       [status, headers, body]
     end
 
+    def profile_mode(request)
+      mode_string = request.params["profile_request"]
+      if mode_string
+        if mode_string.downcase == "true"
+          ::RubyProf::PROCESS_TIME
+        else
+          ::RubyProf.const_get(mode_string.upcase)
+        end
+      end
+    end
+
     def format(printer)
       case printer
       when ::RubyProf::FlatPrinter
@@ -54,15 +64,13 @@ module Rack
     end
 
     def write_result(result, request)
+      result.eliminate_methods!(@exclusions) if @exclusions
       printer = @printer.new(result)
       Dir.mkdir(@path) unless ::File.exists?(@path)
       url = request.fullpath.gsub(/[?\/]/, '-')
       filename = "#{Time.now.strftime('%Y-%m-%d-%H-%M-%S')}-#{url}.#{format(printer)}"
       ::File.open(@path + filename, 'w+') do |f|
-        # HACK to keep this from crashing under patched 1.9.2
-        GC.disable
         printer.print(f)
-        GC.enable
       end
     end
   end

data/lib/request_profiler/version.rb

@@ -1,3 +1,3 @@
 module RequestProfiler
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/patches/set_trace_func_fix192.patch

@@ -0,0 +1,389 @@
+diff --git a/ChangeLog b/ChangeLog
+index fb1dc55..63cde44 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,21 @@
++Sat Oct  9 11:00:06 2010  Nobuyoshi Nakada  <nobu@ruby-lang.org>
++
++	* thread.c (thread_reset_event_flags, exec_event_hooks): ignore
++	  hooks marked as removed.
++
++	* thread.c (thread_exec_event_hooks): remove hooks to be removed.
++
++	* thread.c (rb_threadptr_remove_event_hook, rb_remove_event_hook):
++	  defer removing hooks if running the hooks.  [ruby-dev:42350]
++
++Sat Oct  9 10:51:00 2010  Nobuyoshi Nakada  <nobu@ruby-lang.org>
++
++	* thread.c (rb_threadptr_exec_event_hooks): suppress each event
++	  hooks separately.
++
++	* thread.c (thread_suppress_tracing): split from
++	  ruby_suppress_tracing, accepting thread pointer and event mask.
++
+ Wed Aug 18 01:37:49 2010  NARUSE, Yui  <naruse@ruby-lang.org>
+ 
+ 	* regcomp.c: revert r26701; it introduces Bug #3681.
+diff --git a/gc.c b/gc.c
+index 25fcc3d..f6d74c3 100644
+--- a/gc.c
++++ b/gc.c
+@@ -1195,7 +1195,7 @@ ruby_get_stack_grow_direction(volatile VALUE *addr)
+ }
+ #endif
+ 
+-#define GC_WATER_MARK 512
++#define GC_WATER_MARK 1024
+ 
+ size_t
+ ruby_stack_length(VALUE **p)
+diff --git a/test/ruby/test_settracefunc.rb b/test/ruby/test_settracefunc.rb
+index f885cb0..576b4da 100644
+--- a/test/ruby/test_settracefunc.rb
++++ b/test/ruby/test_settracefunc.rb
+@@ -354,4 +354,16 @@ class TestSetTraceFunc < Test::Unit::TestCase
+     assert_equal([], events[:set])
+     assert_equal([], events[:add])
+   end
++
++  def test_remove_in_trace
++    bug3921 = '[ruby-dev:42350]'
++    ok = false
++    func = lambda{|e, f, l, i, b, k|
++      set_trace_func(nil)
++      ok = eval("self", b)
++    }
++
++    set_trace_func(func)
++    assert_equal(self, ok, bug3921)
++  end
+ end
+diff --git a/thread.c b/thread.c
+index aa6eced..a550a9a 100644
+--- a/thread.c
++++ b/thread.c
+@@ -3700,6 +3700,27 @@ rb_exec_recursive_outer(VALUE (*func) (VALUE, VALUE, int), VALUE obj, VALUE arg)
+ }
+ 
+ /* tracer */
++#define RUBY_EVENT_REMOVED 0x1000000
++
++enum {
++    EVENT_RUNNING_NOTHING,
++    EVENT_RUNNING_TRACE = 1,
++    EVENT_RUNNING_THREAD = 2,
++    EVENT_RUNNING_VM = 4,
++    EVENT_RUNNING_EVENT_MASK = EVENT_RUNNING_VM|EVENT_RUNNING_THREAD
++};
++
++static VALUE thread_suppress_tracing(rb_thread_t *th, int ev, VALUE (*func)(VALUE, int), VALUE arg, int always);
++VALUE ruby_suppress_tracing(VALUE (*func)(VALUE, int), VALUE arg, int always);
++
++struct event_call_args {
++    rb_thread_t *th;
++    VALUE klass;
++    VALUE self;
++    VALUE proc;
++    ID id;
++    rb_event_flag_t event;
++};
+ 
+ static rb_event_hook_t *
+ alloc_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data)
+@@ -3718,7 +3739,8 @@ thread_reset_event_flags(rb_thread_t *th)
+     rb_event_flag_t flag = th->event_flags & RUBY_EVENT_VM;
+ 
+     while (hook) {
+-	flag |= hook->flag;
++	if (!(flag & RUBY_EVENT_REMOVED))
++	    flag |= hook->flag;
+ 	hook = hook->next;
+     }
+     th->event_flags = flag;
+@@ -3771,34 +3793,74 @@ set_threads_event_flags(int flag)
+     st_foreach(GET_VM()->living_threads, set_threads_event_flags_i, (st_data_t) flag);
+ }
+ 
+-static inline void
++static inline int
+ exec_event_hooks(const rb_event_hook_t *hook, rb_event_flag_t flag, VALUE self, ID id, VALUE klass)
+ {
++    int removed = 0;
+     for (; hook; hook = hook->next) {
++	if (hook->flag & RUBY_EVENT_REMOVED) {
++	    removed++;
++	    continue;
++	}
+ 	if (flag & hook->flag) {
+ 	    (*hook->func)(flag, hook->data, self, id, klass);
+ 	}
+     }
++    return removed;
+ }
+ 
+-void
+-rb_threadptr_exec_event_hooks(rb_thread_t *th, rb_event_flag_t flag, VALUE self, ID id, VALUE klass)
+-{
+-    const VALUE errinfo = th->errinfo;
++static int remove_defered_event_hook(rb_event_hook_t **root);
++
++static VALUE
++thread_exec_event_hooks(VALUE args, int running)
++{
++    struct event_call_args *argp = (struct event_call_args *)args;
++    rb_thread_t *th = argp->th;
++    rb_event_flag_t flag = argp->event;
++    VALUE self = argp->self;
++    ID id = argp->id;
++    VALUE klass = argp->klass;
+     const rb_event_flag_t wait_event = th->event_flags;
++    int removed;
++
++    if (self == rb_mRubyVMFrozenCore) return 0;
+ 
+-    if (self == rb_mRubyVMFrozenCore) return;
+-    if (wait_event & flag) {
+-	exec_event_hooks(th->event_hooks, flag, self, id, klass);
++    if ((wait_event & flag) && !(running & EVENT_RUNNING_THREAD)) {
++	th->tracing |= EVENT_RUNNING_THREAD;
++	removed = exec_event_hooks(th->event_hooks, flag, self, id, klass);
++	th->tracing &= ~EVENT_RUNNING_THREAD;
++	if (removed) {
++	    remove_defered_event_hook(&th->event_hooks);
++	}
+     }
+     if (wait_event & RUBY_EVENT_VM) {
+ 	if (th->vm->event_hooks == NULL) {
+ 	    th->event_flags &= (~RUBY_EVENT_VM);
+ 	}
+-	else {
+-	    exec_event_hooks(th->vm->event_hooks, flag, self, id, klass);
++	else if (!(running & EVENT_RUNNING_VM)) {
++	    th->tracing |= EVENT_RUNNING_VM;
++	    removed = exec_event_hooks(th->vm->event_hooks, flag, self, id, klass);
++	    th->tracing &= ~EVENT_RUNNING_VM;
++	    if (removed) {
++		remove_defered_event_hook(&th->vm->event_hooks);
++	    }
+ 	}
+     }
++    return 0;
++}
++
++void
++rb_threadptr_exec_event_hooks(rb_thread_t *th, rb_event_flag_t flag, VALUE self, ID id, VALUE klass)
++{
++    const VALUE errinfo = th->errinfo;
++    struct event_call_args args;
++    args.th = th;
++    args.event = flag;
++    args.self = self;
++    args.id = id;
++    args.klass = klass;
++    args.proc = 0;
++    thread_suppress_tracing(th, EVENT_RUNNING_EVENT_MASK, thread_exec_event_hooks, (VALUE)&args, FALSE);
+     th->errinfo = errinfo;
+ }
+ 
+@@ -3815,23 +3877,49 @@ rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data)
+ }
+ 
+ static int
++defer_remove_event_hook(rb_event_hook_t *hook, rb_event_hook_func_t func)
++{
++    while (hook) {
++	if (func == 0 || hook->func == func) {
++	    hook->flag |= RUBY_EVENT_REMOVED;
++	}
++	hook = hook->next;
++    }
++    return -1;
++}
++
++static int
+ remove_event_hook(rb_event_hook_t **root, rb_event_hook_func_t func)
+ {
+-    rb_event_hook_t *prev = NULL, *hook = *root, *next;
++    rb_event_hook_t *hook = *root, *next;
+ 
+     while (hook) {
+ 	next = hook->next;
+-	if (func == 0 || hook->func == func) {
+-	    if (prev) {
+-		prev->next = hook->next;
+-	    }
+-	    else {
+-		*root = hook->next;
+-	    }
++	if (func == 0 || hook->func == func || (hook->flag & RUBY_EVENT_REMOVED)) {
++	    *root = next;
++	    xfree(hook);
++	}
++	else {
++	    root = &hook->next;
++	}
++	hook = next;
++    }
++    return -1;
++}
++
++static int
++remove_defered_event_hook(rb_event_hook_t **root)
++{
++    rb_event_hook_t *hook = *root, *next;
++
++    while (hook) {
++	next = hook->next;
++	if (hook->flag & RUBY_EVENT_REMOVED) {
++	    *root = next;
+ 	    xfree(hook);
+ 	}
+ 	else {
+-	    prev = hook;
++	    root = &hook->next;
+ 	}
+ 	hook = next;
+     }
+@@ -3841,7 +3929,13 @@ remove_event_hook(rb_event_hook_t **root, rb_event_hook_func_t func)
+ static int
+ rb_threadptr_revmove_event_hook(rb_thread_t *th, rb_event_hook_func_t func)
+ {
+-    int ret = remove_event_hook(&th->event_hooks, func);
++    int ret;
++    if (th->tracing & EVENT_RUNNING_THREAD) {
++	ret = defer_remove_event_hook(th->event_hooks, func);
++    }
++    else {
++	ret = remove_event_hook(&th->event_hooks, func);
++    }
+     thread_reset_event_flags(th);
+     return ret;
+ }
+@@ -3852,14 +3946,49 @@ rb_thread_remove_event_hook(VALUE thval, rb_event_hook_func_t func)
+     return rb_threadptr_revmove_event_hook(thval2thread_t(thval), func);
+ }
+ 
++static rb_event_hook_t *
++search_live_hook(rb_event_hook_t *hook)
++{
++    while (hook) {
++	if (!(hook->flag & RUBY_EVENT_REMOVED))
++	    return hook;
++	hook = hook->next;
++    }
++    return NULL;
++}
++
++static int
++running_vm_event_hooks(st_data_t key, st_data_t val, st_data_t data)
++{
++    rb_thread_t *th = thval2thread_t((VALUE)key);
++    if (!(th->tracing & EVENT_RUNNING_VM)) return ST_CONTINUE;
++    *(rb_thread_t **)data = th;
++    return ST_STOP;
++}
++
++static rb_thread_t *
++vm_event_hooks_running_thread(rb_vm_t *vm)
++{
++    rb_thread_t *found = NULL;
++    st_foreach(vm->living_threads, running_vm_event_hooks, (st_data_t)&found);
++    return found;
++}
++
+ int
+ rb_remove_event_hook(rb_event_hook_func_t func)
+ {
+     rb_vm_t *vm = GET_VM();
+-    rb_event_hook_t *hook = vm->event_hooks;
+-    int ret = remove_event_hook(&vm->event_hooks, func);
++    rb_event_hook_t *hook = search_live_hook(vm->event_hooks);
++    int ret;
++
++    if (vm_event_hooks_running_thread(vm)) {
++	ret = defer_remove_event_hook(vm->event_hooks, func);
++    }
++    else {
++	ret = remove_event_hook(&vm->event_hooks, func);
++    }
+ 
+-    if (hook != NULL && vm->event_hooks == NULL) {
++    if (hook && !search_live_hook(vm->event_hooks)) {
+ 	set_threads_event_flags(0);
+     }
+ 
+@@ -4020,20 +4149,10 @@ get_event_name(rb_event_flag_t event)
+     }
+ }
+ 
+-VALUE ruby_suppress_tracing(VALUE (*func)(VALUE, int), VALUE arg, int always);
+-
+-struct call_trace_func_args {
+-    rb_event_flag_t event;
+-    VALUE proc;
+-    VALUE self;
+-    ID id;
+-    VALUE klass;
+-};
+-
+ static VALUE
+ call_trace_proc(VALUE args, int tracing)
+ {
+-    struct call_trace_func_args *p = (struct call_trace_func_args *)args;
++    struct event_call_args *p = (struct event_call_args *)args;
+     const char *srcfile = rb_sourcefile();
+     VALUE eventname = rb_str_new2(get_event_name(p->event));
+     VALUE filename = srcfile ? rb_str_new2(srcfile) : Qnil;
+@@ -4048,7 +4167,7 @@ call_trace_proc(VALUE args, int tracing)
+ 	klass = p->klass;
+     }
+     else {
+-	rb_thread_method_id_and_class(GET_THREAD(), &id, &klass);
++	rb_thread_method_id_and_class(p->th, &id, &klass);
+     }
+     if (id == ID_ALLOCATOR)
+       return Qnil;
+@@ -4074,8 +4193,9 @@ call_trace_proc(VALUE args, int tracing)
+ static void
+ call_trace_func(rb_event_flag_t event, VALUE proc, VALUE self, ID id, VALUE klass)
+ {
+-    struct call_trace_func_args args;
++    struct event_call_args args;
+ 
++    args.th = GET_THREAD();
+     args.event = event;
+     args.proc = proc;
+     args.self = self;
+@@ -4088,22 +4208,28 @@ VALUE
+ ruby_suppress_tracing(VALUE (*func)(VALUE, int), VALUE arg, int always)
+ {
+     rb_thread_t *th = GET_THREAD();
+-    int state, tracing;
++    return thread_suppress_tracing(th, EVENT_RUNNING_TRACE, func, arg, always);
++}
++
++static VALUE
++thread_suppress_tracing(rb_thread_t *th, int ev, VALUE (*func)(VALUE, int), VALUE arg, int always)
++{
++    int state, tracing = th->tracing, running = tracing & ev;
+     volatile int raised;
+     VALUE result = Qnil;
+ 
+-    if ((tracing = th->tracing) != 0 && !always) {
++    if (running == ev && !always) {
+ 	return Qnil;
+     }
+     else {
+-	th->tracing = 1;
++	th->tracing |= ev;
+     }
+ 
+     raised = rb_threadptr_reset_raised(th);
+ 
+     PUSH_TAG();
+     if ((state = EXEC_TAG()) == 0) {
+-	result = (*func)(arg, tracing);
++	result = (*func)(arg, running);
+     }
+ 
+     if (raised) {

data/test/request_profiler_test.rb

@@ -31,6 +31,17 @@ class RequestProfilerTest < Test::Unit::TestCase
     assert last_response.ok?
   end
 
+  def test_mode_set_by_param
+    self.app = Rack::RequestProfiler.new(FakeApp.new)
+    RubyProf.expects(:measure_mode=).with(::RubyProf::PROCESS_TIME)
+    get "/?profile_request=true"
+    assert last_response.ok?
+
+    RubyProf.expects(:measure_mode=).with(::RubyProf::WALL_TIME)
+    get "/?profile_request=wall_time"
+    assert last_response.ok?
+  end
+  
   def test_file_format
     self.app = Rack::RequestProfiler.new(FakeApp.new)
     RubyProf.start

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Justin Weiss
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-15 00:00:00 -08:00
+date: 2010-12-16 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -87,6 +87,7 @@ files:
 - lib/rack/request_profiler.rb
 - lib/request_profiler.rb
 - lib/request_profiler/version.rb
+- patches/set_trace_func_fix192.patch
 - request_profiler.gemspec
 - test/fake_app.rb
 - test/request_profiler_test.rb