rorvswild 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87b6214d8ddec4d743dc4498fae53c2ce5d39531
-  data.tar.gz: fe6e1d5192ad34f8b2f9c51659a575fd1f73f170
+  metadata.gz: 802001256223c866089c33029d0e0b5b4a396bb0
+  data.tar.gz: 501c456458c29d982882775b6d106456a1f23483
 SHA512:
-  metadata.gz: dde693b8dca1e8ce5a092b08c814387cbd6eaa5286001ef152ef1b81f8893646bfbaaf913ff34ff9295783ab8d6b1de248f76b0ad620efd79347d6a7e237dffd
-  data.tar.gz: 118a2bb80c5f60e19a140aed778b42bfa362e22de280b091119c413d974164a4f2a08f14a8f6be06129fdecb57dff6f5caf009d6685a181ae7d4de0f809827a9
+  metadata.gz: d49be58f9ec73146b3fd62c437c863cbccca35187ccb0668e2ed072fdd0dea733fe1b09cca4a8d2ae77105132fd8483ba94efcb4e2787ed9de00ca506a811237
+  data.tar.gz: 4c1afafbc9312d1e4589f0fc20d478e968267cab12534398a03be2cf74b73c83c676479e3918325ae6ba58c7870eebe97200aed69eee2c5adeabf140dcea44a3

data/lib/rorvswild/client.rb

@@ -58,8 +58,11 @@ module RorVsWild
         ActionController::Base.rescue_from(StandardError) { |exception| client.after_exception(exception, self) }
       end
 
+      Plugin::Redis.setup
+      Plugin::Mongo.setup
       Plugin::Resque.setup
       Plugin::Sidekiq.setup
+      Plugin::NetHttp.setup
       Kernel.at_exit(&method(:at_exit))
       ActiveJob::Base.around_perform(&method(:around_active_job)) if defined?(ActiveJob::Base)
       Delayed::Worker.lifecycle.around(:invoke_job, &method(:around_delayed_job)) if defined?(Delayed::Worker)
@@ -86,7 +89,7 @@ module RorVsWild
       file, line, method = extract_most_relevant_location(caller)
       runtime, sql = compute_duration(start, finish), payload[:sql]
       plan = runtime >= explain_sql_threshold ? explain(payload[:sql], payload[:binds]) : nil
-      push_query(file: file, line: line, method: method, sql: sql, plan: plan, runtime: runtime)
+      push_query(kind: "sql", file: file, line: line, method: method, command: sql, plan: plan, runtime: runtime)
     rescue => exception
       log_error(exception)
     end
@@ -143,6 +146,20 @@ module RorVsWild
       end
     end
 
+    def measure_query(kind, command, &block)
+      return block.call if @query_started_at  # Prevent from recursive queries
+      @query_started_at = Time.now.utc
+      begin
+        result = block.call
+        runtime = (Time.now.utc - @query_started_at) * 1000
+        file, line, method = extract_most_relevant_location(caller)
+        push_query(kind: kind, command: command, file: file, line: line, method: method, runtime: runtime)
+        result
+      ensure
+        @query_started_at = nil
+      end
+    end
+
     def catch_error(extra_details = nil, &block)
       begin
         block.call
@@ -194,12 +211,13 @@ module RorVsWild
     MEANINGLESS_QUERIES = %w[BEGIN  COMMIT].freeze
 
     def push_query(query)
-      hash = queries.find { |hash| hash[:line] == query[:line] && hash[:file] == query[:file] }
-      queries << hash = {file: query[:file], line: query[:line], runtime: 0, times: 0} if !hash
+      return if !queries
+      hash = queries.find { |hash| hash[:line] == query[:line] && hash[:file] == query[:file] && hash[:kind] == query[:kind] }
+      queries << hash = {kind: query[:kind], file: query[:file], line: query[:line], runtime: 0, times: 0} if !hash
       hash[:runtime] += query[:runtime]
-      if !MEANINGLESS_QUERIES.include?(query[:sql])
+      if !MEANINGLESS_QUERIES.include?(query[:command])
         hash[:times] += 1
-        hash[:sql] ||= query[:sql]
+        hash[:command] ||= query[:command]
         hash[:plan] ||= query[:plan] if query[:plan]
       end
     end

data/lib/rorvswild/plugin/mongo.rb

@@ -0,0 +1,37 @@
+module RorVsWild
+  module Plugin
+    class Mongo
+      def self.setup
+        return if @installed
+        return if !defined?(::Mongo::Monitoring::Global)
+        ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, Mongo.new)
+        @installed = true
+      end
+
+      attr_reader :commands
+
+      def initialize
+        @commands = {}
+      end
+
+      def started(event)
+        commands[event.request_id] = event.command
+      end
+
+      def failed(event)
+        after_query(event)
+      end
+
+      def succeeded(event)
+        after_query(event)
+      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)
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/net_http.rb

