rails_performance 0.9.9 → 1.0.0.beta1

data/lib/rails_performance/extensions/{capture_everything.rb → trace.rb}

@@ -3,7 +3,7 @@ module RailsPerformance
     module View
 
       def info(&block)
-        CurrentRequest.current.store({
+        CurrentRequest.current.trace({
           group: :view,
           message: block.call
         })
@@ -19,7 +19,7 @@ module RailsPerformance
     module Db
 
       def sql(event)
-        CurrentRequest.current.store({
+        CurrentRequest.current.trace({
           group: :db,
           duration: event.duration.round(2),
           sql: event.payload[:sql]

data/lib/rails_performance/gems/custom_ext.rb

@@ -0,0 +1,33 @@
+module RailsPerformance
+  module Gems
+    module CustomExtension
+      extend self
+
+      def measure(tag_name, namespace_name = nil)
+        return yield unless RailsPerformance.enabled
+
+        begin
+          now    = Time.now
+          status = 'success'
+          result = yield
+          result
+        rescue Exception => ex
+          status = 'error'
+          raise(ex)
+        ensure
+          RailsPerformance::Models::CustomRecord.new(
+            tag_name: tag_name,
+            namespace_name: namespace_name,
+            status: status,
+            duration: (Time.now - now) * 1000,
+            datetime: now.strftime(RailsPerformance::FORMAT),
+            datetimei: now.to_i,
+          ).save
+
+          result
+        end
+      end
+
+    end
+  end
+end

data/lib/rails_performance/gems/delayed_job_ext.rb

@@ -0,0 +1,54 @@
+module RailsPerformance
+  module Gems
+    class DelayedJobExt
+
+      class Plugin < ::Delayed::Plugin
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job) do |job, *args, &block|
+            begin
+              now = Time.now
+              block.call(job, *args)
+              status = 'success'
+            rescue Exception => error
+              status = 'error'
+              raise error
+            ensure
+              meta_data = RailsPerformance::Gems::DelayedJobExt::Plugin.meta(job.payload_object)
+              record    = RailsPerformance::Models::DelayedJobRecord.new(
+                jid: job.id,
+                duration: (Time.now - now) * 1000,
+                datetime: now.strftime(RailsPerformance::FORMAT),
+                datetimei: now.to_i,
+                source_type: meta_data[0],
+                class_name: meta_data[1],
+                method_name: meta_data[2],
+                status: status
+              )
+              record.save
+            end
+          end
+        end
+
+        # [source_type, class_name, method_name, duration]
+        def self.meta(payload_object)
+          if payload_object.is_a?(::Delayed::PerformableMethod)
+            if payload_object.object.is_a?(Module)
+              [:class_method, payload_object.object.name, payload_object.method_name.to_s]
+            else
+              [:instance_method, payload_object.object.class.name, payload_object.method_name.to_s]
+            end
+          else
+            [:instance_method, payload_object.class.name, "perform"]
+          end
+        rescue
+          [:unknown, :unknown, :unknown]
+        end
+      end
+
+      def self.init
+        ::Delayed::Worker.plugins += [::RailsPerformance::Gems::DelayedJobExt::Plugin]
+      end
+
+    end
+  end
+end

data/lib/rails_performance/gems/grape_ext.rb

@@ -0,0 +1,35 @@
+module RailsPerformance
+  module Gems
+    class GrapeExt
+
+      def self.init
+        ActiveSupport::Notifications.subscribe(/grape/) do |name, start, finish, id, payload|
+          # TODO change to set
+          CurrentRequest.current.ignore.add(:performance)
+
+          now                                           = Time.now
+          CurrentRequest.current.data               ||= {}
+          CurrentRequest.current.record             ||= RailsPerformance::Models::GrapeRecord.new(request_id: CurrentRequest.current.request_id)
+          CurrentRequest.current.record.datetimei   ||= now.to_i
+          CurrentRequest.current.record.datetime    ||= now.strftime(RailsPerformance::FORMAT)
+
+          if ['endpoint_render.grape', 'endpoint_run.grape', 'format_response.grape'].include?(name)
+            CurrentRequest.current.record.send(name.gsub(".", "_") + "=", (finish - start) * 1000)
+          end
+
+          if payload[:env]
+            CurrentRequest.current.record.status      = payload[:env]['api.endpoint'].status
+            CurrentRequest.current.record.format      = payload[:env]["api.format"]
+            CurrentRequest.current.record.method      = payload[:env]['REQUEST_METHOD']
+            CurrentRequest.current.record.path        = payload[:env]["PATH_INFO"]
+          end
+
+          if name == 'format_response.grape'
+            CurrentRequest.current.record.save
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rails_performance/gems/rake_ext.rb

@@ -0,0 +1,40 @@
+module RailsPerformance
+  module Gems
+
+    class RakeExt
+      def self.init
+        ::Rake::Task.class_eval do
+          def invoke_with_rails_performance(*args)
+            begin
+              now    = Time.now
+              status = 'success'
+              invoke_without_new_rails_performance(*args)
+            rescue Exception => ex
+              status = 'error'
+              raise(ex)
+            ensure
+              RailsPerformance::Models::RakeRecord.new(
+                task: RailsPerformance::Gems::RakeExt.find_task_name(*args),
+                datetime: now.strftime(RailsPerformance::FORMAT),
+                datetimei: now.to_i,
+                duration: (Time.now - now) * 1000,
+                status: status,
+              ).save
+            end
+          end
+
+          alias_method :invoke_without_new_rails_performance, :invoke
+          alias_method :invoke, :invoke_with_rails_performance
+
+          def invoke(*args)
+            invoke_with_rails_performance(*args)
+          end
+        end
+      end
+
+      def self.find_task_name(*args)
+        (ARGV + args).compact
+      end
+    end
+  end
+end

data/lib/rails_performance/gems/{sidekiq.rb → sidekiq_ext.rb}

@@ -1,33 +1,34 @@
 module RailsPerformance
   module Gems
-    class Sidekiq
+    class SidekiqExt
 
       def initialize(options=nil)
       end
 
       def call(worker, msg, queue)
-        now  = Time.now
-        data = {
+        now    = Time.now
+        record = RP::Models::SidekiqRecord.new(
           enqueued_ati: msg['enqueued_at'].to_i,
-          created_ati: msg['created_at'].to_i,
+          datetimei: msg['created_at'].to_i,
           jid: msg['jid'],
           queue: queue,
           start_timei: now.to_i,
           datetime: now.strftime(RailsPerformance::FORMAT),
           worker: msg['wrapped'.freeze] || worker.class.to_s
-        }
+        )
         begin
-          yield
-          data[:status]   = "success"
+          result = yield
+          record.status = "success"
+          result
         rescue Exception => ex
-          data[:status]   = "exception"
-          data[:message]  = ex.message
+          record.status   = "exception"
+          record.message  = ex.message
           raise ex
         ensure
           # store in ms instead of seconds
-          data[:duration] = (Time.now - now) * 1000
-          #puts data
-          RailsPerformance::Utils.log_job_in_redis(data)
+          record.duration = (Time.now - now) * 1000
+          record.save
+          result
         end
       end
 

data/lib/rails_performance/instrument/metrics_collector.rb

@@ -16,9 +16,10 @@ module RailsPerformance
       # }
 
       def call(event_name, started, finished, event_id, payload)
+        return if RailsPerformance.skip
+        # TODO do we need this new?
         event = ActiveSupport::Notifications::Event.new(event_name, started, finished, event_id, payload)
 
-        return if %r{#{RailsPerformance.mount_at}}.match? event.payload[:path]
         return if RailsPerformance.ignored_endpoints.include? "#{event.payload[:controller]}##{event.payload[:action]}"
 
         record = {
@@ -35,7 +36,7 @@ module RailsPerformance
           duration: event.duration
         }
 
-        CurrentRequest.current.record = record
+        CurrentRequest.current.data = record
       end
     end
   end

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