rorvswild 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91ff73c055e4c1842915157c1efa958eb24cfad1
-  data.tar.gz: 6e6d5b3070ba4156499b9710c94260a857df5ac0
+  metadata.gz: 4149e3a909cd273aa8aa37ad8e59b77755382ad1
+  data.tar.gz: a99acd4ecbae3fa5b6a2d800e54a612aee0e628d
 SHA512:
-  metadata.gz: 7ea535f196c3f3964d9b8bd33654e2591637bdd2949ef599d6aed5359b3ade919254d1ff489c0f00108eb780b5b2fb8cd48ae84598fedfa0066de314ceb41acd
-  data.tar.gz: cc15c40d7b585a8496e4ba2d12f9681f5a7951b61acee64fc180ffe254b4ec236cbf22335375a41a75c429ec6917d8fe99d95e1bc0310c184f16c40e6f4ee736
+  metadata.gz: 9fee4cf6ba25541d6f3cb2723bfa427005fdc953688ba6984d0af8910c4c3ff7cd0cac170d7455d7e9c4eecef4f5d16c10409b690a5dd999ca09212be3ba0ca9
+  data.tar.gz: 29cc6945e10e4600423d7e1162d85b0a67f28dc67bcd050562cbca06059c2a55a161d66d9e63aba2d80a32ecfff8464a17e7212d04769b690d0c2e1d3e59a703

data/README.md

@@ -1,10 +1,23 @@
 # RorVsWild
 
-All-in-one monitoring for Ruby on Rails applications.
+Ruby on Rails app monitoring: performances & quality insights for rails developers.
 
 ## Installation
 
-Signup to http://www.rorvswild.com.
+First you need an API key. Signup here https://www.rorvswild.com to get one and a 14 day free trial.
+
+1. Add in your Gemfile `gem "rorvswild"`
+2. Run `bundle install`
+3. Run `rorvswild-setup API_KEY`
+4. Restart / deploy your app !
+
+The `rorvswild-setup` create a `config/rorvswild.yml` file.
+For those who prefer to manually use an initializer, they can do the following.
+
+```ruby
+# config/initializers/rorvswild.rb
+RorVsWild::Client.new(api_key: API_KEY)
+```
 
 ## Contributing
 

data/bin/rorvswild-install

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
+
+require "rorvswild/installer"
+
+if ARGV[0]
+  RorVsWild::Installer.create_rails_config(ARGV[0])
+else
+  puts "You must provide an API key."
+end

data/lib/rorvswild/client.rb

