rails_performance 0.9.5 → 1.0.0.beta1

data/lib/rails_performance/models/base_record.rb

@@ -1,6 +1,18 @@
 module RailsPerformance
   module Models
     class BaseRecord
+      def self.from_db(key, value)
+        raise 'implement me'
+      end
+
+      def save
+        raise 'implement me'
+      end
+
+      def record_hash
+        raise 'implement me'
+      end
+
       def value
         @value ||= JSON.parse(@json || "{}")
       end

data/lib/rails_performance/models/custom_record.rb

@@ -0,0 +1,48 @@
+module RailsPerformance
+  module Models
+    class CustomRecord < BaseRecord
+      attr_accessor :tag_name, :namespace_name, :duration, :datetime, :datetimei, :status, :json
+
+      def CustomRecord.from_db(key, value)
+        items = key.split("|")
+
+        CustomRecord.new(
+          tag_name: items[2],
+          namespace_name: items[4],
+          datetime: items[6],
+          datetimei: items[8],
+          status: items[10],
+          json: value
+        )
+      end
+
+      def initialize(tag_name:, namespace_name: nil, duration: nil, datetime:, datetimei:, status:, json: '{}')
+        @tag_name       = tag_name
+        @namespace_name = namespace_name
+        @duration       = duration
+        @datetime       = datetime
+        @datetimei      = datetimei.to_i
+        @status         = status
+        @json           = json
+      end
+
+      def record_hash
+        {
+          tag_name: self.tag_name,
+          namespace_name: self.namespace_name,
+          status: self.status,
+          datetimei: datetimei,
+          datetime: Time.at(self.datetimei.to_i),
+          duration: self.value['duration'],
+        }
+      end
+
+      def save
+        key   = "custom|tag_name|#{tag_name}|namespace_name|#{namespace_name}|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/delayed_job_record.rb

@@ -0,0 +1,62 @@
+module RailsPerformance
+  module Models
+    class DelayedJobRecord < BaseRecord
+      attr_accessor :jid, :duration, :datetime, :datetimei, :source_type, :class_name, :method_name, :status, :json
+
+      # delayed_job
+      #|jid|22
+      #|datetime|20210415T0616
+      #|datetimei|1618492591
+      #|source_type|instance_method
+      #|class_name|User
+      #|method_name|say_hello_without_delay
+      #|status|success|END|1.0.0
+      def DelayedJobRecord.from_db(key, value)
+        items = key.split("|")
+
+        DelayedJobRecord.new(
+          jid: items[2],
+          datetime: items[4],
+          datetimei: items[6],
+          source_type: items[8],
+          class_name: items[10],
+          method_name: items[12],
+          status: items[14],
+          json: value
+        )
+      end
+
+      def initialize(jid:, duration: nil, datetime:, datetimei:, source_type:, class_name:, method_name:, status:, json: '{}')
+        @jid          = jid
+        @duration     = duration
+        @datetime     = datetime
+        @datetimei    = datetimei.to_i
+        @source_type  = source_type
+        @class_name   = class_name
+        @method_name  = method_name
+        @status       = status
+        @json         = json
+      end
+
+      def record_hash
+        {
+          jid: jid,
+          datetime: Time.at(datetimei),
+          datetimei: datetimei,
+          duration: value['duration'],
+          status: status,
+          source_type: source_type,
+          class_name: class_name,
+          method_name: method_name,
+        }
+      end
+
+      def save
+        key   = "delayed_job|jid|#{jid}|datetime|#{datetime}|datetimei|#{datetimei}|source_type|#{source_type}|class_name|#{class_name}|method_name|#{method_name}|status|#{status}|END|#{RailsPerformance::VERSION}"
+        value = { duration: duration }
+        Utils.save_to_redis(key, value)
+      end
+
+    end
+  end
+end

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::VERSION}"
+        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::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"