lrd_rack_bug 0.3.0.4 → 0.3.1

data/lib/lrd_rack_bug.rb

@@ -1 +1 @@
-require File.expand_path('../rack/bug', __FILE__)
+require 'rack/bug'

data/lib/rack/bug.rb

@@ -7,7 +7,7 @@ require "rack/bug/autoloading"
 class Rack::Bug
   include Options
   
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
   
   class SecurityError < StandardError
   end
@@ -25,8 +25,8 @@ class Rack::Bug
   end
 
   def initialize(app, options = {}, &block)
-    @app = asset_server(app)
     initialize_options options
+    @app = asset_server(app)
     instance_eval(&block) if block_given?
     
     @toolbar = Toolbar.new(RedirectInterceptor.new(@app))
@@ -52,7 +52,22 @@ private
   end
 
   def asset_server(app)
-    RackStaticBugAvoider.new(app, Rack::Static.new(app, :urls => ["/__rack_bug__"], :root => public_path))
+    builder = Rack::Builder.new
+
+    read_option(:panel_classes).each do |panel_class|
+      begin
+        middleware = panel_class.const_get("Middleware")
+        puts "Using middleware for #{panel_class.name}"
+        builder.use middleware
+      rescue NameError
+        #I guess no Middleware for you then.
+      end
+    end
+
+    builder.run app
+    app = builder.to_app
+    static_app = Rack::Static.new(app, :urls => ["/__rack_bug__"], :root => public_path)
+    return RackStaticBugAvoider.new(app, static_app)
   end
 
   def public_path

data/lib/rack/bug/autoloading.rb

@@ -22,4 +22,5 @@ class Rack::Bug
   autoload :TemplatesPanel,         "rack/bug/panels/templates_panel"
   autoload :TimerPanel,             "rack/bug/panels/timer_panel"
   autoload :SphinxPanel,            "rack/bug/panels/sphinx_panel"
+  autoload :SpeedTracerPanel,       "rack/bug/panels/speedtracer_panel"
 end

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

@@ -36,6 +36,15 @@ module Rack
         Thread.current["rack.bug.logs"] ||= []
       end
 
+      def initialize(app)
+        if Rails.logger and not Rails.logger.class.include?(Rack::Bug::LoggerExtension)
+          Rails.logger.class.class_eval do
+            include Rack::Bug::LoggerExtension
+          end
+        end
+        super
+      end
+
       def name
         "log"
       end

data/lib/rack/bug/panels/log_panel/logger_extension.rb

@@ -21,4 +21,4 @@ end
 
 if logger
   logger.class.send :include, Rack::Bug::LoggerExtension
-end
+end

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

@@ -0,0 +1,113 @@
+require 'rack/bug'
+begin
+  require 'yajl'
+rescue LoadError
+  #Means no Chrome Speedtracer...
+end
+require 'uuid'
+
+require 'rack/bug/panels/speedtracer_panel/trace-app'
+require 'rack/bug/panels/speedtracer_panel/tracer'
+
+class Rack::Bug
+  class SpeedTracerPanel < Panel
+    class Middleware
+      def initialize(app)
+        @app = app
+        @uuid = UUID.new
+      end
+
+      def database
+        SpeedTracerPanel.database
+      end
+
+      def call(env)
+        if %r{^/__rack_bug__/} =~ env["REQUEST_URI"] 
+          @app.call(env)
+        else
+          env['st.id'] = @uuid.generate
+
+          tracer = SpeedTrace::Tracer.new(env['st.id'], 
+                                          env['REQUEST_METHOD'], 
+                                          env['REQUEST_URI'])
+          env['st.tracer'] = tracer
+          Thread::current['st.tracer'] = tracer
+
+          status, headers, body = @app.call(env)
+
+          env['st.tracer'].finish
+          database[env['st.id']] = env['st.tracer']
+          headers['X-TraceUrl'] = '/speedtracer?id=' + env['st.id']
+          return [status, headers, body]
+        end
+      end
+    end
+
+    class << self
+      def database
+        @db ||= make_database
+      end
+
+      def make_database
+      #  begin
+          require 'rack/bug/panels/speedtracer_panel/database'
+          return Database.new("speedtracer")
+#        rescue Object => ex
+#          msg = "Speedtracer issue while loading SQLite DB:" + [ex.class, ex.message, ex.backtrace[0..4]].inspect 
+#          if Rails.logger
+#            Rails.logger.debug msg
+#          else
+#            puts msg
+#          end
+#
+#          return {}
+#        end
+      end
+
+    end
+
+
+    def database
+      self.class.database
+    end
+
+    def initialize(app)
+      @app  = app
+      super
+    end
+
+    def panel_app
+      return SpeedTrace::TraceApp.new(database)
+    end
+
+    def name
+      "speedtracer"
+    end
+
+    def heading
+      "#{database.keys.length} traces"
+    end
+
+    def content
+      traces = database.to_a.sort do |one, two|
+        two[1].start <=> one[1].start
+      end
+      advice = []
+      if not defined?(Yajl)
+        advice << "yajl-ruby not installed - Speedtracer server events won't be available"
+      end
+      if not defined?(SQLite3)
+        advice << "sqlite3 not installed - Speedtracer will behave oddly if run behind a forking webserver"
+      end
+      render_template "panels/speedtracer/traces", :traces => traces, :advice => advice
+    end
+
+    def before(env)
+    end
+
+    def after(env, status, headers, body)
+    end
+  end
+end
+
+require 'rack/bug/panels/speedtracer_panel/instrument'

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

