rack-mini-profiler 0.1.26 → 0.1.31

data/Ruby/lib/mini_profiler/context.rb

@@ -1,6 +1,6 @@
 class Rack::MiniProfiler::Context
   attr_accessor :inject_js,:current_timer,:page_struct,:skip_backtrace,:full_backtrace,:discard, :mpt_init, :measure
-  
+
   def initialize(opts = {})
     opts["measure"] = true unless opts.key? "measure"
     opts.each do |k,v|

data/Ruby/lib/mini_profiler/gc_profiler_ruby_head.rb

@@ -0,0 +1,40 @@
+require 'objspace'
+
+class Rack::MiniProfiler::GCProfilerRubyHead
+  def profile_rack(app,env)
+  end
+
+  def profile(&block)
+    GC.start
+    GC.disable
+
+    items = []
+    objs = []
+
+    ObjectSpace.trace_object_allocations do
+      block.call
+
+      ObjectSpace.each_object do |o|
+        objs << o
+      end
+
+      objs.each do |o|
+        g = ObjectSpace.allocation_generation(o)
+        if g
+          l = ObjectSpace.allocation_sourceline(o)
+          f = ObjectSpace.allocation_sourcefile(o)
+          c = ObjectSpace.allocation_class_path(o)
+          m = ObjectSpace.allocation_method_id(o)
+          items << "Allocated #{c} in #{m} #{f}:#{l}"
+        end
+      end
+    end
+
+    items.group_by{|x| x}.sort{|a,b| b[1].length <=> a[1].length}.each do |row, group|
+      puts "#{row} x #{group.length}"
+    end
+
+    GC.enable
+    profile_allocations(name, &block)
+  end
+end

data/Ruby/lib/mini_profiler/page_timer_struct.rb

@@ -43,16 +43,16 @@ module Rack
       def root
         @attributes['Root']
       end
-      
+
       def to_json(*a)
         attribs = @attributes.merge(
-          "Started" => '/Date(%d)/' % @attributes['Started'], 
+          "Started" => '/Date(%d)/' % @attributes['Started'],
           "DurationMilliseconds" => @attributes['Root']['DurationMilliseconds'],
           "CustomTimingNames" => @attributes['CustomTimingStats'].keys.sort
-        )        
+        )
         ::JSON.generate(attribs, :max_nesting => 100)
       end
     end
-    
+
   end
 end

data/Ruby/lib/mini_profiler/profiler.rb

@@ -18,7 +18,8 @@ require 'mini_profiler/profiling_methods'
 require 'mini_profiler/context'
 require 'mini_profiler/client_settings'
 require 'mini_profiler/gc_profiler'
-require 'mini_profiler/flame_graph'
+# TODO
+# require 'mini_profiler/gc_profiler_ruby_head' if Gem::Version.new('2.1.0') <= Gem::Version.new(RUBY_VERSION)
 
 module Rack
 
@@ -123,7 +124,7 @@ module Rack
 
         # Otherwise give the HTML back
         html = MiniProfiler.share_template.dup
-        html.gsub!(/\{path\}/, @config.base_url_path)
+        html.gsub!(/\{path\}/, "#{env['SCRIPT_NAME']}#{@config.base_url_path}")
         html.gsub!(/\{version\}/, MiniProfiler::VERSION)
         html.gsub!(/\{json\}/, result_json)
         html.gsub!(/\{includes\}/, get_profile_script(env))
@@ -224,6 +225,7 @@ module Rack
 
       MiniProfiler.create_current(env, @config)
       MiniProfiler.deauthorize_request if @config.authorization_mode == :whitelist
+
       if query_string =~ /pp=normal-backtrace/
         client_settings.backtrace_level = ClientSettings::BACKTRACE_DEFAULT
       elsif query_string =~ /pp=no-backtrace/
@@ -236,52 +238,48 @@ module Rack
         current.skip_backtrace = true
       end
 
