tuttle 0.0.5 → 0.0.6

data/lib/tuttle/engine.rb

@@ -1,17 +1,18 @@
+require 'tuttle'
 require 'rails/engine'
 
 module Tuttle
   class Engine < ::Rails::Engine
     isolate_namespace Tuttle
 
-    mattr_accessor :reload_needed, :session_start, :session_id
+    attr_accessor :reload_needed, :session_start, :session_id
 
-    mattr_reader :logger
+    attr_reader :logger
 
     config.tuttle = ActiveSupport::OrderedOptions.new
 
     config.before_configuration do
-      Tuttle::Engine.session_start = Time.now
+      Tuttle::Engine.session_start = Time.current
       Tuttle::Engine.session_id = SecureRandom.uuid
     end
 
@@ -25,27 +26,38 @@ module Tuttle
 
       next unless Tuttle.enabled
 
-      @@logger = ::Logger.new("#{Rails.root}/log/tuttle.log")
+      @logger = ::Logger.new("#{Rails.root}/log/tuttle.log")
       Tuttle::Engine.logger.info('Tuttle engine started')
 
-      Tuttle.automount_engine = true if Tuttle.automount_engine == nil
+      Tuttle.automount_engine = true if Tuttle.automount_engine.nil?
 
-      if Tuttle.automount_engine
-        Rails.application.routes.prepend do
-          Tuttle::Engine.logger.info('Auto-mounting /tuttle routes')
-          mount Tuttle::Engine, at: "tuttle"
-        end
-      end
+      mount_engine! if Tuttle.automount_engine
+      use_profiling_middleware! if Tuttle.enable_profiling
 
       if Tuttle.track_notifications
         Tuttle::Instrumenter.initialize_tuttle_instrumenter
       end
-
     end
 
     config.to_prepare do
       Tuttle::Engine.reload_needed = true
     end
 
+    private
+
+    def mount_engine!
+      Rails.application.routes.prepend do
+        Tuttle::Engine.logger.info('Auto-mounting /tuttle routes')
+        mount Tuttle::Engine, at: 'tuttle'
+      end
+    end
+
+    def use_profiling_middleware!
+      # Add memory/cpu profiler middleware at the end of the stack
+      Tuttle::Engine.logger.info('Using Tuttle::Middleware::RequestProfiler middleware')
+      require 'tuttle/middleware/request_profiler'
+      Rails.application.config.middleware.use Tuttle::Middleware::RequestProfiler
+    end
+
   end
 end

data/lib/tuttle/instrumenter.rb

@@ -2,9 +2,9 @@ module Tuttle
   class Instrumenter
 
     mattr_accessor :events, :event_counts, :cache_events
-    @@events = []
-    @@event_counts = Hash.new(0)
-    @@cache_events = []
+    self.events = []
+    self.event_counts = Hash.new(0)
+    self.cache_events = []
 
     def self.initialize_tuttle_instrumenter
       # For now, only instrument non-production mode
@@ -16,7 +16,8 @@ module Tuttle
         end
       end
 
-      # Note: For Rails < 4.2 instrumentation is not enabled by default. Hitting the cache inspector page will enable it for that session.
+      # Note: For Rails < 4.2 instrumentation is not enabled by default.
+      # Hitting the cache inspector page will enable it for that session.
       Tuttle::Engine.logger.info('Initializing cache_read subscriber')
       ActiveSupport::Notifications.subscribe('cache_read.active_support') do |*args|
         cache_call_location = caller_locations.detect { |cl| cl.path.start_with?("#{Rails.root}/app".freeze) }
@@ -24,14 +25,13 @@ module Tuttle
 
         Tuttle::Engine.logger.info("Cache Read called: #{cache_call_location.path} on line #{cache_call_location.lineno} :: #{event.payload.inspect}")
 
-        event.payload.merge!({:call_location_path => cache_call_location.path, :call_location_lineno => cache_call_location.lineno })
+        event.payload.merge!(:call_location_path => cache_call_location.path, :call_location_lineno => cache_call_location.lineno)
         Tuttle::Instrumenter.cache_events << event
       end
 
-      ActiveSupport::Notifications.subscribe('cache_generate.active_support') do |*args|
+      ActiveSupport::Notifications.subscribe('cache_generate.active_support') do
         Tuttle::Engine.logger.info('Cache Generate called')
       end
-
     end
 
   end

