rack-insight 0.5.0

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

@@ -0,0 +1,46 @@
+module Rack::Insight
+  class MongoPanel
+
+    class Stats
+      class Query
+        attr_reader :time
+        attr_reader :command
+
+        def initialize(time, command)
+          @time = time
+          @command = command
+        end
+
+        def display_time
+          "%.2fms" % time
+        end
+      end
+
+      attr_reader :calls
+      attr_reader :queries
+
+      def initialize
+        @queries = []
+        @calls = 0
+        @time = 0.0
+      end
+
+      def record_call(time, command)
+        @queries << Query.new(time, command)
+        @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/rails_info_panel.rb

@@ -0,0 +1,19 @@
+module Rack::Insight
+  class RailsInfoPanel < Panel
+
+    def name
+      "rails_info"
+    end
+
+    def heading
+      return unless (defined?(Rails) && defined?(Rails::Info))
+      "Rails #{Rails.version}"
+    end
+
+    def content
+      return unless (defined?(Rails) && defined?(Rails::Info))
+      render_template "panels/rails_info"
+    end
+
+  end
+end

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

@@ -0,0 +1,42 @@
+module Rack::Insight
+
+  class RedisPanel < Panel
+    require "rack/insight/panels/redis_panel/redis_extension"
+
+    require "rack/insight/panels/redis_panel/stats"
+
+    def self.record(redis_command_args, backtrace, &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, redis_command_args, backtrace)
+      return result
+    end
+
+    def self.reset
+      Thread.current["rack-insight.redis"] = Stats.new
+    end
+
+    def self.stats
+      Thread.current["rack-insight.redis"] ||= Stats.new
+    end
+
+    def name
+      "redis"
+    end
+
+    def heading
+      "Redis: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
+    end
+
+    def content
+      result = render_template "panels/redis", :stats => self.class.stats
+      self.class.reset
+      return result
+    end
+
+  end
+
+end

data/lib/rack/insight/panels/redis_panel/redis_extension.rb

@@ -0,0 +1,23 @@
+if defined?(Redis)
+  Redis.class_eval do
+    if Redis.methods.include?('call_command') # older versions of redis-rb
+      def call_command_with_insight(*argv)
+        Rack::Insight::RedisPanel.record(argv, Kernel.caller) do
+          call_command_without_insight(*argv)
+        end
+      end
+
+      alias_method_chain :call_command, :insight
+
+    elsif defined?(Redis::Client) # newer versions of redis-rb
+
+      Redis::Client.class_eval do
+        def call_with_insight(*argv)
+        end
+      end
+
+      alias_method_chain :call, :insight
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Rack::Insight
+  class RedisPanel
+
+    class Stats
+      class Query
+        include Rack::Insight::FilteredBacktrace
+
+        attr_reader :time
+        attr_reader :command
+
+        def initialize(time, command_args, backtrace)
+          @time = time
+          @command = command_args.inspect
+          @backtrace = backtrace
+        end
+
+        def display_time
+          "%.2fms" % time
+        end
+      end
+
+      attr_reader :calls
+      attr_reader :queries
+
+      def initialize
+        @queries = []
+        @calls = 0
+        @time = 0.0
+      end
+
+      def record_call(time, command_args, backtrace)
+        @queries << Query.new(time, command_args, backtrace)
+        @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/request_variables_panel.rb

@@ -0,0 +1,70 @@
+module Rack::Insight
+  class RequestVariablesPanel < Panel
+    def initialize(app)
+      super
+
+      table_setup("request_variables")
+    end
+
+    def name
+      "request_variables"
+    end
+
+    def after(env,status,headers,body)
+      sections = {}
+      sections["GET"] = sort(@request.GET) if @request.GET.any?
+      sections["POST"] = sort(@request.POST) if @request.POST.any?
+      sections["Session"] = sort(@request.env["rack.session"]) if @request.env["rack.session"] && @request.env["rack.session"].any?
+      sections["Cookies"] = sort(@request.env["rack.request.cookie_hash"]) if @request.env["rack.request.cookie_hash"] && @request.env["rack.request.cookie_hash"].any?
+      server, rack = split_and_filter_env(@env)
+      sections["SERVER VARIABLES"] = sort(server)
+      sections["Rack ENV"] = sort(rack)
+
+#      require 'pp'
+#      ::File.open("sections.dump", "w") do |file|
+#        PP.pp(sections, file)
+#      end
+      store(env, sections)
+    end
+
+    def heading
+      "Rack Env"
+    end
+
+    def content_for_request(number)
+      sections = retrieve(number).first
+
+      render_template "panels/request_variables", :sections => sections
+    end
+
+    private
+    def sort(hash)
+      scrub(hash.sort_by { |k, v| k.to_s })
+    end
+
+    def scrub(enum)
+      enum.map do |k,v|
+        if Hash === v
+          [k, v.inspect]
+        else
+          [k, v.to_s]
+        end
+      end
+    end
+
+    def split_and_filter_env(env)
+      server, rack = {}, {}
+      env.each do |k,v|
+        if k.index("rack.") == 0
+          rack[k] = v
+        elsif k.index("rack-insight") == 0 or k.index("rack-insight") == 0
+          #don't output the insight variables - especially secret_key
+        else
+          server[k] = v
+        end
+      end
+      return server, rack
+    end
+
+  end
+end

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

