rorvswild 0.6.1 → 1.0.0.pre.alpha

data/test/plugin/action_mailer_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "active_job"
+
+class RorVsWild::Plugin::ActiveMailerTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  def test_callback
+    line = nil
+    agent = initialize_agent(app_root: File.dirname(__FILE__))
+    agent.measure_block("test") do
+      ActiveSupport::Notifications.instrument("deliver.action_mailer", {mailer: "Mailer"}) do line = __LINE__
+        sleep 0.01
+      end
+    end
+
+    section = agent.data[:sections][0]
+
+    assert_equal(1, agent.data[:sections].size)
+    assert_equal("Mailer", section.command)
+    assert_equal(line, section.line.to_i)
+    assert_equal("mail", section.kind)
+    assert(section.self_runtime > 10)
+    assert_equal(1, section.calls)
+  end
+end
+

data/test/plugin/action_view_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "active_job"
+
+class RorVsWild::Plugin::ActionViewTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  def test_render_template_callback
+    agent.measure_block("test") do
+      ActiveSupport::Notifications.instrument("render_template.action_view", {identifier: "template.html.erb"}) do
+        ActiveSupport::Notifications.instrument("render_partial.action_view", {identifier: "_partial.html.erb"}) do
+          ActiveSupport::Notifications.instrument("render_partial.action_view", {identifier: "_sub_partial.html.erb"}) do
+            sleep 0.03
+          end
+          sleep 0.02
+        end
+        sleep 0.01
+      end
+    end
+
+    sections = agent.data[:sections]
+    sub_partial, partial, template = sections[0], sections[1], sections[2]
+    assert_equal(3, sections.size)
+
+    assert_equal("view", sub_partial.kind)
+    assert_equal("_sub_partial.html.erb", sub_partial.command)
+
+    assert_equal("view", partial.kind)
+    assert_equal("_partial.html.erb", partial.command)
+
+    assert_equal("view", template.kind)
+    assert_equal("template.html.erb", template.command)
+
+    assert(sub_partial.self_runtime > partial.self_runtime)
+    assert(partial.self_runtime > template.self_runtime)
+    assert(partial.total_runtime < template.total_runtime)
+    assert(sub_partial.total_runtime < partial.total_runtime)
+  end
+end
+

data/test/plugin/active_job_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "active_job"
+
+class RorVsWild::Plugin::ActiveJobTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  class SampleJob < ::ActiveJob::Base
+    queue_as :default
+
+    def perform
+    end
+  end
+
+  def test_callback
+    ActiveJob::Base.logger = Logger.new("/dev/null")
+    agent.expects(:post_job)
+    SampleJob.perform_now
+  end
+end
+

data/test/plugin/active_record_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "active_job"
+
+class RorVsWild::Plugin::ActiveRecordTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  def test_render_template_callback
+    line1, line2 = nil
+    agent = initialize_agent(app_root: File.dirname(__FILE__))
+    agent.measure_block("test") do
+      ActiveSupport::Notifications.instrument("sql.active_record", {sql: "SELECT COUNT(*) FROM users"}) do line1 = __LINE__
+        sleep 0.01
+      end
+      2.times do
+        ActiveSupport::Notifications.instrument("sql.active_record", {sql: "SELECT * FROM users"}) do line2 = __LINE__
+          sleep 0.02
+        end
+      end
+    end
+
+    sections = agent.data[:sections]
+    sql1, sql2 = sections[0], sections[1]
+    assert_equal(2, sections.size)
+
+    assert_equal("sql", sql1.kind)
+    assert_equal("SELECT COUNT(*) FROM users", sql1.command)
+    assert_equal(line1, sql1.line.to_i)
+    assert_equal(1, sql1.calls)
+    assert(sql1.self_runtime > 10)
+
+    assert_equal("sql", sql2.kind)
+    assert_equal("SELECT * FROM users", sql2.command)
+    assert_equal(line2, sql2.line.to_i)
+    assert(sql2.self_runtime > 40)
+    assert_equal(2, sql2.calls)
+  end
+end
+

data/test/plugin/delayed_job_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "delayed_job"
+
+class RorVsWild::Plugin::DelayedJobTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  class SampleJob
+    def perform
+    end
+  end
+
+  class SampleBackend
+    include Delayed::Backend::Base
+
+    attr_accessor :id,  :attempts
+
+    def initialize(options)
+    end
+
+    def payload_object
+      SampleJob.new
+    end
+
+    def destroy
+    end
+  end
+
+  def test_callback
+    agent.expects(:post_job)
+    Delayed::Worker.delay_jobs = false
+    SampleBackend.enqueue(SampleJob.new)
+  end
+end
+