@@ -0,0 +1,64 @@
+require 'sqlite3'
+require 'rack/bug'
+
+
+class Rack::Bug::SpeedTracerPanel
+  class Database
+    class << self
+      def db
+        if @db.nil?
+          open_database
+        end
+        return @db
+      end
+
+      def open_database
+        @db = SQLite3::Database.new("rack_bug.sqlite")
+      end
+
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          open_database if forked
+        end
+      end
+    end
+
+    def db
+      self.class.db
+    end
+
+    def initialize(table_name)
+      @table_name = table_name
+      if(db.execute("select * from sqlite_master where name = ?", table_name).empty?)
+        db.execute("create table #@table_name ( key varchar primary key, value varchar )")
+      end
+      if Rails.logger
+        Rails.logger.debug{ "Initializing a table called #{table_name}" }
+      end
+    end
+
+    def [](key)
+      rows = db.execute("select value from #@table_name where key = ?", key.to_s)
+      if rows.empty?
+        return nil
+      else
+        Marshal.load(rows.first.first)
+      end
+    end
+
+    def []=(key, value)
+      db.execute("insert or replace into #@table_name ( key, value ) values ( ?, ? )", key.to_s, Marshal.dump(value))
+    end
+
+    def keys
+      db.execute("select key from #@table_name").flatten
+    end
+    
+    def to_a
+      db.execute("select key, value from #@table_name").map do |key, value|
+        [key, Marshal.load(value)]
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,31 @@
+require "rack/bug/panels/speedtracer_panel/instrumentation"
+
+# Figure out what kind of app we're in front of.  For right now, we'll assume 
+# the answer is "Rails 3"
+#
+# TODO: Quickly so that it does drive me nuts: what I want to do here is have a 
+# class responsible for per-framework intrumentation, and an auto-instrument 
+# class method: run through registered subclasses, looking for one that says "I 
+# recognize this" and then run it.  First one wins.  Should have a nice "I need 
+# to come before..." method.
+
+
+Rack::Bug::SpeedTracerPanel::Instrumentation::connect do |inst|
+  inst.instrument("ActionView::Rendering") do |avt|
+    avt.trace_methods :render
+  end
+
+  inst.instrument("ActionView::Partials::PartialRenderer") do |avppr|
+    avppr.trace_methods :render
+  end
+
+  inst.instrument("ActiveRecord::Base") do |ar_b| 
+    ar_b.trace_class_methods :find, :all, :first, :last, :count, :delete_all
+    ar_b.trace_methods :save, :save!, :destroy, :delete
+  end
+
+  inst.instrument("ActionController::Base") do |ac_b|
+    ac_b.trace_methods :process, :render
+  end
+end
+

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

