lrd_rack_bug 0.3.0.4 → 0.3.1

data/lib/rack/bug/panels/speedtracer_panel/tracer.rb

@@ -0,0 +1,214 @@
+class Rack::Bug
+  module SpeedTrace
+    class TraceRecord
+      include Render
+      def initialize(id)
+        @id = id
+        @start = Time.now
+        @children = []
+      end
+
+      attr_reader :start
+
+      def finish
+        @finish ||= Time.now
+      end
+
+      def time_in_children
+        @children.inject(0) do |time, child|
+          time + child.duration
+        end
+      end
+
+      def duration
+        ((@finish - @start) * 1000).to_i
+      end
+
+      def to_json
+        Yajl::Encoder.encode(hash_representation, :pretty => true, :indent => '  ')
+      end
+
+      private
+      # all timestamps in SpeedTracer are in milliseconds
+      def range(start, finish)
+        {
+          'duration'  =>  ((finish - start) * 1000).to_i,
+          'start'     =>  [start.to_i,  start.usec/1000].join(''),
+          #'end'       =>  [finish.to_i, finish.usec/1000].join('')
+        }
+      end
+
+      def symbolize_hash(hash)
+        hash.each_key do |key|
+          if String === key
+            next if hash.has_key?(key.to_sym)
+            hash[key.to_sym] = hash[key]
+          end
+        end
+      end
+    end
+
+    class ServerEvent < TraceRecord
+      attr_accessor :children
+      attr_reader :name
+
+      def initialize(id, file, line, method, context, arguments)
+        super(id)
+
+        @file = file
+        @line = line
+        @method = method
+        @context = context
+        @arguments = arguments
+        @name = [context, method, "(", arguments, ")"].join("")
+      end
+
+      def hash_representation
+        {
+          'range' => range(@start, @finish),
+          #'id' =>  @id,
+          'operation' =>  {
+          #          'sourceCodeLocation' =>  {
+          #          'className'   =>  @file,
+          #          'methodName'  =>  @method,
+          #          'lineNumber'  =>  @line
+          #        },
+          'type' =>  'METHOD',
+          'label' =>  @name
+        },
+          'children' =>  @children
+        }
+      end
+
+      def to_html
+        render_template('panels/speedtracer/serverevent', 
+                        {:self_time => duration - time_in_children}.merge(symbolize_hash(hash_representation)))
+      end
+    end
+
+    class Tracer < TraceRecord
+      def initialize(id, method, uri)
+        super(id)
+
+        @method = method
+        @uri = uri
+        @event_id = 0
+        @pstack = []
+      end
+
+      #TODO: Threadsafe
+      def run(context="::", called_at = caller[0], args=[], &blk)
+        file, line, method = called_at.split(':')
+
+        method = method.gsub(/^in|[^\w]+/, '') if method
+
+        start_event(file, line, method, context, args)
+        blk.call      # execute the provided code block
+        finish_event
+      end
+
+      def short_string(item, max_per_elem = 50)
+        begin
+          string = item.inspect
+          if string.length > max_per_elem
+            case item
+            when NilClass
+              "nil"
+            when Hash
+              "{ " + item.map do |key, value|
+                short_string(key, 15) + "=>" + short_string(value, 30)
+              end.join(", ") + " }"
+            when find_constant("ActionView::Base")
+              tmpl = item.template
+              if tmpl.nil?
+                item.path.inspect
+              else
+                [tmpl.base_path, tmpl.name].join("/")
+              end
+            when find_constant("ActiveRecord::Base")
+              string = "#{item.class.name}(#{item.id})" 
+            else
+              string = item.class.name
+            end
+          else
+            string
+          end
+        rescue Exception => ex
+          "..."
+        end
+      end
+
+      def make_string_of(array)
+        array.map do |item|
+          short_string(item)
+        end.join(",")
+      end
+
+      def start_event(file, line, method, context, arguments)
+        @event_id += 1
+
+        arguments_string = make_string_of(arguments)
+        event = ServerEvent.new(@event_id, file, line, method, context, arguments_string)
+        @pstack.push event
+      end
+
+      def finish_event
+        event = @pstack.pop
+        if event.nil?
+        else
+          event.finish
+
+
+          unless (parent = @pstack.last).nil?
+            parent.children.push event
+          else
+            @children.push event
+          end
+        end
+      end
+
+      def hash_representation
+        finish
+        { 'trace' =>  {
+
+          'url' => "/speedtracer?id=#@id",
+
+          'frameStack' => {
+
+            'range' => range(@start, @finish),
+            'operation' =>  {
+            'type' =>  'HTTP',
+            'label' =>  [@method, @uri].join(' ')
+          },
+            'children' =>  @children
+
+          }, #end frameStack
+
+            'resources' => {
+            'Application' => '/', #Should get the Rails app name...
+            'Application.endpoint' => '/' #Should get the env path thing
+          }, #From what I can tell, Speed Tracer treats this whole hash as optional
+
+            'range' =>  range(@start, @finish)
+        }
+        }
+      end
+
+      def to_html
+        hash = hash_representation
+        extra = {:self_time => duration - time_in_children}
+        "<a href='#{hash['trace']['url']}'>Raw JSON</a>\n" + 
+          render_template('panels/speedtracer/serverevent', extra.merge(symbolize_hash(hash['trace']['frameStack'])))
+      end
+
+      def finish
+        super()
+
+        until @pstack.empty?
+          finish_event
+        end
+        self
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Rack
       require "rack/bug/panels/sql_panel/sql_extension"
 
       autoload :PanelApp, "rack/bug/panels/sql_panel/panel_app"
