rack-reqorder 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 980b4a8e4de9b3696b27754a43753a7ee813b0e2
-  data.tar.gz: fcbfdaa4bf6ed3fb96923dd41b610642231275a7
+  metadata.gz: 92a69c99b0738479b0b998e1a7f7c5d3f3051f46
+  data.tar.gz: 7e032e5347593d459db3e183dd1b1cb653d91b7e
 SHA512:
-  metadata.gz: 0ba82134c8dfec0aaf62df4df6e2b3562db24624cf4f1e1a27c0d5c6dac7b7351aa824b5678b57f6f207df2deaeb8b924a754c8f730e88f81c7322a0cc165ad3
-  data.tar.gz: 64e885c60ed26a5951bf50102034a4c73701a104f6da0e80525900bd8e38192ee76def5fd0163b2b13213c39d591088d205ec88952542708f8f6e788e239a7b4
+  metadata.gz: 0b80ff10e5dfb1ff79ae7f5233b495f62f2e63374528e31742614e4b1f34b2501c4a44399c8d7655e0e65cc9b2efa845040b2f302c49d2a621290328b0889a08
+  data.tar.gz: f732af69470fb3123ada1da63fb932d68863832c53901fbe2ef98441a3d36256bb90bf49a20ff7fa60c0b00772665ee9ffc3ef993c33bb1fb967a3ff59cce71d

data/Gemfile

@@ -1,8 +1,5 @@
 source 'https://rubygems.org'
 
-gem 'mongoid_hash_query', path: '../mongoid_hash_query'
-gem 'pry'
-
 # Specify your gem's dependencies in rack-reqorder.gemspec
 gemspec
 

data/README.md

@@ -27,7 +27,13 @@ Or install it yourself as:
     $ gem install rack-reqorder
 
 ## Usage
-Just add it on the middleware pipeline and initialize it.
+You first need to initialize mongoid/mongodb by running:
+
+```bash
+bundle exec rails g mongoid:config
+```
+
+Then just add it on the middleware pipeline and initialize it.
 
 For instance, in Rails, in an initializer add:
 
@@ -51,6 +57,8 @@ end
 Please note that you can configure origins and resource depending on how you
 mount the rack-monitor engine and where you deploy your front-end.
 
+For viewing your statistics please check [rack-reqorder-monitor](https://github.com/kollegorna/rack-reqorder-monitor)
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment. 

data/lib/rack/reqorder.rb

@@ -3,9 +3,14 @@ require 'active_support/inflector'
 require 'mongoid'
 require 'kaminari'
 require 'kaminari/models/mongoid_extension'
+require 'rack/reqorder/route_recognizers'
 
 module Rack
   module Reqorder
+    extend Rack::Reqorder::GrapeRecognizer
+    extend Rack::Reqorder::SinatraRecognizer
+    extend Rack::Reqorder::RailsRecognizer
+
     class << self
       attr_accessor :configuration
     end
@@ -24,24 +29,9 @@ module Rack
       )
     end
 
-    def self.paths
-      return @paths unless @paths.blank?
-      @paths = {}
-      Rails.application.routes.routes.routes.each do |route|
-        @paths[route.defaults] = route.path.spec.left.to_s
-      end
-
-      return @paths
-    end
-
-    def self.recognise_path(path_uri, options = {})
-      res = Rack::Reqorder.paths[Rails.application.routes.recognize_path(path_uri, options)
-        .select{|key, value| [:action, :controller].include?(key)}
-      ]
-    end
-
     class Configuration
-      attr_accessor :mongoid_yml, :environment
+      attr_accessor :mongoid_yml, :environment, :auth_email, :auth_password,
+        :no_auth
 
       def validate!
         if mongoid_yml.blank?
@@ -52,6 +42,10 @@ module Rack
           puts 'rack-reqorder: No environment found, assuming development environment'
           self.environment = :development
         end
+
+        self.auth_email = 'admin@example.com' if auth_email.blank?
+        self.auth_password = 'password' if auth_password.blank?
+        self.no_auth = false if self.no_auth.blank?
       end
     end
   end
@@ -79,3 +73,4 @@ require 'rack/reqorder/logger'
 require 'rack/reqorder/monitor'
 
 load 'rack/reqorder/tasks/routes.rake'
+load 'rack/reqorder/tasks/test_database.rake'

