rails_performance 0.9.8 → 1.0.0.beta4

data/lib/rails_performance/models/grape_record.rb

@@ -0,0 +1,61 @@
+module RailsPerformance
+  module Models
+    class GrapeRecord < BaseRecord
+      attr_accessor :datetime, :datetimei, :format, :status, :path, :method, :request_id, :json
+      attr_accessor :endpoint_render_grape, :endpoint_run_grape, :format_response_grape
+
+      # key = grape|datetime|20210409T1115|datetimei|1617992134|format|json|path|/api/users|status|200|method|GET|request_id|1122|END|1.0.0
+      # value = {"endpoint_render.grape"=>0.000643989, "endpoint_run.grape"=>0.002000907, "format_response.grape"=>0.0348967}
+      def GrapeRecord.from_db(key, value)
+        items = key.split("|")
+
+        GrapeRecord.new(
+          datetime: items[2],
+          datetimei: items[4],
+          format: items[6],
+          path: items[8],
+          status: items[10],
+          method: items[12],
+          request_id: items[14],
+          json: value
+        )
+      end
+
+      def initialize(datetime: nil, datetimei: nil, format: nil, path: nil, status: nil, method: nil, request_id:, endpoint_render_grape: nil, endpoint_run_grape: nil, format_response_grape: nil, json: '{}')
+        @datetime     = datetime
+        @datetimei    = datetimei.to_i unless datetimei.nil?
+        @format       = format
+        @path         = path
+        @status       = status
+        @method       = method
+        @request_id   = request_id
+
+        @endpoint_render_grape = endpoint_render_grape
+        @endpoint_run_grape    = endpoint_run_grape
+        @format_response_grape = format_response_grape
+
+        @json         = json
+      end
+
+      def record_hash
+        {
+          format: self.format,
+          status: self.status,
+          method: self.method,
+          path: self.path,
+          datetime: Time.at(self.datetimei.to_i),
+          datetimei: datetimei.to_i,
+          request_id: self.request_id,
+        }.merge(self.value)
+      end
+
+      def save
+        key   = "grape|datetime|#{datetime}|datetimei|#{datetimei}|format|#{format}|path|#{path}|status|#{status}|method|#{method}|request_id|#{request_id}|END|#{RailsPerformance::SCHEMA}"
+        value = { "endpoint_render.grape" => endpoint_render_grape, "endpoint_run.grape" => endpoint_run_grape, "format_response.grape" => format_response_grape }
+
+        Utils.save_to_redis(key, value)
+      end
+
+    end
+  end
+end

data/lib/rails_performance/models/rake_record.rb

@@ -0,0 +1,49 @@
+module RailsPerformance
+  module Models
+    class RakeRecord < BaseRecord
+      attr_accessor :task, :duration, :datetime, :datetimei, :status
+
+      # rake|task|["task3"]|datetime|20210416T1254|datetimei|1618602843|status|error|END|1.0.0
+      # {"duration":0.00012442}
+      def RakeRecord.from_db(key, value)
+        items = key.split("|")
+
+        RakeRecord.new(
+          task: JSON.parse(items[2]),
+          datetime: items[4],
+          datetimei: items[6],
+          status: items[8],
+          json: value
+        )
+      end
+
+      def initialize(task:, duration: nil, datetime:, datetimei:, status:, json: '{}')
+        @task         = Array.wrap(task)
+        @datetime     = datetime
+        @datetimei    = datetimei.to_i
+        @status       = status
+        @duration     = duration
+        @json         = json
+
+        @duration ||= value['duration']
+      end
+
+      def record_hash
+        {
+          task: task,
+          datetime: Time.at(datetimei),
+          datetimei: datetimei,
+          duration: duration,
+          status: status,
+        }
+      end
+
+      def save
+        key   = "rake|task|#{task.to_json}|datetime|#{datetime}|datetimei|#{datetimei}|status|#{status}|END|#{RailsPerformance::SCHEMA}"
+        value = { duration: duration }
+        Utils.save_to_redis(key, value)
+      end
+
+    end
+  end
+end

data/lib/rails_performance/models/request_record.rb

