rack-mini-profiler 0.1.29 → 0.9.1

data/{Ruby/lib → lib}/mini_profiler/config.rb

@@ -12,10 +12,10 @@ module Rack
       @attributes
     end
 
-    attr_accessor :auto_inject, :base_url_path, :pre_authorize_cb, :position,
-        :backtrace_remove, :backtrace_includes, :backtrace_ignores, :skip_schema_queries,
-        :storage, :user_provider, :storage_instance, :storage_options, :skip_paths, :authorization_mode,
-        :toggle_shortcut, :start_hidden, :backtrace_threshold_ms
+    attr_accessor :authorization_mode, :auto_inject, :backtrace_ignores, :backtrace_includes, :backtrace_remove,
+      :backtrace_threshold_ms, :base_url_path, :enabled, :flamegraph_sample_rate, :logger, :position,
+      :pre_authorize_cb, :skip_paths, :skip_schema_queries, :start_hidden, :storage, :storage_failure,
+      :storage_instance, :storage_options, :toggle_shortcut, :user_provider
 
     # Deprecated options
     attr_accessor :use_existing_jquery
@@ -37,6 +37,13 @@ module Rack
           @toggle_shortcut = 'Alt+P'
           @start_hidden = false
           @backtrace_threshold_ms = 0
+          @flamegraph_sample_rate = 0.5
+          @storage_failure = Proc.new do |exception|
+            if @logger
+              @logger.warn("MiniProfiler storage failure: #{exception.message}")
+            end
+          end
+          @enabled = true
           self
         }
       end