-      autoload :Query,    "rack/bug/panels/sql_panel/query"
+      autoload :QueryResult,    "rack/bug/panels/sql_panel/query"
 
       def panel_app
         PanelApp.new
@@ -18,14 +18,14 @@ module Rack
 
         start_time = Time.now
         result = block.call
-        queries << Query.new(sql, Time.now - start_time, backtrace)
+        queries << QueryResult.new(sql, Time.now - start_time, backtrace)
 
         return result
       end
       
       def self.record_event(sql, duration, backtrace = [])
         return unless Rack::Bug.enabled?
-        queries << Query.new(sql, duration, backtrace)
+        queries << QueryResult.new(sql, duration, backtrace)
       end
 
       def self.reset
@@ -37,7 +37,10 @@ module Rack
       end
 
       def self.total_time
-        (queries.inject(0) { |memo, query| memo + query.time}) * 1_000
+        (queries.inject(0) do |memo, query| 
+          Rails.logger.debug{ "QTime: #{query.time}" }
+          memo + query.time
+        end) * 1_000
       end
 
       def name

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

@@ -1,3 +1,5 @@
+require 'rack/bug/panels/sql_panel/query'
+
 module Rack
   class Bug
     class SQLPanel
@@ -15,20 +17,20 @@ module Rack
 
         def explain_sql
           validate_params
-          query = Query.new(params["query"], params["time"].to_f)
-          render_template "panels/explain_sql", :result => query.explain, :query => query.sql, :time => query.time
+          query = ExplainResult.new(params["query"], params["time"].to_f)
+          render_template "panels/explain_sql", :query => query
         end
 
         def profile_sql
           validate_params
-          query = Query.new(params["query"], params["time"].to_f)
-          render_template "panels/profile_sql", :result => query.profile, :query => query.sql, :time => query.time
+          query = ProfileResult.new(params["query"], params["time"].to_f)
+          render_template "panels/profile_sql", :query => query
         end
 
         def execute_sql
           validate_params
-          query = Query.new(params["query"], params["time"].to_f)
-          render_template "panels/execute_sql", :result => query.execute, :query => query.sql, :time => query.time
+          query = QueryResult.new(params["query"], params["time"].to_f)
+          render_template "panels/execute_sql", :query => query
         end
 
       end

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

