rails_performance 0.9.5 → 1.0.0.beta1

data/lib/rails_performance/data_source.rb

@@ -1,20 +1,27 @@
 module RailsPerformance
   class DataSource
+    KLASSES = {
+      requests: RailsPerformance::Models::RequestRecord,
+      sidekiq: RailsPerformance::Models::SidekiqRecord,
+      delayed_job: RailsPerformance::Models::DelayedJobRecord,
+      grape: RailsPerformance::Models::GrapeRecord,
+      rake: RailsPerformance::Models::RakeRecord,
+      custom: RailsPerformance::Models::CustomRecord,
+    }
+
     attr_reader :q, :klass, :type
 
-    def initialize(q: {}, type:, klass:)
-      @klass   = klass
+    def initialize(q: {}, type:)
       @type    = type
+      @klass   = KLASSES[type]
       q[:on] ||= Date.today
       @q       = q
-
-      #puts "  [DataSource Q]  -->  #{@q.inspect}\n\n"
     end
 
     def db
       result = RP::Models::Collection.new
       (RP::Utils.days + 1).times do |e|
-        RP::DataSource.new(q: self.q.merge({ on: e.days.ago.to_date }), klass: klass, type: type).add_to(result)
+        RP::DataSource.new(q: self.q.merge({ on: e.days.ago.to_date }), type: type).add_to(result)
       end
       result
     end
@@ -36,7 +43,7 @@ module RailsPerformance
       return [] if keys.blank?
 
       keys.each_with_index do |key, index|
-        yield klass.new(key, values[index])
+        yield klass.from_db(key, values[index])
       end
     end
 
@@ -45,9 +52,17 @@ module RailsPerformance
     def query
       case type
       when :requests
-        "performance|*#{compile_requests_query}*|END"
-      when :jobs
-        "jobs|*#{compile_jobs_query}*|END"
+        "performance|*#{compile_requests_query}*|END|#{RailsPerformance::VERSION}"
+      when :sidekiq
+        "sidekiq|*#{compile_sidekiq_query}*|END|#{RailsPerformance::VERSION}"
+      when :delayed_job
+        "delayed_job|*#{compile_delayed_job_query}*|END|#{RailsPerformance::VERSION}"
+      when :grape
+        "grape|*#{compile_grape_query}*|END|#{RailsPerformance::VERSION}"
+      when :rake
+        "rake|*#{compile_rake_query}*|END|#{RailsPerformance::VERSION}"
+      when :custom
+        "custom|*#{compile_custom_query}*|END|#{RailsPerformance::VERSION}"
       else
         raise "wrong type for datasource query builder"
       end
@@ -55,7 +70,6 @@ module RailsPerformance
 
     def compile_requests_query
       str = []
-
       str << "controller|#{q[:controller]}|" if q[:controller].present?
       str << "action|#{q[:action]}|" if q[:action].present?
       str << "format|#{q[:format]}|" if q[:format].present?
@@ -63,18 +77,43 @@ module RailsPerformance
       str << "datetime|#{q[:on].strftime('%Y%m%d')}*|" if q[:on].present?
       str << "method|#{q[:method]}|" if q[:method].present?
       str << "path|#{q[:path]}|" if q[:path].present?
-
       str.join("*")
     end
 
-    def compile_jobs_query
+    def compile_sidekiq_query
       str = []
-
       str << "queue|#{q[:queue]}|" if q[:queue].present?
       str << "worker|#{q[:worker]}|" if q[:worker].present?
       str << "datetime|#{q[:on].strftime('%Y%m%d')}*|" if q[:on].present?
       str << "status|#{q[:status]}|" if q[:status].present?
+      str.join("*")
+    end
+
+    def compile_delayed_job_query
+      str = []
+      str << "datetime|#{q[:on].strftime('%Y%m%d')}*|" if q[:on].present?
+      str << "status|#{q[:status]}|" if q[:status].present?
+      str.join("*")
+    end
+
+    def compile_rake_query
+      str = []
+      str << "datetime|#{q[:on].strftime('%Y%m%d')}*|" if q[:on].present?
+      str << "status|#{q[:status]}|" if q[:status].present?
+      str.join("*")
+    end
+
+    def compile_custom_query
+      str = []
+      str << "datetime|#{q[:on].strftime('%Y%m%d')}*|" if q[:on].present?
+      str << "status|#{q[:status]}|" if q[:status].present?
+      str.join("*")
+    end
 
+    def compile_grape_query
+      str = []
+      str << "datetime|#{q[:on].strftime('%Y%m%d')}*|" if q[:on].present?
+      str << "status|#{q[:status]}|" if q[:status].present?
       str.join("*")
     end
 

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,32 +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,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)
 
-        return if event.payload[:path] =~ /^\/rails\/performance/
+        return if RailsPerformance.ignored_endpoints.include? "#{event.payload[:controller]}##{event.payload[:action]}"
 
         record = {
           controller: event.payload[:controller],
@@ -34,8 +36,8 @@ module RailsPerformance
           duration: event.duration
         }
 
-        CurrentRequest.current.record = record
+        CurrentRequest.current.data = record
       end
     end
   end
-end
+end