fiveruns_tuneup 0.8.2

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/runs.rb

@@ -0,0 +1,86 @@
+module Fiveruns
+  module Tuneup
+    module Runs
+      
+      def run_dir
+        @run_dir ||= File.join(RAILS_ROOT, 'tmp', 'tuneup', 'runs')
+      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,219 @@
+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
+          unless leaf?
+            if disparity > 0
+              percentages[layer] += disparity / self.time
+            end
+          end
+          percentages[:other] ||= 0
+          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
+          time - child_total
+        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
+        @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
+  

data/lib/fiveruns/tuneup/urls.rb

@@ -0,0 +1,23 @@
+module Fiveruns
+  module Tuneup
+    module Urls
+      
+      def collector_url
+        @collector_url ||= begin
+          url = ENV['TUNEUP_COLLECTOR'] || 'https://tuneup-collector.fiveruns.com'
+          url = "http://#{url}" unless url =~ /^http/
+          url
+        end
+      end
+      
+      def frontend_url
+        @frontend_url ||= begin
+          url = ENV['TUNEUP_FRONTEND'] || 'https://tuneup.fiveruns.com'
+          url = "http://#{url}" unless url =~ /^http/
+          url
+        end
+      end
+      
+    end
+  end
+end