rack-mini-profiler 0.1.28 → 0.9.0

data/{Ruby/lib → 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 → 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
 
@@ -137,7 +138,9 @@ module Rack
 
     def serve_html(env)
       file_name = env['PATH_INFO'][(@config.base_url_path.length)..1000]
+
       return serve_results(env) if file_name.eql?('results')
+
       full_path = ::File.expand_path("../html/#{file_name}", ::File.dirname(__FILE__))
       return [404, {}, ["Not found"]] unless ::File.exists? full_path
       f = Rack::File.new nil
@@ -201,11 +204,12 @@ module Rack
         skip_it = true
       end
 
-      if query_string =~ /pp=enable/
+      if query_string =~ /pp=enable/ && (@config.authorization_mode != :whitelist || MiniProfiler.request_authorized?)
         skip_it = false
+        config.enabled = true
       end
 
-      if skip_it
+      if skip_it || !config.enabled
         status,headers,body = @app.call(env)
         client_settings.disable_profiling = true
         client_settings.write!(headers)
@@ -215,8 +219,18 @@ module Rack
       end
 
       if query_string =~ /pp=profile-gc/
+        current.measure = false if current
+
         if query_string =~ /pp=profile-gc-time/
           return Rack::MiniProfiler::GCProfiler.new.profile_gc_time(@app, env)
+        elsif query_string =~ /pp=profile-gc-ruby-head/
+          result = StringIO.new
+          report = MemoryProfiler.report do
+            _,_,body = @app.call(env)
+            body.close if body.respond_to? :close
+          end
+          report.pretty_print(result)
+          return text_result(result.string)
         else
           return Rack::MiniProfiler::GCProfiler.new.profile_gc(@app, env)
         end
@@ -237,38 +251,21 @@ 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
@@ -276,13 +273,33 @@ module Rack
         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
+            match_data = query_string.match(/flamegraph_sample_rate=(?<rate>[\d\.]+)/)
+
+            mode = query_string =~ /mode=c/ ? :c : :ruby
+
+            if match_data && !match_data[:rate].to_f.zero?
+              sample_rate = match_data[:rate].to_f
+            else
+              sample_rate = config.flamegraph_sample_rate
+            end
+            flamegraph = Flamegraph.generate(nil, fidelity: sample_rate, embed_resources: query_string =~ /embed/, mode: mode) 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
@@ -299,6 +316,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
@@ -313,56 +335,65 @@ 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
 
 
-      # no matter what it is, it should be unviewed, otherwise we will miss POST
-      @storage.set_unviewed(page_struct['User'], page_struct['Id'])
-      @storage.save(page_struct)
-
-      content_type = headers['Content-Type']
-      # inject headers, script
-      if 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'
+      begin
+        # no matter what it is, it should be unviewed, otherwise we will miss POST
+        @storage.set_unviewed(page_struct['User'], page_struct['Id'])
+        @storage.save(page_struct)
 
-        # inject header
-        if headers.is_a? Hash
-          headers['X-MiniProfiler-Ids'] = ids_json(env)
+        # inject headers, script
+        if headers['Content-Type'] && status == 200
+          client_settings.write!(headers)
+          result = inject_profiler(env,status,headers,body)
+          return result if result
         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
-          return response.finish
+      rescue Exception => e
+        if @config.storage_failure != nil
+          @config.storage_failure.call(e)
         end
       end
 
       client_settings.write!(headers)
       [status, headers, body]
+
     ensure
       # Make sure this always happens
-      current = nil
+      self.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)
@@ -377,9 +408,9 @@ module Rack
         regex = /<\/html>/i
         close_tag = '</html>'
       else
-        # implicit </body> and </html>. Just append the script.
+        # implicit </body> and </html>. Don't do anything.
 
-        return fragment + script
+        return fragment
       end
 
       matches = fragment.scan(regex).length
@@ -402,8 +433,17 @@ module Rack
       end
     end
 
-    def dump_env(env)
+    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)
       body = "Rack Environment\n---------------\n"
       env.each do |k,v|
         body << "#{k}: #{v}\n"
@@ -414,11 +454,19 @@ 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"
       body << config.storage_instance.diagnostics(user(env)) rescue "no diagnostics implemented for storage"
 
+      text_result(body)
+    end
+
+    def text_result(body)
+      headers = {'Content-Type' => 'text/plain'}
       [200, headers, [body]]
     end
 
@@ -432,73 +480,37 @@ 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=profile-gc-ruby-head: requires the memory_profiler gem, new location based report
+  pp=flamegraph: works best on Ruby 2.0, a graph representing sampled activity (requires the flamegraph gem).
+  pp=flamegraph&flamegraph_sample_rate=1: creates a flamegraph with the specified sample rate (in ms). Overrides value set in config
+  pp=flamegraph_embed: works best on Ruby 2.0, a graph representing sampled activity (requires the flamegraph gem), embedded resources for use on an intranet.
+  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]]
+      [200, headers, [graph]]
     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]]
+    def ids(env)
+      # cap at 10 ids, otherwise there is a chance you can blow the header
+      ([current.page_struct["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])[0..8]).uniq
     end
 
     def ids_json(env)
-      # cap at 10 ids, otherwise there is a chance you can blow the header
-      ids = [current.page_struct["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])[0..8]
-      ::JSON.generate(ids.uniq)
+      ::JSON.generate(ids(env))
     end
 
     def ids_comma_separated(env)
-      # cap at 10 ids, otherwise there is a chance you can blow the header
-      ids = [current.page_struct["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])[0..8]
-      ids.join(",")
+      ids(env).join(",")
     end
 
     # get_profile_script returns script to be injected inside current html page
@@ -508,26 +520,37 @@ module Rack
     # * you have disabled auto append behaviour throught :auto_inject => false flag
     # * 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 = "#{env['SCRIPT_NAME']}#{@config.base_url_path}"
-      version = MiniProfiler::VERSION
-      position = @config.position
-      showTrivial = false
-      showChildren = false
-      maxTracesToShow = 10
-      showControls = false
-      currentId = current.page_struct["Id"]
-      authorized = true
-      toggleShortcut = @config.toggle_shortcut
-      startHidden = @config.start_hidden
+
+      settings = {
+       :path => "#{env['SCRIPT_NAME']}#{@config.base_url_path}",
+       :version => MiniProfiler::VERSION,
+       :position => @config.position,
+       :showTrivial => false,
+       :showChildren => false,
+       :maxTracesToShow => 10,
+       :showControls => false,
+       :authorized => true,
+       :toggleShortcut => @config.toggle_shortcut,
+       :startHidden => @config.start_hidden
+      }
+
+      if current && current.page_struct
+        settings[:ids] = ids_comma_separated(env)
+        settings[:currentId] = current.page_struct["Id"]
+      else
+        settings[:ids] = []
+        settings[:currentId] = ""
+      end
+
       # TODO : cache this snippet
       script = IO.read(::File.expand_path('../html/profile_handler.js', ::File.dirname(__FILE__)))
       # replace the variables
-      [:ids, :path, :version, :position, :showTrivial, :showChildren, :maxTracesToShow, :showControls, :currentId, :authorized, :toggleShortcut, :startHidden].each do |v|
-        regex = Regexp.new("\\{#{v.to_s}\\}")
-        script.gsub!(regex, eval(v.to_s).to_s)
+      settings.each do |k,v|
+        regex = Regexp.new("\\{#{k.to_s}\\}")
+        script.gsub!(regex, v.to_s)
       end
-      current.inject_js = false
+
+      current.inject_js = false if current
       script
     end