ghazel-fiveruns_tuneup 0.8.22

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

@@ -0,0 +1,187 @@
+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
+              begin
+                handle_exclusions_in step do
+                  step.time = stopwatch { result = yield(sql) }
+                end
+              ensure
+                stack.pop
+              end
+            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(name_of_filter(filter))
+            next if controller.respond_to?(format % :with, true)
+            wrap(klass, format, name_of_filter(filter), "#{filter.type.to_s.titleize} filter #{name_of_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)
+          return if klass.instance_methods.include?(format % :with)
+          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| name_of_filter(f).is_a?(Symbol) }
+        end
+        
+        def name_of_filter(filter)
+          if filter.respond_to?(:filter)
+            filter.filter
+          else
+            filter.method
+          end
+        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)
+            
+            instrumentation = "Fiveruns::Tuneup::Instrumentation::#{constant_name}".constantize            
+            next if instrumentation.respond_to?(:relevant?) && !instrumentation.relevant?
+              
+            if (constant = constant_name.constantize rescue nil)             
+              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
+      

data/lib/fiveruns/tuneup/multipart.rb

@@ -0,0 +1,75 @@
+require 'net/http'
+require 'cgi'
+
+module Fiveruns
+
+  module Tuneup
+
+    class Multipart
+    
+      BOUNDARY_ROOT = 'B0UND~F0R~UPL0AD'
+    
+      attr_reader :file, :params
+      def initialize(file, params={})
+        @file = file
+        @params = params
+      end
+    
+      def content_type
+        %(multipart/form-data, boundary="#{boundary}")
+      end
+    
+      def to_s
+        %(#{parts}\r\n#{separator}--)
+      end
+      
+      #######
+      private
+      #######
+      
+      def boundary
+        "#{BOUNDARY_ROOT}*#{nonce}"
+      end
+      
+      def parts
+        params.merge(:file => file).map do |name, value|
+          [
+            separator,
+            headers_for(name, value)
+          ].flatten.join(crlf) + crlf + crlf + content_of(value)
+        end.flatten.join(crlf)
+      end
+      
+      def separator
+        %(--#{boundary})
+      end
+      
+      def crlf
+        @crlf ||= "\r\n"
+      end
+      
+      def headers_for(name, value)
+        if value.respond_to?(:read)
+          [
+            %(Content-Disposition: form-data; name="#{name}"; filename="#{File.basename(value.path)}"),
+            %(Content-Transfer-Encoding: binary),
+            %(Content-Type: application/octet-stream)
+          ]
+        else
+          [ %(Content-Disposition: form-data; name="#{name}") ]
+        end
+      end
+      
+      def nonce
+        @nonce ||= (Time.now.utc.to_f * 1000).to_i
+      end
+      
+      def content_of(value)
+        value.respond_to?(:read) ? value.read : value.to_s
+      end
+    
+    end  
+  
+  end
+  
+end

data/lib/fiveruns/tuneup/routing.rb

@@ -0,0 +1,25 @@
+module Fiveruns::Tuneup
+
+  module Routing
+    
+    def self.install
+      ActionController::Routing::RouteSet.send(:include, self)
+    end
+    
+    def self.included(base)
+      base.alias_method_chain :draw, :fiveruns_tuneup
+    end
+    def draw_with_fiveruns_tuneup(*args, &block)
+      draw_without_fiveruns_tuneup(*args) do |map|
+        map.connect '/tuneup', :controller => 'tuneup', :action => 'show'
+        map.connect '/tuneup/:action', :controller => 'tuneup'
+        yield map
+      end
+    end
+    
+  end
+  
+end
+      
+      
+  

data/lib/fiveruns/tuneup/runs.rb

@@ -0,0 +1,86 @@
+module Fiveruns
+  module Tuneup
+    module Runs
+      
+      def run_dir
+        @run_dir ||= File.join(RAILS_ROOT, 'tmp', 'tuneup', 'runs', RAILS_ENV)
+      end
+      
+      def retrieve_run(run_id)
+        filename = filename_for(run_id)
+        if File.file?(filename)
+          load_from_file(filename)
+        else
+          log :error, "Couldn't find filename: #{filename}"
+          nil
+        end
+      end
+      
+      def load_from_file(filename)
+        decompressed = Zlib::Inflate.inflate(File.open(filename, 'rb') { |f| f.read })        
+        YAML.load(decompressed)
+      end
+      
+      def last_filename_for_run_uri(uri)
+        filename_for(last_run_id_for(uri))
+      end
+      
+      def last_run
+        last_file = sorted_run_files.last
+        load_from_file(last_file)
+      end
+      
+      #######
+      private
+      #######
+      
+      def sorted_run_files
+        Dir[File.join(run_dir, '*/*.gz')].sort_by do |f|
+          File.basename(f).split('_').first.to_i
+        end
+      end
+            
+      def trend_for(run_id)
+        Dir[File.join(run_dir, File.dirname(run_id), "*.gz")].map do |filename|
+          Integer(File.basename(filename, '.yml.gz').split('_').last)
+        end
+      end
+      
+      def last_run_id_for(url)
+        last_file = Dir[File.join(run_dir, stub(url), '*.gz')].last
+        if last_file
+          File.join(File.basename(File.dirname(last_file)), File.basename(last_file, '.yml.gz'))
+        end
+      end
+      
+      # Use Run ID, current timestamp, and total time (in microseconds)
+      def generate_run_id(url, time)
+        timestamp = '%d' % (Time.now.to_f * 1000)
+        File.join(stub(url), timestamp.to_s << "_#{(time * 1000).to_i}")
+      end
+      
+      def persist(run_id, environment, schemas, data)
+        log :info, "Persisting #{run_id}"
+        filename = filename_for(run_id)
+        FileUtils.mkdir_p File.dirname(filename)
+        compressed = Zlib::Deflate.deflate(package_for(run_id, environment, schemas, data).to_yaml)
+        File.open(filename, 'wb') { |f| f.write compressed }
+      end
+      
+      def filename_for(run_id)
+        File.join(run_dir, run_id) << '.yml.gz'
+      end
+      
+      def stub(url)
+        Digest::SHA1.hexdigest(url)
+      end
+      
+      def package_for(run_id, environment, schemas, data)
+        {'id' => run_id, 'environment' => environment, 'schemas' => schemas, 'stack' => data}
+      end
+      
+    end
+    
+  end
+
+end

data/lib/fiveruns/tuneup/schema.rb

@@ -0,0 +1,43 @@
+module Fiveruns
+  module Tuneup
+    module Schema
+      
+      def schemas
+        @schemas ||= {}
+      end
+              
+      def add_schema_for(table, connection)
+        schemas[table] ||= begin
+          {
+            :columns => columns_for(table, connection),
+            :indexes => indexes_for(table, connection)
+          }
+        end
+      end
+        
+      #######
+      private
+      #######
+      
+      def columns_for(table, connection)
+        connection.columns(table).map do |column|
+          extract(column, :name, :sql_type)
+        end
+      end
+      
+      def indexes_for(table, connection)
+        connection.indexes(table).map do |index|
+          extract(index, :name, :unique, :columns)
+        end
+      end
+      
+      def extract(obj, *fields)
+        fields.inject({}) do |hash, field|
+          hash[field] = obj.__send__(field)
+          hash
+        end
+      end
+      
+    end
+  end
+end

data/lib/fiveruns/tuneup/step.rb

@@ -0,0 +1,221 @@
+module Fiveruns
+  module Tuneup
+    
+    class RootStep
+      
+      delegate :blank?, :to => :children
+      alias_method :id, :object_id # Avoid record identitication warnings
+            
+      def self.layers
+        framework_layers + [:other]
+      end
+      
+      def self.framework_layers
+        [:model, :view, :controller]
+      end
+      
+      def schemas
+        @schemas ||= {}
+      end
+      
+      def time
+        children.map(&:time).sum || 0
+      end
+      
+      def depth
+        @depth ||= 0
+      end
+      
+      def <<(child)
+        child.depth = depth + 1
+        children << child
+      end
+      
+      def size
+        children.map(&:size).sum || 0
+      end
+      
+      def children_with_disparity
+        children + [Step.disparity(disparity, self)]
+      end
+      
+      def children
+        @children ||= []
+      end
+      
+      def leaf?
+        children.blank?
+      end
+            
+      def leaves
+        @leaves ||= begin
+          if children.blank?
+            [self]
+          else
+            children.map(&:leaves).flatten
+          end
+        end
+      end
+      
+      def child_times_by_layer
+        @child_times_by_layer ||= children.inject(Hash.new(0)) do |totals, child|
+          child.percentages_by_layer.each do |layer, percentage|
+            totals[layer] += child.time * percentage
+          end
+          totals
+        end
+      end
+      
+      def percentages_by_layer
+        @percentages_by_layer ||= begin
+          percentages = self.class.framework_layers.inject({}) do |map, layer|
+            map[layer] = if leaf?
+              self.layer == layer ? 1.0 : 0
+            else
+              result = child_times_by_layer[layer] / self.time
+              result = nil unless result.to_s =~ /\d/
+              result.is_a?(Numeric) ? result : 0 # TODO: Fix issue at source
+            end
+            map
+          end
+          fill percentages
+        end
+      end
+      
+      #######
+      private
+      #######
+
+      def fill(percentages)
+        returning percentages do
+          percentages[:other] ||= 0
+          unless leaf?
+            if disparity > 0
+              percentages[layer] += disparity / self.time
+            end
+          end
+          total = percentages.values.sum
+          if total < 0.999
+            percentages[:other] += 1.0 - total
+          end
+        end
+      end
+      
+      def disparity
+        @disparity ||= begin
+          child_total = children.map(&:time).sum || 0
+          disparity = time - child_total
+          disparity > 0 ? disparity : 0
+        end
+      end
+      
+    end
+    
+    class Step < RootStep
+      
+      attr_reader :name, :layer, :file, :line, :sql
+      attr_accessor :table_name
+      attr_writer :time, :depth
+      
+      def self.disparity(time, parent)
+        returning Step.new("Other", parent.layer) do |step|
+          step.time = time
+        end
+      end
+      
+      def initialize(name, layer=nil, file=nil, line=nil, sql=nil)
+        @name = name
+        @layer = layer
+        @file = file
+        @line = line
+        @sql = sql
+      end
+      
+      def time
+        # FIXME: rank hack to get around weird JRuby YAML bug
+        @time.respond_to?(:value) ? @time.value.to_f : @time || 0
+      end
+            
+      def size
+        children.map(&:size).sum + 1
+      end
+      
+      class SQL
+        
+        attr_reader :query, :explain
+        
+        def initialize(sql, connection)
+          @query = sql
+          @explain = explain_from(connection)
+        end
+        
+        #######
+        private
+        #######
+        
+        def explain_from(connection)
+          return nil unless @query =~ /^select\b/i
+          return nil unless connection.adapter_name == 'MySQL'
+          explain = Explain.new(@query, connection)
+          explain if explain.valid?
+        end
+        
+        class Explain
+          
+          attr_reader :fields, :rows
+          
+          def initialize(sql, connection)
+            result = connection.execute("explain #{sql}")
+            @fields = fetch_fields_from(result)
+            @rows = fetch_rows_from(result)
+            result.free
+            add_schemas(connection)
+            @valid = true
+          rescue Exception
+            @valid = false
+          end
+          
+          def valid?
+            @valid
+          end
+          
+          def table_offset
+            @table_offset ||= @fields.index('table')
+          end
+
+          #######
+          private
+          #######
+
+          def fetch_fields_from(result)
+            result.fetch_fields.map(&:name)
+          end
+
+          def fetch_rows_from(result)
+            returning [] do |rows|
+              result.each do |row|
+                rows << row
+              end
+            end
+          end
+          
+          def add_schemas(connection)
+            tables.each do |table|
+              Fiveruns::Tuneup.add_schema_for(table, connection)
+            end
+          end
+          
+          def tables
+            return [] unless table_offset
+            @rows.map { |row| row[table_offset] }.compact
+          end
+          
+        end
+
+      end
+
+    end
+    
+  end
+end
+