data/test/plugin/mongo_test.rb

@@ -3,6 +3,8 @@ require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 require "mongo"
 
 class RorVsWild::Plugin::MongoTest < Minitest::Test
+  include RorVsWildAgentHelper
+
   Mongo::Logger.logger.level = ::Logger::FATAL
 
   def test_callback
@@ -10,26 +12,13 @@ class RorVsWild::Plugin::MongoTest < Minitest::Test
       {name: "Mont Blanc", altitude: 4807},
       {name: "Mont Cervin", altitude: 4478},
     ]
-    client.measure_block("mongo") do
-      client = Mongo::Client.new('mongodb://127.0.0.1:27017/test')
-      mountains.each { |m| client[:mountains].insert_one(m) }
+    agent.measure_block("mongo") do
+      agent = Mongo::Client.new('mongodb://127.0.0.1:27017/test')
+      mountains.each { |m| agent[:mountains].insert_one(m) }
     end
-    assert_equal(1, client.send(:queries).size)
-    assert_equal(2, client.send(:queries)[0][:times])
-    assert_equal("mongo", client.send(:queries)[0][:kind])
-    assert_match('{"insert"=>"mountains", "documents"=>', client.send(:queries)[0][:command])
-  end
-
-  private
-
-  def client
-    @client ||= initialize_client(app_root: "/rails/root")
-  end
-
-  def initialize_client(options = {})
-    client = RorVsWild::Client.new(options)
-    client.stubs(:post_request)
-    client.stubs(:post_job)
-    client
+    assert_equal(1, agent.data[:sections].size)
+    assert_equal(2, agent.data[:sections][0].calls)
+    assert_equal("mongo", agent.data[:sections][0].kind)
+    assert_match('{"insert"=>"mountains", "documents"=>', agent.data[:sections][0].command)
   end
 end

data/test/plugin/net_http_test.rb

@@ -3,39 +3,28 @@ require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 require "net/http"
 
 class RorVsWild::Plugin::NetHttpTest < Minitest::Test
+  include RorVsWildAgentHelper
+
   def test_callback
-    client.measure_block("test") { Net::HTTP.get("ruby-lang.org", "/index.html") }
-    assert_equal(1, client.send(:queries).size)
-    assert_equal(1, client.send(:queries)[0][:times])
-    assert_equal("http", client.send(:queries)[0][:kind])
-    assert_match("GET http://ruby-lang.org/index.html", client.send(:queries)[0][:command])
+    agent.measure_block("test") { Net::HTTP.get("ruby-lang.org", "/index.html") }
+    assert_equal(1, agent.data[:sections].size)
+    assert_equal(1, agent.data[:sections][0].calls)
+    assert_equal("http", agent.data[:sections][0].kind)
+    assert_match("GET http://ruby-lang.org/index.html", agent.data[:sections][0].command)
   end
 
   def test_callback_with_https
-    client.measure_block("test") { Net::HTTP.get(URI("https://www.ruby-lang.org/index.html")) }
-    assert_match("GET https://www.ruby-lang.org/index.html", client.send(:queries)[0][:command])
-    assert_equal("http", client.send(:queries)[0][:kind])
+    agent.measure_block("test") { Net::HTTP.get(URI("https://www.ruby-lang.org/index.html")) }
+    assert_match("GET https://www.ruby-lang.org/index.html", agent.data[:sections][0].command)
+    assert_equal("http", agent.data[:sections][0].kind)
   end
 
   def test_nested_query_because_net_http_request_is_recursive_when_connection_is_not_started
-    client.measure_block("test") do
+    agent.measure_block("test") do
       uri = URI("http://www.ruby-lang.org/index.html")
       http = Net::HTTP.new(uri.host, uri.port)
       http.request(Net::HTTP::Get.new(uri.path))
     end
-    assert_equal(1, client.send(:queries)[0][:times])
-  end
-
-  private
-
-  def client
-    @client ||= initialize_client(app_root: "/rails/root")
-  end
-
-  def initialize_client(options = {})
-    client = RorVsWild::Client.new(options)
-    client.stubs(:post_request)
-    client.stubs(:post_job)
-    client
+    assert_equal(1, agent.data[:sections][0].calls)
   end
 end

data/test/plugin/redis_test.rb

