rails_performance 0.9.9 → 1.0.0.beta1

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::VERSION}"
+        value = { duration: duration }
+        Utils.save_to_redis(key, value)
+      end
+
+    end
+  end
+end

data/lib/rails_performance/models/request_record.rb

@@ -0,0 +1,98 @@
+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
+
+      def RequestRecord.find_by(request_id:)
+        keys, values = RP::Utils.fetch_from_redis("performance|*|request_id|#{request_id}|*")
+
+        return nil if keys.blank?
+        return nil if values.blank?
+
+        RP::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":8.444603008683771,"db_runtime":0,"duration":9.216095000000001}
+      # 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, 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
+
+        @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'],
+        }
+      end
+
+      def save
+        value = { view_runtime: view_runtime, db_runtime: db_runtime, duration: duration, http_referer: http_referer }
+        key   = "performance|controller|#{controller}|action|#{action}|format|#{format}|status|#{status}|datetime|#{datetime}|datetimei|#{datetimei}|method|#{method}|path|#{path}|request_id|#{request_id}|END|#{RailsPerformance::VERSION}"
+        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::VERSION}"
+        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::VERSION}", 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
 

data/lib/rails_performance/reports/recent_requests_report.rb

@@ -4,53 +4,16 @@ module RailsPerformance
       TIME_WINDOW = 60.minutes
 
       def set_defaults
-        @sort ||= :datetime
+        @sort ||= :datetimei
       end
 
-      def data(type = :requests) # most popular type
-        db.data.collect do |record|
-          case type
-          when :requests
-            record_hash(record)
-          when :jobs
-            job_hash(record)
-          end
-        end
-        .select{|e| e if e[:datetime] >= TIME_WINDOW.ago}
-        .sort{|a, b| b[sort] <=> a[sort]}
-      end
-
-      private
-
-      def record_hash(record)
-        {
-          controller: record.controller,
-          action: record.action,
-          format: record.format,
-          status: record.status,
-          method: record.method,
-          path: record.path,
-          request_id: record.request_id,
-          datetime: Time.at(record.datetimei.to_i),
-          duration: record.value['duration'],
-          db_runtime: record.value['db_runtime'],
-          view_runtime: record.value['view_runtime'],
-        }
-      end
-
-      def job_hash(record)
-        {
-          worker: record.worker,
-          queue: record.queue,
-          
-          jid: record.jid,
-          status: record.status,
-          datetime: Time.at(record.start_timei.to_i),
-          duration: record.value['duration'],
-        }
+      def data
+        time_agoi = TIME_WINDOW.ago.to_i
+        db.data
+          .collect{|e| e.record_hash}
+          .select{|e| e if e[sort] >= time_agoi}
+          .sort{|a, b| b[sort] <=> a[sort]}
       end
     end
-
-
   end
 end

data/lib/rails_performance/reports/trace_report.rb

@@ -8,7 +8,7 @@ module RailsPerformance
       end
 
       def data
-        key   = "trace|#{request_id}"
+        key   = "trace|#{request_id}|END|#{RailsPerformance::VERSION}"
         JSON.parse(RP.redis.get(key).presence || '[]')
       end
     end