@@ -0,0 +1,310 @@
+require "json/ext"
+require "net/http"
+require "logger"
+require "uri"
+require "set"
+
+module RorVsWild
+  class Client
+    include RorVsWild::Location
+
+    def self.default_config
+      {
+        api_url: "https://www.rorvswild.com/api",
+        explain_sql_threshold: 500,
+        ignored_exceptions: [],
+      }
+    end
+
+    attr_reader :api_url, :api_key, :app_id, :explain_sql_threshold, :app_root, :ignored_exceptions
+
+    attr_reader :threads, :app_root_regex
+
+    def initialize(config)
+      config = self.class.default_config.merge(config)
+      @explain_sql_threshold = config[:explain_sql_threshold]
+      @ignored_exceptions = config[:ignored_exceptions]
+      @app_root = config[:app_root]
+      @api_url = config[:api_url]
+      @api_key = config[:api_key]
+      @app_id = config[:app_id]
+      @logger = config[:logger]
+      @threads = Set.new
+      @data = {}
+
+      if defined?(Rails)
+        @logger ||= Rails.logger
+        @app_root ||= Rails.root.to_s
+        config = Rails.application.config
+        @parameter_filter = ActionDispatch::Http::ParameterFilter.new(config.filter_parameters)
+        @ignored_exceptions ||= %w[ActionController::RoutingError] + config.action_dispatch.rescue_responses.map { |(key,value)| key }
+      end
+
+      @logger ||= Logger.new(STDERR)
+      @app_root_regex = app_root ? /\A#{app_root}/ : nil
+
+      setup_callbacks
+      RorVsWild.register_client(self)
+    end
+
+    def setup_callbacks
+      client = self
+      if defined?(ActiveSupport::Notifications)
+        ActiveSupport::Notifications.subscribe("sql.active_record", &method(:after_sql_query))
+        ActiveSupport::Notifications.subscribe("render_partial.action_view", &method(:after_view_rendering))
+        ActiveSupport::Notifications.subscribe("render_template.action_view", &method(:after_view_rendering))
+        ActiveSupport::Notifications.subscribe("process_action.action_controller", &method(:after_http_request))
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller", &method(:before_http_request))
+        ActionController::Base.rescue_from(StandardError) { |exception| client.after_exception(exception, self) }
+      end
+
+      Plugin::Resque.setup
+      Plugin::Sidekiq.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)
+    end
+
+    def before_http_request(name, start, finish, id, payload)
+      request.merge!(controller: payload[:controller], action: payload[:action], path: payload[:path], queries: [], views: {})
+    end
+
+    def after_http_request(name, start, finish, id, payload)
+      request[:db_runtime] = (payload[:db_runtime] || 0).round
+      request[:view_runtime] = (payload[:view_runtime] || 0).round
+      request[:other_runtime] = compute_duration(start, finish) - request[:db_runtime] - request[:view_runtime]
+      request[:error][:parameters] = filter_sensitive_data(payload[:params]) if request[:error]
+      post_request
+    rescue => exception
+      log_error(exception)
+    end
+
+    IGNORED_QUERIES = %w[EXPLAIN SCHEMA].freeze
+
+    def after_sql_query(name, start, finish, id, payload)
+      return if !queries || IGNORED_QUERIES.include?(payload[:name])
+      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)
+    rescue => exception
+      log_error(exception)
+    end
+
+    def after_view_rendering(name, start, finish, id, payload)
+      if views
+        if view = views[file = relative_path(payload[:identifier])]
+          view[:runtime] += compute_duration(start, finish)
+          view[:times] += 1
+        else
+          views[file] = {file: file, runtime: compute_duration(start, finish), times: 1}
+        end
+      end
+    end
+
+    def after_exception(exception, controller)
+      if !ignored_exception?(exception)
+        file, line = exception.backtrace.first.split(":")
+        request[:error] = exception_to_hash(exception).merge(
+          session: controller.session.to_hash,
+          environment_variables: filter_sensitive_data(filter_environment_variables(controller.request.env))
+        )
+      end
+      raise exception
+    end
+
+    def around_active_job(job, block)
+      measure_block(job.class.name, &block)
+    end
+
+    def around_delayed_job(job, &block)
+      measure_block(job.name) { block.call(job) }
+    end
+
+    def measure_code(code)
+      measure_block(code) { eval(code) }
+    end
+
+    def measure_block(name, &block)
+      return block.call if job[:name] # Prevent from recursive jobs
+      job[:name] = name
+      job[:queries] = []
+      started_at = Time.now
+      cpu_time_offset = cpu_time
+      begin
+        block.call
+      rescue Exception => ex
+        job[:error] = exception_to_hash(ex) if !ignored_exception?(ex)
+        raise
+      ensure
+        job[:runtime] = (Time.now - started_at) * 1000
+        job[:cpu_runtime] = (cpu_time -  cpu_time_offset) * 1000
+        post_job
+      end
+    end
+
+    def catch_error(extra_details = nil, &block)
+      begin
+        block.call
+      rescue Exception => ex
+        record_error(ex, extra_details) if !ignored_exception?(ex)
+        ex
+      end
+    end
+
+    def record_error(exception, extra_details = nil)
+      post_error(exception_to_hash(exception, extra_details))
+    end
+
+    def cpu_time
+      time = Process.times
+      time.utime + time.stime + time.cutime + time.cstime
+    end
+
+    #######################
+    ### Private methods ###
+    #######################
+
+    private
+
+    def queries
+      data[:queries]
+    end
+
+    def views
+      data[:views]
+    end
+
+    def job
+      data
+    end
+
+    def request
+      data
+    end
+
+    def data
+      @data[Thread.current.object_id] ||= {}
+    end
+
+    def cleanup_data
+      @data.delete(Thread.current.object_id)
+    end
+
+    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
+      hash[:runtime] += query[:runtime]
+      if !MEANINGLESS_QUERIES.include?(query[:sql])
+        hash[:times] += 1
+        hash[:sql] ||= query[:sql]
+        hash[:plan] ||= query[:plan] if query[:plan]
+      end
+    end
+
+    def slowest_views
+      views.values.sort { |h1, h2| h2[:runtime] <=> h1[:runtime] }[0, 25]
+    end
+
+    def slowest_queries
+      queries.sort { |h1, h2| h2[:runtime] <=> h1[:runtime] }[0, 25]
+    end
+
+    SELECT_REGEX = /\Aselect/i.freeze
+
+    def explain(sql, binds)
+      ActiveRecord::Base.connection.explain(sql, binds) if sql =~ SELECT_REGEX
+    end
+
+    def post_request
+      attributes = request.merge(queries: slowest_queries, views: slowest_views)
+      post_async("/requests".freeze, request: attributes)
+    ensure
+      cleanup_data
+    end
+
+    def post_job
+      attributes = job.merge(queries: slowest_queries)
+      post_async("/jobs".freeze, job: attributes)
+    rescue => exception
+      log_error(exception)
+    ensure
+      cleanup_data
+    end
+
+    def post_error(hash)
+      post_async("/errors".freeze, error: hash)
+    end
+
+    def compute_duration(start, finish)
+      ((finish - start) * 1000)
+    end
+
+    def exception_to_hash(exception, extra_details = nil)
+      file, line, method = extract_most_relevant_location(exception.backtrace)
+      {
+        method: method,
+        line: line.to_i,
+        file: relative_path(file),
+        message: exception.message,
+        backtrace: exception.backtrace,
+        exception: exception.class.to_s,
+        extra_details: extra_details,
+      }
+    end
+
+    HTTPS = "https".freeze
+    CERTIFICATE_AUTHORITIES_PATH = File.expand_path("../../../cacert.pem", __FILE__)
+
+    def post(path, data)
+      uri = URI(api_url + path)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if uri.scheme == HTTPS
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.ca_file = CERTIFICATE_AUTHORITIES_PATH
+        http.use_ssl = true
+      end
+
+      post = Net::HTTP::Post.new(uri.path)
+      post.content_type = "application/json".freeze
+      post.basic_auth(app_id, api_key)
+      post.body = data.to_json
+      http.request(post)
+    end
+
+    def post_async(path, data)
+      Thread.new do
+        begin
+          threads.add(Thread.current)
+          post(path, data)
+        ensure
+          threads.delete(Thread.current)
+        end
+      end
+    end
+
+    def at_exit
+      threads.each(&:join)
+    end
+
+    def filter_sensitive_data(hash)
+      @parameter_filter ? @parameter_filter.filter(hash) : hash
+    end
+
+    def filter_environment_variables(hash)
+      hash.clone.keep_if { |key,value| key == key.upcase }
+    end
+
+    def ignored_exception?(exception)
+      ignored_exceptions.include?(exception.class.to_s)
+    end
+
+    def log_error(exception)
+      @logger.error("[RorVsWild] " + exception.inspect)
+      @logger.error("[RorVsWild] " + exception.backtrace.join("\n[RorVsWild] "))
+    end
+  end
+end