@@ -3,40 +3,28 @@ require File.expand_path("#{File.dirname(__FILE__)}/../helper")
 require "redis"
 
 class RorVsWild::Plugin::RedisTest < Minitest::Test
+  include RorVsWildAgentHelper
+
   def test_callback
-    client.measure_code("::Redis.new.get('foo')")
-    assert_equal(1, client.send(:queries).size)
-    assert_equal("redis", client.send(:queries)[0][:kind])
-    assert_equal("get foo", client.send(:queries)[0][:command])
+    agent.measure_code("::Redis.new.get('foo')")
+    assert_equal(1, agent.data[:sections].size)
+    assert_equal("redis", agent.data[:sections][0].kind)
+    assert_equal("get foo", agent.data[:sections][0].command)
   end
 
-  def test_callback_with_pipeline
-    skip
-    client.measure_block("pipeline") do
-      redis = ::Redis.new
-      redis.get("foo")
-      redis.set("foo", "bar")
+  def test_callback_when_pipelined
+    agent.measure_block("pipeline") do
+      (redis = ::Redis.new).pipelined do
+        redis.get("foo")
+        redis.set("foo", "bar")
+      end
     end
-    assert_equal(2, client.send(:queries).size)
-    assert_equal("redis", client.send(:queries)[0][:kind])
-    assert_equal("get foo", client.send(:queries)[0][:command])
-    assert_equal("set foo bar", client.send(:queries)[1][:command])
+    assert_equal(1, agent.data[:sections].size)
+    assert_equal("redis", agent.data[:sections][0].kind)
+    assert_equal("get foo\nset foo bar", agent.data[:sections][0].command)
   end
 
   def test_commands_to_string_hide_auth_password
     assert_equal("auth *****", RorVsWild::Plugin::Redis.commands_to_string([[:auth, "SECRET"]]))
   end
-
-  private
-
-  def client
-    @client ||= initialize_client(app_root: "/rails/root")
-  end
-
-  def initialize_client(options = {})
-    client ||= RorVsWild::Client.new(options)
-    client.stubs(:post_request)
-    client.stubs(:post_job)
-    client
-  end
 end

data/test/rorvswild_test.rb

