rack-insight 0.5.0

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

@@ -0,0 +1,48 @@
+require "digest"
+
+module Rack::Insight
+  class ActiveResourcePanel < Panel
+    require 'rack/insight/panels/active_resource_panel/query'
+    #require "rack/insight/panels/sql_panel/panel_app"
+    #require "rack/insight/panels/sql_panel/query"
+
+    def initialize(app)
+      super
+      probe(self) do
+        instrument "ActiveResource::Connection" do
+          instance_probe :request
+        end
+      end
+      table_setup("active_resource_requests")
+    end
+
+    def after_detect(method_call, timing, arguments, results)
+      body = "<no body>"
+      if results.respond_to? :body
+        body = results.body
+      end
+      store(@env, RequestResult.new(arguments[0], arguments[1..-1], timing.duration, method_call.backtrace[0..5], body))
+    end
+
+    def total_time(queries)
+      (queries.inject(0) do |memo, query|
+        memo + query.time
+      end)
+    end
+
+    def name
+      "active_resource"
+    end
+
+    def heading_for_request(number)
+      queries = retrieve(number)
+      "ARes: #{queries.size} Queries (%.2fms)" % total_time(queries)
+    end
+
+    def content_for_request(number)
+      queries = retrieve(number)
+      logger.debug{ "ARes: #{queries.inspect}" }
+      render_template "panels/active_resource", :queries => queries
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Rack::Insight
+  class ActiveResourcePanel
+    class RequestResult
+      include Rack::Insight::FilteredBacktrace
+
+      attr_reader :path, :args, :result, :time
+      alias results result
+
+      def initialize(path, args, time, backtrace = [], result=nil)
+        @path = path
+        @args = args
+        @time = time
+        @backtrace = backtrace
+        @result = result
+      end
+
+      def human_time
+        "%.2fms" % (@time)
+      end
+
+      def valid_hash?(secret_key, possible_hash)
+        hash = Digest::SHA1.hexdigest [secret_key, @sql].join(":")
+        possible_hash == hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+
+module Rack::Insight
+
+  class CachePanel < Panel
+    require "rack/insight/panels/cache_panel/panel_app"
+    require "rack/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)
+      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 = retrieve(number).first
+
+      "Cache: %.2fms (#{stats.queries.size} calls)" % stats.time
+    end
+
+    def content_for_request(number)
+      logger.debug{{ :req_num => number }}
+      stats = retrieve(number).first
+      render_template "panels/cache", :stats => stats
+    end
+
+  end
+
+end

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

@@ -0,0 +1,46 @@
+module Rack::Insight
+  class CachePanel
+
+    class PanelApp < ::Rack::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/rack/insight/panels/cache_panel/stats.rb

@@ -0,0 +1,90 @@
+module Rack::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, :keys, :queries, :time
+
+      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 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/rack/insight/panels/log_panel.rb

@@ -0,0 +1,53 @@
+module Rack::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/rack/insight/panels/memory_panel.rb

@@ -0,0 +1,36 @@
+module Rack::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
+
+    def name
+      "Memory"
+    end
+
+  end
+
+end

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

@@ -0,0 +1,41 @@
+module Rack::Insight
+
+  class MongoPanel < Panel
+    require "rack/insight/panels/mongo_panel/mongo_extension"
+    require "rack/insight/panels/mongo_panel/stats"
+
+    def self.record(command, &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, command)
+      return result
+    end
+
+    def self.reset
+      Thread.current["rack-insight.mongo"] = Stats.new
+    end
+
+    def self.stats
+      Thread.current["rack-insight.mongo"] ||= Stats.new
+    end
+
+    def name
+      "mongo"
+    end
+
+    def heading
+      "Mongo: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
+    end
+
+    def content
+      result = render_template "panels/mongo", :stats => self.class.stats
+      self.class.reset
+      return result
+    end
+
+  end
+
+end

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

@@ -0,0 +1,24 @@
+require 'mongo'
+if defined?(Mongo)
+  Mongo::Connection.class_eval do
+
+    def send_message_with_insight(operation, message, log_message=nil)
+      Rack::Insight::MongoPanel.record(log_message || message) do
+        send_message_without_insight(operation, message, log_message)
+      end
+    end
+    alias_method_chain :send_message, :insight
+
+    def send_message_with_safe_check_with_insight(operation, message, db_name, log_message=nil, last_error_params=false)
+      Rack::Insight::MongoPanel.record(log_message || message) do
+        send_message_with_safe_check_without_insight(operation, message, db_name, log_message, last_error_params)
+      end
+    end
+    alias_method_chain :send_message_with_safe_check, :insight
+
+    def receive_message_with_insight(operation, message, log_message=nil, socket=nil)
+    end
+  end
+  alias_method_chain :receive_message, :insight
+end
+