data/lib/rorvswild/installer.rb

@@ -0,0 +1,33 @@
+module RorVsWild
+  class Installer
+    PATH = "config/rorvswild.yml"
+
+    def self.create_rails_config(api_key)
+      if File.directory?("config")
+        if !File.exists?(PATH)
+          File.write(PATH, template(api_key))
+          puts "File #{PATH} has been created. Restart / deploy your app to start collecting data."
+        else
+          puts "File #{PATH} already exists."
+        end
+      else
+        puts "There is no config directory to create #{PATH}."
+      end
+    end
+
+    def self.template(api_key)
+      <<YAML
+# Keep the development block for testing on your local machine only.
+development:
+  api_key: #{api_key}
+
+production:
+  api_key: #{api_key}
+  # explain_sql_threshold: 500  # Execute EXPLAIN for queries above the specified time in ms.
+  # ignored_exceptions:
+  #   - ActionController::RoutingError
+  #   - UncommentToIgnoreAnyExceptionNameListedHere
+YAML
+    end
+  end
+end

data/lib/rorvswild/location.rb

@@ -0,0 +1,42 @@
+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
+    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
+    end
+
+    def gem_home_regex
+      @gem_home_regex ||= gem_home ? /\A#{gem_home}/.freeze : /\/gems\//.freeze
+    end
+
+    def 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)
+        first_gem_path if first_gem_path && !first_gem_path.empty?
+      end
+    end
+
+    def relative_path(path)
+      app_root_regex ? path.sub(app_root_regex, "".freeze) : path
+    end
+  end
+end