@@ -0,0 +1,102 @@
+require 'rack/bug/panels/speedtracer_panel'
+
+class Rack::Bug::SpeedTracerPanel
+  class Instrumentation
+    @instruments = Hash.new do |h,k|
+      h[k] = Instrument.new(k)
+    end
+
+    class << self
+      def get_instrument(const)
+        return @instruments[const]
+      end
+
+      def connect
+        yield(self.new)
+      end
+    end
+
+    def instrument(name)
+      parts = name.split("::")
+      begin
+        const = parts.inject(Kernel) do |namespace, part|
+          namespace.const_get(part)
+        end
+      rescue NameError => ex
+        warn "Couldn't find #{name}"
+        return nil
+      end
+      instrument = self.class.get_instrument(const)
+      yield(instrument) if block_given?
+      return instrument
+    end
+
+  end
+end
+
+class Instrument
+  def initialize(const)
+    @const = const
+    @traced = {}
+    @unsafe_names = (@const.public_instance_methods(true) + 
+                    @const.protected_instance_methods(true) + 
+                    @const.private_instance_methods(true)).sort.uniq
+  end
+
+  def trace_class_methods(*methods_names)
+    build_tracing_wrappers((class << @const; self; end), '#{self.name}::', *methods_names)
+  end
+
+  def trace_methods(*methods)
+    build_tracing_wrappers(@const, '#{self.class.name}#', *methods)
+  end
+
+  module TraceRunner
+    def trace_run(context = "::", called_at=caller[1], args=[])
+      tracer = Thread.current['st.tracer']
+      result = nil
+      if tracer.nil?
+        Rails.logger.debug{"No tracer in thread - #{context} / #{called_at}"}
+        result = yield
+      else
+        tracer.run(context, called_at, args){ result = yield }
+      end
+      result
+    end
+  end
+
+  def safe_method_names(method_names)
+    method_names.map do |name|
+      name = name.to_s
+      prefix = "0"
+      hidden_name = ["_", prefix, name].join("_")
+      while @unsafe_names.include?(hidden_name)
+        prefix = prefix.next
+        hidden_name = ["_", prefix, name].join("_")
+      end
+
+      @unsafe_names << hidden_name
+      [name, hidden_name]
+    end
+  end
+
+  def build_tracing_wrappers(target, context, *methods)
+    safe_method_names(methods).each do |method_name, old_method|
+      next if @traced.has_key?(method_name)
+      @traced[method_name] = true
+
+
+      #TODO: nicer chaining
+      target.class_eval <<-EOC, __FILE__, __LINE__
+      alias #{old_method} #{method_name}
+      include TraceRunner
+      def #{method_name}(*args, &block)
+
+        trace_run("#{context}", caller(0)[0], args) do
+          #{old_method}(*args, &block)
+        end
+      end
+      EOC
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'rack/bug/speedtracer'
+
+module Rack::Bug
+  #Variant of the Speed Tracer Panel that performs a nearly complete profile of 
+  #all code called during a request.  Note that this will slow overall response 
+  #time by several orders of magnitude, and may return more data than 
+  #SpeedTracer is prepared to display
+  class ProfilingSpeedTracer < SpeedTracer
+    def before(env)
+      super
+      tracer = env['st.tracer']
+      Kernel::set_trace_func proc {|event, file, line, name, binding,classname|
+        case event
+        when "c-call", "call"
+          methodname = classname ? "" : classname
+          methodname += name.to_s
+          tracer.start_event(file, line, name, classname || "", "")
+        when "c-return", "return"
+          tracer.finish_event
+        end
+      }
+    end
+
+    def after(env, status, headers, body)
+      Kernel::set_trace_func(nil)
+      super
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Rack::Bug::SpeedTrace
+  module Render
+    include ::Rack::Bug::Render
+
+    def compiled_source(filename)
+      ::ERB.new(::File.read(::File.dirname(__FILE__) + "/../views/#{filename}.html.erb"), nil, "-").src
+    end
+  end
+end

data/lib/rack/bug/panels/speedtracer_panel/trace-app.rb

@@ -0,0 +1,56 @@
+class Rack::Bug
+  module SpeedTrace
+    class TraceApp
+      TRACER_PATH  = /^\/speedtracer/.freeze
+      CONTENT_TYPE = 'application/json;charset=UTF-8'.freeze
+
+      FourOhFour = [404, {"Content-Type" => "text/html"}, "App tracker doesn't know that path or id"].freeze
+
+      def initialize(db)
+        @db = db
+      end
+
+      def call(env)
+        Rails.logger.debug{ "#{env['PATH_INFO']} ?= #{TRACER_PATH}" }
+        return FourOhFour unless env['PATH_INFO'].match(TRACER_PATH)
+
+        resp = Rack::Response.new('', 200)
+        resp['Content-Type'] = CONTENT_TYPE
+
+        Rails.logger.debug{ env['REQUEST_METHOD'] }
+
+        case env['REQUEST_METHOD']
+        when 'HEAD' then
+          # SpeedTracer dispatches HEAD requests to verify the
+          # tracer endpoint when it detects the X-TraceUrl
+          # header for the first time. After the initial load
+          # the verification is cached by the extension.
+          #
+          # By default, we'll return 200.
+
+        when 'GET' then
+          # GET requests for specific trace are generated by
+          # the extension when the user expands the network
+          # resource tab. Hence, server-side tracer data is
+          # request on-demand, and we need to store it for
+          # some time.
+          #
+
+          qs = Rack::Utils.parse_query(env['QUERY_STRING'])
+          Rails.logger.debug{ { qs['id'] => @db.keys }.inspect }
+          if qs['id'] && @db[qs['id']]
+            resp.write @db[qs['id']].to_json
+          else
+            # Invalid request or missing request trace id
+            return FourOhFour
+          end
+        else
+          # SpeedTracer should only issue GET & HEAD requests
+          resp.status = 400
+        end
+
+        return resp.finish
+      end
+    end
+  end
+end