logical-insight 0.4.0

data/lib/insight/panel_app.rb

@@ -0,0 +1,31 @@
+module Insight
+
+  class PanelApp
+    include Insight::Render
+
+    attr_reader :request
+
+    def call(env)
+      @request = Rack::Request.new(env)
+      dispatch
+    end
+
+    def render_template(*args)
+      Rack::Response.new([super]).to_a
+    end
+
+    def params
+      @request.GET
+    end
+
+    def not_found(message="")
+      [404, {}, [message]]
+    end
+
+    def validate_params
+      ParamsSignature.new(request).validate!
+    end
+
+  end
+
+end

data/lib/insight/panels-content.rb

@@ -0,0 +1,22 @@
+module Insight
+  class PanelsContent < PanelApp
+    def initialize(insight_app)
+      @insight_app = insight_app
+      @request_table = Database::RequestTable.new
+    end
+
+    def dispatch
+      return not_found("not get") unless @request.get?
+      return not_found("id nil") if params['request_id'].nil?
+      request = @request_table.select("*", "id = #{params['request_id']}").first
+      return not_found("id not found") if request.nil?
+      requests = @request_table.to_a.map do |row|
+        { :id => row[0], :method => row[1], :path => row[2] }
+      end
+      render_template("request_fragment",
+                      :request_id => params['request_id'].to_i,
+                      :requests => requests,
+                      :panels => @insight_app.panels)
+    end
+  end
+end

data/lib/insight/panels-header.rb

@@ -0,0 +1,18 @@
+module Insight
+  class PanelsHeader < PanelApp
+    def initialize(insight_app)
+      @insight_app = insight_app
+      @request_table = Database::RequestTable.new
+    end
+
+    def dispatch
+      return not_found("not get") unless @request.get?
+      return not_found("id nil") if params['request_id'].nil?
+      request = @request_table.select("*", "id = #{params['request_id']}").first
+      return not_found("id not found") if request.nil?
+      render_template("headers_fragment",
+                      :request_id => params['request_id'].to_i,
+                      :panels => @insight_app.panels)
+    end
+  end
+end

data/lib/insight/panels/active_record_panel.rb

@@ -0,0 +1,46 @@
+module Insight
+  class ActiveRecordPanel < Panel
+    def initialize(app)
+      super
+
+      table_setup("active_record")
+
+      probe(self) do
+        instrument "ActiveRecord::Base" do
+          class_probe :allocate
+        end
+      end
+    end
+
+    def request_start(env, start)
+      @records = Hash.new{ 0 }
+    end
+
+    def after_detect(method_call, timing, results, args)
+      @records[method_call.object.base_class.name] += 1
+    end
+
+    def request_finish(env, status, headers, body, timing)
+      store(env, @records)
+    end
+
+    def name
+      "active_record"
+    end
+
+    def heading_for_request(number)
+      record = retrieve(number).first
+      total = record.inject(0) do |memo, (key, value)|
+        memo + value
+      end
+      "#{total} AR Objects"
+    end
+
+    def content_for_request(number)
+      records = retreive(number).first.to_a.sort_by { |key, value| value }.reverse
+      render_template "panels/active_record", :records => records
+    end
+
+  end
+
+end

data/lib/insight/panels/cache_panel.rb

@@ -0,0 +1,69 @@
+
+module Insight
+
+  class CachePanel < Panel
+    require "insight/panels/cache_panel/panel_app"
+    require "insight/panels/cache_panel/stats"
+
+    def initialize(app)
+      super
+
+      probe(self) do
+        instrument("Memcached") do
+          instance_probe :decrement, :get, :increment, :set, :add,
+            :replace, :delete, :prepend, :append
+        end
+
+        instrument("MemCache") do
+          instance_probe :decr, :get, :get_multi, :incr, :set, :add, :delete
+        end
+
+        instrument("Dalli::Client") do
+          instance_probe :perform
+        end
+      end
+
+      table_setup("cache")
+    end
+
+    def request_start(env, start)
+      @stats = Stats.new
+    end
+
+    def request_finish(env, st, hd, bd, timing)
+      logger(env).debug{ "Stats: #@stats" }
+      store(env, @stats)
+    end
+
+    def after_detect(method_call, timing, args, result)
+      method, key = method_call.method, args.first
+      if(defined? Dalli and Dalli::Client === method_call.object)
+        method, key = args[0], args[1]
+      end
+      logger.info{ "Cache panel got #{method} #{key.inspect}" }
+      @stats.record_call(method, timing.duration, !result.nil?, key)
+    end
+
+    def panel_app
+      PanelApp.new
+    end
+
+    def name
+      "cache"
+    end
+
+    def heading_for_request(number)
+      stats = retreive(number).first
+
+      "Cache: %.2fms (#{stats.queries.size} calls)" % stats.time
+    end
+
+    def content_for_request(number)
+      logger.debug{{ :req_num => number }}
+      stats = retreive(number).first
+      render_template "panels/cache", :stats => stats
+    end
+
+  end
+
+end

data/lib/insight/panels/cache_panel/panel_app.rb