@@ -0,0 +1,89 @@
+begin
+  require 'yajl'
+rescue LoadError
+  #Means no Chrome Speedtracer...
+end
+require 'uuidtools'
+require 'rack/insight/panels/speedtracer_panel/trace-app'
+require 'rack/insight/panels/speedtracer_panel/tracer'
+
+module Rack::Insight
+  module SpeedTracer
+    class Panel < ::Rack::Insight::Panel
+
+    def initialize(app)
+      @app = app
+      @uuid = UUIDTools::UUID.random_create.to_s
+      table_setup("speedtracer", "uuid")
+      key_sql_template("'%s'")
+
+      @tracer = Tracer.new(@table)
+      probe(@tracer) do
+        instrument("ActiveSupport::Notifications") do
+          class_probe :instrument
+        end
+
+        instrument("ActionView::Rendering") do
+          instance_probe :render
+        end
+
+        instrument("ActionView::Helpers::RecordTagHelper") do
+          instance_probe :content_tag_for
+        end
+
+        instrument("ActionView::Partials::PartialRenderer") do
+          instance_probe :render, :find_template, :render_collection, :collection_with_template, :collection_without_template, :partial_path, :collection_paths
+        end
+
+        instrument("ActionView::Template") do
+          instance_probe :render, :compile
+        end
+
+        instrument("ActiveRecord::Base") do
+          class_probe :find, :find_by_sql, :all, :first, :last, :count, :delete_all
+          instance_probe :save, :save!, :destroy, :delete
+        end
+
+        instrument("ActionController::Base") do
+          instance_probe :process, :render
+        end
+      end
+
+      super
+    end
+
+
+    def call(env)
+      env['rack-insight.speedtracer-id'] = @uuid
+
+      status, headers, body = @app.call(env)
+
+      store(env, env['rack-insight.speedtracer-id'], env['rack-insight.speedtracer-record'])
+      headers['X-TraceUrl'] = '__insight__/speedtracer?id=' + env['rack-insight.speedtracer-id']
+      return [status, headers, body]
+    end
+
+    def self.panel_mappings
+      { "speedtracer" => TraceApp.new }
+    end
+
+    def name
+      "speedtracer"
+    end
+
+    def heading
+      "#{table_length} traces"
+    end
+
+    def content_for_request(request_id)
+      trace = retrieve(request_id).first
+      return "" if trace.nil?
+      advice = []
+      if not defined?(Yajl)
+        advice << "yajl-ruby not installed - Speedtracer server events won't be available"
+      end
+      render_template "panels/speedtracer/traces", :trace => trace, :advice => advice
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Rack::Insight
+
+
+  #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/insight/panels/speedtracer_panel/trace-app.rb

@@ -0,0 +1,52 @@
+module Rack::Insight
+  module SpeedTracer
+    class TraceApp
+      include Database::RequestDataClient
+
+      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
+        table_setup("speedtracer", "uuid")
+        key_sql_template = "'%s'"
+      end
+
+      def call(env)
+        resp = Rack::Response.new('', 200)
+        resp['Content-Type'] = CONTENT_TYPE
+
+        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'])
+          if qs['id'] && (trace = @table.retrieve("uuid = '#{qs['id']}'"))
+            resp.write trace.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

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

@@ -0,0 +1,213 @@
+module Rack::Insight
+  module SpeedTracer
+    class Tracer
+      def initialize(table)
+        @pstack = []
+        @table = table
+        @event_id = 0
+      end
+
+      def request_start(env, start)
+        id, method, uri = env.values_at("rack-insight.speedtracer-id", "REQUEST_METHOD", "PATH_INFO")
+        @pstack.push RequestRecord.new(id, method, uri)
+      end
+
+      def request_finish(env, status, headers, body, timing)
+        env["rack-insight.speedtracer-record"] = @pstack.pop
+      end
+
+      def before_detect(method_call, arguments)
+        @event_id += 1
+
+        #arguments_string = make_string_of(arguments)
+        arguments_string = ""
+        #XXX ServerEvent use method call...
+        event = ServerEvent.new(method_call, arguments_string)
+        @pstack.push event
+      end
+
+      def after_detect(method_call, timing, arguments, result)
+        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 make_string_of(array)
+        array.map do |item|
+          short_string(item)
+        end.join(",")
+      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
+
+    end
+
+    class TraceRecord
+      include Render
+      def initialize
+        @start = Time.now
+        @children = []
+      end
+
+      attr_accessor :children
+      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)
+        symbolled_hash = {}
+        hash.each_key do |key|
+          if String === key
+            next if hash.has_key?(key.to_sym)
+            symbolled_hash[key.to_sym] = hash[key]
+          end
+        end
+        hash.merge!(symbolled_hash)
+      end
+    end
+
+    class ServerEvent < TraceRecord
+      attr_reader :name
+
+      def initialize(method_call, arguments)
+        super()
+        @arguments = arguments
+        @name = "#{method_call.context}#{method_call.kind == :instance ? "#" : "::"}#{method_call.method}(#{arguments})"
+      end
+
+      def hash_representation
+        {
+          'range' => range(@start, @finish),
+          '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 RequestRecord < TraceRecord
+      def initialize(id, method, uri)
+        super()
+
+        @id = id
+        @method = method
+        @uri = uri
+        @event_id = 0
+      end
+
+      def uuid
+        @id
+      end
+
+      def hash_representation
+        finish
+        { 'trace' =>  {
+
+          'url' => "/__insight__/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
+    end
+  end
+end