data/lib/tuttle/middleware/request_profiler.rb

@@ -1,4 +1,4 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Tuttle
   module Middleware
@@ -11,17 +11,18 @@ module Tuttle
       def call(env)
         query_string = env['QUERY_STRING']
 
-        tuttle_profiler_action = /tuttle\-profiler=([\w\-]*)/.match(query_string) { $1.to_sym }
+        tuttle_profiler_action = /(^|[&?])tuttle\-profiler=([\w\-]*)/.match(query_string) { |m| m[2] }
 
         case tuttle_profiler_action
-        when :'memory_profiler', :'memory'
+        when 'memory_profiler', 'memory'
           profile_memory(env, query_string)
-        when :'ruby-prof', :'cpu'
+        when 'ruby-prof', 'cpu'
           profile_cpu(env, query_string)
+        when 'busted'
+          profile_busted(env, query_string)
         else
           @app.call(env)
         end
-
       end
 
       private
@@ -31,24 +32,42 @@ module Tuttle
 
         query_params = Rack::Utils.parse_nested_query(query_string)
         options = {
-            :ignore_files => query_params['memory_profiler_ignore_files'],
-            :allow_files => query_params['memory_profiler_allow_files'],
+          :ignore_files => query_params['memory_profiler_ignore_files'],
+          :allow_files => query_params['memory_profiler_allow_files']
         }
-        options[:top]= Integer(query_params['memory_profiler_top']) if query_params.key?('memory_profiler_top')
+        options[:top] = Integer(query_params['memory_profiler_top']) if query_params.key?('memory_profiler_top')
+
+        status = nil
+        body = nil
 
+        t0 = Time.current
         report = MemoryProfiler.report(options) do
-          _,_,body = @app.call(env)
-          body.close if body.respond_to? :close
+          status, _headers, body = @app.call(env)
+          body.close if body.respond_to?(:close)
         end
+        response_time = Time.current - t0
 
         result = StringIO.new
         report.pretty_print(result)
 
-        [200, { 'Content-Type' => 'text/plain' }, ["Report from Tuttle::Middeware::RequestProfiler\n", result.string]]
+        response = ["Report from Tuttle::Middeware::RequestProfiler\n"]
+        response << "Time of request: #{Time.current}\n"
+        response << "Response status: #{status}\n" unless status == 200
+        response << "Response time: #{response_time}\n"
+        response << "Response body size: #{body.body.length}\n" if body.respond_to?(:body)
+        response << "\n"
+        response << result.string
+        [200, { 'Content-Type' => 'text/plain' }, response]
       end
 
       def profile_cpu(env, query_string)
         require 'ruby-prof'
+        require 'tuttle/ruby_prof/fast_call_stack_printer'
+
+        query_params = Rack::Utils.parse_nested_query(query_string)
+        options = {}
+        options[:threshold] = Float(query_params['ruby-prof_threshold']) if query_params.key?('ruby-prof_threshold')
+        rubyprof_printer = /ruby\-prof_printer=([\w]*)/.match(query_string) { |m| m[1] }
 
         data = ::RubyProf::Profile.profile do
           _, _, body = @app.call(env)
@@ -56,25 +75,147 @@ module Tuttle
         end
 
         result = StringIO.new
-        rubyprof_printer    = /ruby\-prof_printer=([\w]*)/.match(query_string) { $1.to_sym }
         content_type = 'text/html'
 
-        case rubyprof_printer
-        when :flat
-          ::RubyProf::FlatPrinter.new(data).print(result)
-          content_type = 'text/plain'
-        when :graph
-          ::RubyProf::GraphHtmlPrinter.new(data).print(result)
-        when :fast_stack
-          require 'tuttle/ruby_prof/fast_call_stack_printer'
-          ::Tuttle::RubyProf::FastCallStackPrinter.new(data).print(result, { :application => env['REQUEST_URI']})
-        else
-          ::RubyProf::CallStackPrinter.new(data).print(result)
-        end
+        profiler = case rubyprof_printer
+                   when 'flat'
+                     content_type = 'text/plain'
+                     ::RubyProf::FlatPrinter
+                   when 'graph'
+                     ::RubyProf::GraphHtmlPrinter
+                   when 'stack', 'call_stack'
+                     ::RubyProf::CallStackPrinter
+                   else
+                     options[:application] = env['REQUEST_URI']
+                     ::Tuttle::RubyProf::FastCallStackPrinter
+                   end
+
+        profiler.new(data).print(result, options)
 
         [200, { 'Content-Type' => content_type }, [result.string]]
       end
 