@@ -2,7 +2,7 @@ module Rack
   class Bug
     class SQLPanel
 
-      class Query
+      class QueryResult
         include Rack::Bug::FilteredBacktrace
 
         attr_reader :sql
@@ -12,36 +12,43 @@ module Rack
           @sql = sql
           @time = time
           @backtrace = backtrace
+          @results = nil
         end
 
-        def human_time
-          "%.2fms" % (@time * 1_000)
+        def result
+          @results ||= execute
+          return @results
         end
 
-        def inspectable?
-          sql.strip =~ /^SELECT /i
+        def column_names
+          if result.respond_to?(:fields)
+            return result.fields
+          else
+            return result.fetch_fields.map{|col| col.name}
+          end
         end
 
-        def with_profiling
-          self.class.execute("SET PROFILING=1")
-          result = yield
-          self.class.execute("SET PROFILING=0")
-          return result
+        def rows
+          if result.respond_to?(:values)
+            result.values
+          else
+            result.map do |row|
+              row
+            end
+          end
         end
 
-        def explain
-          self.class.execute "EXPLAIN #{@sql}"
+        def human_time
+          "%.2fms" % (@time * 1_000)
         end
 
-        def profile
-          with_profiling do
-            execute
-            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
+        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
@@ -52,12 +59,37 @@ module Rack
           hash = Digest::SHA1.hexdigest [secret_key, @sql].join(":")
           possible_hash == hash
         end
+      end
 
-        def self.execute(sql)
-          ActiveRecord::Base.connection.execute(sql)
+      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
 end

data/lib/rack/bug/panels/sql_panel/sql_extension.rb

@@ -1,22 +1,11 @@
 if defined?(ActiveRecord) && defined?(ActiveRecord::ConnectionAdapters)
-
-  if defined?(ActiveSupport::Notifications)
-    require 'active_record/base'
-    ActiveSupport::Notifications.subscribe(/sql.active_record/) do |*args|
-      event = ActiveSupport::Notifications::Event.new(*args)
-      Rack::Bug::SQLPanel.record_event(event.payload[:sql], event.duration) # TODO: is there any way to get a backtrace out of here?
-    end
-  else
-  
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
-      def log_with_rack_bug(sql, name, &block)
-        Rack::Bug::SQLPanel.record(sql, Kernel.caller) do
-          log_without_rack_bug(sql, name, &block)
-        end
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
+    def log_with_rack_bug(sql, name, &block)
+      Rack::Bug::SQLPanel.record(sql, Kernel.caller) do
+        log_without_rack_bug(sql, name, &block)
       end
-
-      alias_method_chain :log, :rack_bug
     end
-    
+
+    alias_method_chain :log, :rack_bug
   end
 end

data/lib/rack/bug/panels/templates_panel/actionview_extension.rb

@@ -1,21 +1,12 @@
 if defined?(ActionView) && defined?(ActionView::Template)
-  if defined?(ActiveSupport::Notifications)
+  ActionView::Template.class_eval do
 
-    ActiveSupport::Notifications.subscribe /^render.*\.action_view/ do |*args|
-      event = ActiveSupport::Notifications::Event.new(*args)
-      Rack::Bug::TemplatesPanel.record_event(event)
-    end
-
-  else
-    ActionView::Template.class_eval do
-
-      def render_template_with_rack_bug(*args, &block)
-        Rack::Bug::TemplatesPanel.record(path_without_format_and_extension) do
-          render_template_without_rack_bug(*args, &block)
-        end
+    def render_with_rack_bug(*args, &block)
+      Rack::Bug::TemplatesPanel.record(virtual_path) do
+        render_without_rack_bug(*args, &block)
       end
-
-      alias_method_chain :render_template, :rack_bug
     end
+
+    alias_method_chain :render, :rack_bug
   end
 end