@@ -0,0 +1,111 @@
+module RailsPerformance
+  module Models
+    class RequestRecord < BaseRecord
+      attr_accessor :controller, :action, :format, :status, :datetime, :datetimei, :method, :path, :request_id, :json
+      attr_accessor :view_runtime, :db_runtime, :duration, :http_referer
+      attr_accessor :exception, :exception_object
+
+      def RequestRecord.find_by(request_id:)
+        keys, values = RailsPerformance::Utils.fetch_from_redis("performance|*|request_id|#{request_id}|*")
+
+        return nil if keys.blank?
+        return nil if values.blank?
+
+        RailsPerformance::Models::RequestRecord.from_db(keys[0], values[0])
+      end
+
+      # key = performance|
+      # controller|HomeController|
+      # action|index|
+      # format|html|
+      # status|200|
+      # datetime|20200124T0523|
+      # datetimei|1579861423|
+      # method|GET|
+      # path|/|
+      # request_id|454545454545454545|
+      # END|1.0.0
+      # = {"view_runtime":null,"db_runtime":0,"duration":27.329741000000002,"http_referer":null,"exception":"ZeroDivisionError divided by 0","backtrace":["/root/projects/rails_performance/test/dummy/app/controllers/account/site_controller.rb:17:in `/'","/root/projects/rails_performance/test/dummy/app/controllers/account/site_controller.rb:17:in `crash'","/usr/local/rvm/gems/ruby-2.6.3/gems/actionpack-6.1.3.1/lib/action_controller/metal/basic_implicit_render.rb:6:in `send_action'"]}
+      # value = JSON
+      def RequestRecord.from_db(key, value)
+        items = key.split("|")
+
+        RequestRecord.new(
+          controller: items[2],
+          action: items[4],
+          format: items[6],
+          status: items[8],
+          datetime: items[10],
+          datetimei: items[12],
+          method: items[14],
+          path: items[16],
+          request_id: items[18],
+          json: value
+        )
+      end
+
+      def initialize(controller:, action:, format:, status:, datetime:, datetimei:, method:, path:, request_id:, view_runtime: nil, db_runtime: nil, duration: nil, http_referer: nil, exception: nil, exception_object: nil, json: '{}')
+        @controller = controller
+        @action     = action
+        @format     = format
+        @status     = status
+        @datetime   = datetime
+        @datetimei  = datetimei.to_i
+        @method     = method
+        @path       = path
+        @request_id = request_id
+
+        @view_runtime = view_runtime
+        @db_runtime   = db_runtime
+        @duration     = duration
+        @http_referer = http_referer
+
+        @exception        = Array.wrap(exception).compact.join(" ")
+        @exception_object = exception_object
+
+        @json       = json
+      end
+
+      def controller_action
+        "#{controller}##{action}"
+      end
+
+      def controller_action_format
+        "#{controller}##{action}|#{format}"
+      end
+
+      def record_hash
+        {
+          controller: self.controller,
+          action: self.action,
+          format: self.format,
+          status: self.status,
+          method: self.method,
+          path: self.path,
+          request_id: self.request_id,
+          datetime: Time.at(self.datetimei.to_i),
+          datetimei: datetimei,
+          duration: self.value['duration'],
+          db_runtime: self.value['db_runtime'],
+          view_runtime: self.value['view_runtime'],
+          exception: self.value['exception'],
+          backtrace: self.value['backtrace']
+        }
+      end
+
+      def save
+        key   = "performance|controller|#{controller}|action|#{action}|format|#{format}|status|#{status}|datetime|#{datetime}|datetimei|#{datetimei}|method|#{method}|path|#{path}|request_id|#{request_id}|END|#{RailsPerformance::SCHEMA}"
+        value = {
+          view_runtime: view_runtime,
+          db_runtime: db_runtime,
+          duration: duration,
+          http_referer: http_referer,
+        }
+        value[:exception] = exception if exception.present?
+        value[:backtrace] = exception_object.backtrace.take(3) if exception_object
+        Utils.save_to_redis(key, value)
+      end
+
+    end
+  end
+end

data/lib/rails_performance/models/sidekiq_record.rb

@@ -0,0 +1,66 @@
+module RailsPerformance
+  module Models
+    class SidekiqRecord < BaseRecord
+      attr_accessor :queue, :worker, :jid, :datetimei, :enqueued_ati, :datetime, :start_timei, :status, :duration, :message
+
+      # key = job-performance
+      # |queue|default
+      # |worker|SimpleWorker
+      # |jid|7d48fbf20976c224510dbc60
+      # |datetime|20200124T0523
+      # |datetimei|1583146613
+      # |enqueued_ati|1583146613
+      # |start_timei|1583146614
+      # |status|success|END|1.0.0
+      # value = JSON
+      def SidekiqRecord.from_db(key, value)
+        items = key.split("|")
+
+        SidekiqRecord.new(
+          queue: items[2],
+          worker: items[4],
+          jid: items[6],
+          datetime: items[8],
+          datetimei: items[10],
+          enqueued_ati: items[12],
+          start_timei: items[14],
+          status: items[16],
+          json: value
+        )
+      end
+
+      def initialize(queue:, worker:, jid:, datetime:, datetimei:, enqueued_ati:, start_timei:, status: nil, duration: nil, json: "{}")
+        @queue        = queue
+        @worker       = worker
+        @jid          = jid
+        @datetime     = datetime
+        @datetimei    = datetimei.to_i
+        @enqueued_ati = enqueued_ati
+        @start_timei  = start_timei
+        @status       = status
+        @duration     = duration
+        @json         = json
+      end
+
+      def record_hash
+        {
+          worker: self.worker,
+          queue: self.queue,
+          jid: self.jid,
+          status: self.status,
+          datetimei: datetimei,
+          datetime: Time.at(self.start_timei.to_i),
+          duration: self.value['duration'],
+          message: value['message']
+        }
+      end
+
+      def save
+        key   = "sidekiq|queue|#{queue}|worker|#{worker}|jid|#{jid}|datetime|#{datetime}|datetimei|#{datetimei}|enqueued_ati|#{enqueued_ati}|start_timei|#{start_timei}|status|#{status}|END|#{RailsPerformance::SCHEMA}"
+        value = { message: message, duration: duration }
+        Utils.save_to_redis(key, value)
+      end
+
+    end
+  end
+end

