rack-webprofiler 0.1.0.pre.alpha1

data/lib/rack/web_profiler/collector.rb

@@ -0,0 +1,142 @@
+require "docile"
+
+module Rack
+
+  # Collector
+  class WebProfiler::Collector
+    autoload :RubyCollector, "rack/web_profiler/collector/ruby_collector"
+    autoload :TimeCollector, "rack/web_profiler/collector/time_collector"
+
+    module Rack
+      autoload :RackCollector,    "rack/web_profiler/collector/rack/rack_collector"
+      autoload :RequestCollector, "rack/web_profiler/collector/rack/request_collector"
+    end
+
+    module Rails
+      autoload :ActiveRecordCollector,  "rack/web_profiler/collector/rails/active_record_collector"
+      autoload :LoggerCollector,        "rack/web_profiler/collector/rails/logger_collector"
+      autoload :RailsCollector,         "rack/web_profiler/collector/rails/rails_collector"
+      autoload :RequestCollector,       "rack/web_profiler/collector/rails/request_collector"
+    end
+
+    module Sinatra
+      autoload :RequestCollector, "rack/web_profiler/collector/sinatra/request_collector"
+      autoload :SinatraCollector, "rack/web_profiler/collector/sinatra/sinatra_collector"
+    end
+
+    # DSL
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          @definition            = Definition.new
+          @definition.position   = 1
+          @definition.is_enabled = true
+          @definition.klass      = self
+        end
+      end
+
+      module ClassMethods
+        attr_reader :definition
+
+        def icon(icon = nil);           definition.icon     = icon;          end
+        def collector_name(name = nil); definition.name     = name;          end
+        def position(position = nil);   definition.position = position.to_i; end
+        def collect(&block);            definition.collect  = block;         end
+
+        def template(template = nil, type: :file)
+          template = get_data_contents(template) if type == :DATA
+          definition.template = template
+        end
+
+        def is_enabled?(is_enabled = true)
+          definition.is_enabled = Proc.new if block_given?
+          definition.is_enabled = is_enabled
+        end
+
+        private
+
+        def get_data_contents(path)
+          data = ""
+          ::File.open(path, "rb") do |f|
+            begin
+              line = f.gets
+            end until line.nil? || /^__END__$/ === line
+            data << line while line = f.gets
+          end
+          data
+        end
+      end
+    end
+
+    # Definition
+    #
+    # Collector definition.
+    class Definition
+      attr_accessor :icon, :name, :position, :collect, :template, :is_enabled, :klass
+      attr_reader   :data_storage
+
+      # Collect the data who the Collector need.
+      #
+      # @param request [Rack::WebProfiler::Request]
+      # @param response [Rack::Response]
+      #
+      # @return [Rack::WebProfiler::Collector::DSL::DataStorage]
+      def collect!(request, response)
+        @data_storage = Docile.dsl_eval(DataStorage.new, request, response, &collect)
+      end
+
+      # Is the collector enabled.
+      #
+      # @return [Boolean]
+      def is_enabled?
+        return !!@is_enabled.call if @is_enabled.is_a?(Proc)
+        !!@is_enabled
+      end
+    end
+
+    # DataStorage
+    #
+    # Used to store datas who Collector needs.
+    #
+    # @todo do DataStorage compatible with Marshal
+    class DataStorage
+      attr_reader :datas
+
+      def initialize
+        @datas  = Hash.new
+        @status = nil
+      end
+
+      # Store a value.
+      #
+      # @param k [String, Symbol]
+      # @param v
+      def store(k, v)
+        # @todo check data format (must be compatible with Marshal)
+        @datas[k.to_sym] = v
+      end
+
+      # Status.
+      #
+      # @param v [Symbol, nil]
+      #
+      # @return [Symbol, nil]
+      def status(v = nil)
+        # @todo check status?
+        @status = v.to_sym unless v.nil?
+        @status
+      end
+
+      # Transform DataStorage to an Hash
+      #
+      # @return [Hash<Symbol, Object>]
+      def to_h
+        {
+          datas: @datas,
+          status: @status
+        }
+      end
+    end
+  end
+end