data/lib/rorvswild/plugin/resque.rb

@@ -0,0 +1,13 @@
+module RorVsWild
+  module Plugin
+    module Resque
+      def self.setup
+        ::Resque::Job.send(:extend, Resque) if defined?(::Resque::Job)
+      end
+
+      def around_perform_rorvswild(*args, &block)
+        RorVsWild.measure_block(to_s, &block)
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/sidekiq.rb

@@ -0,0 +1,18 @@
+module RorVsWild
+  module Plugin
+    class Sidekiq
+      def self.setup
+        if defined?(::Sidekiq)
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware { |chain| chain.add(SidekiqPlugin) }
+          end
+        end
+      end
+
+      def call(worker, item, queue, &block)
+        # Wrapped contains the real class name of the ActiveJob wrapper
+        RorVsWild.measure_block(item["wrapped".freeze] || item["class".freeze], &block)
+      end
+    end
+  end
+end

data/lib/rorvswild/rails_loader.rb

@@ -0,0 +1,26 @@
+module RorVsWild
+  class RailsLoader
+    @started = false
+
+    def self.start_on_rails_initialization
+      return if !defined?(Rails)
+      Rails::Railtie.initializer "rorvswild.detect_config_file" do
+        RorVsWild::RailsLoader.start
+      end
+    end
+
+    def self.start
+      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)
+          @started = true
+        end
+      end
+    end
+
+    def self.load_config_file(path)
+      YAML.load(ERB.new(path.read).result)
+    end
+  end
+end

data/lib/rorvswild/version.rb

@@ -1,3 +1,3 @@
 module RorVsWild
-  VERSION = "0.4.1".freeze
+  VERSION = "0.5.0".freeze
 end

data/lib/rorvswild.rb

@@ -1,411 +1,36 @@
 require "rorvswild/version"
-require "json/ext"
-require "net/http"
-require "logger"
-require "uri"
-require "set"
+require "rorvswild/location"
+require "rorvswild/plugin/resque"
+require "rorvswild/plugin/sidekiq"
+require "rorvswild/client"
 
 module RorVsWild
-  def self.new(*args)
-    warn "WARNING: RorVsWild.new is deprecated. Use RorVsWild::Client.new instead."
-    Client.new(*args) # Compatibility with 0.0.1
-  end
-
-  def self.detect_config_file
-    return if !defined?(Rails)
-    Rails::Railtie.initializer "rorvswild.detect_config_file" do
-      if !RorVsWild.default_client && (path = Rails.root.join("config/rorvswild.yml")).exist?
-        if config = RorVsWild.load_config_file(path)[Rails.env]
-          RorVsWild::Client.new(config.symbolize_keys)
-        end
-      end
-    end
-  end
-
-  def self.load_config_file(path)
-    YAML.load(ERB.new(path.read).result)
-  end
-
-  def self.register_default_client(client)
-    @default_client = client
-  end
-
-  def self.default_client
-    @default_client
-  end
-
-  def self.measure_job(code)
-    default_client ? default_client.measure_job(code) : eval(code)
-  end
-
   def self.measure_code(code)
-    default_client ? default_client.measure_code(code) : eval(code)
+    client ? client.measure_code(code) : eval(code)
   end
 
   def self.measure_block(name, &block)
-    default_client ? default_client.measure_block(name , &block) : block.call
+    client ? client.measure_block(name , &block) : block.call
   end
 
   def self.catch_error(extra_details = nil, &block)
-    default_client ? default_client.catch_error(extra_details, &block) : block.call
+    client ? client.catch_error(extra_details, &block) : block.call
   end
 
   def self.record_error(exception, extra_details = nil)