data/lib/rack/reqorder/logger.rb

@@ -7,23 +7,24 @@ module Rack::Reqorder
     end
 
     def call(environment)
-      #http_request = save_http_request(environment)
+      rack_request = Rack::Request.new(environment.clone)
 
       start = Time.now.to_f
       begin
         status, headers, body = @app.call(environment)
+        response = Rack::Response.new(body, status, headers)
       rescue => exception
-        log_exception(exception, environment)
+        response = log_exception(exception, environment)
         raise exception
+      ensure
+        response_time = Time.now.to_f - start
+
+        save_statistics(
+          rack_request: rack_request,
+          rack_response: response,
+          response_time: response_time
+        )
       end
-      response_time = Time.now.to_f - start
-
-      #save_http_response(body, status, headers, http_request)
-      save_statistics(
-        rack_request: Rack::Request.new(environment),
-        rack_response: Rack::Response.new(body, status, headers),
-        response_time: response_time
-      )
 
       return [status, headers, body]
     end
@@ -42,15 +43,27 @@ module Rack::Reqorder
       ]
     end
 
+    def route_template(request_path:, request_method:)
+      Rack::Reqorder.recognize_path(request_path, {method: request_method})
+    end
+
     def save_statistics(rack_request:, rack_response:, response_time:)
       route_path = RoutePath.find_or_create_by({
-        route: Rack::Reqorder.recognise_path(rack_request.path),
+        route: route_template({
+          #response_status: rack_response.status,
+          request_path: rack_request.path,
+          request_method: rack_request.request_method
+        }),
         http_method: rack_request.request_method
       })
 
-      [:all.to_s, DateTime.now.hour.to_s].each do |key|
+      [:all.to_s, DateTime.now.utc.hour.to_s].each do |key|
         statistic = route_path.send("statistic_#{key}".to_sym)
 
+        if key != :all && statistic && statistic.created_at.to_date < DateTime.now.utc.to_date
+          statistic = route_path.send("create_statistic_#{key}")
+        end
+
         if statistic.nil?
           statistic = route_path.send("create_statistic_#{key}")
         end
@@ -79,7 +92,7 @@ module Rack::Reqorder
       request = Rack::Request.new(environment)
 
       route_path = RoutePath.find_or_create_by({
-        route: Rack::Reqorder.recognise_path(request.path),
+        route: Rack::Reqorder.recognize_path(request.path),
         http_method: request.request_method
       })
 
@@ -128,11 +141,12 @@ module Rack::Reqorder
         path, line, _ = exception.backtrace.first.split(':')
       end
 
-
       app_fault = AppFault.find_or_create_by(
         e_class: exception.class,
         line: line.to_i,
-        filepath: path[1..-1]
+        filepath: path[1..-1],
+        route_path: http_request.route_path,
+        environment: app_environment
       )
 
       AppException.create(
@@ -147,7 +161,7 @@ module Rack::Reqorder
         http_request: http_request
       )
 