+      # These methods *may* cause the method cache to be invalidated
+      TRACE_METHODS = Set.new([:extend, :include, :const_set, :remove_const, :alias_method, :remove_method,
+                               :prepend, :append_features, :prepend_features,
+                               :public_constant, :private_constant, :autoload,
+                               :define_method, :define_singleton_method])
+
+      def profile_busted(env, _query_string)
+        # Note: Requires Busted (of course) and DTrace so will need much better error handling and information
+        # For DTrace on OS X (post 10.11) you may need to disable SIP as well as be running with root privileges
+        # https://derflounder.wordpress.com/2015/10/01/system-integrity-protection-adding-another-layer-to-apples-security-model/
+
+        require 'busted'
+        require 'busted/profiler/default' # Required so `autoload :Default` does not get included in trace
+
+        # Notes:
+        # Much of this is per https://tenderlovemaking.com/2015/12/23/inline-caching-in-mri.html
+        #   and https://github.com/charliesome/charlie.bz/blob/master/posts/things-that-clear-rubys-method-cache.md
+        # RubyVM.stat tracks the :global_method_state, :global_constant_state, and :class_serial
+        #   :global_method_state - "global serial number that increments every time certain classes get mutated"
+        #      ** Changes to this are BAD because they invalidate all caches
+        #   :global_constant_state - counter of constants defined *or redefined(?)*
+        #   :class_serial - global serial number that increments every time a method is Class is created/modified (?-verify)
+        # Since Ruby 2.1(2.2?) the method caches are per-Class rather than global.
+        #   So clearing the method cache of a single Class is less of a performance hit than blowing away the entire method cache
+        #
+        # Busted Dtraces :method-cache-clear internal events which are when Ruby says the method cache was cleared
+        # The @cache_buster_tracepoint Dtraces Class/Module definitions (:class)
+        # and calls to C method (:c_call) which would likely cause a method cache clear
+        #
+        # From the observed results...
+        #   :method-cache-clear may fire more times than RubyVM.stat[]
+        cache_busters = []
+
+        # This is really still incomplete...
+        # Internally, Ruby does not fire :c_call or :class for many events that would increment the :class_serial
+        # For example `Person = Class.new` does not fire a :class event
+        # And it also does create a new constant (:constant_state) but does not fire a :const_set event
+
+        # Trace class definitions (which always(?) invalidate the cache) and c-calls which may invalidate the cache
+        @cache_buster_tracepoint ||= TracePoint.new(:class, :c_call) do |trace|
+          if trace.event == :class
+            cache_busters << {
+              :event => trace.event,
+              :event_description => "Class definition",
+              :location => "#{trace.path}##{trace.lineno}",
+              :target_class => trace.self
+            }
+          elsif TRACE_METHODS.include?(trace.method_id)
+            cache_busters << {
+              :event => trace.event,
+              :event_description => "#{trace.defined_class}##{trace.method_id}",
+              :location => "#{trace.path}##{trace.lineno}",
+              :target_class => trace.self.class,
+              :defined_class => trace.defined_class,
+              :method_id => trace.method_id
+            }
+          end
+        end
+
+        # Trace the request and capture the RubyVM.stat before/after
+        vmstat_before = RubyVM.stat
+        results = @cache_buster_tracepoint.enable do
+          Busted.run(trace: true) do
+            _, _, body = @app.call(env)
+            body.close if body.respond_to?(:close)
+          end
+        end
+        vmstat_after = RubyVM.stat
+
+        # Prepare the output
+        output = "\nRubyVM.stat:           Before     After      Change\n".dup
+        [:global_method_state, :global_constant_state, :class_serial].each do |stat|
+          output << format("%-22s %-10d %-10d %+d\n",
+                           stat,
+                           vmstat_before[stat],
+                           vmstat_after[stat],
+                           vmstat_after[stat] - vmstat_before[stat])
+        end
+
+        output << "\nCounts:\n"
+        output << "method-cache-clear: #{results[:traces][:method].size}\n"
+        output << "C calls that may cause cache clear: #{cache_busters.size}\n"
+        grouped_traces = cache_busters.group_by do |trace_info|
+          if trace_info[:event] == :c_call
+            "#{trace_info[:defined_class]}##{trace_info[:method_id]}"
+          else
+            "Class Defined"
+          end
+        end
+        grouped_traces.each do |grouping, traces|
+          output << "  #{grouping}: #{traces.size}\n"
+        end
+
+        output << "\nTraces (method-cache-clear): (#{results[:traces][:method].size} times)\n"
+        results[:traces][:method].each do |trace|
+          output << "#{trace[:class]} - #{trace[:sourcefile]}##{trace[:lineno]}\n"
+        end
+
+        output << "\nTraces (method cache clearing calls): (#{cache_busters.size} times)\n"
+        cache_busters.each do |trace_info|
+          if trace_info[:event] == :c_call
+            output << format("%s\#%s: %s %s\n",
+                             trace_info[:defined_class],
+                             trace_info[:method_id],
+                             trace_info[:target_class],
+                             trace_info[:location])
+          else
+            output << format("Class Definition: %s %s %s\n",
+                             trace_info[:target_class],
+                             trace_info[:defined_class],
+                             trace_info[:location])
+          end
+        end
+
+        [200,
+         { 'Content-Type' => 'text/plain' },
+         ["Tuttle - Ruby Method/Constant Caches Request Observer v0.0.1\n",
+          "Ruby Version: #{RUBY_VERSION}\n",
+          output]]
+      end
+
     end
   end
 end

