rack-insight 0.5.0

data/lib/rack/insight/instrumentation/setup.rb

@@ -0,0 +1,32 @@
+module Rack::Insight::Instrumentation
+  class Setup
+    def initialize(app)
+      @app = app
+    end
+
+    def setup(env)
+      instrument = Instrument.new
+
+      PackageDefinition.start
+      instrument.start(env)
+
+      env["rack-insight.instrument"] = instrument
+      Thread::current["rack-insight.instrument"] = instrument
+    end
+
+    def teardown(env, status, headers, body)
+      instrument, env["rack-insight.instrument"] = env["rack-insight.instrument"], nil
+      instrument.finish(env, status, headers, body)
+      Thread::current["rack-insight.instrument"] = nil
+
+      env["rack-insight.duration"] = instrument.duration
+    end
+
+    def call(env)
+      setup(env)
+      status, headers, body = @app.call(env)
+      teardown(env, status, headers, body)
+      return [status, headers, body]
+    end
+  end
+end

data/lib/rack/insight/logger.rb

@@ -0,0 +1,53 @@
+module Rack::Insight
+  class Logger
+    def initialize(level, path)
+      @level = level
+      @log_path = path
+      @logfile = nil
+    end
+
+    attr_accessor :level
+
+    DEBUG    =  0
+    INFO     =  1
+    WARN     =  2
+    ERROR    =  3
+    FATAL    =  4
+    UNKNOWN  =  5
+
+    def log(severity, message)
+      message = message.inspect unless String === message
+      return unless severity >= @level
+
+      if defined? Rails and Rails.respond_to?(:logger) and not Rails.logger.nil?
+        Rails.logger.add(severity, "[Rack::Insight]: " + message)
+      end
+
+      logfile.puts(message)
+    end
+
+    def logfile
+      @logfile ||= File::open(@log_path, "a+")
+    rescue
+      $stderr
+    end
+
+    def debug;   log(DEBUG,   yield) end
+    def info;    log(INFO,    yield) end
+    def warn;    log(WARN,    yield) end
+    def error;   log(ERROR,   yield) end
+    def fatal;   log(FATAL,   yield) end
+    def unknown; log(UNKNOWN, yield) end
+  end
+
+  module Logging
+    def logger(env = nil)
+      if env.nil?
+        Thread.current['rack-insight.logger'] ||= Rack::Insight::Logger.new(Logger::DEBUG, "")
+      else
+        env["rack-insight.logger"] ||= Rack::Insight::Logger.new(Logger::DEBUG, "")
+      end
+    end
+    module_function :logger
+  end
+end

data/lib/rack/insight/options.rb

@@ -0,0 +1,116 @@
+require 'ipaddr'
+
+module Rack::Insight
+  module Options
+    class << self
+      private
+      def option_accessor(key)
+        define_method(key) { || read_option(key) }
+        define_method("#{key}=") { |value| write_option(key, value) }
+        define_method("#{key}?") { || !! read_option(key) }
+      end
+    end
+
+    option_accessor :secret_key
+    option_accessor :ip_masks
+    option_accessor :password
+    option_accessor :panel_classes
+    option_accessor :intercept_redirects
+    option_accessor :database_path
+
+    # The underlying options Hash. During initialization (or outside of a
+    # request), this is a default values Hash. During a request, this is the
+    # Rack environment Hash. The default values Hash is merged in underneath
+    # the Rack environment before each request is processed.
+    def options
+      @env || @default_options
+    end
+
+    # Set multiple options.
+    def options=(hash={})
+      hash.each { |key,value| write_option(key, value) }
+    end
+
+    # Set an option. When +option+ is a Symbol, it is set in the Rack
+    # Environment as "rack-cache.option". When +option+ is a String, it
+    # exactly as specified. The +option+ argument may also be a Hash in
+    # which case each key/value pair is merged into the environment as if
+    # the #set method were called on each.
+    def set(option, value=self, &block)
+      if block_given?
+        write_option option, block
+      elsif value == self
+        self.options = option.to_hash
+      else
+        write_option option, value
+      end
+    end
+
+    private
+
+    def read_option(key)
+      key = option_name(key)
+      if @env and @env.has_key?(key)
+        @env[key]
+      else
+        @default_options[key]
+      end
+    end
+
+    def write_option(key, value)
+      @default_options[option_name(key)] = value
+      if @env.respond_to? :[]
+        @env[option_name(key)] = value
+      end
+    end
+
+    def option_name(key)
+      case key
+      when Symbol ; "rack-insight.#{key}"
+      when String ; key
+      else raise ArgumentError
+      end
+    end
+
+    def process_options
+      if(file_list = read_option('rack-insight.panel_files'))
+        class_list = read_option('rack-insight.panel_classes') || []
+        file_list.each do |file|
+          class_list |= Rack::Insight::Panel.from_file(file)
+        end
+        write_option('rack-insight.panel_classes', class_list)
+      end
+
+      Rack::Insight::Database.database_path = read_option('rack-insight.database_path')
+    end
+
+    def initialize_options(options=nil)
+      @default_options = {
+        'rack-insight.ip_masks'             =>  [IPAddr.new("127.0.0.1")],
+        'rack-insight.password'             =>  nil,
+        'rack-insight.verbose'              =>  nil,
+        'rack-insight.secret_key'           =>  nil,
+        'rack-insight.intercept_redirects'  =>  false,
+        'rack-insight.panels'               =>  [],
+        'rack-insight.path_filters'         =>  %w{/assets/},
+        'rack-insight.log_level'            =>  Logger::INFO,
+        'rack-insight.log_path'             =>  "log/rack-insight.log",
+        'rack-insight.database_path'        =>  "rack-insight.sqlite",
+        'rack-insight.panel_files'          =>  %w{
+          rails_info_panel
+          timer_panel
+          request_variables_panel
+          sql_panel
+          active_record_panel
+          cache_panel
+          templates_panel
+          log_panel
+          memory_panel
+        }
+      }
+      self.options = options || {}
+      process_options
+    end
+
+  end
+end

data/lib/rack/insight/panel.rb

@@ -0,0 +1,135 @@
+require "erb"
+require "rack/insight/logger"
+require 'rack/insight/database'
+require 'rack/insight/instrumentation'
+require 'rack/insight/render'
+
+module Rack::Insight
+
+  # Panels are also Rack middleware
+  class Panel
+    include ERB::Util
+    include Rack::Insight::Logging
+    include Rack::Insight::Render
+    include Rack::Insight::Database::RequestDataClient
+    include Rack::Insight::Instrumentation::Client
+
+    attr_reader :request
+
+    class << self
+      def file_index
+        return @file_index ||= Hash.new do |h,k|
+          h[k] = []
+        end
+      end
+
+      def panel_exclusion
+        return @panel_exclusion ||= []
+      end
+
+      def from_file(rel_path)
+        old_rel, Thread::current['rack-panel_file'] = Thread::current['rack-panel_file'], rel_path
+        Rack::Insight::Config.config[:panel_load_paths].each do |load_path|
+          begin
+            require File::join(load_path, rel_path)
+          rescue LoadError => e
+          end
+        end
+        return (file_index[rel_path] - panel_exclusion)
+      ensure
+        Thread::current['rack-panel_file'] = old_rel
+      end
+
+      def current_panel_file
+        return Thread::current['rack-panel_file'] ||
+          begin
+            file_name = nil
+            matched_line = nil
+            caller.each do |line|
+              # First make sure we are not matching rack-insight's own panel class, which will be in the caller stack,
+              # and which may match some custom load path added (try adding 'rack' as a custom load path!)
+              next if line =~ /rack-insight.*\/lib\/rack\/insight\/panel.rb:/
+              Rack::Insight::Config.config[:panel_load_paths].each do |load_path|
+                regex = %r{^[^:]*#{load_path}/([^:]*)\.rb:}
+                md = regex.match line
+                file_name = md[1] unless md.nil?
+                matched_line = line unless file_name.nil?
+                break unless file_name.nil?
+              end
+              break unless file_name.nil?
+            end
+            file_name
+          end
+      end
+
+      def inherited(sub)
+        if filename = current_panel_file
+          Panel::file_index[current_panel_file] << sub
+        else
+          warn "Rack::Insight::Panel inherited by #{sub.name} outside rack-insight's :panel_load_paths.  Discarded.  Configured panel load paths are: #{Rack::Insight::Config.config[:panel_load_paths].inspect}"
+        end
+      end
+
+      def excluded(klass = nil)
+        Panel::panel_exclusion << klass || self
+      end
+
+    end
+
+    def initialize(app)
+      if panel_app
+        #XXX use mappings
+        @app = Rack::Cascade.new([panel_app, app])
+      else
+        @app = app
+      end
+    end
+
+    def call(env)
+      @env = env
+      logger.debug{ "Before call: #{self.name}" }
+      before(env)
+      status, headers, body = @app.call(env)
+      @request = Rack::Request.new(env)
+      logger.debug{ "After call: #{self.name}" }
+      after(env, status, headers, body)
+      env["rack-insight.panels"] << self
+      return [status, headers, body]
+    end
+
+    def panel_app
+      nil
+    end
+
+    def self.panel_mappings
+      {}
+    end
+
+    def has_content?
+      true
+    end
+
+    def name
+      "Unnamed panel: #{self.class.name}" #for shame
+    end
+
+    def heading_for_request(number)
+      heading rescue "xxx" #XXX: no panel should need this
+    end
+
+    def content_for_request(number)
+      content rescue "" #XXX: no panel should need this
+    end
+
+    def before(env)
+    end
+
+    def after(env, status, headers, body)
+    end
+
+    def render(template)
+    end
+
+  end
+
+end

data/lib/rack/insight/panel_app.rb

@@ -0,0 +1,31 @@
+module Rack::Insight
+
+  class PanelApp
+    include Rack::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/rack/insight/panels-content.rb

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

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

@@ -0,0 +1,46 @@
+module Rack::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 = retrieve(number).first.to_a.sort_by { |key, value| value }.reverse
+      render_template "panels/active_record", :records => records
+    end
+
+  end
+
+end