@@ -0,0 +1,141 @@
+require File.expand_path("#{File.dirname(__FILE__)}/helper")
+
+class RorVsWildTest < Minitest::Test
+  include TopTests
+
+  def test_measure_code
+    agent.expects(:post_job)
+    assert_equal(2, agent.measure_code("1 + 1"))
+    assert_equal("1 + 1", agent.send(:data)[:name])
+    assert(agent.send(:data)[:runtime] > 0)
+  end
+
+  def test_measure_code_when_raising
+    agent.expects(:post_job)
+    assert_raises(RuntimeError) { agent.measure_code("raise 'error'") }
+    assert_equal(("raise 'error'"), agent.send(:data)[:name])
+    assert(agent.send(:data)[:runtime])
+    assert(agent.send(:data)[:error])
+  end
+
+  def test_mesure_block_when_exception_is_ignored
+    agent = initialize_agent(ignored_exceptions: %w[ZeroDivisionError])
+    agent.expects(:post_job)
+    assert_raises(ZeroDivisionError) { RorVsWild.measure_code("1/0") }
+    refute(agent.send(:data)[:error])
+  end
+
+  def test_measure_code_when_no_agent
+    RorVsWild.instance_variable_set(:@agent, nil)
+    RorVsWild::Agent.any_instance.expects(:post_job).never
+    assert_equal(2, RorVsWild.measure_code("1+1"))
+  end
+
+  def test_measure_block_when_no_agent
+    RorVsWild.instance_variable_set(:@agent, nil)
+    RorVsWild::Agent.any_instance.expects(:post_job).never
+    assert_equal(2, RorVsWild.measure_block("1+1") { 1+1 })
+  end
+
+  def test_measure_block_recursive
+    agent.expects(:post_job)
+    result = RorVsWild.measure_block("1") do
+      RorVsWild.measure_block("2") { 1 } + 1
+    end
+    assert_equal(2, result)
+  end
+
+  def test_catch_error
+    agent.expects(:post_error)
+    exception = RorVsWild.catch_error { 1 / 0 }
+    assert_equal(ZeroDivisionError, exception.class)
+  end
+
+  def test_catch_error_with_extra_details
+    agent.expects(:post_error)
+    exception = RorVsWild.catch_error(foo: "bar") { 1 / 0 }
+    assert_equal(ZeroDivisionError, exception.class)
+  end
+
+  def test_catch_error_when_no_errors
+    agent.expects(:post_error).never
+    assert_equal(2, RorVsWild.catch_error { 1 + 1 })
+  end
+
+  def test_extract_most_relevant_file_and_line
+    callstack = [
+      stub(path: "#{ENV["GEM_HOME"]}/lib/sql.rb", lineno: 1),
+      stub(path: "/usr/lib/ruby/net/http.rb", lineno: 2),
+      stub(path: "/rails/root/app/models/user.rb", lineno: 3),
+    ]
+    assert_equal(["/app/models/user.rb", 3], agent.extract_most_relevant_file_and_line(callstack))
+
+    locations = [stub(path: "#{ENV["GEM_HOME"]}/lib/sql.rb", lineno: 1)]
+    assert_equal(["#{ENV["GEM_HOME"]}/lib/sql.rb", 1], agent.extract_most_relevant_file_and_line(locations))
+  end
+
+  def test_extract_most_relevant_file_and_line_when_there_is_not_app_root
+    agent = initialize_agent
+    callstack = [
+      stub(path: "#{ENV["GEM_HOME"]}/lib/sql.rb", lineno: 1),
+      stub(path: "/usr/lib/ruby/net/http.rb", lineno: 2),
+      stub(path: "/rails/root/app/models/user.rb", lineno: 3),
+    ]
+    assert_equal(["/usr/lib/ruby/net/http.rb", 2], agent.extract_most_relevant_file_and_line(callstack))
+  end
+
+  def test_extract_most_relevant_file_and_line_when_there_is_no_method_name
+    assert_equal(["/foo/bar.rb", 123], agent.extract_most_relevant_file_and_line([stub(path: "/foo/bar.rb", lineno:123)]))
+  end
+
+  def test_extract_most_relevant_file_and_line_when_gem_home_is_in_heroku_app_root
+    agent = initialize_agent(app_root: app_root = File.dirname(gem_home = ENV["GEM_HOME"]))
+    callstack = [
+      stub(path: "#{gem_home}/lib/sql.rb", lineno: 1),
+      stub(path: "/usr/lib/ruby/net/http.rb", lineno: 2),
+      stub(path: "#{app_root}/app/models/user.rb", lineno: 3)
+    ]
+    assert_equal(["/app/models/user.rb", 3], agent.extract_most_relevant_file_and_line(callstack))
+  end
+
+  def test_extract_most_relevant_file_and_line_when_gem_path_is_set_instead_of_gem_home
+    original_gem_home, original_gem_path = ENV["GEM_HOME"], ENV["GEM_PATH"]
+    ENV["GEM_HOME"], ENV["GEM_PATH"] = "", "/gem/path"
+
+    callstack = [
+      stub(path: "/gem/path/lib/sql.rb", lineno:1),
+      stub(path: "/usr/lib/ruby/net/http.rb", lineno: 2),
+      stub(path: "/rails/root/app/models/user.rb",lineno: 3),
+    ]
+    assert_equal(["/app/models/user.rb", 3], agent.extract_most_relevant_file_and_line(callstack))
+  ensure
+    ENV["GEM_HOME"], ENV["GEM_PATH"] = original_gem_home,  original_gem_path
+  end
+
+  def test_extract_most_relevant_file_and_line_when_gem_path_and_gem_home_are_undefined
+    original_gem_home, original_gem_path = ENV["GEM_HOME"], ENV["GEM_PATH"]
+    ENV["GEM_HOME"], ENV["GEM_PATH"] = "", ""
+
+    callstack = [
+      stub(path: "/gem/path/lib/sql.rb", lineno: 1),
+      stub(path: "/usr/lib/ruby/net/http.rb", lineno: 2),
+      stub(path: "/rails/root/app/models/user.rb", lineno: 3),
+    ]
+    assert_equal(["/app/models/user.rb", 3], agent.extract_most_relevant_file_and_line(callstack))
+  ensure
+    ENV["GEM_HOME"], ENV["GEM_PATH"] = original_gem_home,  original_gem_path
+  end
+
+  private
+
+  def agent
+    @agent ||= initialize_agent(app_root: "/rails/root")
+  end
+
+  def initialize_agent(options = {})
+    agent ||= RorVsWild.start(options)
+    agent.stubs(:post_request)
+    agent.stubs(:post_task)
+    agent
+  end
+end