data/lib/tuttle/presenters/action_dispatch/routing/route_wrapper.rb

@@ -5,7 +5,11 @@ module Tuttle
         class RouteWrapper < ::ActionDispatch::Routing::RouteWrapper
 
           def endpoint_or_app_name
-            uses_dispatcher? ? endpoint : (rack_app.is_a?(Class) ? rack_app : rack_app.class)
+            if uses_dispatcher?
+              endpoint
+            else
+              rack_app.is_a?(Class) ? rack_app : rack_app.class
+            end
           end
 
           def controller
@@ -20,8 +24,8 @@ module Tuttle
             rack_app.respond_to?(:dispatcher?)
           end
 
-          def is_internal_to_rails?
-            !!internal?
+          def internal_to_rails?
+            true == internal?
           end
 
         end

data/lib/tuttle/presenters/rack_mini_profiler/client_settings.rb

@@ -0,0 +1,27 @@
+module Tuttle
+  module Presenters
+    module RackMiniProfiler
+      class ClientSettings < SimpleDelegator
+
+        def initialize(env)
+          rmp_cs_args = [env]
+          rmp_cs_args += [::Rack::MiniProfiler.config.storage_instance, Time.current] if version_10?
+          super(::Rack::MiniProfiler::ClientSettings.new(*rmp_cs_args))
+        end
+
+        def version_10?
+          Rack::MiniProfiler::ClientSettings.instance_method(:initialize).arity > 1
+        end
+
+        def tuttle_check_cookie
+          version_10? ? has_valid_cookie? : has_cookie?
+        end
+
+        def tuttle_check_cookie_method
+          version_10? ? 'has_valid_cookie?' : 'has_cookie?'
+        end
+
+      end
+    end
+  end
+end

data/lib/tuttle/ruby_prof/fast_call_stack_printer.rb

@@ -11,30 +11,7 @@ module Tuttle
 
       # Specify print options.
       #
-      # options - Hash table
-      #   :min_percent - Number 0 to 100 that specifes the minimum
-      #                  %self (the methods self time divided by the
-      #                  overall total time) that a method must take
-      #                  for it to be printed out in the report.
-      #                  Default value is 0.
-      #
-      #   :print_file  - True or false. Specifies if a method's source
-      #                  file should be printed.  Default value if false.
-      #
-      #   :threshold   - a float from 0 to 100 that sets the threshold of
-      #                  results displayed.
-      #                  Default value is 1.0
-      #
-      #   :title       - a String to overide the default "ruby-prof call tree"
-      #                  title of the report.
-      #
-      #   :expansion   - a float from 0 to 100 that sets the threshold of
-      #                  results that are expanded, if the percent_total
-      #                  exceeds it.
-      #                  Default value is 10.0
-      #
-      #   :application - a String to overide the name of the application,
-      #                  as it appears on the report.
+      # options - See CallStackPrinter for based options
       #
       def print(output = STDOUT, options = {})
         @output = output