data/{Ruby/lib → 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/lib/mini_profiler/gc_profiler.rb

@@ -0,0 +1,181 @@
+class Rack::MiniProfiler::GCProfiler
+
+  def initialize
+    @ignore = []
+    @ignore << @ignore.__id__
+  end
+
+  def object_space_stats
+    stats = {}
+    ids = {}
+
+    @ignore << stats.__id__
+    @ignore << ids.__id__
+
+    i=0
+    ObjectSpace.each_object { |o|
+      begin
+        i = stats[o.class] || 0
+        i += 1
+        stats[o.class] = i
+        ids[o.__id__] = o if Integer === o.__id__
+      rescue NoMethodError
+        # protect against BasicObject
+      end
+    }
+
+    @ignore.each do |id|
+      if ids.delete(id)
+        klass = ObjectSpace._id2ref(id).class
+        stats[klass] -= 1
+      end
+    end
+
+    result = {:stats => stats, :ids => ids}
+    @ignore << result.__id__
+
+    result
+  end
+
+  def diff_object_stats(before,after)
+    diff = {}
+    after.each do |k,v|
+      diff[k] = v - (before[k] || 0)
+    end
+    before.each do |k,v|
+      diff[k] = 0 - v unless after[k]
+    end
+
+    diff
+  end
+
+  def analyze_strings(ids_before,ids_after)
+    result = {}
+    ids_after.each do |id,_|
+      obj = ObjectSpace._id2ref(id)
+      if String === obj && !ids_before.include?(obj.object_id)
+        result[obj] ||= 0
+        result[obj] += 1
+      end
+    end
+    result
+  end
+
+  def analyze_growth(ids_before, ids_after)
+    new_objects = 0
+    memory_allocated = 0
+
+    ids_after.each do |id,_|
+      if !ids_before.include?(id) && obj=ObjectSpace._id2ref(id)
+        # this is going to be version specific (may change in 2.1)
+        size = ObjectSpace.memsize_of(obj)
+        memory_allocated += size
+        new_objects += 1
+      end
+    end
+
+    [new_objects, memory_allocated]
+  end
+
+  def analyze_initial_state(ids_before)
+    memory_allocated = 0
+    objects = 0
+
+    ids_before.each do |id,_|
+      if obj=ObjectSpace._id2ref(id)
+        # this is going to be version specific (may change in 2.1)
+        memory_allocated += ObjectSpace.memsize_of(obj)
+        objects += 1
+      end
+    end
+
+    [objects,memory_allocated]
+  end
+
+  def profile_gc_time(app,env)
+    body = []
+
+    begin
+      GC::Profiler.clear
+      prev_profiler_state = GC::Profiler.enabled?
+      prev_gc_state = GC.enable
+      GC::Profiler.enable
+      b = app.call(env)[2]
+      b.close if b.respond_to? :close
+      body << "GC Profiler ran during this request, if it fired you will see the cost below:\n\n"
+      body << GC::Profiler.result
+    ensure
+      prev_gc_state ? GC.disable : GC.enable
+      GC::Profiler.disable unless prev_profiler_state
+    end
+
+    return [200, {'Content-Type' => 'text/plain'}, body]
+  end
+
+  def profile_gc(app,env)
+
+    # for memsize_of
+    require 'objspace'
+
+    body = [];
+
+    stat_before,stat_after,diff,string_analysis,
+      new_objects, memory_allocated, stat, memory_before, objects_before = nil
+
+    # clean up before
+    GC.start
+    stat = GC.stat
+    prev_gc_state = GC.disable
+    stat_before = object_space_stats
+    b = app.call(env)[2]
+    b.close if b.respond_to? :close
+    stat_after = object_space_stats
+    # so we don't blow out on memory
+    prev_gc_state ? GC.disable : GC.enable
+
+    diff = diff_object_stats(stat_before[:stats],stat_after[:stats])
+    string_analysis = analyze_strings(stat_before[:ids], stat_after[:ids])
+    new_objects, memory_allocated = analyze_growth(stat_before[:ids], stat_after[:ids])
+    objects_before, memory_before = analyze_initial_state(stat_before[:ids])
+
+
+    body << "
+Overview
+------------------------------------
+Initial state: object count - #{objects_before} , memory allocated outside heap (bytes) #{memory_before}
+
+GC Stats: #{stat.map{|k,v| "#{k} : #{v}" }.join(", ")}
+
+New bytes allocated outside of Ruby heaps: #{memory_allocated}
+New objects: #{new_objects}
+"
+
+    body << "
+ObjectSpace delta caused by request:
+--------------------------------------------\n"
+    diff.to_a.reject{|k,v| v == 0}.sort{|x,y| y[1] <=> x[1]}.each do |k,v|
+      body << "#{k} : #{v}\n" if v != 0
+    end
+
+    body << "\n
+ObjectSpace stats:
+-----------------\n"
+
+    stat_after[:stats].to_a.sort{|x,y| y[1] <=> x[1]}.each do |k,v|
+      body << "#{k} : #{v}\n"
+    end
+
+
+    body << "\n
+String stats:
+------------\n"
+
+    string_analysis.to_a.sort{|x,y| y[1] <=> x[1] }.take(1000).each do |string,count|
+      body << "#{count} : #{string}\n"
+    end
+
+    return [200, {'Content-Type' => 'text/plain'}, body]
+  ensure
+    prev_gc_state ? GC.disable : GC.enable
+  end
+end

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
 
@@ -106,7 +107,9 @@ module Rack
       page_struct = @storage.load(id)
       unless page_struct
         @storage.set_viewed(user(env), id)
-        return [404, {}, ["Request not found: #{request['id']} - user #{user(env)}"]]
+        id = ERB::Util.html_escape(request['id'])
+        user_info = ERB::Util.html_escape(user(env))
+        return [404, {}, ["Request not found: #{id} - user #{user_info}"]]
       end
       unless page_struct['HasUserViewed']
         page_struct['ClientTimings'] = ClientTimerStruct.init_from_form_data(env, page_struct)
@@ -137,7 +140,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 +206,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 +221,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,35 +253,7 @@ 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
@@ -287,15 +275,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=([\d\.]+)/)
+
+            mode = query_string =~ /mode=c/ ? :c : :ruby
+
+            if match_data && !match_data[1].to_f.zero?
+              sample_rate = match_data[1].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
         trace.disable if trace
-
-        if backtraces
-          done_sampling = true
-          sleep 0.001 until quit_sampler
-        end
       end
 
       skip_it = current.discard
@@ -331,26 +337,27 @@ 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)
-
-      # inject headers, script
-      if headers['Content-Type'] && status == 200
-        client_settings.write!(headers)
+      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)
 
-        result = inject_profiler(env,status,headers,body)
-        return result if result
+        # 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
+      rescue Exception => e
+        if @config.storage_failure != nil
+          @config.storage_failure.call(e)
+        end
       end
 
       client_settings.write!(headers)
@@ -358,7 +365,7 @@ module Rack
 
     ensure
       # Make sure this always happens
-      current = nil
+      self.current = nil
     end
 
     def inject_profiler(env,status,headers,body)
@@ -403,9 +410,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
@@ -439,7 +446,6 @@ module Rack
     end
 
     def dump_env(env)
-      headers = {'Content-Type' => 'text/plain'}
       body = "Rack Environment\n---------------\n"
       env.each do |k,v|
         body << "#{k}: #{v}\n"
@@ -450,11 +456,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
 
@@ -468,12 +482,14 @@ 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
 "
 
@@ -481,61 +497,22 @@ module Rack
       [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
@@ -545,26 +522,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