@@ -0,0 +1,46 @@
+module Insight
+  class CachePanel
+
+    class PanelApp < ::Insight::PanelApp
+
+      def dispatch
+        case request.path_info
+        when "/__insight__/view_cache"         then view_cache
+        when "/__insight__/delete_cache"       then delete_cache
+        when "/__insight__/delete_cache_list"  then delete_cache_list
+        else not_found
+        end
+      end
+
+      def ok
+        Rack::Response.new(["OK"]).to_a
+      end
+
+      def view_cache
+        validate_params
+        render_template "panels/view_cache", :key => params["key"], :value => Rails.cache.read(params["key"])
+      end
+
+      def delete_cache
+        validate_params
+        raise "Rails not found... can't delete key" unless defined?(Rails)
+        Rails.cache.delete(params["key"])
+        ok
+      end
+
+      def delete_cache_list
+        validate_params
+        raise "Rails not found... can't delete key" unless defined?(Rails)
+
+        params.each do |key, value|
+          next unless key =~ /^keys_/
+            Rails.cache.delete(value)
+        end
+
+        ok
+      end
+
+    end
+
+  end
+end

data/lib/insight/panels/cache_panel/stats.rb

@@ -0,0 +1,98 @@
+module Insight
+  class CachePanel
+
+    class Stats
+      class Query
+        attr_reader :method, :time, :hit, :keys
+
+        def initialize(method, time, hit, keys)
+          @method = method
+          @time = time
+          @hit = hit
+          @keys = keys
+        end
+
+        def display_time
+          "%.2fms" % time
+        end
+
+        def display_keys
+          if keys.size == 1
+            keys.first
+          else
+            keys.join(", ")
+          end
+        end
+      end
+
+      attr_reader :calls
+      attr_reader :keys
+      attr_reader :queries
+
+      def initialize
+        @queries = []
+        @misses =
+          @calls = 0
+        @time = 0.0
+        @keys = []
+      end
+
+      def record_call(method, time, hit, key)
+        if Array === key
+          @queries << Query.new(:get_multi, time, hit, key)
+        else
+          @queries << Query.new(method.to_sym, time, hit, [key])
+        end
+        @calls += 1
+        @time += time
+        @keys += keys
+      end
+
+      def display_time
+        "%.2fms" % time
+      end
+
+      def time
+        @queries.inject(0) do |memo, query|
+          memo + query.time
+        end
+      end
+
+      def gets
+        count_queries(:get)
+      end
+
+      def sets
+        count_queries(:set)
+      end
+
+      def deletes
+        count_queries(:delete)
+      end
+
+      def get_multis
+        count_queries(:get_multi)
+      end
+
+      def hits
+        @queries.select { |q| [:get, :get_multi].include?(q.method) && q.hit }.size
+      end
+
+      def misses
+        @queries.select { |q| [:get, :get_multi].include?(q.method) && !q.hit }.size
+      end
+
+      def count_queries(method)
+        @queries.select { |q| q.method == method }.size
+      end
+
+      def queries_to_param
+        params = {}
+        @queries.each_with_index do |query, index|
+          params["keys_#{index}"] = query.keys.first
+        end
+        params
+      end
+    end
+  end
+end

data/lib/insight/panels/log_panel.rb

@@ -0,0 +1,54 @@
+module Insight
+  class LogPanel < Panel
+    class LogEntry
+      attr_reader :level, :time, :message
+      LEVELS = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL']
+
+      def initialize(level, time, message)
+        @level = LEVELS[level]
+        @time = time
+        @message = message
+      end
+
+      def cleaned_message
+        @message.to_s.gsub(/\e\[[;\d]+m/, "")
+      end
+    end
+
+
+    def after_detect(method_call, timing, args, message)
+      message = args[1] || args[2] unless message.is_a?(String)
+      log_level = args[0]
+      store(@env, LogEntry.new(log_level, timing.delta_t, message))
+    end
+
+    def initialize(app)
+      probe(self) do
+        instrument "ActiveSupport::BufferedLogger" do
+          instance_probe :add
+        end
+
+        instrument "Logger" do
+          instance_probe :add
+        end
+      end
+
+      table_setup("log_entries")
+
+      super
+    end
+
+    def name
+      "log"
+    end
+
+    def heading
+      "Log"
+    end
+
+    def content_for_request(number)
+      render_template "panels/log", :logs => retrieve(number)
+    end
+  end
+
+end

data/lib/insight/panels/memory_panel.rb

@@ -0,0 +1,32 @@
+module Insight
+
+  class MemoryPanel < Panel
+    def initialize(app)
+      super
+      table_setup("memory_records")
+    end
+
+    def before(env)
+      @original_memory = `ps -o rss= -p #{$$}`.to_i
+    end
+
+    def after(env, status, headers, body)
+      total_memory = `ps -o rss= -p #{$$}`.to_i
+      store(env, {:total_memory => total_memory,
+            :memory_increase => total_memory - @original_memory,
+            :original_memory => @original_memory})
+    end
+
+    def heading_for_request(number)
+      record = retrieve(number).first
+
+      "#{record[:memory_increase]} KB &#916;, #{record[:total_memory]} KB total"
+    end
+
+    def has_content?
+      false
+    end
+
+  end
+
+end

data/lib/insight/panels/rails_info_panel.rb

@@ -0,0 +1,19 @@
+module 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