@@ -43,18 +20,19 @@ module Tuttle
         print_header
 
         @overall_threads_time = @result.threads.inject(0) do |val, thread|
-          val += thread.total_time
+          val + thread.total_time
         end
 
-        @method_full_name_cache = Hash.new.compare_by_identity
+        @method_full_name_cache = {}.compare_by_identity
 
         @result.threads.each do |thread|
           @overall_time = thread.total_time
           thread_info = "Thread: #{thread.id}"
           thread_info << ", Fiber: #{thread.fiber_id}" unless thread.id == thread.fiber_id
-          thread_info << " (#{"%4.2f%%" % ((@overall_time/@overall_threads_time)*100)} ~ #{@overall_time})"
+          thread_info << format(' (%4.2f%% ~ %f)', (@overall_time / @overall_threads_time) * 100, @overall_time)
+
           @output.print "<div class=\"thread\">#{thread_info}</div>"
-          @output.print "<ul name=\"thread\">"
+          @output.print '<ul name="thread">'
           thread.methods.each do |m|
             # $stderr.print m.dump
             next unless m.root?
@@ -63,38 +41,35 @@ module Tuttle
               print_stack ci, @overall_time
             end
           end
-          @output.print "</ul>"
+          @output.print '</ul>'
         end
 
         @method_full_name_cache = nil
 
         print_footer
-
       end
 
       def print_stack(call_info, parent_time)
         total_time = call_info.total_time
-        percent_total = (total_time/@overall_time)*100
+        percent_total = (total_time / @overall_time) * 100
         return unless percent_total > min_percent
 
-        percent_parent = (total_time/parent_time)*100
+        percent_parent = (total_time / parent_time) * 100
         if percent_total < threshold
-          @output.write "<li style=\"display:none;\">".freeze
+          @output.write '<li style="display:none;">'.freeze
         else
-          @output.write "<li>".freeze
+          @output.write '<li>'.freeze
         end
 
         expanded = percent_total >= expansion
         kids = call_info.children
 
-        toggle_href = if kids.empty? || kids.none?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
-                        "<a href=\"#\" class=\"toggle empty\" ></a>".freeze
+        toggle_href = if kids.empty? || kids.none? {|ci| (ci.total_time / @overall_time) * 100 >= threshold}
+                        '<a href="#" class="toggle empty"></a>'.freeze
+                      elsif expanded
+                        '<a href="#" class="toggle minus"></a>'.freeze
                       else
-                        if expanded
-                          "<a href=\"#\" class=\"toggle minus\" ></a>".freeze
-                        else
-                          "<a href=\"#\" class=\"toggle plus\" ></a>".freeze
-                        end
+                        '<a href="#" class="toggle plus"></a>'.freeze
                       end
         @output.write toggle_href
 
@@ -104,25 +79,25 @@ module Tuttle
                        method_full_name(method), call_info.called, method.called
         unless kids.empty?
           if expanded
-            @output.write "<ul>".freeze
+            @output.write '<ul>'.freeze
           else
             @output.write '<ul style="display:none">'.freeze
           end
           kids.sort_by!(&:total_time).reverse_each do |callinfo|
             print_stack callinfo, total_time
           end
-          @output.write "</ul>".freeze
+          @output.write '</ul>'.freeze
         end
-        @output.write "</li>".freeze
-      end
-
-      def name(call_info)
-        method = call_info.target
-        method.full_name
+        @output.write '</li>'.freeze
       end
 
       def method_full_name(method)
-        @method_full_name_cache[method] ||= h(method.full_name)
+        @method_full_name_cache[method] ||= begin
+          # Use ruby-prof klass_name only for non-Classes or klasses that do not report a name
+          # This prevents klass.inspect from being used which prints complex names for ActiveRecord classes
+          klass_name = method.klass && method.klass.class == Class && method.klass.name || method.klass_name
+          h("#{klass_name}##{method.method_name}")
+        end
       end
 
       def threshold
@@ -141,7 +116,7 @@ module Tuttle
         @output.puts <<-"end_title_bar"
 <div id="titlebar">
 Call tree for application <b>#{h application} #{h arguments}</b><br/>
-Generated on #{Time.now} with options #{h @options.inspect}<br/>
+Generated on #{Time.current} with options #{h @options.inspect}<br/>
 </div>
 end_title_bar
       end
@@ -159,6 +134,4 @@ CSS_OVERRIDE
 
     end
   end
-
 end
-