-    default_client.record_error(exception, extra_details) if default_client
-  end
-
-  class Client
-    def self.default_config
-      {
-        api_url: "https://www.rorvswild.com/api",
-        explain_sql_threshold: 500,
-        ignored_exceptions: [],
-      }
-    end
-
-    attr_reader :api_url, :api_key, :app_id, :explain_sql_threshold, :app_root, :ignored_exceptions
-
-    attr_reader :threads, :app_root_regex
-
-    def initialize(config)
-      config = self.class.default_config.merge(config)
-      @explain_sql_threshold = config[:explain_sql_threshold]
-      @ignored_exceptions = config[:ignored_exceptions]
-      @app_root = config[:app_root]
-      @api_url = config[:api_url]
-      @api_key = config[:api_key]
-      @app_id = config[:app_id]
-      @logger = config[:logger]
-      @threads = Set.new
-      @data = {}
-
-      if defined?(Rails)
-        @logger ||= Rails.logger
-        @app_root ||= Rails.root.to_s
-        config = Rails.application.config
-        @parameter_filter = ActionDispatch::Http::ParameterFilter.new(config.filter_parameters)
-        @ignored_exceptions ||= %w[ActionController::RoutingError] + config.action_dispatch.rescue_responses.map { |(key,value)| key }
-      end
-
-      @logger ||= Logger.new(STDERR)
-      @app_root_regex = app_root ? /\A#{app_root}/ : nil
-
-      setup_callbacks
-      RorVsWild.register_default_client(self)
-    end
-
-    def setup_callbacks
-      client = self
-      if defined?(ActiveSupport::Notifications)
-        ActiveSupport::Notifications.subscribe("sql.active_record", &method(:after_sql_query))
-        ActiveSupport::Notifications.subscribe("render_partial.action_view", &method(:after_view_rendering))
-        ActiveSupport::Notifications.subscribe("render_template.action_view", &method(:after_view_rendering))
-        ActiveSupport::Notifications.subscribe("process_action.action_controller", &method(:after_http_request))
-        ActiveSupport::Notifications.subscribe("start_processing.action_controller", &method(:before_http_request))
-        ActionController::Base.rescue_from(StandardError) { |exception| client.after_exception(exception, self) }
-      end
-
-      Kernel.at_exit(&method(:at_exit))
-      Resque::Job.send(:extend, ResquePlugin) if defined?(Resque::Job)
-      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)
-      Sidekiq.configure_server { |config| config.server_middleware { |chain| chain.add(SidekiqPlugin) } } if defined?(Sidekiq)
-    end
-
-    def before_http_request(name, start, finish, id, payload)
-      request.merge!(controller: payload[:controller], action: payload[:action], path: payload[:path], queries: [], views: {})
-    end
-
-    def after_http_request(name, start, finish, id, payload)
-      request[:db_runtime] = (payload[:db_runtime] || 0).round
-      request[:view_runtime] = (payload[:view_runtime] || 0).round
-      request[:other_runtime] = compute_duration(start, finish) - request[:db_runtime] - request[:view_runtime]
-      request[:error][:parameters] = filter_sensitive_data(payload[:params]) if request[:error]
-      post_request
-    rescue => exception
-      log_error(exception)
-    end
-
-    IGNORED_QUERIES = %w[EXPLAIN SCHEMA].freeze
-
-    def after_sql_query(name, start, finish, id, payload)
-      return if !queries || IGNORED_QUERIES.include?(payload[:name])
-      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)
-    rescue => exception
-      log_error(exception)
-    end
-
-    def after_view_rendering(name, start, finish, id, payload)
-      if views
-        if view = views[file = relative_path(payload[:identifier])]
-          view[:runtime] += compute_duration(start, finish)
-          view[:times] += 1
-        else
-          views[file] = {file: file, runtime: compute_duration(start, finish), times: 1}
-        end
-      end
-    end
-
-    def after_exception(exception, controller)
-      if !ignored_exception?(exception)
-        file, line = exception.backtrace.first.split(":")
-        request[:error] = exception_to_hash(exception).merge(
-          session: controller.session.to_hash,
-          environment_variables: filter_sensitive_data(filter_environment_variables(controller.request.env))
-        )
-      end
-      raise exception
-    end
-
-    def around_active_job(job, block)
-      measure_block(job.class.name, &block)
-    end
-
-    def around_delayed_job(job, &block)
-      measure_block(job.name) { block.call(job) }
-    end
-
-    def measure_job(code)
-      warn "WARNING: RorVsWild.measure_job is deprecated. Use RorVsWild.measure_code instead."
-      measure_block(code) { eval(code) }
-    end
-
-    def measure_code(code)
-      measure_block(code) { eval(code) }
-    end
-
-    def measure_block(name, &block)
-      return block.call if job[:name] # Prevent from recursive jobs
-      job[:name] = name
-      job[:queries] = []
-      started_at = Time.now
-      cpu_time_offset = cpu_time
-      begin
-        block.call
-      rescue Exception => ex
-        job[:error] = exception_to_hash(ex) if !ignored_exception?(ex)
-        raise
-      ensure
-        job[:runtime] = (Time.now - started_at) * 1000
-        job[:cpu_runtime] = (cpu_time -  cpu_time_offset) * 1000
-        post_job
-      end
-    end
-
-    def catch_error(extra_details = nil, &block)
-      begin
-        block.call
-      rescue Exception => ex
-        record_error(ex, extra_details) if !ignored_exception?(ex)
-        ex
-      end
-    end
-
-    def record_error(exception, extra_details = nil)
-      post_error(exception_to_hash(exception, extra_details))
-    end
-
-    def cpu_time
-      time = Process.times
-      time.utime + time.stime + time.cutime + time.cstime
-    end
-
-    #######################
-    ### Private methods ###
-    #######################
-
-    private
-
-    def queries
-      data[:queries]
-    end
-
-    def views
-      data[:views]
-    end
-
-    def job
-      data
-    end
-
-    def request
-      data
-    end
-
-    def data
-      @data[Thread.current.object_id] ||= {}
-    end
-
-    def cleanup_data
-      @data.delete(Thread.current.object_id)
-    end
-
-    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
-      hash[:runtime] += query[:runtime]
-      if !MEANINGLESS_QUERIES.include?(query[:sql])
-        hash[:times] += 1
-        hash[:sql] ||= query[:sql]
-        hash[:plan] ||= query[:plan] if query[:plan]
-      end
-    end
-
-    def slowest_views
-      views.values.sort { |h1, h2| h2[:runtime] <=> h1[:runtime] }[0, 25]
-    end
-
-    def slowest_queries
-      queries.sort { |h1, h2| h2[:runtime] <=> h1[:runtime] }[0, 25]
-    end
-
-    SELECT_REGEX = /\Aselect/i.freeze
-
-    def explain(sql, binds)
-      ActiveRecord::Base.connection.explain(sql, binds) if sql =~ SELECT_REGEX
-    end
-
-    def post_request
-      attributes = request.merge(queries: slowest_queries, views: slowest_views)
-      post_async("/requests".freeze, request: attributes)
-    ensure
-      cleanup_data
-    end
-
-    def post_job
-      attributes = job.merge(queries: slowest_queries)
-      post_async("/jobs".freeze, job: attributes)
-    rescue => exception
-      log_error(exception)
-    ensure
-      cleanup_data
-    end
-
-    def post_error(hash)
-      post_async("/errors".freeze, error: hash)
-    end
-
-    def 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)
-        first_gem_path if first_gem_path && !first_gem_path.empty?
-      end
-    end
-
-    def gem_home_regex
-      @gem_home_regex ||= gem_home ? /\A#{gem_home}/.freeze : /\/gems\//.freeze
-    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
-      split_file_location(relative_path(location || stack.first))
-    end
-
-    def split_file_location(location)
-      file, line, method = location.split(":")
-      method = cleanup_method_name(method) if method
-      [file, line, method]
-    end
-
-    def 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
-    end
-
-    def compute_duration(start, finish)
-      ((finish - start) * 1000)
-    end
-
-    def relative_path(path)
-      app_root_regex ? path.sub(app_root_regex, "".freeze) : path
-    end
-
-    def exception_to_hash(exception, extra_details = nil)
-      file, line, method = extract_most_relevant_location(exception.backtrace)
-      {
-        method: method,
-        line: line.to_i,
-        file: relative_path(file),
-        message: exception.message,
-        backtrace: exception.backtrace,
-        exception: exception.class.to_s,
-        extra_details: extra_details,
-      }
-    end
-
-    HTTPS = "https".freeze
-    CERTIFICATE_AUTHORITIES_PATH = File.expand_path("../../cacert.pem", __FILE__)
-
-    def post(path, data)
-      uri = URI(api_url + path)
-      http = Net::HTTP.new(uri.host, uri.port)
-
-      if uri.scheme == HTTPS
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        http.ca_file = CERTIFICATE_AUTHORITIES_PATH
-        http.use_ssl = true
-      end
-
-      post = Net::HTTP::Post.new(uri.path)
-      post.content_type = "application/json".freeze
-      post.basic_auth(app_id, api_key)
-      post.body = data.to_json
-      http.request(post)
-    end
-
-    def post_async(path, data)
-      Thread.new do
-        begin
-          threads.add(Thread.current)
-          post(path, data)
-        ensure
-          threads.delete(Thread.current)
-        end
-      end
-    end
-
-    def at_exit
-      threads.each(&:join)
-    end
-
-    def filter_sensitive_data(hash)
-      @parameter_filter ? @parameter_filter.filter(hash) : hash
-    end
-
-    def filter_environment_variables(hash)
-      hash.clone.keep_if { |key,value| key == key.upcase }
-    end
-
-    def ignored_exception?(exception)
-      ignored_exceptions.include?(exception.class.to_s)
-    end
-
-    def log_error(exception)
-      @logger.error("[RorVsWild] " + exception.inspect)
-      @logger.error("[RorVsWild] " + exception.backtrace.join("\n[RorVsWild] "))
-    end
+    client.record_error(exception, extra_details) if client
   end
 
