rorvswild 0.6.1 → 1.0.0.pre.alpha

data/lib/rorvswild/installer.rb

@@ -23,7 +23,6 @@ development:
 
 production:
   api_key: #{api_key}
-  # explain_sql_threshold: 500  # Execute EXPLAIN for queries above the specified time in ms.
   # ignored_exceptions:
   #   - ActionController::RoutingError
   #   - UncommentToIgnoreAnyExceptionNameListedHere

data/lib/rorvswild/location.rb

@@ -1,26 +1,13 @@
 module RorVsWild
   module Location
-    def self.cleanup_method_name(method)
-      method.sub!("block in ".freeze, "".freeze)
-      method.sub!("in `".freeze, "".freeze)
-      method.sub!("'".freeze, "".freeze)
-      method.index("_app_views_".freeze) == 0 ? nil : method
+    def find_most_relevant_location(locations)
+      result = locations.find { |l| l.path.index(app_root) == 0 && !(l.path =~ gem_home_regex) } if app_root
+      result || locations.find { |l| !(l.path =~ gem_home_regex) } || locations.first
     end
 
-    def self.split_file_location(location)
-      file, line, method = location.split(":")
-      method = cleanup_method_name(method) if method
-      [file, line, method]
-    end
-
-    def extract_most_relevant_location(stack)
-      location = stack.find { |str| str =~ app_root_regex && !(str =~ gem_home_regex) } if app_root_regex
-      location ||= stack.find { |str| !(str =~ gem_home_regex) } if gem_home_regex
-      RorVsWild::Location.split_file_location(relative_path(location || stack.first))
-    end
-
-    def app_root_regex
-      @app_root_regex ||= RorVsWild.default_client.app_root ? /\A#{RorVsWild.default_client.app_root}/ : nil
+    def extract_most_relevant_file_and_line(stack)
+      location = find_most_relevant_location(stack)
+      [relative_path(location.path), location.lineno]
     end
 
     def gem_home_regex
@@ -28,6 +15,10 @@ module RorVsWild
     end
 
     def gem_home
+      @gem_home ||= guess_gem_home
+    end
+
+    def guess_gem_home
       if ENV["GEM_HOME"] && !ENV["GEM_HOME"].empty?
         ENV["GEM_HOME"]
       elsif ENV["GEM_PATH"] && !(first_gem_path = ENV["GEM_PATH"].split(":").first)

data/lib/rorvswild/plugin/action_controller.rb

@@ -0,0 +1,46 @@
+module RorVsWild
+  module Plugin
+    class ActionController
+      def self.setup
+        return if @installed
+        return unless defined?(::ActionController::Base)
+        ActiveSupport::Notifications.subscribe("process_action.action_controller", new)
+        ::ActionController::Base.around_action(&method(:around_action))
+        ::ActionController::Base.rescue_from(StandardError) { |ex| RorVsWild::Plugin::ActionController.after_exception(ex, self) }
+        @installed = true
+      end
+
+      def self.after_exception(exception, controller)
+        if hash = RorVsWild.agent.push_exception(exception)
+          hash[:session] = controller.session.to_hash
+          hash[:environment_variables] = controller.request.filtered_env
+        end
+        raise exception
+      end
+
+      def self.around_action(controller, block)
+        begin
+          RorVsWild::Section.start do |section|
+            method_name = controller.method_for_action(controller.action_name)
+            section.file, section.line = controller.method(method_name).source_location
+            section.command = "#{controller.class}##{method_name}"
+            section.kind = "code".freeze
+          end
+          block.call
+        ensure
+          RorVsWild::Section.stop
+        end
+      end
+
+      # Payload: controller, action, params, format, method, path
+      def start(name, id, payload)
+        name = "#{payload[:controller]}##{payload[:action]}"
+        RorVsWild.agent.start_request(name: name, path: payload[:path])
+      end
+
+      def finish(name, id, payload)
+        RorVsWild.agent.stop_request
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/action_mailer.rb