data/lib/rack/web_profiler/collectors.rb

@@ -0,0 +1,88 @@
+module Rack
+
+  # Collectors.
+  #
+  # Container of Collector objects.
+  class WebProfiler::Collectors
+
+    # Initialize.
+    def initialize
+      @collectors        = {}
+      @sorted_collectors = {}
+    end
+
+    # Get a collector definition by his name.
+    #
+    # @param name [String]
+    #
+    # @return [Rack::WebProfiler::Collector::DSL::Definition, nil]
+    def definition_by_name(name)
+      name = name.to_sym
+      @sorted_collectors[name] unless @sorted_collectors[name].nil?
+    end
+
+    # Returns all collectors definition.
+    #
+    # @return [Hash<Symbol, Rack::WebProfiler::Collector::DSL::Definition>]
+    def all
+      @sorted_collectors
+    end
+
+    # Add a collector.
+    #
+    # @param collector_class [Class]
+    #
+    # @raise [ArgumentError] if `collector_class' is not a Class or is not an instance of Rack::WebProfiler::Collector::DSL
+    #   or a collector with this name is already registrered.
+    def add_collector(collector_class)
+      unless collector_class.is_a? Class
+        raise ArgumentError, "`collector_class' must be a class"
+      end
+
+      unless collector_class.included_modules.include?(Rack::WebProfiler::Collector::DSL)
+        raise ArgumentError, "#{collector_class.class.name} must be an instance of \"Rack::WebProfiler::Collector::DSL\""
+      end
+
+      definition = collector_class.definition
+
+      if definition_by_name(definition.name)
+        raise ArgumentError, "A collector with name \“#{definition.name}\" already exists"
+      end
+
+      return false unless definition.is_enabled?
+
+      @collectors[collector_class] = definition
+
+      sort_collectors!
+    end
+
+    # Remove a collector.
+    #
+    # @param collector_class [Class]
+    #
+    # @raise [ArgumentError] if `collector_class' is not a Class or if this collector is not registered.
+    def remove_collector(collector_class)
+      unless collector_class.is_a? Class
+        raise ArgumentError, "`collector_class' must be a class"
+      end
+
+      unless @collectors[collector_class]
+        raise ArgumentError, "No collector found with class \“#{collector_class}\""
+      end
+
+      @collectors.delete(collector_class)
+
+      sort_collectors!
+    end
+
+    private
+
+    # Sort collectors by definition name.
+    def sort_collectors!
+      @sorted_collectors = {}
+
+      tmp = @collectors.sort_by { |_klass, definition| definition.position }
+      tmp.each { |_k, v| @sorted_collectors[v.name.to_sym] = v }
+    end
+  end
+end

data/lib/rack/web_profiler/config.rb

@@ -0,0 +1,61 @@
+require "fileutils"
+
+module Rack
+  # Config
+  class WebProfiler::Config
+    attr_accessor :collectors, :tmp_dir
+
+    DEFAULT_COLLECTORS = [
+      # Commons
+      Rack::WebProfiler::Collector::RubyCollector,
+      Rack::WebProfiler::Collector::TimeCollector,
+
+      # Rack
+      # Rack::WebProfiler::Collector::Rack::RackCollector,
+      Rack::WebProfiler::Collector::Rack::RequestCollector,
+
+      # Rails
+      # Rack::WebProfiler::Collector::Rails::ActiveRecordCollector,
+      # Rack::WebProfiler::Collector::Rails::LoggerCollector,
+      Rack::WebProfiler::Collector::Rails::RailsCollector,
+      Rack::WebProfiler::Collector::Rails::RequestCollector,
+
+      # Sinatra
+      Rack::WebProfiler::Collector::Sinatra::RequestCollector,
+      Rack::WebProfiler::Collector::Sinatra::SinatraCollector,
+    ].freeze
+    def initialize
+      @collectors = Rack::WebProfiler::Collectors.new
+
+      load_defaults!
+    end
+
+    # Setup the configuration
+    #
+    # @param [block] block
+    def build!
+      unless block_given?
+        # @todo raise an Exception if no block given
+      end
+      instance_eval(&Proc.new)
+    end
+
+    # protected
+
+    def tmp_dir
+      FileUtils.mkdir_p @tmp_dir
+      @tmp_dir
+    end
+
+    private
+
+    def load_defaults!
+      # Add default collectors
+      DEFAULT_COLLECTORS.each do |collector_class|
+        @collectors.add_collector(collector_class)
+      end
+
+      @tmp_dir = Dir.tmpdir
+    end
+  end
+end