-      done_sampling = false
-      quit_sampler = false
-      backtraces = nil
-      
-      if query_string =~ /pp=sample/ || query_string =~ /pp=flamegraph/
-        current.measure = false
-        skip_frames = 0
-        backtraces = []
-        t = Thread.current
-
-        Thread.new {
-          # new in Ruby 2.0
-          has_backtrace_locations = t.respond_to?(:backtrace_locations)
-          begin
-            i = 10000 # for sanity never grab more than 10k samples
-            while i > 0
-              break if done_sampling
-              i -= 1
-              backtraces << (has_backtrace_locations ? t.backtrace_locations : t.backtrace)
-              
-              # On my machine using Ruby 2.0 this give me excellent fidelity of stack trace per 1.2ms
-              #   with this fidelity analysis becomes very powerful
-              sleep 0.0005
-            end
-          ensure
-            quit_sampler = true
-          end
-        }
-      end
+      flamegraph = nil
+
+      trace_exceptions = query_string =~ /pp=trace-exceptions/ && defined? TracePoint
+      status, headers, body, exceptions,trace = nil
 
-      status, headers, body = nil
       start = Time.now
+
+      if trace_exceptions
+        exceptions = []
+        trace = TracePoint.new(:raise) do |tp|
+          exceptions << tp.raised_exception
+        end
+        trace.enable
+      end
+
       begin
 
         # Strip all the caching headers so we don't get 304s back
         #  This solves a very annoying bug where rack mini profiler never shows up
-        env['HTTP_IF_MODIFIED_SINCE'] = nil
-        env['HTTP_IF_NONE_MATCH'] = nil
+        env['HTTP_IF_MODIFIED_SINCE'] = ''
+        env['HTTP_IF_NONE_MATCH'] = ''
 
-        status,headers,body = @app.call(env)
+        if query_string =~ /pp=flamegraph/
+          unless defined?(Flamegraph) && Flamegraph.respond_to?(:generate)
+
+            flamegraph = "Please install the flamegraph gem and require it: add gem 'flamegraph' to your Gemfile"
+            status,headers,body = @app.call(env)
+          else
+            # do not sully our profile with mini profiler timings
+            current.measure = false
+            # first param is the path
+            # 0.5 means attempt to collect a sample each 0.5 secs
+            flamegraph = Flamegraph.generate(nil, fidelity: 0.5) do
+              status,headers,body = @app.call(env)
+            end
+          end
+        else
+          status,headers,body = @app.call(env)
+        end
         client_settings.write!(headers)
       ensure
-        if backtraces
-          done_sampling = true
-          sleep 0.001 until quit_sampler
-        end
+        trace.disable if trace
       end
 
       skip_it = current.discard
@@ -298,6 +296,11 @@ module Rack
       return [status,headers,body] if skip_it
 
       # we must do this here, otherwise current[:discard] is not being properly treated
+      if trace_exceptions
+        body.close if body.respond_to? :close
+        return dump_exceptions exceptions
+      end
+
       if query_string =~ /pp=env/
         body.close if body.respond_to? :close
         return dump_env env
@@ -312,13 +315,9 @@ module Rack
       page_struct['User'] = user(env)
       page_struct['Root'].record_time((Time.now - start) * 1000)
 
-      if backtraces
+      if flamegraph
         body.close if body.respond_to? :close
-        if query_string =~ /pp=sample/
-          return analyze(backtraces, page_struct)
-        else 
-          return flame_graph(backtraces, page_struct)
-        end
+        return self.flamegraph(flamegraph)
       end
 
 
@@ -327,46 +326,51 @@ module Rack
       @storage.save(page_struct)
 
       # inject headers, script
-      if status == 200
-
+      if headers['Content-Type'] && status == 200
         client_settings.write!(headers)
 
-        # mini profiler is meddling with stuff, we can not cache cause we will get incorrect data
-        # Rack::ETag has already inserted some nonesense in the chain
-        headers.delete('ETag')
-        headers.delete('Date')
-        headers['Cache-Control'] = 'must-revalidate, private, max-age=0'
-
-        # inject header
-        if headers.is_a? Hash
-          headers['X-MiniProfiler-Ids'] = ids_json(env)
-        end
-
-        # inject script
-        if current.inject_js \
-          && headers.has_key?('Content-Type') \
-          && !headers['Content-Type'].match(/text\/html/).nil? then
-
-          response = Rack::Response.new([], status, headers)
-          script = self.get_profile_script(env)
-
-          if String === body
-            response.write inject(body,script)
-          else
-            body.each { |fragment| response.write inject(fragment, script) }
-          end
-          body.close if body.respond_to? :close
-          return response.finish
-        end
+        result = inject_profiler(env,status,headers,body)
+        return result if result
       end
 
       client_settings.write!(headers)
       [status, headers, body]