@@ -0,0 +1,23 @@
+module RorVsWild
+  module Plugin
+    class ActionMailer
+      def self.setup
+        return if @installed
+        return unless defined?(::ActiveSupport::Notifications.subscribe)
+        ActiveSupport::Notifications.subscribe("deliver.action_mailer", new)
+        @installed = true
+      end
+
+      def start(name, id, payload)
+        RorVsWild::Section.start
+      end
+
+      def finish(name, id, payload)
+        RorVsWild::Section.stop do |section|
+          section.command = payload[:mailer]
+          section.kind = "mail".freeze
+        end
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/action_view.rb

@@ -0,0 +1,26 @@
+module RorVsWild
+  module Plugin
+    class ActionView
+      def self.setup
+        return if @installed
+        return unless defined?(::ActiveSupport::Notifications.subscribe)
+        ActiveSupport::Notifications.subscribe("render_partial.action_view", new)
+        ActiveSupport::Notifications.subscribe("render_template.action_view", new)
+        @installed = true
+      end
+
+      def start(name, id, payload)
+        RorVsWild::Section.start
+      end
+
+      def finish(name, id, payload)
+        RorVsWild::Section.stop do |section|
+          section.kind = "view".freeze
+          section.command = RorVsWild.agent.relative_path(payload[:identifier])
+          section.file = section.command
+          section.line = 1
+        end
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/active_job.rb

@@ -0,0 +1,16 @@
+module RorVsWild
+  module Plugin
+    module ActiveJob
+      def self.setup
+        return if @installed
+        return unless defined?(::ActiveJob::Base)
+        ::ActiveJob::Base.around_perform(&method(:around_perform))
+        @installed = true
+      end
+
+      def self.around_perform(job, block)
+        RorVsWild.measure_block(job.class.name, &block)
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/active_record.rb

@@ -0,0 +1,31 @@
+module RorVsWild
+  module Plugin
+    class ActiveRecord
+      def self.setup
+        return if @installed
+        setup_callback
+        @installed = true
+      end
+
+      def self.setup_callback
+        return unless defined?(::ActiveSupport::Notifications.subscribe)
+        ActiveSupport::Notifications.subscribe("sql.active_record", new)
+      end
+
+      IGNORED_QUERIES = %w[EXPLAIN SCHEMA].freeze
+
+      def start(name, id, payload)
+        return if IGNORED_QUERIES.include?(payload[:name])
+        RorVsWild::Section.start do |section|
+          section.command = payload[:sql]
+          section.kind = "sql".freeze
+        end
+      end
+
+      def finish(name, id, payload)
+        return if IGNORED_QUERIES.include?(payload[:name])
+        RorVsWild::Section.stop
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/delayed_job.rb

@@ -0,0 +1,16 @@
+module RorVsWild
+  module Plugin
+    module DelayedJob
+      def self.setup
+        return if @installed
+        return unless defined?(Delayed::Worker)
+        Delayed::Worker.lifecycle.around(:invoke_job, &method(:around_perform))
+        @installed = true
+      end
+
+      def self.around_perform(job, &block)
+        RorVsWild.measure_block(job.name) { block.call(job) }
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/mongo.rb

@@ -15,6 +15,7 @@ module RorVsWild
       end
 
       def started(event)
+        RorVsWild::Section.start
         commands[event.request_id] = event.command
       end
 
@@ -27,10 +28,10 @@ module RorVsWild
       end
 
       def after_query(event)
-        runtime = event.duration * 1000
-        command = commands.delete(event.request_id).to_s
-        file, line, method = RorVsWild.client.extract_most_relevant_location(caller)
-        RorVsWild.client.send(:push_query, kind: "mongo", command: command, file: file, line: line, method: method, runtime: runtime)
+        RorVsWild::Section.stop do |section|
+          section.kind = "mongo".freeze
+          section.command = commands.delete(event.request_id).to_s
+        end
       end
     end
   end

data/lib/rorvswild/plugin/net_http.rb

@@ -1,6 +1,9 @@
 module RorVsWild
   module Plugin
     class NetHttp