data/lib/rack/web_profiler/controller.rb

@@ -0,0 +1,125 @@
+require "erb"
+require "json"
+
+module Rack
+  # Controller
+  #
+  # Generate the views of the WebProfiler.
+  class WebProfiler::Controller
+    # Initialize
+    #
+    # @param request [Rack::WebProfiler::Request]
+    def initialize(request)
+      @request      = request
+      @contents_for = {}
+    end
+
+    # List the webprofiler history.
+    def index
+      @collections = Rack::WebProfiler::Model::CollectionRecord.order(Sequel.desc(:created_at))
+                                                            .limit(20)
+
+      erb "panel/index.erb", layout: "panel/layout.erb"
+    end
+
+    # Show the webprofiler panel.
+    def show(token)
+      @collection = Rack::WebProfiler::Model::CollectionRecord[token: token]
+      return error404 if @collection.nil?
+
+      @collectors = Rack::WebProfiler.config.collectors.all
+
+      # @todo return json if request.content_type ask json (same for xml?)
+      # @example json {} if @request.media_type.include? "json"
+
+      erb "panel/show.erb", layout: "panel/layout.erb"
+    end
+
+    # Print the webprofiler toolbar
+    def show_toolbar(token)
+      @collection = Rack::WebProfiler::Model::CollectionRecord[token: token]
+      return erb nil, status: 404 if @collection.nil?
+
+      @collectors = Rack::WebProfiler.config.collectors.all
+      # @todo process the callector views
+      # @collectors = Rack::WebProfiler::Collector.render_tabs(@record)
+
+      erb "profiler.erb"
+    end
+
+    # Clean the webprofiler.
+    def delete
+      Rack::WebProfiler::Model.clean
+
+      redirect WebProfiler::Router.url_for_profiler
+    end
+
+    private
+
+    def redirect(path)
+      Rack::Response.new([], 302, {
+        "Location" => "#{@request.base_url}#{path}",
+      })
+    end
+
+    # Render a HTML reponse from an ERB template.
+    #
+    # @param path [String] Path to the ERB template
+    #
+    # @return [Rack::Response]
+    def erb(path, layout: nil, status: 200)
+      content = ""
+
+      unless path.nil?
+        templates = [read_template(path)]
+        templates << read_template(layout) unless layout.nil?
+
+        content = templates.inject(nil) do |prev, temp|
+          _render_erb(temp) { prev }
+        end
+      end
+
+      Rack::Response.new(content, status, {
+        "Content-Type" => "text/html",
+      })
+    end
+
+    # Render a JSON response from an Array or a Hash.
+    #
+    # @param data [Array, Hash] Data
+    #
+    # @return [Rack::Response]
+    def json(data = {})
+      Rack::Response.new(data.to_json, 200, {
+        "Content-Type" => "application/json",
+      })
+    end
+
+    def error404
+      erb "404.erb", layout: "panel/layout.erb", status: 404
+    end
+
+    def _render_erb(template)
+      ERB.new(template).result(binding)
+    end
+
+    def partial(path)
+      return "" if path.nil?
+      ERB.new(read_template(path)).result(binding)
+    end
+
+    def render_collector(path, data)
+      @data = data
+      return "" if path.nil?
+      ERB.new(read_template(path)).result(binding)
+    end
+
+    def read_template(template)
+      unless template.empty?
+        path = ::File.expand_path("../../templates/#{template}", __FILE__)
+        return ::File.read(path) if ::File.exist?(path)
+      end
+      template
+    end
+  end
+end