-  module ResquePlugin
-    def around_perform_rorvswild(*args, &block)
-      RorVsWild.measure_block(to_s, &block)
-    end
+  def self.register_client(client)
+    @client = client
   end
 
-  class SidekiqPlugin
-    def call(worker, item, queue, &block)
-      RorVsWild.measure_block(item["wrapped".freeze] || item["class".freeze], &block)
-    end
+  def self.client
+    @client
   end
 end
 
-RorVsWild.detect_config_file
+if defined?(Rails)
+  require "rorvswild/rails_loader"
+  RorVsWild::RailsLoader.start_on_rails_initialization
+end

data/test/ror_vs_wild_test.rb

@@ -35,13 +35,13 @@ class RorVsWildTest < Minitest::Test
   end
 
   def test_measure_code_when_no_client
-    RorVsWild.register_default_client(nil)
+    RorVsWild.register_client(nil)
     RorVsWild::Client.any_instance.expects(:post_job).never
     assert_equal(2, RorVsWild.measure_code("1+1"))
   end
 
   def test_measure_block_when_no_client
-    RorVsWild.register_default_client(nil)
+    RorVsWild.register_client(nil)
     RorVsWild::Client.any_instance.expects(:post_job).never
     assert_equal(2, RorVsWild.measure_block("1+1") { 1+1 })
   end