+      HTTP = "http".freeze
+      HTTPS = "https".freeze
+
       def self.setup
         return if !defined?(Net::HTTP)
         return if Net::HTTP.method_defined?(:request_without_rorvswild)
@@ -9,12 +12,19 @@ module RorVsWild
           alias_method :request_without_rorvswild, :request
 
           def request(req, body = nil, &block)
-            scheme = use_ssl? ? "https".freeze : "http".freeze
+            return request_without_rorvswild(req, body, &block) if request_called_twice?
+            scheme = use_ssl? ? HTTPS : HTTP
             url = "#{req.method} #{scheme}://#{address}#{req.path}"
-            RorVsWild.client.measure_query("http".freeze, url) do
+            RorVsWild.agent.measure_section(url, HTTP) do
               request_without_rorvswild(req, body, &block)
             end
           end
+
+          def request_called_twice?
+            # Net::HTTP#request calls itself when connection is not started.
+            # This condition prevents from counting twice the request.
+            (current_section = RorVsWild::Section.current) && current_section.kind == HTTP
+          end
         end
       end
     end

data/lib/rorvswild/plugin/redis.rb

@@ -9,7 +9,7 @@ module RorVsWild
 
           def process(commands, &block)
             string = RorVsWild::Plugin::Redis.commands_to_string(commands)
-            RorVsWild.client.measure_query("redis".freeze, string) do
+            RorVsWild.agent.measure_block(string, "redis".freeze) do
               process_without_rorvswild(commands, &block)
             end
           end

data/lib/rorvswild/plugins.rb

@@ -0,0 +1,14 @@
+require "rorvswild/plugin/net_http"
+
+require "rorvswild/plugin/redis"
+require "rorvswild/plugin/mongo"
+
+require "rorvswild/plugin/resque"
+require "rorvswild/plugin/sidekiq"
+require "rorvswild/plugin/active_job"
+require "rorvswild/plugin/delayed_job"
+
+require "rorvswild/plugin/action_view"
+require "rorvswild/plugin/active_record"
+require "rorvswild/plugin/action_mailer"
+require "rorvswild/plugin/action_controller"

data/lib/rorvswild/rails_loader.rb

@@ -13,7 +13,7 @@ module RorVsWild
       return if @started
       if (path = Rails.root.join("config/rorvswild.yml")).exist?
         if config = RorVsWild::RailsLoader.load_config_file(path)[Rails.env]
-          RorVsWild::Client.new(config.symbolize_keys)
+          RorVsWild.start(config.symbolize_keys)
           @started = true
         end
       end

data/lib/rorvswild/section.rb

@@ -0,0 +1,54 @@
+module RorVsWild
+  class Section
+    attr_reader :started_at
+    attr_accessor :kind, :file, :line, :calls, :command, :children_runtime, :total_runtime
+
+    def self.start(&block)
+      section = Section.new
+      block.call(section) if block_given?
+      stack.push(section)
+      section
+    end
+
+    def self.stop(&block)
+      section = stack.pop
+      block.call(section) if block_given?
+      section.total_runtime = (Time.now.utc - section.started_at) * 1000
+      current.children_runtime += section.total_runtime if current
+      RorVsWild.agent.add_section(section)
+    end
+
+    def self.stack
+      RorVsWild.agent.data[:section_stack] ||= []
+    end
+
+    def self.current
+      stack.last
+    end
+
+    def initialize
+      @calls = 1
+      @total_runtime = 0
+      @children_runtime = 0
+      @started_at = Time.now.utc
+      location = RorVsWild.agent.find_most_relevant_location(caller_locations)
+      @file = RorVsWild.agent.relative_path(location.path)
+      @line = location.lineno
+    end
+
+    def sibling?(section)
+      kind == section.kind && line == section.line && file == section.file
+    end
+
+    def merge(section)
+      self.calls += section.calls
+      self.total_runtime += section.total_runtime
+      self.children_runtime += section.children_runtime
+      self.command ||= section.command
+    end
+
+    def self_runtime
+      total_runtime - children_runtime
+    end
+  end
+end