@@ -0,0 +1,22 @@
+module RorVsWild
+  module Plugin
+    class NetHttp
+      def self.setup
+        return if !defined?(Net::HTTP)
+        return if Net::HTTP.method_defined?(:request_without_rorvswild)
+
+        Net::HTTP.class_eval do
+          alias_method :request_without_rorvswild, :request
+
+          def request(req, body = nil, &block)
+            scheme = use_ssl? ? "https".freeze : "http".freeze
+            url = "#{req.method} #{scheme}://#{address}#{req.path}"
+            RorVsWild.client.measure_query("http".freeze, url) do
+              request_without_rorvswild(req, body = nil, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/redis.rb

@@ -0,0 +1,24 @@
+module RorVsWild
+  module Plugin
+    class Redis
+      def self.setup
+        return if !defined?(::Redis)
+        return if ::Redis::Client.method_defined?(:process_without_rorvswild)
+        ::Redis::Client.class_eval do
+          alias_method :process_without_rorvswild, :process
+
+          def process(commands, &block)
+            string = RorVsWild::Plugin::Redis.commands_to_string(commands)
+            RorVsWild.client.measure_query("redis".freeze, string) do
+              process_without_rorvswild(commands, &block)
+            end
+          end
+        end
+      end
+
+      def self.commands_to_string(commands)
+        commands.map { |c| c[0] == :auth ? "auth *****" : c.join(" ".freeze) }.join("\n".freeze)
+      end
+    end
+  end
+end

data/lib/rorvswild/version.rb

@@ -1,3 +1,3 @@
 module RorVsWild
-  VERSION = "0.5.1".freeze
+  VERSION = "0.6.0".freeze
 end

data/lib/rorvswild.rb

@@ -1,7 +1,10 @@
 require "rorvswild/version"
 require "rorvswild/location"
+require "rorvswild/plugin/redis"
+require "rorvswild/plugin/mongo"
 require "rorvswild/plugin/resque"
 require "rorvswild/plugin/sidekiq"
+require "rorvswild/plugin/net_http"
 require "rorvswild/client"
 
 module RorVsWild

data/test/helper.rb

@@ -0,0 +1,7 @@
+path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$LOAD_PATH.unshift(path)
+
+require "rorvswild"
+require "minitest/autorun"
+require "mocha/mini_test"
+require "top_tests"

data/test/plugin/mongo_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "mongo"
+
+class RorVsWild::Plugin::MongoTest < Minitest::Test
+  Mongo::Logger.logger.level = ::Logger::FATAL
+
+  def test_callback
+    mountains = [
+      {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) }
+    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
+  end
+end

data/test/plugin/net_http_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "net/http"
+
+class RorVsWild::Plugin::NetHttpTest < Minitest::Test
+  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])
+  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])
+  end
+
+  def test_nested_query_because_net_http_request_is_recursive_when_connection_is_not_started
+    client.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
+  end
+end

data/test/plugin/redis_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "redis"
+
+class RorVsWild::Plugin::RedisTest < Minitest::Test
+  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])
+  end
+
+  def test_callback_with_pipeline
+    skip
+    client.measure_block("pipeline") do
+      redis = ::Redis.new
+      redis.get("foo")
+      redis.set("foo", "bar")
+    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])
+  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/ror_vs_wild_test.rb

@@ -1,11 +1,4 @@
-root_path = File.expand_path(File.dirname(File.dirname(__FILE__)))
-$LOAD_PATH.unshift(root_path + "/lib")
-
-require "rorvswild"
-
-require "minitest/autorun"
-require 'mocha/mini_test'
-require "top_tests"
+require File.expand_path("#{File.dirname(__FILE__)}/helper")
 
 class RorVsWildTest < Minitest::Test
   include TopTests
@@ -117,11 +110,11 @@ class RorVsWildTest < Minitest::Test
   def test_push_query
     client = initialize_client
     client.send(:data)[:queries] = []
-    client.send(:push_query, {file: "file", line: 123, sql: "BEGIN", runtime: 10})
-    client.send(:push_query, {file: "file", line: 123, sql: "SELECT 1", runtime: 10})
-    client.send(:push_query, {file: "file", line: 123, sql: "SELECT 1", runtime: 10})
-    client.send(:push_query, {file: "file", line: 123, sql: "COMMIT", runtime: 10})
-    assert_equal([{file: "file", line: 123, sql: "SELECT 1", runtime: 40, times: 2}], client.send(:queries))
+    client.send(:push_query, {kind: "sql", file: "file", line: 123, command: "BEGIN", runtime: 10})
+    client.send(:push_query, {kind: "sql", file: "file", line: 123, command: "SELECT 1", runtime: 10})
+    client.send(:push_query, {kind: "sql", file: "file", line: 123, command: "SELECT 1", runtime: 10})
+    client.send(:push_query, {kind: "sql", file: "file", line: 123, command: "COMMIT", runtime: 10})
+    assert_equal([{kind: "sql", file: "file", line: 123, command: "SELECT 1", runtime: 40, times: 2}], client.send(:queries))
   end
 
   def test_after_exception

data/test/run.rb

@@ -0,0 +1,3 @@
+require File.expand_path("#{File.dirname(__FILE__)}/helper")
+
+Dir.glob("**/*_test.rb").each { |file_path| require File.expand_path(file_path) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rorvswild
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Alexis Bernard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-20 00:00:00.000000000 Z
+date: 2017-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,12 +43,20 @@ files:
 - lib/rorvswild/client.rb
 - lib/rorvswild/installer.rb
 - lib/rorvswild/location.rb
+- lib/rorvswild/plugin/mongo.rb
+- lib/rorvswild/plugin/net_http.rb
+- lib/rorvswild/plugin/redis.rb
 - lib/rorvswild/plugin/resque.rb
 - lib/rorvswild/plugin/sidekiq.rb
 - lib/rorvswild/rails_loader.rb
 - lib/rorvswild/version.rb
 - rorvswild.gemspec
+- test/helper.rb
+- test/plugin/mongo_test.rb
+- test/plugin/net_http_test.rb
+- test/plugin/redis_test.rb
 - test/ror_vs_wild_test.rb
+- test/run.rb
 homepage: https://www.rorvswild.com
 licenses:
 - MIT
@@ -74,5 +82,10 @@ signing_key:
 specification_version: 4
 summary: Ruby on Rails app monitoring
 test_files:
+- test/helper.rb
+- test/plugin/mongo_test.rb
+- test/plugin/net_http_test.rb
+- test/plugin/redis_test.rb
 - test/ror_vs_wild_test.rb
+- test/run.rb
 has_rdoc: