rack-insight 0.5.0

data/lib/rack/insight/app.rb

@@ -0,0 +1,198 @@
+require 'rack'
+require "digest/sha1"
+require "rack/insight/config"
+require "rack/insight/logger"
+require "rack/insight/filtered_backtrace"
+require "rack/insight/options"
+require "rack/insight/panel"
+require "rack/insight/panel_app"
+require "rack/insight/params_signature"
+require "rack/insight/rack_static_bug_avoider"
+require "rack/insight/redirect_interceptor"
+require "rack/insight/render"
+require "rack/insight/toolbar"
+require "rack/insight/enable-button"
+require "rack/insight/path-filter"
+require 'rack/insight/request-recorder'
+require 'rack/insight/instrumentation/setup'
+require 'rack/insight/panels-content'
+require 'rack/insight/panels-header'
+
+module Rack::Insight
+  class App
+    include Options
+    INSIGHT_ROOT = "/__insight__"
+    INSIGHT_REGEX = %r{^#{INSIGHT_ROOT}}
+
+    VERSION = "0.4.4"
+
+    class SecurityError < StandardError
+    end
+
+    def initialize(app, options = {}, &block)
+      initialize_options options
+      @base_app = app
+      @panels = []
+      instance_eval(&block) if block_given?
+
+      @logger = Logger.new(read_option(:log_level), read_option(:log_path))
+      Thread.current['rack-insight.logger'] = @logger
+      build_normal_stack
+      build_debug_stack
+      if options[:on_initialize]
+        options[:on_initialize].call(self)
+      end
+    end
+    attr_reader :logger
+    attr_accessor :panels
+
+    def call(env)
+      @original_request = Rack::Request.new(env)
+      if insight_active?
+        @env = env
+        self.options = @default_options
+
+        env['rack-insight.logger'] = @logger
+        Thread.current['rack-insight.logger'] = @logger
+
+        Rack::Insight.enable
+        env["rack-insight.panels"] = []
+        @debug_stack.call(env)
+      else
+        @normal_stack.call(env)
+      end
+    end
+
+
+    def reset(new_options=nil)
+      @env = nil
+      initialize_options(new_options)
+
+      Rack::Insight::Instrumentation::ClassProbe::all_probes.each do |probe|
+        probe.clear_collectors
+      end
+      Rack::Insight::Instrumentation::InstanceProbe::all_probes.each do |probe|
+        probe.clear_collectors
+      end
+      Rack::Insight::Instrumentation::PackageDefinition.clear_collectors
+
+      build_debug_stack
+    end
+
+    private
+
+    def insight_active?
+      return (toolbar_requested? && ip_authorized? && password_authorized?)
+    end
+
+    def build_normal_stack
+      builder = Rack::Builder.new
+      builder.use EnableButton, self
+      builder.run Rack::Cascade.new([ asset_mapped(Rack::Builder.new), @base_app ])
+      @normal_stack = builder.to_app
+    end
+
+    def build_debug_stack
+      @panels.clear
+      builder = Rack::Builder.new
+      builder.use Toolbar, self
+      builder.run Rack::Cascade.new([panel_mappings, shortcut_stack(@base_app), collection_stack(@base_app)])
+
+      @debug_stack = builder.to_app
+    end
+
+    def panel_mappings
+      classes = read_option(:panel_classes)
+      root = INSIGHT_ROOT
+      insight = self
+      builder = Rack::Builder.new do
+        classes.each do |panel_class|
+          panel_class.panel_mappings.each do |path, app|
+            map [root, path].join("/") do
+              run app
+            end
+          end
+        end
+        map root + "/panels_content" do
+          run PanelsContent.new(insight)
+        end
+        map root + "/panels_header" do
+          run PanelsHeader.new(insight)
+        end
+      end
+      return asset_mapped(builder)
+    end
+
+    def shortcut_stack(app)
+      Rack::Builder.app do
+        use PathFilter
+        run app
+      end
+    end
+
+    def collection_stack(app)
+      classes = read_option(:panel_classes)
+      insight_id = self.object_id
+      panels = self.panels
+
+      #Builder makes it impossible to access the panels
+
+      app = Instrumentation::Setup.new(app)
+      app = RedirectInterceptor.new(app)
+      #Reversed?  Does it matter?
+      app = classes.inject(app) do |app, panel_class|
+        panel = panel_class.new(app)
+        panels << panel
+        panel
+      end
+      app = RequestRecorder.new(app)
+      return app
+    end
+
+    def asset_mapped(builder)
+      path = public_path
+      builder.map INSIGHT_ROOT do
+        run Rack::File.new(path)
+      end
+      builder.to_app
+    end
+
+    def public_path
+      ::File.expand_path("../../insight/public/__insight__", __FILE__)
+    end
+
+    def toolbar_requested?
+      @original_request.cookies["rack-insight_enabled"]
+    end
+
+    def ip_authorized?
+      return true unless options["rack-insight.ip_masks"]
+
+      logger.debug{ "Checking #{@original_request.ip} against ip_masks" }
+      ip = IPAddr.new(@original_request.ip)
+
+      mask = options["rack-insight.ip_masks"].find do |ip_mask|
+        ip_mask.include?(ip)
+      end
+      if mask
+        logger.debug{ "Matched #{mask}" }
+        return true
+      else
+        logger.debug{ "Matched no masks" }
+        return false
+      end
+    end
+
+    def password_authorized?
+      return true unless options["rack-insight.password"]
+
+      logger.debug{"Checking password"}
+
+      expected_sha = Digest::SHA1.hexdigest ["rack-insight", options["rack-insight.password"]].join(":")
+      actual_sha = @original_request.cookies["rack-insight_password"]
+
+      logger.debug{"Password result: #{actual_sha == expected_sha}"}
+      actual_sha == expected_sha
+    end
+  end
+end

data/lib/rack/insight/config.rb

@@ -0,0 +1,30 @@
+module Rack::Insight
+  class Config
+    class << self
+      attr_accessor :config
+    end
+
+    DEFAULTS = {
+      # You can augment or replace the default set of panel load paths.
+      # These are the paths where rack-insight will look for panels.
+      # A rack-insight extension gem could place panels in:
+      #   lib/foo/bar/
+      # Since gems' lib/ is automatically shifted onto Ruby load path, this will make the custom panels discoverable:
+      #   Rack::Insight::Config.configure do |config|
+      #     config[:panel_load_paths] << File::join('foo', 'bar')
+      #   end
+      :panel_load_paths => [File::join('rack', 'insight', 'panels')]
+    }
+
+    #cattr_reader :config
+    #cattr_writer :config
+
+    @config ||= DEFAULTS
+    def self.configure &block
+      yield @config
+      unless config[:panel_load_paths].kind_of?(Array)
+        raise "Rack::Insight::Config.config[:panel_load_paths] is invalid: Expected kind of Array but got #{config[:panel_load_paths].class}"
+      end
+    end
+  end
+end

data/lib/rack/insight/database.rb

@@ -0,0 +1,193 @@
+#require 'rack-insight'
+require 'sqlite3'
+require 'base64'
+
+module Rack::Insight
+  class Database
+    module RequestDataClient
+      def key_sql_template(sql)
+        @key_sql_template = sql
+      end
+
+      def table_setup(name, *keys)
+        @table = DataTable.new(name, *keys)
+        if keys.empty?
+          @key_sql_template = ""
+        end
+      end
+
+      def store(env, *keys_and_value)
+        return if env.nil?
+        request_id = env["rack-insight.request-id"]
+        return if request_id.nil?
+
+        value = keys_and_value[-1]
+        keys = keys_and_value[0...-1]
+
+        @table.store(request_id, value, @key_sql_template % keys)
+      end
+
+      def retrieve(request_id)
+        @table.for_request(request_id)
+      end
+      alias retreive retrieve #JDL cannot spell
+
+      def table_length
+        @table.length
+      end
+    end
+
+    class << self
+      include Logging
+
+      def database_path=(value)
+        @database_path = value || "rack-insight.sqlite"
+      end
+
+      def database_path
+        @database_path
+      end
+
+      def db
+        @db ||= open_database
+      end
+
+      def reset
+        @db = nil
+      end
+
+      def open_database
+        @db = SQLite3::Database.new(database_path)
+        @db.execute("pragma foreign_keys = on")
+        @db
+      rescue Object => ex
+        msg = "Issue while loading SQLite DB:" + [ex.class, ex.message, ex.backtrace[0..4]].inspect
+        logger.error{ msg }
+
+        return {}
+      end
+
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          Rack::Insight::Database::open_database if forked
+        end
+      end
+    end
+
+    class Table
+      include Logging
+
+      def db
+        Rack::Insight::Database.db
+      end
+
+      def create_keys_clause
+        "#{@keys.map{|key| "#{key} varchar"}.join(", ")}"
+      end
+
+      def create_sql
+        "create table #@table_name ( id integer primary key, #{create_keys_clause} )"
+      end
+
+      def execute(*args)
+        logger.info{ ins_args = args.inspect; "(#{[ins_args.length,120].min}/#{ins_args.length})" + ins_args[0..120] }
+        db.execute(*args)
+      end
+
+      def initialize(table_name, *keys)
+        @table_name = table_name
+        @keys = keys
+        if(execute("select * from sqlite_master where name = ?", table_name).empty?)
+          logger.warn{ "Initializing a table called #{table_name}" }
+          execute(create_sql)
+        end
+      end
+
+      def select(which_sql, condition_sql)
+        execute("select #{which_sql} from #@table_name where #{condition_sql}")
+      end
+
+      def fields_sql
+        "#{@keys.join(",")}"
+      end
+
+      def insert(values_sql)
+        execute("insert into #@table_name(#{fields_sql}) values (#{values_sql})")
+      end
+
+      def keys(name)
+        execute("select #{name} from #@table_name").flatten
+      end
+
+      def length(where = "1 = 1")
+        execute("select count(1) from #@table_name where #{where}").first.first
+      end
+
+      def to_a
+        execute("select * from #@table_name")
+      end
+    end
+
+    class RequestTable < Table
+      def initialize()
+        super("requests", "method", "url", "date")
+      end
+
+      def store(method, url)
+        result = insert("'#{method}', '#{url}', #{Time.now.to_i}")
+        db.last_insert_row_id
+      end
+
+      def last_request_id
+        execute("select max(id) from #@table_name").first.first
+      end
+
+      def sweep
+        execute("delete from #@table_name where date < #{Time.now.to_i - (60 * 60 * 12)}")
+      end
+    end
+
+    require 'yaml'
+    class DataTable < Table
+      def initialize(name, *keys)
+        super(name, *(%w{request_id} + keys + %w{value}))
+      end
+
+      def create_keys_clause
+        non_request_keys = @keys - %w"request_id"
+        sql = non_request_keys.map{|key| "#{key} varchar"}.join(", ")
+        sql += ", request_id references requests(id) on delete cascade"
+        sql
+      end
+
+      def store(request_id, value, keys_sql = "")
+        sql = "'#{encode_value(value)}'"
+        sql = keys_sql + ", " + sql unless keys_sql.empty?
+        sql = "#{request_id}, #{sql}"
+        insert(sql)
+      end
+
+      def encode_value(value)
+        Base64.encode64(YAML.dump(value))
+      end
+
+      def decode_value(value)
+        YAML.load(Base64.decode64(value))
+      end
+
+      def retrieve(key_sql)
+        select("value", key_sql).map{|value| decode_value(value.first)}
+      end
+
+      def for_request(id)
+        retrieve("request_id = #{id}")
+      end
+
+      def to_a
+        super.map do |row|
+          row[-1] = decode_value(row[-1])
+        end
+      end
+    end
+  end
+end

data/lib/rack/insight/enable-button.rb

@@ -0,0 +1,43 @@
+module Rack::Insight
+  class EnableButton
+    include Render
+
+    MIME_TYPES = ["text/html", "application/xhtml+xml"]
+
+    def initialize(app, insight)
+      @app = app
+      @insight = insight
+    end
+
+    def call(env)
+      @env = env
+      status, headers, body = @app.call(@env)
+
+      response = Rack::Response.new(body, status, headers)
+
+      inject_button(response) if okay_to_modify?(env, response)
+
+      return response.to_a
+    end
+
+    def okay_to_modify?(env, response)
+      req = Rack::Request.new(env)
+      content_type, charset = response.content_type.split(";")
+
+      response.ok? && MIME_TYPES.include?(content_type) && !req.xhr?
+    end
+
+    def inject_button(response)
+      full_body = response.body.join
+      full_body.sub! /<\/body>/, render + "</body>"
+
+      response["Content-Length"] = full_body.bytesize.to_s
+
+      response.body = [full_body]
+    end
+
+    def render
+      render_template("enable-button")
+    end
+  end
+end