data/lib/rorvswild/version.rb

@@ -1,3 +1,3 @@
 module RorVsWild
-  VERSION = "0.6.1".freeze
+  VERSION = "1.0.0-alpha".freeze
 end

data/test/helper.rb

@@ -5,3 +5,16 @@ require "rorvswild"
 require "minitest/autorun"
 require "mocha/mini_test"
 require "top_tests"
+
+module RorVsWildAgentHelper
+  def agent
+    @agent ||= initialize_agent(app_root: File.dirname(__FILE__))
+  end
+
+  def initialize_agent(options = {})
+    agent ||= RorVsWild.start(options)
+    agent.stubs(:post_request)
+    agent.stubs(:post_job)
+    agent
+  end
+end

data/test/measure_nested_sections_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path("#{File.dirname(__FILE__)}/helper")
+
+class RorVsWild::MeasureNestedSectionsTest < Minitest::Test
+  include RorVsWildAgentHelper
+  include TopTests
+
+  def test_measure_section
+    result = agent.measure_block("root") do
+      agent.measure_block("parent") do
+        sleep 0.01
+        agent.measure_block("child") do
+          sleep 0.02
+          42
+        end
+      end
+    end
+    assert_equal(42, result)
+    sections = agent.data[:sections]
+    parent, child = sections[1], sections[0]
+    assert_equal("child", child.command)
+    assert_equal("parent", parent.command)
+    assert(child.self_runtime > 20)
+    assert(parent.self_runtime > 10)
+    assert(child.self_runtime > parent.self_runtime)
+    assert_equal(child.total_runtime + parent.self_runtime, parent.total_runtime)
+  end
+
+  def test_measure_section_with_exception
+    assert_raises(ZeroDivisionError) do
+      agent.measure_block("root") do
+        agent.measure_block("parent") do
+          agent.measure_block("child") { 1 / 0 }
+        end
+      end
+    end
+    assert_equal(2, agent.data[:sections].size)
+  end
+end

data/test/plugin/action_controller_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "action_controller"
+
+class RorVsWild::Plugin::ActionControllerTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  def test_callback
+    agent.expects(:post_request)
+    payload = {controller: "UsersController", action: "show"}
+    ActiveSupport::Notifications.instrument("process_action.action_controller", payload) do
+      sleep 0.01
+    end
+
+    data = agent.send(:data)
+    assert_equal(0, data[:sections].size)
+    assert_equal("UsersController#show", data[:name])
+    assert(data[:runtime] > 10)
+  end
+
+  def test_callback_when_exception_is_raised
+    agent.expects(:post_request)
+    controller = stub(session: {id: "session"}, request: stub(filtered_env: {header: "env"}))
+    payload = {controller: "UsersController", action: "show"}
+    assert_raises(ZeroDivisionError) do
+      ActiveSupport::Notifications.instrument("process_action.action_controller", payload) do
+        begin
+          1 / 0
+        rescue => ex
+          RorVsWild::Plugin::ActionController.after_exception(ex, controller)
+        end
+      end
+    end
+
+    data = agent.send(:data)
+    assert_equal("UsersController#show", data[:name])
+    assert_equal("ZeroDivisionError", data[:error][:exception])
+    assert_equal({id: "session"}, data[:error][:session])
+    assert_equal({header: "env"}, data[:error][:environment_variables])
+  end
+
+  class SampleController
+    def index
+    end
+  end
+
+  def test_around_action
+    controller = SampleController.new
+    controller.stubs(action_name: "index", controller_name: "SampleController", method_for_action: "index")
+    agent.measure_block("test") do
+      RorVsWild::Plugin::ActionController.around_action(controller, controller.method(:index))
+    end
+    assert_equal(1, agent.data[:sections].size)
+    assert_equal(__FILE__, agent.data[:sections][0].file)
+    assert_equal("RorVsWild::Plugin::ActionControllerTest::SampleController#index", agent.data[:sections][0].command)
+  end
+end
+