@@ -73,25 +73,25 @@ class RorVsWildTest < Minitest::Test
 
   def test_extract_most_relevant_location
     callstack = ["#{ENV["GEM_HOME"]}/lib/sql.rb:1:in `method1'", "/usr/lib/ruby/net/http.rb:2:in `method2'", "/rails/root/app/models/user.rb:3:in `method3'"]
-    assert_equal(%w[/app/models/user.rb 3 method3], client.send(:extract_most_relevant_location, callstack))
+    assert_equal(%w[/app/models/user.rb 3 method3], client.extract_most_relevant_location(callstack))
 
-    assert_equal(["#{ENV["GEM_HOME"]}/lib/sql.rb", "1", "method1"], client.send(:extract_most_relevant_location, ["#{ENV["GEM_HOME"]}/lib/sql.rb:1:in `method1'"]))
+    assert_equal(["#{ENV["GEM_HOME"]}/lib/sql.rb", "1", "method1"], client.extract_most_relevant_location(["#{ENV["GEM_HOME"]}/lib/sql.rb:1:in `method1'"]))
   end
 
   def test_extract_most_relevant_location_when_there_is_not_app_root
     client = initialize_client
     callstack = ["#{ENV["GEM_HOME"]}/lib/sql.rb:1:in `method1'", "/usr/lib/ruby/net/http.rb:2:in `method2'", "/rails/root/app/models/user.rb:3:in `method3'"]
