fiveruns_tuneup 0.8.2

data/lib/fiveruns/tuneup/asset_tags.rb

@@ -0,0 +1,39 @@
+module Fiveruns
+  module Tuneup
+    
+    module AssetTags
+      
+      def add_asset_tags_to(response)
+        return unless show_for?(response)
+        before, after = response.body.split(/<\/head>/i, 2)
+        if after
+          insertion = %(
+          <!-- START FIVERUNS TUNEUP ASSETS -->
+          <link rel='stylesheet' type='text/css' href='/stylesheets/tuneup/tuneup.css'/>
+          #{insert_prototype unless response.body.include?('prototype.js')}
+          <script type='text/javascript'>
+            var TuneUp = {};
+            TuneUp.frontend_url = "#{Fiveruns::Tuneup.frontend_url}";
+          </script>
+          <script type='text/javascript' src='/javascripts/tuneup/tuneup.js'></script>
+          <!-- END FIVERUNS TUNEUP ASSETS -->
+          )
+          response.headers["Content-Length"] += insertion.size
+          response.body.replace(before << insertion << '</head>' << after)
+        end
+      end
+      
+      def show_for?(response)
+        return false unless response.body
+        return false unless response.headers['Status'] && response.headers['Status'].include?('200')
+        true
+      end
+      
+      def insert_prototype
+        "<script type='text/javascript' src='/javascripts/tuneup/prototype.js'></script>"
+      end
+      
+    end
+    
+  end
+end

data/lib/fiveruns/tuneup/custom_methods.rb

