rack-insight 0.5.0

data/lib/rack/insight/panels/sphinx_panel.rb

@@ -0,0 +1,41 @@
+module Rack::Insight
+
+  class SphinxPanel < Panel
+    require "rack/insight/panels/sphinx_panel/sphinx_extension"
+    require "rack/insight/panels/sphinx_panel/stats"
+
+    def self.record(*sphinx_command_args, &block)
+      return block.call unless Rack::Insight.enabled?
+
+      start_time = Time.now
+      result = block.call
+      total_time = Time.now - start_time
+      stats.record_call(total_time * 1_000, sphinx_command_args)
+      return result
+    end
+
+    def self.reset
+      Thread.current["rack-insight.sphinx"] = Stats.new
+    end
+
+    def self.stats
+      Thread.current["rack-insight.sphinx"] ||= Stats.new
+    end
+
+    def name
+      "sphinx"
+    end
+
+    def heading
+      "Sphinx: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
+    end
+
+    def content
+      result = render_template "panels/sphinx", :stats => self.class.stats
+      self.class.reset
+      return result
+    end
+
+  end
+
+end

data/lib/rack/insight/panels/sphinx_panel/stats.rb

@@ -0,0 +1,94 @@
+module Rack::Insight
+  class SphinxPanel
+
+    class Stats
+      class Query
+        attr_reader :time
+        attr_reader :command
+
+        def initialize(time, *command_args)
+          @time = time
+          if command_args.flatten.first == :search
+            @command = "search: " + decode_message(command_args.first.flatten.last).collect{|k,v| "#{k} => #{v}"}.join(", ")
+          else
+            @command = command_args.flatten.first.to_s + ": No more info is available for this Sphinx request type"
+          end
+        end
+
+        def display_time
+          "%.2fms" % time
+        end
+
+        def decode_message(m)
+          @m = m.clone
+          params = ActiveSupport::OrderedHash.new
+
+          params[:offset] = consume_int
+          params[:limit] = consume_int
+          params[:match_mode] = consume_int
+          params[:rank_mode] = consume_int
+          params[:sort_mode] = consume_int
+          params[:sort_by] = consume_string
+          params[:query] = consume_string
+          wl = consume_int
+          weights = []
+          wl.times do weights << consume_int end
+          params[:weights] = weights
+
+          params[:index] = consume_string
+
+          consume_string
+
+          params[:id_range] = [consume_64int, consume_64int]
+          params
+        end
+
+        def consume_int
+          i = @m.unpack("N").first
+          @m = @m.slice(4, @m.length - 4)
+          i
+        end
+
+        def consume_64int
+          i = @m.unpack("NN").first
+          @m = @m.slice(8, @m.length - 8)
+          i
+        end
+
+        def consume_string
+          len = consume_int
+          s = @m.slice(0, len)
+          @m = @m.slice(len, @m.length - len)
+          s
+        end
+      end
+
+      attr_reader :calls
+      attr_reader :queries
+
+      def initialize
+        @queries = []
+        @calls = 0
+        @time = 0.0
+      end
+
+      def record_call(time, *command_args)
+
+        @queries << Query.new(time, command_args)
+        @calls += 1
+        @time += time
+      end
+
+      def display_time
+        "%.2fms" % time
+      end
+
+      def time
+        @queries.inject(0) do |memo, query|
+          memo + query.time
+        end
+      end
+    end
+
+  end
+end

data/lib/rack/insight/panels/sql_panel.rb

@@ -0,0 +1,53 @@
+require "digest"
+
+module Rack::Insight
+
+  class SQLPanel < Panel
+
+    require "rack/insight/panels/sql_panel/panel_app"
+    require "rack/insight/panels/sql_panel/query"
+
+    def initialize(app)
+      super
+      probe(self) do
+        %w{ PostgreSQLAdapter MysqlAdapter SQLiteAdapter
+            Mysql2Adapter OracleEnhancedAdapter }.each do |adapter|
+          instrument "ActiveRecord::ConnectionAdapters::#{adapter}" do
+            instance_probe :execute
+          end
+            end
+      end
+      table_setup("sql_queries")
+    end
+
+    def self.panel_mappings
+      { "sql" => PanelApp.new }
+    end
+
+    def after_detect(method_call, timing, arguments, results)
+      store(@env, QueryResult.new(arguments.first, timing.duration, method_call.backtrace, results))
+    end
+
+    def total_time(queries)
+      (queries.inject(0) do |memo, query|
+        memo + query.time
+      end)
+    end
+
+    def name
+      "sql"
+    end
+
+    def heading_for_request(number)
+      queries = retrieve(number)
+      "#{queries.size} Queries (%.2fms)" % total_time(queries)
+    end
+
+    def content_for_request(number)
+      queries = retrieve(number)
+      render_template "panels/sql", :queries => queries
+    end
+
+  end
+
+end

data/lib/rack/insight/panels/sql_panel/panel_app.rb

@@ -0,0 +1,37 @@
+require 'rack/insight/panels/sql_panel/query'
+
+module Rack::Insight
+  class SQLPanel
+
+    class PanelApp < ::Rack::Insight::PanelApp
+
+      def dispatch
+        case request.path_info
+        when "/explain" then explain_sql
+        when "/profile" then profile_sql
+        when "/execute" then execute_sql
+        else not_found
+        end
+      end
+
+      def explain_sql
+        validate_params
+        query = ExplainResult.new(params["query"], params["time"].to_f)
+        render_template "panels/explain_sql", :query => query
+      end
+
+      def profile_sql
+        validate_params
+        query = ProfileResult.new(params["query"], params["time"].to_f)
+        render_template "panels/profile_sql", :query => query
+      end
+
+      def execute_sql
+        validate_params
+        query = QueryResult.new(params["query"], params["time"].to_f)
+        render_template "panels/execute_sql", :query => query
+      end
+
+    end
+  end
+end

