rails_performance 0.9.7 → 1.0.0.beta3

data/lib/rails_performance/engine.rb

@@ -1,3 +1,4 @@
+require 'action_view/log_subscriber'
 require_relative './rails/middleware.rb'
 require_relative './models/collection.rb'
 require_relative './instrument/metrics_collector.rb'
@@ -6,36 +7,56 @@ module RailsPerformance
   class Engine < ::Rails::Engine
     isolate_namespace RailsPerformance
 
-    if RailsPerformance.try(:enabled) # for rails c
+    initializer "rails_performance.middleware" do |app|
+      next unless RailsPerformance.enabled
 
       if ::Rails::VERSION::MAJOR.to_i >= 5
-        config.app_middleware.insert_after ActionDispatch::Executor, RailsPerformance::Rails::Middleware
+        app.middleware.insert_after ActionDispatch::Executor, RailsPerformance::Rails::Middleware
       else
-        config.app_middleware.insert_after ActionDispatch::Static, RailsPerformance::Rails::Middleware
+        app.middleware.insert_after ActionDispatch::Static, RailsPerformance::Rails::Middleware
       end
+      # look like it works in reverse order?
+      app.middleware.insert_before RailsPerformance::Rails::Middleware, RailsPerformance::Rails::MiddlewareTraceStorerAndCleanup
 
-      initializer :configure_metrics, after: :initialize_logger do
-        ActiveSupport::Notifications.subscribe(
-          "process_action.action_controller",
-          RailsPerformance::Instrument::MetricsCollector.new
-        )
-
-        config.after_initialize do |app|
-          ActionView::LogSubscriber.send :prepend, RailsPerformance::Extensions::View
-          ActiveRecord::LogSubscriber.send :prepend, RailsPerformance::Extensions::Db
-        end
-      end
-
-      if const_defined?("Sidekiq")
-        require_relative './gems/sidekiq.rb'
+      if defined?(::Sidekiq)
+        require_relative './gems/sidekiq_ext.rb'
         Sidekiq.configure_server do |config|
           config.server_middleware do |chain|
-            chain.add RailsPerformance::Gems::Sidekiq
+            chain.add RailsPerformance::Gems::SidekiqExt
           end
         end
       end
 
+      if defined?(::Grape)
+        require_relative './gems/grape_ext.rb'
+        RailsPerformance::Gems::GrapeExt.init
+      end
+
+      if defined?(::Delayed::Job)
+        require_relative './gems/delayed_job_ext.rb'
+        RailsPerformance::Gems::DelayedJobExt.init
+      end
+    end
+
+    initializer :configure_metrics, after: :initialize_logger do
+      next unless RailsPerformance.enabled
+
+      ActiveSupport::Notifications.subscribe(
+        "process_action.action_controller",
+        RailsPerformance::Instrument::MetricsCollector.new
+      )
     end
 
+    config.after_initialize do
+      next unless RailsPerformance.enabled
+
+      ActionView::LogSubscriber.send :prepend, RailsPerformance::Extensions::View
+      ActiveRecord::LogSubscriber.send :prepend, RailsPerformance::Extensions::Db
+    end
+
+    if defined?(::Rake::Task)
+      require_relative './gems/rake_ext.rb'
+      RailsPerformance::Gems::RakeExt.init
+    end
   end
 end

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 = RailsPerformance::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,10 +16,11 @@ 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)
 
-        mount_url = RailsPerformance.mount_at || "/rails/performance/"
-        return if event.payload[:path] =~ /^#{Regexp.escape(mount_url)}/ 
+        return if RailsPerformance.ignored_endpoints.include? "#{event.payload[:controller]}##{event.payload[:action]}"
 
         record = {
           controller: event.payload[:controller],
@@ -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::SCHEMA}"
+        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::SCHEMA}"
+        value = { duration: duration }
+        Utils.save_to_redis(key, value)
+      end
+
+    end
+  end
+end