@@ -0,0 +1,8 @@
+module Fiveruns::Tuneup::CustomMethods
+  
+  def tuneup(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    Fiveruns::Tuneup.add_custom_methods(self, *args)
+  end
+  
+end

data/lib/fiveruns/tuneup/environment.rb

@@ -0,0 +1,29 @@
+module Fiveruns
+  module Tuneup
+    module Environment
+      
+      def environment
+        {
+          'application_name' => application_name,
+          'rails_env' => rails_env,
+          'rails_version' => rails_version
+        }
+      end
+      
+      def rails_env
+        RAILS_ENV || 'development'
+      end
+      
+      def rails_version
+        ::Rails::VERSION::STRING rescue 'unknown Rails version'
+      end
+      
+      def application_name
+        app_name = RAILS_ROOT.split('/').last
+        return app_name unless app_name == 'current'             
+        File.join(RAILS_ROOT, '..').split('/').last
+      end
+      
+    end
+  end
+end

data/lib/fiveruns/tuneup/instrumentation/action_controller/base.rb

@@ -0,0 +1,59 @@
+module Fiveruns
+  module Tuneup
+    module Instrumentation
+      module ActionController
+        module Base
+          def self.included(base)
+            Fiveruns::Tuneup.instrument base, ClassMethods, InstanceMethods
+          end
+          module ClassMethods
+            def cache_page_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.step "Cache page", :controller do
+                cache_page_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def expire_page_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.step "Expire cached page", :controller do
+                expire_page_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+          end
+          module InstanceMethods
+            def perform_action_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.run(self, request) do
+                action = (request.parameters['action'] || 'index').to_s
+                if Fiveruns::Tuneup.recording?
+                  Fiveruns::Tuneup.instrument_filters(self) 
+                  Fiveruns::Tuneup.instrument_action_methods(self) 
+                  Fiveruns::Tuneup.instrument_custom_methods
+                end
+                result = Fiveruns::Tuneup.step "Perform #{action.capitalize} action in #{self.class.name}", :controller, false do
+                  perform_action_without_fiveruns_tuneup(*args, &block)
+                end
+              end
+            end
+            def process_with_fiveruns_tuneup(request, response, *args, &block)
+              result = process_without_fiveruns_tuneup(request, response, *args, &block)
+              if !request.xhr? && response.content_type == 'text/html'
+                Fiveruns::Tuneup.add_asset_tags_to(response)
+              end
+              result
+            end
+            
+            def write_fragment_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.step "Cache fragment", :controller do
+                write_fragment_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def expire_fragment_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.step "Expire fragment cache", :controller do
+                expire_fragment_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fiveruns/tuneup/instrumentation/action_view/base.rb

@@ -0,0 +1,77 @@
+module Fiveruns
+  module Tuneup
+    module Instrumentation
+      module ActionView
+        module Base
+                    
+          BASIC_TEMPLATE_PATH = File.join(RAILS_ROOT, 'app', 'views')           
+          
+          def self.included(base)
+            Fiveruns::Tuneup.instrument base, InstanceMethods
+          end
+
+          def self.normalize_path(path)
+            return path unless path
+            if path[0, BASIC_TEMPLATE_PATH.size] == BASIC_TEMPLATE_PATH
+              path[(BASIC_TEMPLATE_PATH.size + 1)..-1]
+            else
+              if (components = path.split(File::SEPARATOR)).size > 2
+                components[-2, 2].join(File::SEPARATOR)
+              else
+                components.join(File::SEPARATOR)
+              end
+            end
+          end
+          
+          module InstanceMethods
+            def render_file_with_fiveruns_tuneup(path, *args, &block)
+              name = Fiveruns::Tuneup::Instrumentation::ActionView::Base.normalize_path(path)
+              Fiveruns::Tuneup.step "Render file #{name}", :view do
+                render_file_without_fiveruns_tuneup(path, *args, &block)
+              end
+            end
+            def update_page_with_fiveruns_tuneup(*args, &block)
+              path = block.to_s.split('/').last.split(':').first rescue ''
+              name = Fiveruns::Tuneup::Instrumentation::ActionView::Base.normalize_path(path)
+              Fiveruns::Tuneup.step "Render page update #{name}", :view do
+                update_page_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def render_with_fiveruns_tuneup(*args, &block)
+              record = true
+              options = args.first || {}
+              path = case options
+              when String
+                "Render #{options}"
+              when :update
+                name = block.to_s.split('/').last.split(':').first rescue ''
+                "Render page update #{name}"
+              when Hash
+                if options[:file]
+                  "Render #{options[:file]}"
+                elsif options[:partial]
+                  # Don't record this as it causes duplicate records
+                  record = false
+                elsif options[:inline]
+                  "Render inline"
+                elsif options[:text]
+                  "Render text"
+                end
+              end
+              path ||= 'Render'
+              
+              if record
+                Fiveruns::Tuneup.step path, :view do
+                  render_without_fiveruns_tuneup(*args, &block)
+                end
+              else
+                render_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fiveruns/tuneup/instrumentation/active_record/base.rb

@@ -0,0 +1,126 @@
+module Fiveruns
+  module Tuneup
+    module Instrumentation
+      module ActiveRecord
+        module Base
+          
+          def self.record(model, name, raw_sql=nil, &operation)
+            sql = nil
+            Fiveruns::Tuneup.exclude do
+              model.silence do
+                sql = Fiveruns::Tuneup::Step::SQL.new(raw_sql, model.connection) if raw_sql
+                Fiveruns::Tuneup.add_schema_for(model.table_name, model.connection)
+              end
+            end
+            Fiveruns::Tuneup.step(name, :model, true, sql, model.table_name, &operation)
+          end
+          
+          def self.included(base)
+            Fiveruns::Tuneup.instrument base, InstanceMethods, ClassMethods
+          end
+               
+          module ClassMethods
+            
+            #
+            # FINDS
+            #
+            
+            def find_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Find #{self.name}" do
+                find_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def find_by_sql_with_fiveruns_tuneup(conditions, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Find #{self.name} by SQL", sanitize_sql(conditions) do
+                find_by_sql_without_fiveruns_tuneup(conditions, &block)
+              end
+            end
+            
+            #
+            # CREATE
+            #
+            
+            def create_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Create #{self.name}" do
+                create_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            
+            #
+            # UPDATES
+            #
+            
+            def update_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Update #{self.name}" do
+                update_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def update_all_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Update #{self.name} (All)" do
+                update_all_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            
+            #
+            # DELETES
+            #
+            
+            def destroy_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Destroy #{self.name}" do
+                destroy_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def destroy_all_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Destroy #{self.name} (All)" do
+                destroy_all_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def delete_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Delete #{self.name}" do
+                delete_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def delete_all_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self, "Delete #{self.name} (All)" do
+                delete_all_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+          end
+          module InstanceMethods
+            
+            #
+            # UPDATES
+            #
+            
+            def update_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self.class, "Update #{self.class.name}" do
+                update_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def save_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self.class, "Save #{self.class.name}" do
+                save_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def save_with_fiveruns_tuneup!(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self.class, "Save #{self.class.name}" do
+                save_without_fiveruns_tuneup!(*args, &block)
+              end
+            end
+            
+            #
+            # DELETES
+            #
+            
+            def destroy_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup::Instrumentation::ActiveRecord::Base.record self.class, "Destroy #{self.class.name}" do
+                destroy_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fiveruns/tuneup/instrumentation/cgi/session.rb

@@ -0,0 +1,30 @@
+module Fiveruns
+  module Tuneup
+    module Instrumentation
+      module CGI
+        module Session
+          def self.included(base)
+            Fiveruns::Tuneup.instrument base, InstanceMethods
+          end
+          module InstanceMethods
+            def initialize_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.step "Create session", :model do
+                initialize_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def close_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.step "Close session", :model do
+                close_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+            def delete_with_fiveruns_tuneup(*args, &block)
+              Fiveruns::Tuneup.step "Delete session", :model do
+                delete_without_fiveruns_tuneup(*args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fiveruns/tuneup/instrumentation/utilities.rb

@@ -0,0 +1,172 @@
+module Fiveruns
+  module Tuneup
+    module Instrumentation
+      module Utilities
+        
+        def stack
+          @stack ||= []
+        end
+
+        def exclusion_stack
+          @exclusion_stack ||= [0]
+        end
+        
+        def custom_methods
+          @custom_methods ||= {}
+        end
+        
+        def add_custom_methods(target, *methods)
+          custom_methods[target] = [] unless custom_methods.key?(target)
+          custom_methods[target].push(*methods)
+        end
+        
+        def stopwatch
+          start = Time.now.to_f
+          yield
+          (Time.now.to_f - start) * 1000
+        end
+        
+        def exclude
+          result = nil
+          exclusion_stack[-1] += stopwatch { result = yield }
+          result
+        end
+
+        def step(name, layer=nil, link=true, sql=nil, table_name=nil, &block)
+          if recording?
+            result = nil
+            caller_line = caller.detect { |l| l.include?(RAILS_ROOT) && l !~ /tuneup|vendor\/rails/ } if link
+            file, line = caller_line ? caller_line.split(':')[0, 2] : [nil, nil]
+            line = line.to_i if line
+            returning ::Fiveruns::Tuneup::Step.new(name, layer, file, line, sql, &block) do |step|
+              step.table_name = table_name
+              stack.last << step
+              stack << step
+              handle_exclusions_in step do
+                step.time = stopwatch { result = yield(sql) }
+              end
+              stack.pop
+            end
+            result
+          else
+            yield(sql)
+          end
+        end
+        
+        # Handle removal of excluded time from total for this step, and
+        # bubble the value up for removal from the parent step
+        def handle_exclusions_in(step)
+          exclusion_stack << 0
+          yield # Must set +step.time+
+          time_to_exclude = exclusion_stack.pop
+          step.time -= time_to_exclude
+          exclusion_stack[-1] += time_to_exclude unless exclusion_stack.blank?
+        end
+
+        def instrument(target, *mods)
+          mods.each do |mod|
+            # Change target for 'ClassMethods' module
+            real_target = mod.name.demodulize == 'ClassMethods' ? (class << target; self; end) : target
+            real_target.__send__(:include, mod)
+            # Find all the instrumentation hooks and chain them in
+            mod.instance_methods.each do |meth|
+              name = meth.to_s.sub('_with_fiveruns_tuneup', '')
+              real_target.alias_method_chain(name, :fiveruns_tuneup) rescue nil
+            end
+          end
+        end
+        
+        def instrument_action_methods(controller)
+          klass = controller.class
+          actions_for(klass).each do |meth|
+            format = alias_format_for(meth)
+            next if controller.respond_to?(format % :with, true)
+            wrap(klass, format, meth, "Invoke #{meth} action", :controller)
+          end
+        end
+        
+        def instrument_filters(controller)
+          klass = controller.class
+          filters_for(klass).each do |filter|
+            format = alias_format_for(filter.filter)
+            next if controller.respond_to?(format % :with, true)
+            wrap(klass, format, filter.filter, "#{filter.type.to_s.titleize} filter #{filter.filter}", :controller)
+          end
+        end
+        
+        def instrument_custom_methods
+          custom_methods.each do |meth_target, meths|
+            lineage = meth_target.ancestors
+            layer = if lineage.include?(ActionController::Base)
+              :controller
+            elsif lineage.include?(ActiveRecord::Base)
+              :model
+            elsif lineage.include?(ActionView::Base)
+              :view
+            else
+              :other
+            end
+            meths.each do |meth|
+              format = alias_format_for(meth)
+              wrap(meth_target, format, meth, "Method #{meth}", layer)
+            end
+          end
+        end
+        
+        #######
+        private
+        #######
+        
+        def wrap(klass, format, meth, name, layer)
+          text = <<-EOC
+            def #{format % :with}(*args, &block)
+              Fiveruns::Tuneup.step "#{name}", :#{layer} do
+                #{format % :without}(*args, &block)
+              end
+            end
+            alias_method_chain :#{meth}, :fiveruns_tuneup
+          EOC
+          begin
+            klass.class_eval text
+          rescue SyntaxError => e
+            # XXX: Catch-all for reports of oddly-named methods affecting dynamically generated code
+            log :warn, %[Bad syntax wrapping #{klass}##{meth}, "#{name}"]
+          end
+        end
+        
+        def alias_format_for(name)
+          name.to_s =~ /^(.*?)(\?|!|=)$/ ? "#{$1}_%s_fiveruns_tuneup#{$2}" : "#{name}_%s_fiveruns_tuneup"
+        end
+        
+        def actions_for(klass)
+          klass.action_methods.reject { |meth| meth.to_s.include?('fiveruns') }
+        end
+        
+        def filters_for(klass)
+          klass.filter_chain.select { |f| f.filter.is_a?(Symbol) }
+        end
+
+        def install_instrumentation
+          instrumentation_path = File.dirname(__FILE__)
+          Dir[File.join(instrumentation_path, '/*/**/*.rb')].each do |filename|
+            constant_path = filename[(instrumentation_path.size + 1)..-4]
+            constant_name = path_to_constant_name(constant_path)
+            if (constant = constant_name.constantize rescue nil)
+              instrumentation = "Fiveruns::Tuneup::Instrumentation::#{constant_name}".constantize
+              constant.__send__(:include, instrumentation)
+            else
+              log :debug, "#{constant_name} not found; skipping instrumentation."
+            end
+          end
+        end
+
+        def path_to_constant_name(path)
+          parts = path.split(File::SEPARATOR)
+          parts.map(&:camelize).join('::').sub('Cgi', 'CGI')
+        end
+        
+      end
+    end
+  end
+end
+