data/lib/rails_performance/models/trace_record.rb

@@ -0,0 +1,19 @@
+module RailsPerformance
+  module Models
+    class TraceRecord < BaseRecord
+      attr_accessor :request_id, :value
+
+      def initialize(request_id:, value:)
+        @request_id = request_id
+        @value      = value
+      end
+
+      def save
+        return if value.empty?
+
+        Utils.save_to_redis("trace|#{request_id}|END|#{RailsPerformance::SCHEMA}", value, RailsPerformance::Reports::RecentRequestsReport::TIME_WINDOW.to_i)
+      end
+
+    end
+  end
+end

data/lib/rails_performance/rails/middleware.rb

@@ -1,5 +1,34 @@
 module RailsPerformance
   module Rails
+    class MiddlewareTraceStorerAndCleanup
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
+        if %r{#{RailsPerformance.mount_at}}.match?(env["PATH_INFO"])
+          RailsPerformance.skip = true
+        end
+
+        @status, @headers, @response = @app.call(env)
+
+        if !RailsPerformance.skip
+          RailsPerformance::Models::TraceRecord.new(
+            request_id: CurrentRequest.current.request_id,
+            value: CurrentRequest.current.tracings
+          ).save
+        end
+
+        CurrentRequest.cleanup
+
+        [@status, @headers, @response]
+      end
+    end
+
     class Middleware
       def initialize(app)
         @app = app
@@ -13,24 +42,21 @@ module RailsPerformance
         @status, @headers, @response = @app.call(env)
 
         #t = Time.now
-        if record = CurrentRequest.current.record
-          begin
-            record[:status]   ||= @status # for 500 errors
-            record[:request_id] = CurrentRequest.current.request_id
-
-            # capture referer from where this page was opened
-            if record[:status] == 404
-              record[:HTTP_REFERER] = env["HTTP_REFERER"]
-            end
+        if !RailsPerformance.skip
+          if !CurrentRequest.current.ignore.include?(:performance) # grape is executed first, and than ignore regular future storage of "controller"-like request
+            if data = CurrentRequest.current.data
+              record = RailsPerformance::Models::RequestRecord.new(**data.merge({request_id: CurrentRequest.current.request_id}))
 
-            # store for section "recent requests"
-            RP::Utils.log_trace_in_redis(CurrentRequest.current.request_id, CurrentRequest.current.storage)
+              # for 500 errors
+              record.status ||= @status
 
-            # store request information
-            RP::Utils.log_request_in_redis(record)
-          ensure
-            # we don't want to have a memory leak
-            CurrentRequest.cleanup
+              # capture referer from where this page was opened
+              record.http_referer = env["HTTP_REFERER"] if record.status == 404
+
+              # store for section "recent requests"
+              # store request information (regular rails request)
+              record.save
+            end
           end
         end
         #puts "==> store performance data: #{(Time.now - t).round(3)}ms"

data/lib/rails_performance/rails/query_builder.rb

@@ -1,5 +1,5 @@
 module RailsPerformance
-  module Rails  
+  module Rails
     class QueryBuilder
 
       def QueryBuilder.compose_from(params)

data/lib/rails_performance/reports/breakdown_report.rb

@@ -3,25 +3,13 @@ module RailsPerformance
     class BreakdownReport < BaseReport
 
       def set_defaults
-        @sort ||= :datetime
+        @sort ||= :datetimei
       end
 
       def data
-        db.data.collect do |record|
-          {
-            controller: record.controller,
-            action: record.action,
-            format: record.format,
-            status: record.status,
-            method: record.method,
-            path: record.path,
-            datetime: Time.at(record.datetimei.to_i),
-            duration: record.value['duration'],
-            db_runtime: record.value['db_runtime'],
-            view_runtime: record.value['view_runtime'],
-          }
-        end
-        .sort{|a, b| b[sort] <=> a[sort]}
+        db.data
+          .collect{|e| e.record_hash}
+          .sort{|a, b| b[sort] <=> a[sort]}
       end
     end
 

data/lib/rails_performance/reports/crash_report.rb

@@ -2,24 +2,13 @@ module RailsPerformance
   module Reports
     class CrashReport < BaseReport
       def set_defaults
-        @sort ||= :datetime
+        @sort ||= :datetimei
       end
 
       def data
-        db.data.collect do |record|
-          {
-            controller: record.controller,
-            action: record.action,
-            format: record.format,
-            status: record.status,
-            method: record.method,
-            path: record.path,
-            datetime: Time.parse(record.datetime),
-            duration: record.value['duration'],
-            db_runtime: record.value['db_runtime'],
-            view_runtime: record.value['view_runtime'],
-          }
-        end.sort{|a, b| b[sort] <=> a[sort]}
+        db.data
+          .collect{|e| e.record_hash}
+          .sort{|a, b| b[sort] <=> a[sort]}
       end
     end