-      HttpResponse.create(
+      return HttpResponse.create(
         status: 500,
         http_request: http_request
       )
@@ -165,5 +179,13 @@ module Rack::Reqorder
         end
       end
     end
+
+    def app_environment
+      if Module.const_defined?(:Rails)
+        return Rails.env
+      else
+        return ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'unknown'
+      end
+    end
   end
 end

data/lib/rack/reqorder/models/app_fault.rb

@@ -8,8 +8,13 @@ module Rack::Reqorder::Models
     field :line, type: Integer
     field :filepath, type: String
 
+    field :resolved, type: Boolean, default: false
+
+    field :environment, type: String
+
     field :app_exceptions_count, type: Integer, default: 0
 
+    belongs_to :route_path, dependent: :nullify
     has_many :app_exceptions, dependent: :destroy
 
     def update_count!

data/lib/rack/reqorder/models/route_path.rb

@@ -9,32 +9,12 @@ module Rack::Reqorder::Models
 
     has_many :http_requests, dependent: :destroy
 
-    embeds_one :statistic_0, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_1, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_2, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_3, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_4, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_5, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_6, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_7, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_8, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_9, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_10, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_11, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_12, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_13, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_14, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_15, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_16, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_17, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_18, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_19, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_20, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_21, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_22, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_23, class_name: 'Rack::Reqorder::Models::Statistic'
-    embeds_one :statistic_24, class_name: 'Rack::Reqorder::Models::Statistic'
-
     embeds_one :statistic_all, class_name: 'Rack::Reqorder::Models::Statistic'
+
+    0.upto(23) do |i|
+      embeds_one "statistic_#{i}", class_name: 'Rack::Reqorder::Models::Statistic'
+    end
+
+    has_one :app_fault, dependent: :destroy
   end
 end

data/lib/rack/reqorder/models/statistic.rb

@@ -20,7 +20,11 @@ module Rack::Reqorder::Models
     field :xhr_count, type: Integer, default: 0
     field :ssl_count, type: Integer, default: 0
 
-    embedded_in :route_path
+    embedded_in :route_path, inverse_of: :statistic_all
+
+    0.upto(23) do |i|
+      embedded_in :route_path, inverse_of: "statistic_#{i}"
+    end
 
     def recalculate_average!(response_time)
       self.avg_response_time = (

data/lib/rack/reqorder/monitor.rb

@@ -1,5 +1,6 @@
 require 'grape'
 require 'grape-entity'
+require 'rack/reqorder/monitor/helpers'
 require 'rack/reqorder/monitor/entities'
 require 'mongoid_hash_query'
 require 'pry'
@@ -10,20 +11,32 @@ module Rack::Reqorder
 end
 
 module Rack::Reqorder::Monitor
+
   class Api < Grape::API
     include Rack::Reqorder::Models
     include Rack::Reqorder::Monitor::Entities
 
     helpers do
       include MongoidHashQuery
+      include Rack::Reqorder::Monitor::Helpers
     end
 
     version 'v1', using: :path, vendor: 'foobar'
     format :json
     prefix :api
 
+=begin
+    rescue_from Grape::Exceptions::ValidationErrors do |e|
+      error!({errors: e.send(:full_messages)}, 422)
+    end
+=end
+
     #collection routes
     resource :route_paths do
+      before do
+        authorize_user!(headers) unless Rack::Reqorder.configuration.no_auth
+      end
+
       get do
         route_paths = apply_filters(RoutePath.all, params)
 
@@ -46,8 +59,23 @@ module Rack::Reqorder::Monitor
       end
     end
 
+    #collection routes
+    resource :route_path_24_statistics do
+      get do
+        route_paths = RoutePath.all
+
+        route_paths = apply_filters(route_paths, params)
+
+        present(route_paths, with: RoutePath24StatisticsEntity)
+      end
+    end
+
     #collection routes
     resource :requests do
+      before do
+        authorize_user!(headers) unless Rack::Reqorder.configuration.no_auth
+      end
+
       get do
         requests = apply_filters(HttpRequest.all, params)
 
@@ -72,6 +100,10 @@ module Rack::Reqorder::Monitor
 
     #collection routes
     resource :responses do
+      before do
+        authorize_user!(headers) unless Rack::Reqorder.configuration.no_auth
+      end
+
       get do
         responses = HttpResponse.all
 
@@ -98,9 +130,15 @@ module Rack::Reqorder::Monitor
 
     #collection routes
     resource :faults do
+      before do
+        authorize_user!(headers) unless Rack::Reqorder.configuration.no_auth
+      end
+
       get do
         faults = AppFault.all
 
+        environments = faults.group_by(&:environment).keys
+
         faults = apply_filters(faults, params)
 
         meta_aggregations = aggregations(faults, params)
@@ -110,7 +148,7 @@ module Rack::Reqorder::Monitor
         present_with_meta(
           faults,
           present(faults, with: FaultEntity),
-          meta_aggregations
+          meta_aggregations.merge(environments: environments)
         )
       end
 
@@ -119,11 +157,28 @@ module Rack::Reqorder::Monitor
         get do
           present(AppFault.find(params[:id]), with: FaultEntity)
         end
+
+        params do
+          requires :fault, type: Hash do
+            optional :resolved, type: Boolean
+          end
+        end
+        put do
+          fault = AppFault.find(params[:id])
+          fault.resolved = declared(params)[:fault][:resolved]
+          fault.save!
+
+          present(fault, with: FaultEntity)
+        end
       end
     end
 
     #collection routes
     resource :exceptions do
+      before do
+        authorize_user!(headers) unless Rack::Reqorder.configuration.no_auth
+      end
+
       get do
         exceptions = AppException.all
 
@@ -148,24 +203,39 @@ module Rack::Reqorder::Monitor
       end
     end
 
+
+    params do
+      requires :user, type: Hash do
+        requires :email, type: String
+        requires :password, type: String
+      end
+    end
+    resource :sessions do
+      post do
+        authenticate_user!(declared(params))
+
+        present(Object.new, with: SessionEntity)
+      end
+    end
+
     helpers do
       def present_with_meta(object, hash, extra_meta)
         hash[:meta] = {
-          currentPage: object.current_page,
-          nextPage: object.next_page,
-          prevPage: object.prev_page,
-          totalPages: object.total_pages,
-          totalCount: object.total_count
+          current_page: object.current_page,
+          next_page: object.next_page,
+          prev_page: object.prev_page,
+          total_pages: object.total_pages,
+          total_count: object.total_count
         }.merge(extra_meta)
 
         return hash
       end
 
       def paginate(object, params)
-        return object.
-          page(params[:page] || 1).
-          per(params[:per_page] || 30).
-          skip(params[:skip] || 0)
+        object = object.page(params[:page] || 1).per(params[:per_page] || 30)
+        object = object.skip(params[:skip]) if params[:skip]
+
+        return object
       end
     end
 

data/lib/rack/reqorder/monitor/entities.rb

@@ -38,9 +38,11 @@ module Rack::Reqorder::Monitor
       expose :http_method
       expose :statistic_all, using: StatisticEntity
 
+=begin
       1.upto(24) do |num|
         expose "statistic_#{num}", using: StatisticEntity
       end
+=end
 
       with_options(format_with: :iso_timestamp) do
         expose :created_at
@@ -48,6 +50,55 @@ module Rack::Reqorder::Monitor
       end
     end
 
+    class RoutePath24StatisticsEntity < Grape::Entity
+      root :route_path_25_statistics
+      present_collection true
+
+      exposures = proc{|aggrs, field|
+        aggrs.each do |aggr|
+          expose aggr do |route_path, options|
+            today_array = []
+            yesterday_array = []
+
+            now = DateTime.now.utc.hour
+
+            0.upto(now) do |i|
+              today_array.push(
+                route_path[:items].where(
+                  "statistic_#{i}.created_at".to_sym.gte => DateTime.now.utc.to_date
+                ).send(aggr,("statistic_#{i}.#{field}"))
+              )
+            end
+
+            if now <23
+              (now+1).upto(23) do |i|
+                yesterday_array.push(
+                  route_path[:items].where(
+                    "statistic_#{i}.created_at".to_sym.gte => (DateTime.now.utc.to_date - 1)
+                  ).send(aggr,("statistic_#{i}.#{field}"))
+                )
+              end
+            end
+
+            [yesterday_array,today_array].flatten
+          end
+        end
+      }
+
+      [:http_requests_count, :statuses_2xx, :statuses_3xx, :statuses_4xx,
+       :statuses_401, :statuses_404, :statuses_422, :statuses_5xx,
+       :xhr_count, :ssl_count
+      ].each do |field|
+        expose field do
+          exposures.call([:sum], field)
+        end
+      end
+
+      expose :avg_response_time do
+        exposures.call([:avg], :avg_response_time)
+      end
+    end
+
     class RequestEntity < BaseEntity
       root :requests, :request
 
@@ -100,15 +151,21 @@ module Rack::Reqorder::Monitor
       expose :e_class
       expose :line
       expose :filepath
+      expose :resolved
       expose :app_exceptions_count, as: :exceptions_count
+      expose :environment
       expose :message do |fault, options|
-        fault.app_exceptions.try(:first).try(:message)
+        fault.app_exceptions.try(:last).try(:message)
       end
 
       expose :app_exception_ids, as: :exception_ids do |fault, options|
         fault.app_exception_ids.map(&:to_s).first(100)
       end
 
+      with_options(format_with: :association_id) do
+        expose :route_path, as: :route_path_id
+      end
+
       with_options(format_with: :iso_timestamp) do
         expose :created_at
         expose :updated_at
@@ -136,5 +193,23 @@ module Rack::Reqorder::Monitor
       end
 
     end
+
+    class SessionEntity < Grape::Entity
+      expose :id do |status, options|
+        1
+      end
+
+      expose :email  do |status, options|
+        Rack::Reqorder.configuration.auth_email
+      end
+
+      expose :token  do |status, options|
+        #need user object...
+        Digest::MD5.hexdigest(
+          Rack::Reqorder.configuration.auth_email +
+          Rack::Reqorder.configuration.auth_password
+        )
+      end
+    end
   end
 end

data/lib/rack/reqorder/monitor/helpers.rb

@@ -0,0 +1,92 @@
+module Rack::Reqorder::Monitor
+  module Helpers
+    def authorize_user!(headers)
+      authorize_user(headers) ? true : error!('403 Forbidden', 403)
+    end
+
+    def authenticate_user!(params)
+      authenticate_user(params) ? true : error!('401 Unauthorized', 401)
+    end
+
+  private
+    #monkeypatch these 2 methods if you want to provide custom authentication/authorization
+    def authorize_user(headers)
+      token, options = AuthorizationHeader.token_and_options(headers)
+
+      user_email = options.blank?? nil : options[:email]
+
+      correct_email = user_email == Rack::Reqorder.configuration.auth_email
+      correct_token = token == user_email_password_md5
+
+      return (correct_email && correct_token) ? true : false
+    end
+
+
+    def authenticate_user(params)
+      email = params.user.email
+      password = params.user.password
+
+      correct_email = email == Rack::Reqorder.configuration.auth_email
+      correct_password = password == Rack::Reqorder.configuration.auth_password
+
+      return (correct_email && correct_password)? true : false
+    end
+
+    def user_email_password_md5(user: nil)
+      #if user.nil?
+      Digest::MD5.hexdigest(
+        Rack::Reqorder.configuration.auth_email +
+        Rack::Reqorder.configuration.auth_password
+      )
+      #else
+      #end
+    end
+    #taken from rails ActionController::HttpAuthentication::Token ^_^
+    class AuthorizationHeader
+      class << self
+        TOKEN_KEY = 'token='
+        TOKEN_REGEX = /^(Token|Bearer) /
+        AUTHN_PAIR_DELIMITERS = /(?:,|;|\t+)/
+
+        def token_and_options(headers)
+          authorization_request = headers['Authorization']
+
+          if authorization_request[TOKEN_REGEX]
+            params = token_params_from authorization_request
+            [params.shift[1], Hash[params].with_indifferent_access]
+          end
+        end
+
+      private
+
+        def token_params_from(auth)
+          rewrite_param_values params_array_from raw_params auth
+        end
+
+        # Takes raw_params and turns it into an array of parameters
+        def params_array_from(raw_params)
+          raw_params.map { |param| param.split %r/=(.+)?/ }
+        end
+
+        # This removes the <tt>"</tt> characters wrapping the value.
+        def rewrite_param_values(array_params)
+          array_params.each { |param| (param[1] || "").gsub! %r/^"|"$/, '' }
+        end
+
+        # This method takes an authorization body and splits up the key-value
+        # pairs by the standardized <tt>:</tt>, <tt>;</tt>, or <tt>\t</tt>
+        # delimiters defined in +AUTHN_PAIR_DELIMITERS+.
+        def raw_params(auth)
+          _raw_params = auth.sub(TOKEN_REGEX, '').split(/\s*#{AUTHN_PAIR_DELIMITERS}\s*/)
+
+          if !(_raw_params.first =~ %r{\A#{TOKEN_KEY}})
+            _raw_params[0] = "#{TOKEN_KEY}#{_raw_params.first}"
+          end
+
+          _raw_params
+        end
+      end
+    end
+  end
+end
+

data/lib/rack/reqorder/route_recognizers.rb

@@ -0,0 +1,156 @@
+module Rack
+  module Reqorder
+    module RailsRecognizer
+      def prefixes
+        return @prefixes unless @prefixes.blank?
+
+        @prefixes = {} #{'/mount_prefix' => {search_method: xxx_recognize_path, rack_app: xxx}}
+        Rails.application.routes.routes.routes.select{|r| r.defaults.blank?}.each do |route|
+          __superclass = route.app.try(:superclass) || route.app.try(:app).try(:superclass)
+
+          next unless __superclass
+
+          case __superclass.to_s
+          when Sinatra::Base.to_s
+            @prefixes[route.path.spec.try(:left).to_s + route.path.spec.try(:right).to_s] = {
+              search_method: :sinatra_recognize_path,
+              rack_app: route.app.try(:superclass).nil? ? route.app.app : route.app
+            }
+          when Rails::Engine.to_s
+            @prefixes[route.path.spec.try(:left).to_s + route.path.spec.try(:right).to_s] = {
+              search_method: :rails_recognize_path,
+              rack_app: route.app.try(:superclass).nil? ? route.app.app : route.app
+            }
+          when Grape::API.to_s
+            @prefixes[route.path.spec.try(:left).to_s + route.path.spec.try(:right).to_s] = {
+              search_method: :grape_recognize_path,
+              rack_app: route.app.try(:superclass).nil? ? route.app.app : route.app
+            }
+          end
+        end
+
+        return @prefixes
+      end
+
+      def rails_paths(rails_app)
+        paths = {}
+        rails_app.routes.routes.routes.reverse.each do |route|
+          paths[route.defaults] = route.path.spec.to_s.gsub('(.:format)', '')
+        end
+
+        return paths
+      end
+
+      def recognize_unknown_path
+        prefixes.each do |prefix, engine|
+          if path_uri.start_with?(prefix)
+            return prefix
+          end
+        end
+
+        return ''
+      end
+
+      def recognize_path(path_uri, options = {})
+        prefixes.each do |prefix, engine|
+          if path_uri.start_with?(prefix)
+            return prefix + self.send(engine[:search_method].to_sym, {
+              path_uri: path_uri.gsub(prefix, ''),
+              rack_app: engine[:rack_app],
+              options: options
+            })
+          end
+        end
+
+        begin
+          return rails_recognize_path(
+            path_uri: path_uri,
+            rack_app: Rails.application,
+            options: options
+          )
+        rescue ActionController::RoutingError
+          return "/#{path_uri.split('/')[1]}"
+        end
+      end
+
+      #rack_app is basically a rails app here but we keep it for the sake of the interface
+      def rails_recognize_path(path_uri:, rack_app:, options: {})
+        memoized_var = "@#{rack_app.class.to_s.split('::').join('_').downcase}".to_sym
+
+        if self.instance_variable_get(memoized_var).nil?
+          self.instance_variable_set(memoized_var, rails_paths(rack_app))
+        end
+
+        Rack::Reqorder.instance_variable_get(memoized_var)[
+          rack_app.routes.recognize_path(path_uri, options)
+          .select{|key, value| [:action, :controller].include?(key)}
+        ]
+      end
+    end
+
+    module GrapeRecognizer
+      def recognize_path(path_uri, options = {})
+        raise 'not implemented yet'
+      end
+
+      def grape_recognize_path(path_uri:, rack_app:, options: {})
+        path_uri = '/' if path_uri.blank?
+
+        rack_app.routes.each do |route|
+          route_options = route.instance_variable_get(:@options)
+          if route_options[:method] == options[:method] && route_options[:compiled] =~ path_uri
+           if route_options[:method] == "OPTIONS"
+             return route_options[:path].
+               gsub('(.json)', '')
+           else
+             return route_options[:path].
+               gsub(':version', route_options[:version]).
+               gsub('(.json)', '')
+           end
+          end
+        end
+
+        #assets in grape? well you never know..
+        if path_uri.end_with?('.js')
+          return '/js_asset'
+        elsif path_uri.end_with?('.css')
+          return '/css_asset'
+        elsif path_uri.end_with?('.png', 'jpg')
+          return '/css_asset'
+        else
+          return '/unknown' #path_uri
+        end
+      end
+    end
+
+    module SinatraRecognizer
+      def recognize_path(path_uri, options = {})
+        raise 'not implemented yet'
+      end
+
+      def sinatra_recognize_path(path_uri:, rack_app:, options: {})
+        path_uri = '/' if path_uri.blank?
+
+        rack_app.routes[options[:method].to_s.upcase].each do |r|
+          if r.first =~ path_uri
+            return r.first.to_s.
+              gsub('([^\\/?#]+)', ":#{r[1].first}").
+              gsub('\\z)','').gsub('(?-mix:\\A', '').
+              gsub('\\','')
+          end
+        end
+
+        if path_uri.end_with?('.js')
+          return '/js_asset'
+        elsif path_uri.end_with?('.css')
+          return '/css_asset'
+        elsif path_uri.end_with?('.png', 'jpg')
+          return '/css_asset'
+        else
+          return '/unknown' #path_uri
+        end
+      end
+    end
+  end
+end
+

data/lib/rack/reqorder/tasks/routes.rake

@@ -1,5 +1,5 @@
 if respond_to?(:namespace, true)
-  namespace 'rack-monitor' do
+  namespace 'rack-reqorder' do
     desc 'rack-monitor API routes'
     task :routes => :environment do
       Rack::Reqorder::Monitor::Api.routes.each do |route|

data/lib/rack/reqorder/tasks/test_database.rake

@@ -0,0 +1,29 @@
+if respond_to?(:namespace, true)
+  namespace 'rack-reqorder' do
+    desc 'rack-monitor API routes'
+    task :test_database => :environment do
+      env = ENV["RACK_ENV"] || ENV["RAILS_ENV"] || Rails.env
+      return 'Available only under development env' unless env == 'development'
+
+      require_relative '../../../../spec/rack/factories/statistics.rb'
+      require_relative '../../../../spec/rack/factories/route_paths.rb'
+      require_relative '../../../../spec/rack/factories/app_faults.rb'
+
+      10.times { FactoryGirl.create(:route_path) }
+
+      FactoryGirl.create(
+        :route_path,
+        route: '/rack-reqorder/api/v1/route_path_24_statistics',
+        http_method: 'GET'
+      )
+
+      FactoryGirl.create(
+        :route_path,
+        route: '/rack-reqorder/api/v1/route_paths',
+        http_method: 'GET'
+      )
+
+      40.times { FactoryGirl.create(:app_fault) }
+    end
+  end
+end

data/lib/rack/reqorder/version.rb

@@ -1,5 +1,5 @@
 module Rack
   module Reqorder
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end

data/rack-reqorder.gemspec

@@ -6,12 +6,12 @@ require 'rack/reqorder/version'
 Gem::Specification.new do |spec|
   spec.name          = "rack-reqorder"
   spec.version       = Rack::Reqorder::VERSION
-  spec.authors       = ["Filippos Vasilakis"]
-  spec.email         = ["vasilakisfil@gmail.com"]
+  spec.authors       = ["Filippos Vasilakis", "Kollegorna"]
+  spec.email         = ["vasilakisfil@gmail.com", "admin@kollegorna.se"]
 
   spec.summary       = %q{Request recorder and analyzer for rack apps}
   spec.description   = %q{Request recorder and analyzer for rack apps}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/kollegorna/rack-reqorder"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
@@ -20,8 +20,12 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.8"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "factory_girl", "~> 4.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "faker"
   spec.add_dependency "mongoid", "~> 4.0.0"
-  spec.add_dependency "activesupport", "~> 4.1.6"
+  spec.add_dependency "activesupport", ">4.0.0"
   spec.add_dependency "grape"
   spec.add_dependency "grape-entity"
   spec.add_dependency "kaminari"

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rack-reqorder
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Filippos Vasilakis
+- Kollegorna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-27 00:00:00.000000000 Z
+date: 2015-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +39,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +113,16 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 4.1.6
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 4.1.6
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: grape
   requirement: !ruby/object:Gem::Requirement
@@ -139,6 +196,7 @@ dependencies:
 description: Request recorder and analyzer for rack apps
 email:
 - vasilakisfil@gmail.com
+- admin@kollegorna.se
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -164,11 +222,14 @@ files:
 - lib/rack/reqorder/models/statistic.rb
 - lib/rack/reqorder/monitor.rb
 - lib/rack/reqorder/monitor/entities.rb
+- lib/rack/reqorder/monitor/helpers.rb
+- lib/rack/reqorder/route_recognizers.rb
 - lib/rack/reqorder/services/backtrace_cleaner.rb
 - lib/rack/reqorder/tasks/routes.rake
+- lib/rack/reqorder/tasks/test_database.rake
 - lib/rack/reqorder/version.rb
 - rack-reqorder.gemspec
-homepage: ''
+homepage: https://github.com/kollegorna/rack-reqorder
 licenses:
 - MIT
 metadata: {}
@@ -188,7 +249,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Request recorder and analyzer for rack apps