rack-reqorder 0.4.8 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f25501aa934652db3f5cc6a5683838a1b6bd1665
-  data.tar.gz: 9c47d97e22515eac1bde1ad85bfcd259b77a7283
+  metadata.gz: a0d9d5b4fe1dadfe5ec2b8f248fb7862378ddd1b
+  data.tar.gz: 238cce079cb09e7ef03f9d11b756a5da73386557
 SHA512:
-  metadata.gz: 0ee9d658036006d1bd825e7dbc94d1e22cb186682cc5fa31421e2f538c103a8e0e2e66e4a9b65ee82ba87cc4c9d9ff8839999d923673ceeb178d45c946940587
-  data.tar.gz: 00241ea89a34078c7be449ffd537a5f14b181b6dbe79c7e94d02d4368904ffaaf7db1076150119def9155a2cd70aa25967fbcd33018276c07e087a6e1ce5f871
+  metadata.gz: b2c55e3216b4d70fc7fe3711b328781c5fad3e18526d545827d7163d150e9713cd871e8d9e7c2bf559b97075de58c0be47aff23a34261e5e1a3f33dc45ebc433
+  data.tar.gz: 91c820d63adea800dd5c5ad1fec1c6257da3c26728822ca3fc7da43ec962cf4c8a9aea65da4d1658634fa93c795a1d70694a3602900a32915211891584e41cfc

data/README.md