+
     ensure
       # Make sure this always happens
       current = nil
     end
 
+    def inject_profiler(env,status,headers,body)
+      # mini profiler is meddling with stuff, we can not cache cause we will get incorrect data
+      # Rack::ETag has already inserted some nonesense in the chain
+      content_type = headers['Content-Type']
+
+      headers.delete('ETag')
+      headers.delete('Date')
+      headers['Cache-Control'] = 'must-revalidate, private, max-age=0'
+
+      # inject header
+      if headers.is_a? Hash
+        headers['X-MiniProfiler-Ids'] = ids_json(env)
+      end
+
+      if current.inject_js && content_type =~ /text\/html/
+        response = Rack::Response.new([], status, headers)
+        script = self.get_profile_script(env)
+
+        if String === body
+          response.write inject(body,script)
+        else
+          body.each { |fragment| response.write inject(fragment, script) }
+        end
+        body.close if body.respond_to? :close
+        response.finish
+      else
+        nil
+      end
+    end
+
     def inject(fragment, script)
       if fragment.match(/<\/body>/i)
         # explicit </body>
@@ -388,9 +392,9 @@ module Rack
       index = 1
       fragment.gsub(regex) do
         # though malformed there is an edge case where /body exists earlier in the html, work around
-        if index < matches 
+        if index < matches
           index += 1
-          close_tag        
+          close_tag
         else
 
           # if for whatever crazy reason we dont get a utf string,
@@ -404,6 +408,16 @@ module Rack
       end
     end
 
+    def dump_exceptions(exceptions)
+      headers = {'Content-Type' => 'text/plain'}
+      body = "Exceptions (#{exceptions.length} raised during request)\n\n"
+      exceptions.each do |e|
+        body << "#{e.class} #{e.message}\n#{e.backtrace.join("\n")}\n\n\n\n"
+      end
+
+      [200, headers, [body]]
+    end
+
     def dump_env(env)
       headers = {'Content-Type' => 'text/plain'}
       body = "Rack Environment\n---------------\n"
@@ -416,6 +430,9 @@ module Rack
         body << "#{k}: #{v}\n"
       end
 
+      body << "\n\nRuby Version\n---------------\n"
+      body << "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL}\n"
+
       body << "\n\nInternals\n---------------\n"
       body << "Storage Provider #{config.storage_instance}\n"
       body << "User #{user(env)}\n"
@@ -434,61 +451,21 @@ module Rack
   pp=no-backtrace #{"(*) " if client_settings.backtrace_none?}: don't collect stack traces from all the SQL executed (sticky, use pp=normal-backtrace to enable)
   pp=normal-backtrace #{"(*) " if client_settings.backtrace_default?}: collect stack traces from all the SQL executed and filter normally
   pp=full-backtrace #{"(*) " if client_settings.backtrace_full?}: enable full backtraces for SQL executed (use pp=normal-backtrace to disable)
-  pp=sample : sample stack traces and return a report isolating heavy usage (works best on Ruby 2.0)
   pp=disable : disable profiling for this session
   pp=enable : enable profiling for this session (if previously disabled)
   pp=profile-gc: perform gc profiling on this request, analyzes ObjectSpace generated by request (ruby 1.9.3 only)
   pp=profile-gc-time: perform built-in gc profiling on this request (ruby 1.9.3 only)
-  pp=flamegraph: works best on Ruby 2.0, a graph representing sampled activity.
+  pp=flamegraph: works best on Ruby 2.0, a graph representing sampled activity (requires the flamegraph gem).
+  pp=trace-exceptions: requires Ruby 2.0, will return all the spots where your application raises execptions
 "
 
       client_settings.write!(headers)
       [200, headers, [body]]
     end
 