data/lib/rack/web_profiler/engine.rb

@@ -0,0 +1,109 @@
+module Rack
+  #
+  class WebProfiler::Engine
+    class << self
+      # Process
+      #
+      # @param request [Rack::WebProfiler::Request]
+      # @param body
+      # @param status
+      # @param headers
+      #
+      # @return [Rack::Response]
+      def process(request, body, status, headers)
+        response = Rack::Response.new(body, status, headers)
+        record   = collect!(request, response)
+
+        return response if !headers[CONTENT_TYPE].nil? and !headers[CONTENT_TYPE].include? "text/html"
+
+        @token = record.token
+        @url   = WebProfiler::Router.url_for_toolbar(record.token)
+
+        response = Rack::Response.new([], status, headers)
+
+        response.header["X-RackWebProfiler-Token"] = @token
+        response.header["X-RackWebProfiler-Url"]   = @url
+
+        if defined? Rails and body.is_a? ActionDispatch::Response::RackBody
+          body = body.body
+        end
+
+        if body.is_a? Array
+          body.each { |fragment| response.write inject(fragment) }
+        elsif body.is_a? String
+          response.write inject(body)
+        end
+
+        response
+      end
+
+      private
+
+      # Collect
+      #
+      # @param request
+      # @param response
+      def collect!(request, response)
+        processor = Processor.new(request, response)
+        processor.save!
+
+        processor.record
+      end
+
+      # Inject the webprofiler
+      #
+      # @param body [String]
+      def inject(body)
+        body.gsub(%r{</body>}, template.result(binding) + "</body>")
+      end
+
+      # Get the javascript code template to inject.
+      #
+      # @return [String]
+      def template
+        @template ||= ERB.new(::File.read(::File.expand_path("../../templates/async.erb", __FILE__)))
+      end
+
+      class Processor
+        attr_reader :record
+
+        def initialize(request, response)
+          @collectors = {}
+          @request    = request.clone.freeze
+          @response   = response.clone.freeze
+          @record     = nil
+        end
+
+        def save!
+          create_record!
+          save_collected_datas!
+
+          @record.save
+        end
+
+        private
+
+        def create_record!
+          @record ||= WebProfiler::Model::CollectionRecord.create({
+            url:           @request.path,
+            ip:            @request.ip,
+            http_method:   @request.request_method,
+            http_status:   @response.status,
+            content_type:  @response.content_type,
+            datas:         {},
+          })
+        end
+
+        def save_collected_datas!
+          datas = {}
+
+          Rack::WebProfiler.config.collectors.all.each do |name, definition|
+            datas[name.to_sym] = definition.collect!(@request, @response).to_h
+          end
+
+          @record.datas = datas
+        end
+      end
+    end
+  end
+end

data/lib/rack/web_profiler/erb.rb

@@ -0,0 +1,9 @@
+module Rack
+  class WebProfiler
+    # ERB
+    class ERB
+      def initialize(template, layout: nil)
+      end
+    end
+  end
+end

data/lib/rack/web_profiler/model/collection_record.rb

@@ -0,0 +1,45 @@
+module Rack
+  #
+  class WebProfiler::Model::CollectionRecord < Sequel::Model(Rack::WebProfiler::Model.database)
+    # Plugins
+    plugin :schema
+    plugin :hook_class_methods
+    plugin :serialization
+    plugin :timestamps
+
+    # Attributes:
+    #   - id
+    #   - token
+    #   - ip
+    #   - url
+    #   - http_method
+    #   - http_status
+    #   - content_type
+    #   - datas
+    #   - created_at
+    set_schema do
+      primary_key :id
+
+      varchar  :token,       unique: true, empty: false
+      varchar  :url,         empty: false
+      varchar  :ip,          empty: false
+      varchar  :http_method, empty: false
+      integer  :http_status
+      varchar  :content_type
+      string   :datas,       text: true, empty: false
+      datetime :created_at
+    end
+    create_table unless table_exists?
+
+    # Serialization
+    serialize_attributes :marshal, :datas
+
+    # Hooks
+    before_create :before_create
+
+    def before_create
+      token      = Time.now.to_f.to_s.delete(".").to_i
+      self.token = token.to_s(36)
+    end
+  end
+end