@@ -4,12 +4,21 @@ Simple gem for monitoring Rack apps. Uses MongoDB. It can be used in combination
 with [rack-reqorder-monitor](https://github.com/kollegorna/rack-reqorder-monitor).
 
 ## Introduction
-Simple gem that sits on top of Rack and records request/response statistics
-as well as monitors for exceptions. It saves everything in MongoDB and exposes
-a simple API for retrieving these data.
+Simple gem that sits on top of Rack and can:
+
+- monitors for exceptions
+- record full requests/responses, based on a header
+- record request/response statistics
+
+It saves everything in MongoDB and exposes simple API for retrieving these data.
 
 The API is very robust, built with the help of [mongoid_hash_query](https://github.com/kollegorna/mongoid_hash_query).
 
+A simple, default, dashboard is build in ember can be found [here](https://github.com/kollegorna/rack-reqorder-monitor).
+
+At the moment, Rails, Sinatra and Grape are supported.
+We are looking forward to add support for Hanami (ex-lotus)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -44,20 +53,16 @@ end
 
 Rack::Reqorder.boot!
 
+#if you run on development mode
 Rails.application.config.middleware.insert_after(ActionDispatch::DebugExceptions , Rack::Reqorder::Logger)
-
-#rack-cors also needed
-Rails.application.config.middleware.insert_before 0, "Rack::Cors" do
-  allow do
-    origins '*'
-    resource '*', :headers => :any, :methods => [:get, :post, :options]
-  end
-end
+#or if run on production
+#Rails.application.config.middleware.insert_after(0, Rack::Reqorder::Logger)
+```
+Then in routes.rb enable the API for the [rack-reqorder-monitor](https://github.com/kollegorna/rack-reqorder-monitor).
+```ruby
+  require 'rack/reqorder/monitor'
+  mount Rack::Reqorder::Monitor::Api => '/rack-reqorder'
 ```
-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
 
@@ -67,7 +72,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/rack-reqorder/fork )
+1. Fork it ( https://github.com/kollegorna/rack-reqorder/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/rack/reqorder.rb

@@ -2,6 +2,7 @@ require 'rack/reqorder/version'
 require 'active_support/inflector'
 require 'mongoid'
 require 'kaminari'
+require 'rack/cors'
 require 'kaminari/models/mongoid_extension'
 require 'rack/reqorder/route_recognizers'
 
@@ -31,7 +32,7 @@ module Rack
 
     class Configuration
       attr_accessor :mongoid_yml, :environment, :auth_email, :auth_password,
-        :no_auth
+        :no_auth, :metrics_monitoring, :exception_monitoring, :request_monitoring
 
       def validate!
         if mongoid_yml.blank?
@@ -42,18 +43,24 @@ module Rack
           self.environment = app_environment
         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
 
       def app_environment
         if Module.const_defined?(:Rails)
           return Rails.env
         else
-          return ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'staging'
+          return ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'unknown'
         end
       end
+
+      def initialize
+        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?
+        self.metrics_monitoring = true if self.metrics_monitoring.blank?
+        self.exception_monitoring = true if self.exception_monitoring.blank?
+        self.request_monitoring = true if self.request_monitoring.blank?
+      end
     end
   end
 end
@@ -75,9 +82,9 @@ require 'rack/reqorder/models/route_path'
 require 'rack/reqorder/models/http_response'
 require 'rack/reqorder/models/app_fault'
 require 'rack/reqorder/models/app_exception'
+require 'rack/reqorder/models/recording'
 require 'rack/reqorder/services/backtrace_cleaner'
 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

@@ -9,33 +9,57 @@ module Rack::Reqorder
     def call(environment)
       rack_request = Rack::Request.new(environment.clone)
 
+      http_request = record_request(rack_request) if conf.request_monitoring
+
       start = Time.now.to_f
       begin
         status, headers, body = @app.call(environment)
-        response = Rack::Response.new(body, status, headers)
+        rack_response = Rack::Response.new(body, status, headers)
       rescue => exception
-        response = log_exception(exception, environment)
+        rack_response = log_exception(exception, rack_request) if conf.exception_monitoring
+
         raise exception
       ensure
-        response_time = Time.now.to_f - start
-
-        if response
-          save_statistics(
-            rack_request: rack_request,
-            rack_response: response,
-            response_time: response_time
-          )
-        end
+        record_statistics(rack_request, rack_response, Time.now.to_f - start)
       end
+      record_response(rack_response, http_request) if conf.request_monitoring
 
       return [status, headers, body]
     end
 
   private
+    def record_statistics(rack_request, rack_response, response_time)
+      if rack_response && conf.metrics_monitoring
+        save_statistics(
+          rack_request: rack_request,
+          rack_response: rack_response,
+          response_time: response_time
+        )
+      end
+    end
+
+    def record_request(rack_request)
+      request_headers = extract_all_headers(rack_request.env)
+      recording = nil
+
+      Recording.enabled.all.each do |rec|
+        if request_headers[rec.http_header] == rec.http_header_value
+          recording = rec and break
+        end
+      end
+
+      return save_http_request(rack_request, recording)
+    end
 
-    def extract_all_headers(request)
+    def record_response(rack_response, http_request)
+      if http_request && http_request.recording
+        return save_http_response(rack_response, http_request)
+      end
+    end
+
+    def extract_all_headers(env)
       Hash[
-        request.env.select{|k,v|
+        env.select{|k,v|
           k.start_with? 'HTTP_'
         }.map{|k,v|
           [k.gsub('HTTP_','').upcase, v]
@@ -90,44 +114,46 @@ module Rack::Reqorder
       end
     end
 
-    def save_http_request(environment)
-      request = Rack::Request.new(environment)
 
-      route_path = RoutePath.find_or_create_by({
-        route: Rack::Reqorder.recognize_path(request.path),
-        http_method: request.request_method
-      })
+    def save_http_request(rack_request, recording = nil)
+      if not recording
+        route_path = RoutePath.find_or_create_by({
+          route: Rack::Reqorder.recognize_path(rack_request.path),
+          http_method: rack_request.request_method
+        })
+      end
 
       HttpRequest.create({
-        ip: request.ip,
-        url: request.url,
-        scheme: request.scheme,
-        base_url: request.base_url,
-        port: request.port,
-        path: request.path,
-        full_path: request.fullpath,
-        http_method: request.request_method,
-        headers: extract_all_headers(request),
-        params: request.params,
-        ssl: request.ssl?,
-        xhr: request.xhr?,
-        route_path: route_path
+        ip: rack_request.ip,
+        url: rack_request.url,
+        scheme: rack_request.scheme,
+        base_url: rack_request.base_url,
+        port: rack_request.port,
+        path: rack_request.path,
+        full_path: rack_request.fullpath,
+        http_method: rack_request.request_method,
+        headers: extract_all_headers(rack_request.env),
+        params: rack_request.params,
+        ssl: rack_request.ssl?,
+        xhr: rack_request.xhr?,
+        route_path: recording ? nil : route_path,
+        recording: recording ? recording : nil
       })
     end
 
-    def save_http_response(body, status, headers, http_request)
-      response = Rack::Response.new(body, status, headers)
-
+    def save_http_response(rack_response, http_request)
       HttpResponse.create(
-        headers: response.headers,
-        #body: response.body.first,
-        status: response.status.to_i,
-        http_request: http_request
+        headers: rack_response.headers,
+        body: rack_response.body.first,
+        status: rack_response.status.to_i,
+        length: rack_response.length,
+        http_request: http_request,
+        recording: http_request.recording.nil? ? nil : http_request.recording
       )
     end
 
-    def log_exception(exception, environment)
-      http_request = save_http_request(environment)
+    def log_exception(exception, rack_request)
+      http_request = save_http_request(rack_request)
 
       bc = BacktraceCleaner.new
       bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') }
@@ -147,7 +173,7 @@ module Rack::Reqorder
         e_class: exception.class,
         line: line.to_i,
         filepath: path[1..-1],
-        environment: app_environment
+        environment: conf.environment
       )
 
       AppException.create(
@@ -181,12 +207,8 @@ module Rack::Reqorder
       end
     end
 
-    def app_environment
-      if Module.const_defined?(:Rails)
-        return Rails.env
-      else
-        return ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'unknown'
-      end
+    def conf
+      Rack::Reqorder.configuration
     end
   end
 end

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

@@ -8,6 +8,8 @@ module Rack::Reqorder::Models
     field :line, type: Integer
     field :filepath, type: String
 
+    field :last_seen_at, type: Time
+
     field :resolved, type: Boolean, default: false
 
     field :environment, type: String
@@ -18,7 +20,9 @@ module Rack::Reqorder::Models
 
     def update_count!
       self.app_exceptions_count = self.app_exceptions.count
+      self.last_seen_at = DateTime.now
       self.save!
     end
+
   end
 end

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

@@ -23,11 +23,17 @@ module Rack::Reqorder::Models
     has_one :app_exception, dependent: :destroy
 
     belongs_to :route_path, dependent: :nullify
+    belongs_to :recording, dependent: :nullify
 
     before_create :add_param_keys
+    after_save :update_recording_requests_count, if: :recording_id
   private
     def add_param_keys
       self.param_keys = self.params.keys
     end
+
+    def update_recording_requests_count
+      self.recording.update_requests_count!
+    end
   end
 end

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

@@ -6,10 +6,12 @@ module Rack::Reqorder::Models
 
     field :headers, type: Hash
     field :status, type: Integer
-    #field :body, type: String
+    field :body, type: String
+    field :length, type: Integer
     field :response_time, type: Float
 
     belongs_to :http_request, dependent: :nullify
+    belongs_to :recording, dependent: :nullify
 
     before_create :set_response_time
     after_create :set_response_time_to_request

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

@@ -0,0 +1,22 @@
+module Rack::Reqorder::Models
+  class Recording
+    include ::Mongoid::Document
+    include ::Kaminari::MongoidExtension::Document
+    include ::Mongoid::Timestamps
+
+    field :http_header, type: String
+    field :http_header_value, type: String
+    field :enabled, type: Boolean, default: true
+    field :requests_count, type: Integer, default: 0
+
+    has_many :http_requests, dependent: :nullify
+    has_many :http_responses, dependent: :nullify
+
+    scope :enabled, -> {where(enabled: true)}
+
+    def update_requests_count!
+      self.requests_count = self.http_requests.count
+      self.save!
+    end
+  end
+end

data/lib/rack/reqorder/monitor.rb

@@ -24,11 +24,14 @@ module Rack::Reqorder::Monitor
     format :json
     prefix :api
 
-=begin
     rescue_from Grape::Exceptions::ValidationErrors do |e|
       error!({errors: e.send(:full_messages)}, 422)
     end
-=end
+
+    before do
+      header 'Access-Control-Allow-Origin', '*'
+      header 'Access-Control-Allow-Methods', '*'
+    end
 
     #collection routes
     resource :route_paths do
@@ -50,6 +53,15 @@ module Rack::Reqorder::Monitor
         )
       end
 
+      delete do
+        route_paths = RoutePath.delete_all
+
+        present_with_meta(
+          route_paths,
+          present(route_paths, with: RoutePathEntity)
+        )
+      end
+
       #element routes
       route_param :id do
         get do
@@ -89,6 +101,15 @@ module Rack::Reqorder::Monitor
         )
       end
 
+      delete do
+        requests = HttpRequest.delete_all
+
+        present_with_meta(
+          requests,
+          present(requests, with: RequestEntity)
+        )
+      end
+
       #element routes
       route_param :id do
         get do
@@ -119,6 +140,15 @@ module Rack::Reqorder::Monitor
         )
       end
 
+      delete do
+        responses = HttpResponse.delete_all
+
+        present_with_meta(
+          responses,
+          present(responses, with: ResponseEntity)
+        )
+      end
+
       #element routes
       route_param :id do
         get do
@@ -151,6 +181,16 @@ module Rack::Reqorder::Monitor
         )
       end
 
+      delete do
+        faults = AppFault.delete_all
+
+        present_with_meta(
+          faults,
+          present(faults, with: FaultEntity)
+        )
+
+      end
+
       #element routes
       route_param :id do
         get do
@@ -194,6 +234,15 @@ module Rack::Reqorder::Monitor
         )
       end
 
+      delete do
+        exceptions = AppException.delete_all
+
+        present_with_meta(
+          exceptions,
+          present(exceptions, with: ExceptionEntity)
+        )
+      end
+
       #element routes
       route_param :id do
         get do
@@ -202,6 +251,56 @@ module Rack::Reqorder::Monitor
       end
     end
 
+    #collection routes
+    resource :recordings do
+      before do
+        authorize_user!(headers) unless Rack::Reqorder.configuration.no_auth
+      end
+
+      get do
+        recordings = apply_filters(Recording.all, params)
+
+        meta_aggregations = aggregations(recordings, params)
+
+        recordings = paginate(recordings, params)
+
+        present_with_meta(
+          recordings,
+          present(recordings, with: RecordingEntity),
+          meta_aggregations
+        )
+      end
+
+      params do
+        requires :recording, type: Hash do
+          requires :http_header, type: String
+          requires :http_header_value, type: String
+        end
+      end
+      post do
+        present(
+          Recording.create!({
+            http_header: declared(params)[:recording][:http_header],
+            http_header_value: declared(params)[:recording][:http_header_value]
+          }),
+          with: RecordingEntity
+        )
+      end
+
+      #element routes
+      route_param :id do
+        get do
+          present(Recording.find(params[:id]), with: RecordingEntity)
+        end
+
+        delete do
+          recording = Recording.find(params[:id])
+          recording.destroy
+
+          present(recording, with: RecordingEntity)
+        end
+      end
+    end
 
     params do
       requires :user, type: Hash do

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

@@ -124,6 +124,7 @@ module Rack::Reqorder::Monitor
 
       with_options(format_with: :association_id) do
         expose :http_response, as: :response_id
+        expose :recording, as: :recording_id
       end
 
     end
@@ -133,6 +134,7 @@ module Rack::Reqorder::Monitor
 
       expose :headers
       expose :status
+      expose :body
       expose :response_time
 
       with_options(format_with: :iso_timestamp) do
@@ -142,6 +144,7 @@ module Rack::Reqorder::Monitor
 
       with_options(format_with: :association_id) do
         expose :http_request, as: :request_id
+        expose :recording, as: :recording_id
       end
     end
 
@@ -163,6 +166,7 @@ module Rack::Reqorder::Monitor
       end
 
       with_options(format_with: :iso_timestamp) do
+        expose :last_seen_at
         expose :created_at
         expose :updated_at
       end
@@ -187,7 +191,20 @@ module Rack::Reqorder::Monitor
         expose :http_request, as: :request_id
         expose :app_fault, as: :fault_id
       end
+    end
+
+    class RecordingEntity < BaseEntity
+      root :recordings, :recording
 
+      expose :http_header
+      expose :http_header_value
+      expose :enabled
+      expose :requests_count
+
+      with_options(format_with: :iso_timestamp) do
+        expose :created_at
+        expose :updated_at
+      end
     end
 
     class SessionEntity < Grape::Entity

data/lib/rack/reqorder/version.rb

@@ -1,5 +1,5 @@
 module Rack
   module Reqorder
-    VERSION = "0.4.8"
+    VERSION = "0.5"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-reqorder
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: '0.5'
 platform: ruby
 authors:
 - Filippos Vasilakis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2016-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -218,6 +218,7 @@ files:
 - lib/rack/reqorder/models/app_fault.rb
 - lib/rack/reqorder/models/http_request.rb
 - lib/rack/reqorder/models/http_response.rb
+- lib/rack/reqorder/models/recording.rb
 - lib/rack/reqorder/models/route_path.rb
 - lib/rack/reqorder/models/statistic.rb
 - lib/rack/reqorder/monitor.rb
@@ -226,7 +227,6 @@ files:
 - 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: https://github.com/kollegorna/rack-reqorder

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

@@ -1,29 +0,0 @@
-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