-    def flame_graph(traces, page_struct)
-      graph = FlameGraph.new(traces)
-      data = graph.graph_data
-
+    def flamegraph(graph)
       headers = {'Content-Type' => 'text/html'}
-      
-      body = IO.read(::File.expand_path('../html/flamegraph.html', ::File.dirname(__FILE__)))
-      body.gsub!("/*DATA*/", ::JSON.generate(data));
-
-      [200, headers, [body]]
-    end
-
-    def analyze(traces, page_struct)
-      headers = {'Content-Type' => 'text/plain'}
-      body = "Collected: #{traces.count} stack traces. Duration(ms): #{page_struct.duration_ms}"
-
-      seen = {}
-      fulldump = ""
-      traces.each do |trace|
-        fulldump << "\n\n"
-        distinct = {}
-        trace.each do |frame|
-          frame = frame.to_s unless String === frame
-          unless distinct[frame]
-            distinct[frame] = true
-            seen[frame] ||= 0
-            seen[frame] += 1
-          end
-          fulldump << frame << "\n"
-        end
-      end
-
-      body << "\n\nStack Trace Analysis\n"
-      seen.to_a.sort{|x,y| y[1] <=> x[1]}.each do |name, count|
-        if count > traces.count / 10
-          body << "#{name} x #{count}\n"
-        end
-      end
-
-      body << "\n\n\nRaw traces \n"
-      body << fulldump
-
-      [200, headers, [body]]
+      [200, headers, [graph]]
     end
 
     def ids_json(env)
@@ -511,7 +488,7 @@ module Rack
     # * you do not want script to be automatically appended for the current page. You can also call cancel_auto_inject
     def get_profile_script(env)
       ids = ids_comma_separated(env)
-      path = @config.base_url_path
+      path = "#{env['SCRIPT_NAME']}#{@config.base_url_path}"
       version = MiniProfiler::VERSION
       position = @config.position
       showTrivial = false

data/Ruby/lib/mini_profiler/profiling_methods.rb

@@ -55,8 +55,16 @@ module Rack
         end
       end
 
-      def profile_method(klass, method, &blk)
-        default_name = klass.to_s + " " + method.to_s
+      def counter_method(klass, method, &blk)
+        self.profile_method(klass, method, :counter, &blk)
+      end
+
+      def uncounter_method(klass, method)
+        self.unprofile_method(klass, method)
+      end
+
+      def profile_method(klass, method, type = :profile, &blk)
+        default_name = type==:counter ? method.to_s  : klass.to_s + " " + method.to_s
         clean = clean_method_name(method)
 
         with_profiling =  ("#{clean}_with_mini_profiler").intern
@@ -81,22 +89,34 @@ module Rack
               end
           end
 
-          parent_timer = Rack::MiniProfiler.current.current_timer
-          page_struct = Rack::MiniProfiler.current.page_struct
           result = nil
+          parent_timer = Rack::MiniProfiler.current.current_timer
 
-          Rack::MiniProfiler.current.current_timer = current_timer = parent_timer.add_child(name)
-          begin
-            result = self.send without_profiling, *args, &orig
-          ensure
-            current_timer.record_time
-            Rack::MiniProfiler.current.current_timer = parent_timer
+          if type == :counter
+            start = Time.now
+            begin
+              result = self.send without_profiling, *args, &orig
+            ensure
+              duration_ms = (Time.now - start).to_f * 1000
+              parent_timer.add_custom(name, duration_ms, Rack::MiniProfiler.current.page_struct )
+            end
+          else
+            page_struct = Rack::MiniProfiler.current.page_struct
+
+            Rack::MiniProfiler.current.current_timer = current_timer = parent_timer.add_child(name)
+            begin
+              result = self.send without_profiling, *args, &orig
+            ensure
+              current_timer.record_time
+              Rack::MiniProfiler.current.current_timer = parent_timer
+            end
           end
+
           result
         end
         klass.send :alias_method, method, with_profiling
       end
-      
+
       # Add a custom timing. These are displayed similar to SQL/query time in
       # columns expanding to the right.
       #