data/lib/rack/web_profiler/model.rb

@@ -0,0 +1,35 @@
+require "sequel"
+
+module Rack
+  # Model
+  class WebProfiler::Model
+    autoload :CollectionRecord, "rack/web_profiler/model/collection_record"
+
+    class << self
+      # Get the WebProfiler database.
+      #
+      # @return [Sequel::SQLite::Database]
+      def database
+        @db ||= Sequel.connect("sqlite://#{db_file_path}", timeout: 50)
+      end
+
+      # Remove the database content.
+      def clean
+        return unless ::File.exist?(db_file_path)
+
+        ::File.delete(db_file_path)
+        @db = nil
+        @db_file_path = nil
+      end
+
+      private
+
+      # Returns the db file path.
+      #
+      # @return [String]
+      def db_file_path
+        @db_file_path ||= ::File.join(WebProfiler.config.tmp_dir, "rack-webprofiler.db")
+      end
+    end
+  end
+end

data/lib/rack/web_profiler/request.rb

@@ -0,0 +1,14 @@
+module Rack
+  #
+  class WebProfiler::Request < Rack::Request
+    attr_reader :runtime
+
+    def start_runtime!
+      @request_start ||= Time.now.to_f
+    end
+
+    def save_runtime!
+      @runtime ||= Time.now.to_f - @request_start
+    end
+  end
+end

data/lib/rack/web_profiler/router.rb

@@ -0,0 +1,71 @@
+module Rack
+  # Router
+  #
+  # Show WebProfiler page if the request path match with one
+  # of the webprofiler routes.
+  class WebProfiler::Router
+    BASE_PATH = "/_rwpt".freeze
+
+    class << self
+      # Get response for given request.
+      #
+      # @param request [Rack::WebProfiler::Request]
+      #
+      # @return [Rack::Reponse, false]
+      def response_for(request)
+        @request = request
+        path     = Rack::Utils.unescape(request.path_info)
+
+        # Stop process if the request path does not start
+        # by the BASE_PATH
+        return false unless path.start_with?(BASE_PATH)
+
+        path.slice!(BASE_PATH)
+
+        route(request, path)
+      end
+
+      # Route!
+      def route(request, path)
+        controller = WebProfiler::Controller.new(request)
+
+        if request.get? && path =~ %r{^\/toolbar\/([a-z0-9]*)(\/)?$}
+          controller.show_toolbar(Regexp.last_match(1))
+        elsif request.get? && path =~ %r{^\/clean(\/)?$}
+          controller.delete
+        elsif request.get? && path =~ %r{^(\/)?$}
+          controller.index
+        elsif request.get? && path =~ %r{^\/([a-z0-9]*)(\/)?$}
+          controller.show(Regexp.last_match(1))
+        else
+          false
+        end
+      end
+
+      # Get url for toobar.
+      #
+      # @param token [String]
+      #
+      # @return [String]
+      def url_for_toolbar(token)
+        "#{@request.script_name}#{BASE_PATH}/toolbar/#{token}"
+      end
+
+      # Get url for the webprofiler.
+      #
+      # @param token [String, nil]
+      #
+      # @return [String]
+      def url_for_profiler(token = nil)
+        "#{@request.script_name}#{BASE_PATH}/#{token}"
+      end
+
+      # Get url to clean webprofiler.
+      #
+      # @return [String]
+      def url_for_clean_profiler
+        "#{@request.script_name}#{BASE_PATH}/clean"
+      end
+    end
+  end
+end

data/lib/rack/web_profiler/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class WebProfiler
+    VERSION = "0.1.0-alpha1".freeze
+  end
+end