data/lib/rack/insight/panels/sql_panel/query.rb

@@ -0,0 +1,94 @@
+module Rack::Insight
+  class SQLPanel
+
+    class QueryResult
+      include Rack::Insight::FilteredBacktrace
+
+      attr_reader :sql
+      attr_reader :time
+
+      def initialize(sql, time, backtrace = [], result=nil)
+        @sql = sql
+        @time = time
+        @backtrace = backtrace
+        @result = result
+        @results = nil
+      end
+
+      def result
+        @results ||= execute
+        return @results
+      end
+
+      def column_names
+        if result.respond_to?(:fields)
+          return result.fields
+        else
+          return result.fetch_fields.map{|col| col.name}
+        end
+      end
+
+      def rows
+        if result.respond_to?(:values)
+          result.values
+        else
+          result.map do |row|
+            row
+          end
+        end
+      end
+
+      def human_time
+        "%.2fms" % (@time)
+      end
+
+      def inspectable?
+        sql.strip =~ /^SELECT /i
+      end
+
+      #Downside is: we re-execute the SQL...
+      def self.execute(sql)
+        ActiveRecord::Base.connection.execute(sql)
+      end
+
+      def execute
+        self.class.execute(@sql)
+      end
+
+      def valid_hash?(secret_key, possible_hash)
+        hash = Digest::SHA1.hexdigest [secret_key, @sql].join(":")
+        possible_hash == hash
+      end
+    end
+
+    class ExplainResult < QueryResult
+      def execute
+        self.class.execute "EXPLAIN #{@sql}"
+      end
+    end
+
+    class ProfileResult < QueryResult
+      def with_profiling
+        result = nil
+        begin
+          self.class.execute("SET PROFILING=1")
+          result = yield
+        ensure
+          self.class.execute("SET PROFILING=0")
+        end
+        return result
+      end
+
+      def execute
+        with_profiling do
+          super
+          self.class.execute <<-SQL
+              SELECT *
+                FROM information_schema.profiling
+               WHERE query_id = (SELECT query_id FROM information_schema.profiling ORDER BY query_id DESC LIMIT 1)
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/rack/insight/panels/templates_panel.rb

@@ -0,0 +1,58 @@
+module Rack::Insight
+
+  class TemplatesPanel < Panel
+    require "rack/insight/panels/templates_panel/rendering"
+
+    def initialize(app)
+      super
+
+      probe(self) do
+        instrument "ActionView::Template" do
+          instance_probe :render
+        end
+      end
+
+      table_setup("templates")
+
+      @current = nil
+    end
+
+
+    def request_start(env, start)
+      @current = Rendering.new("root")
+    end
+
+    def request_finish(env, status, headers, body, timing)
+      store(env, @current)
+      @current = nil
+    end
+
+    def before_detect(method_call, args)
+      template_name = method_call.object.virtual_path
+
+      rendering = Rendering.new(template_name)
+      @current.add(rendering)
+      @current = rendering
+    end
+
+    def after_detect(method_call, timing, args, result)
+      @current.timing = timing
+      @current = @current.parent
+    end
+
+    def name
+      "templates"
+    end
+
+    def heading_for_request(number)
+      "Templates: %.2fms" % (retrieve(number).inject(0.0){|memo, rendering| memo + rendering.duration})
+    end
+
+    def content_for_request(number)
+      result = render_template "panels/templates", :root_rendering => retrieve(number).first
+      return result
+    end
+
+  end
+
+end

data/lib/rack/insight/panels/templates_panel/rendering.rb

@@ -0,0 +1,81 @@
+module Rack::Insight
+  class TemplatesPanel
+
+    class Rendering
+      attr_accessor :name
+      attr_accessor :parent
+      attr_accessor :timing
+      attr_reader :children
+
+      def initialize(name, timing = nil)
+        @name = name
+        @timing = timing
+        @children = []
+      end
+
+      def start_time
+        @timing.start
+      end
+      alias_method :time, :start_time
+
+      def end_time
+        @timing.end
+      end
+
+      def add(rendering)
+        @children << rendering
+        rendering.parent = self
+      end
+
+      def delete(rendering)
+        @children.delete(rendering)
+      end
+
+      def duration
+        if @timing
+          @timing.duration
+        else
+          child_duration
+        end
+      end
+
+      def exclusive_duration
+        duration - child_duration
+      end
+
+      def child_duration
+        children.inject(0.0) { |memo, c| memo + c.duration }
+      end
+
+      def duration_summary
+        if children.any?
+          "%.2fms, %.2f exclusive" % [duration, exclusive_duration]
+        else
+          "%.2fms" % (duration)
+        end
+      end
+      def html
+        <<-HTML
+            <li>
+              <p>#{name} (#{duration_summary})</p>
+
+        #{children_html}
+            </li>
+        HTML
+      end
+
+      def children_html
+        return "" unless children.any?
+
+        <<-HTML
+            <ul>#{joined_children_html}</ul>
+        HTML
+      end
+
+      def joined_children_html
+        children.map { |c| c.html }.join
+      end
+    end
+
+  end
+end