-    assert_equal(%w[/usr/lib/ruby/net/http.rb 2 method2], client.send(:extract_most_relevant_location, callstack))
+    assert_equal(%w[/usr/lib/ruby/net/http.rb 2 method2], client.extract_most_relevant_location(callstack))
   end
 
   def test_extract_most_relevant_location_when_there_is_no_method_name
-    assert_equal(["/foo/bar.rb", "123", nil], client.send(:extract_most_relevant_location, ["/foo/bar.rb:123"]))
+    assert_equal(["/foo/bar.rb", "123", nil], client.extract_most_relevant_location(["/foo/bar.rb:123"]))
   end
 
   def test_extract_most_relevant_location_when_gem_home_is_in_heroku_app_root
     client = initialize_client(app_root: app_root = File.dirname(gem_home = ENV["GEM_HOME"]))
     callstack = ["#{gem_home}/lib/sql.rb:1:in `method1'", "/usr/lib/ruby/net/http.rb:2:in `method2'", "#{app_root}/app/models/user.rb:3:in `method3'"]
-    assert_equal(["/app/models/user.rb", "3", "method3"], client.send(:extract_most_relevant_location, callstack))
+    assert_equal(["/app/models/user.rb", "3", "method3"], client.extract_most_relevant_location(callstack))
   end
 
   def test_extract_most_relevant_location_when_gem_path_is_set_instead_of_gem_home
@@ -99,7 +99,7 @@ class RorVsWildTest < Minitest::Test
     ENV["GEM_HOME"], ENV["GEM_PATH"] = "", "/gem/path"
 
     callstack = ["/gem/path/lib/sql.rb:1:in `method1'", "/usr/lib/ruby/net/http.rb:2:in `method2'", "/rails/root/app/models/user.rb:3:in `method3'"]
-    assert_equal(%w[/app/models/user.rb 3 method3], client.send(:extract_most_relevant_location, callstack))
+    assert_equal(%w[/app/models/user.rb 3 method3], client.extract_most_relevant_location(callstack))
   ensure
     ENV["GEM_HOME"], ENV["GEM_PATH"] = original_gem_home,  original_gem_path
   end
@@ -109,7 +109,7 @@ class RorVsWildTest < Minitest::Test
     ENV["GEM_HOME"], ENV["GEM_PATH"] = "", ""
 
     callstack = ["/gem/path/lib/sql.rb:1:in `method1'", "/usr/lib/ruby/net/http.rb:2:in `method2'", "/rails/root/app/models/user.rb:3:in `method3'"]
-    assert_equal(%w[/app/models/user.rb 3 method3], client.send(:extract_most_relevant_location, callstack))
+    assert_equal(%w[/app/models/user.rb 3 method3], client.extract_most_relevant_location(callstack))
   ensure
     ENV["GEM_HOME"], ENV["GEM_PATH"] = original_gem_home,  original_gem_path
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rorvswild
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Alexis Bernard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-05 00:00:00.000000000 Z
+date: 2017-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -27,7 +27,8 @@ dependencies:
 description: Performances & quality insights for rails developers.
 email:
 - alexis@bernard.io
-executables: []
+executables:
+- rorvswild-install
 extensions: []
 extra_rdoc_files: []
 files:
@@ -36,8 +37,15 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/rorvswild-install
 - cacert.pem
 - lib/rorvswild.rb
+- lib/rorvswild/client.rb
+- lib/rorvswild/installer.rb
+- lib/rorvswild/location.rb
+- lib/rorvswild/plugin/resque.rb
+- lib/rorvswild/plugin/sidekiq.rb
+- lib/rorvswild/rails_loader.rb
 - lib/rorvswild/version.rb
 - rorvswild.gemspec
 - test/ror_vs_wild_test.rb