rorvswild 1.5.0 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 875777242efff56c2c1e19d2cf7248e7cb08f8f69c8c35e305e2fc2131b7563f
-  data.tar.gz: c04de4df6091f8b364fffd020deaf1fc50983dde67f57e45c23d4db8af867d71
+  metadata.gz: c48c5689b1cc41d4954efcf44a2c415ee4a803da60f6beb36424f9103d06d72e
+  data.tar.gz: 62da47461a2d4dc9e182aebe765d6dda46e188ea57687bcd8298e61acf8d51d6
 SHA512:
-  metadata.gz: 4ab22a6282828a0b9f682cdffe2484e63074a68fc4c1bb53b7c8a0a02b0817ef2cf74001491d7345b8a1de29328ddf4e9178bd303a594e835de0423fd625e551
-  data.tar.gz: d3e3846d7a7e6d39b51795e14e238826fee503a0a0cfcfd6b56875b30b5dd0f3774453e8de408e6947b16172d0a852850e1f99615987416d098317975281df02
+  metadata.gz: e00fa04cd7566a8f64fe7d69ebc2a36acabec87619eee6e05ef2534ea429614a2be1ac7cd102b45440f5aa81333cdc6595f30b77c277ef7b7c2b832785ac48b8
+  data.tar.gz: 8e1b010d4057131da1178041640b095dea3f90c685f50d4f8c15fcda2ab0257c37cce986e72a5eca68154ecb39d78f1fd3e5912d2493f9a03400182b676563af

data/README.md

@@ -32,11 +32,11 @@ Signup on https://www.rorvswild.com and create an app to get one.
 
 * Add in your Gemfile `gem "rorvswild"`
 * Run `bundle install` in you terminal
-* Run `rorvswild-setup API_KEY` in you terminal
+* Run `rorvswild-install API_KEY` in you terminal
 * Deploy/Restart your app
 * Make a few requests and refresh your app page on rorvswild.com to view the dashboard.
 
-The `rorvswild-setup` command creates a `config/rorvswild.yml` file.
+The `rorvswild-install` command creates a `config/rorvswild.yml` file.
 
 If you prefer to use an initializer, you can do the following:
 
@@ -167,6 +167,32 @@ Finally here is the list of all plugins you can ignore :
   - Resque
   - Sidekiq
 
+#### Change logger
+
+By default RorVsWild uses `Rails.logger` or standard output. However in some cases you want to isolate RorVsWild's logs.
+To do that, you have to specifiy the log destination via the `logger` option :
+
+```yaml
+# config/rorvswild.yml
+production:
+  api_key: API_KEY
+  logger: log/rorvswild.yml
+```
+
+Here is the equivalent if you prefer initialising RorVsWild manually :
+
+```ruby
+# config/initializers/rorvswild.rb
+RorVsWild.start(api_key: "API_KEY", logger: "log/rorvswild.log")
+```
+
+In the case you want a custom logger such as Syslog, you can only do it by initialising it manually :
+
+```ruby
+# config/initializers/rorvswild.rb
+RorVsWild.start(api_key: "API_KEY", logger: Logger::Syslog.new)
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/rorvswild/fork )

data/lib/rorvswild.rb

@@ -20,7 +20,7 @@ module RorVsWild
   end
 
   def self.logger
-    @logger ||= Logger.new(STDOUT)
+    @logger ||= initialize_logger
   end
 
   def self.measure_code(code)
@@ -39,17 +39,31 @@ module RorVsWild
     agent.record_error(exception, extra_details) if agent
   end
 
-  def self.initialize_logger(destination)
-    if destination
+  def self.initialize_logger(destination = nil)
+    if destination.respond_to?(:info) && destination.respond_to?(:warn) && destination.respond_to?(:error)
+      destination
+    elsif destination
       Logger.new(destination)
     elsif defined?(Rails)
-      Logger.new(Rails.root + "log/rorvswild.log")
+      Rails.logger
+    else
+      Logger.new(STDOUT)
     end
   end
 
   def self.clock_milliseconds
     Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
   end
+
+  def self.check
+    api_key = RorVsWild.agent.config[:api_key]
+    return puts "You API key is missing and has to be defined in config/rorvswild.yml." if !api_key || api_key.empty?
+    puts case response = agent.client.post("/jobs", jobs: [{sections: [], name: "RorVsWild.check", runtime: 0}])
+    when Net::HTTPOK then "Connection to RorVsWild works fine !"
+    when Net::HTTPUnauthorized then "Wrong API key"
+    else puts "Something went wrong: #{response.inspect}"
+    end
+  end
 end
 
 if defined?(Rails)

data/lib/rorvswild/agent.rb

@@ -37,7 +37,7 @@ module RorVsWild
       for name in RorVsWild::Plugin.constants
         next if config[:ignore_plugins] && config[:ignore_plugins].include?(name.to_s)
         if (plugin = RorVsWild::Plugin.const_get(name)).respond_to?(:setup)
-          RorVsWild.logger.info("Load plugin #{name}")
+          RorVsWild.logger.info("Setup RorVsWild::Plugin::#{name}")
           plugin.setup
         end
       end
@@ -48,11 +48,11 @@ module RorVsWild
     end
 
     def measure_block(name, kind = "code".freeze, &block)
-      data[:name] ? measure_section(name, kind: kind, &block) : measure_job(name, &block)
+      current_data ? measure_section(name, kind: kind, &block) : measure_job(name, &block)
     end
 
     def measure_section(name, kind: "code", appendable_command: false, &block)
-      return block.call unless data[:name]
+      return block.call unless current_data
       begin
         RorVsWild::Section.start do |section|
           section.appendable_command = appendable_command
@@ -66,29 +66,27 @@ module RorVsWild
     end
 
     def measure_job(name, parameters: nil, &block)
-      return measure_section(name, &block) if data[:name] # For recursive jobs
+      return measure_section(name, &block) if current_data # For recursive jobs
       return block.call if ignored_job?(name)
-      initialize_data(name)
+      initialize_data[:name] = name
       begin
         block.call
       rescue Exception => ex
         push_exception(ex, parameters: parameters)
         raise
       ensure
-        data[:runtime] = RorVsWild.clock_milliseconds - data[:started_at]
+        current_data[:runtime] = RorVsWild.clock_milliseconds - current_data[:started_at]
         post_job
       end
     end
 
-    def start_request(payload)
-      return if data[:name]
-      initialize_data(payload[:name])
-      data[:path] = payload[:path]
+    def start_request
+      current_data || initialize_data
     end
 
     def stop_request
-      return unless data[:name]
-      data[:runtime] = RorVsWild.clock_milliseconds - data[:started_at]
+      return unless current_data
+      current_data[:runtime] = RorVsWild.clock_milliseconds - current_data[:started_at]
       post_request
     end
 
@@ -107,21 +105,21 @@ module RorVsWild
 
     def push_exception(exception, options = nil)
       return if ignored_exception?(exception)
-      data[:error] = exception_to_hash(exception)
-      data[:error].merge!(options) if options
-      data[:error]
+      current_data[:error] = exception_to_hash(exception)
+      current_data[:error].merge!(options) if options
+      current_data[:error]
     end
 
-    def data
-      Thread.current[:rorvswild_data] ||= {}
+    def current_data
+      Thread.current[:rorvswild_data]
     end
 
     def add_section(section)
-      return unless data[:sections]
-      if sibling = data[:sections].find { |s| s.sibling?(section) }
+      return unless current_data[:sections]
+      if sibling = current_data[:sections].find { |s| s.sibling?(section) }
         sibling.merge(section)
       else
-        data[:sections] << section
+        current_data[:sections] << section
       end
     end
 
@@ -139,11 +137,8 @@ module RorVsWild
 
     private
 
-    def initialize_data(name)
-      data[:name] = name
-      data[:sections] = []
-      data[:section_stack] = []
-      data[:started_at] = RorVsWild.clock_milliseconds
+    def initialize_data
+      Thread.current[:rorvswild_data] = {sections: [], section_stack: [], started_at: RorVsWild.clock_milliseconds}
     end
 
     def cleanup_data
@@ -153,7 +148,7 @@ module RorVsWild
     end
 
     def post_request
-      queue.push_request(cleanup_data)
+      (data = cleanup_data) && data[:name] && queue.push_request(data)
     end
 
     def post_job

data/lib/rorvswild/client.rb

@@ -21,12 +21,13 @@ module RorVsWild
       @connection_count = 0
       @mutex = Mutex.new
       @config = config
+      @headers = {"Content-Type" => "application/json", "X-Gem-Version" => RorVsWild::VERSION}
+      @headers["X-Rails-Version"] = Rails.version if defined?(Rails)
     end
 
     def post(path, data)
       uri = URI(api_url + path)
-      post = Net::HTTP::Post.new(uri.path, "X-Gem-Version".freeze => RorVsWild::VERSION)
-      post.content_type = "application/json".freeze
+      post = Net::HTTP::Post.new(uri.path, @headers)
       post.basic_auth(nil, api_key)
       post.body = data.to_json
       transmit(post)
@@ -46,6 +47,7 @@ module RorVsWild
 
     def take_or_create_connection
       if http = take_connection
+        http.start unless http.active?
         http
       elsif @connection_count < max_connections
         @connection_count += 1
@@ -57,6 +59,8 @@ module RorVsWild
       if http = take_or_create_connection
         http.request(request)
       end
+    rescue Exception => ex
+      RorVsWild.logger.error(ex.full_message)
     ensure
       release_connection(http)
     end
@@ -65,6 +69,7 @@ module RorVsWild
       uri = URI(api_url)
       http = Net::HTTP.new(uri.host, uri.port)
       http.open_timeout = timeout
+      http.keep_alive_timeout = 5
 
       if uri.scheme == HTTPS
         # Disable peer verification while there is a memory leak with OpenSSL

data/lib/rorvswild/installer.rb

@@ -38,6 +38,7 @@ production:
     #   - Redis
     #   - Resque
     #   - Sidekiq
+    # logger: log/rorvswild.log # By default it uses Rails.logger or Logger.new(STDOUT)
 YAML
     end
   end

data/lib/rorvswild/locator.rb

@@ -34,15 +34,15 @@ module RorVsWild
     end
 
     def relative_path(path)
-      path.index(current_path) == 0 ? path.sub(current_path, "".freeze) : path
+      path.start_with?(current_path) ? path.sub(current_path, "".freeze) : path
     end
 
     def relevant_path?(path)
-      path.index(current_path) == 0 && !irrelevant_path?(path)
+      path.start_with?(current_path) && !irrelevant_path?(path)
     end
 
     def irrelevant_path?(path)
-      irrelevant_paths.any? { |irrelevant_path| path.index(irrelevant_path) }
+      path.start_with?(*irrelevant_paths)
     end
 
     def irrelevant_paths
@@ -52,7 +52,7 @@ module RorVsWild
     private
 
     def initialize_irrelevant_paths
-      array = ["RUBYLIB", "GEM_HOME", "GEM_PATH", "BUNDLER_ORIG_PATH", "BUNDLER_ORIG_GEM_PATH"].flat_map do |name|
+      array = ["RUBYLIB", "GEM_HOME", "GEM_PATH", "BUNDLER_ORIG_GEM_PATH"].flat_map do |name|
         ENV[name].split(":".freeze) if ENV[name]
       end
       array += [heroku_ruby_lib_path] if File.exists?(heroku_ruby_lib_path)

data/lib/rorvswild/plugin/action_controller.rb

@@ -4,29 +4,21 @@ module RorVsWild
       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[:parameters] = controller.request.filtered_parameters
-          hash[:environment_variables] = extract_http_headers(controller.request.filtered_env)
-        end
-        raise exception
-      end
-
       def self.around_action(controller, block)
+        controller_action = "#{controller.class}##{controller.action_name}"
+        return block.call if RorVsWild.agent.ignored_request?(controller_action)
         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.file = RorVsWild.agent.locator.relative_path(section.file)
             section.command = "#{controller.class}##{method_name}"
-            section.kind = "code".freeze
+            RorVsWild.agent.current_data[:name] = controller_action
           end
           block.call
         ensure
@@ -34,15 +26,13 @@ module RorVsWild
         end
       end
 
-      # Payload: controller, action, params, format, method, path
-      def start(name, id, payload)
-        if !RorVsWild.agent.ignored_request?(name = "#{payload[:controller]}##{payload[:action]}")
-          RorVsWild.agent.start_request(name: name, path: payload[:path])
+      def self.after_exception(exception, controller)
+        if hash = RorVsWild.agent.push_exception(exception)
+          hash[:session] = controller.session.to_hash
+          hash[:parameters] = controller.request.filtered_parameters
+          hash[:environment_variables] = extract_http_headers(controller.request.filtered_env)
         end
-      end
-
-      def finish(name, id, payload)
-        RorVsWild.agent.stop_request
+        raise exception
       end
 
       def self.extract_http_headers(headers)

data/lib/rorvswild/plugin/active_job.rb

@@ -1,6 +1,6 @@
 module RorVsWild
   module Plugin
-    module ActiveJob
+    class ActiveJob
       def self.setup
         return if @installed
         return unless defined?(::ActiveJob::Base)
@@ -9,7 +9,17 @@ module RorVsWild
       end
 
       def self.around_perform(job, block)
-        RorVsWild.agent.measure_job(job.class.name, parameters: job.arguments, &block)
+        RorVsWild.agent.measure_job(job.class.name, parameters: job.arguments) do
+          begin
+            section = RorVsWild::Section.start
+            section.command = "#{job.class}#perform"
+            section.file, section.line = job.method(:perform).source_location
+            section.file = RorVsWild.agent.locator.relative_path(section.file)
+            block.call
+          ensure
+            RorVsWild::Section.stop
+          end
+        end
       end
     end
   end

data/lib/rorvswild/plugin/middleware.rb

@@ -0,0 +1,31 @@
+module RorVsWild
+  module Plugin
+    class Middleware
+      def self.setup
+        return if @installed
+        Rails.application.config.middleware.unshift(RorVsWild::Plugin::Middleware, nil) if defined?(Rails)
+        @installed = true
+      end
+
+      def initialize(app, config)
+        @app, @config = app, config
+      end
+
+      def call(env)
+        RorVsWild.agent.start_request
+        RorVsWild.agent.current_data[:path] = env["ORIGINAL_FULLPATH".freeze]
+        section = RorVsWild::Section.start
+        section.file, section.line = rails_engine_location
+        section.command = "Rails::Engine#call".freeze
+        @app.call(env)
+      ensure
+        RorVsWild::Section.stop
+        RorVsWild.agent.stop_request
+      end
+
+      def rails_engine_location
+        @rails_engine_location = ::Rails::Engine.instance_method(:call).source_location
+      end
+    end
+  end
+end

data/lib/rorvswild/queue.rb

@@ -58,7 +58,6 @@ module RorVsWild
     end
 
     def flush
-      RorVsWild.logger.info("RorVsWild::Queue#flush".freeze)
       data = pull_jobs and client.post("/jobs", jobs: data)
       data = pull_requests and client.post("/requests", requests: data)
     end

data/lib/rorvswild/section.rb

@@ -6,12 +6,12 @@ module RorVsWild
     def self.start(&block)
       section = Section.new
       block.call(section) if block_given?
-      stack.push(section)
+      stack && stack.push(section)
       section
     end
 
     def self.stop(&block)
-      section = stack.pop
+      return unless stack && section = stack.pop
       block.call(section) if block_given?
       section.total_runtime = RorVsWild.clock_milliseconds - section.started_at
       current.children_runtime += section.total_runtime if current
@@ -19,17 +19,18 @@ module RorVsWild
     end
 
     def self.stack
-      RorVsWild.agent.data[:section_stack] ||= []
+      (data = RorVsWild.agent.current_data) && data[:section_stack]
     end
 
     def self.current
-      stack.last
+      (sections = stack) && sections.last
     end
 
     def initialize
       @calls = 1
       @total_runtime = 0
       @children_runtime = 0
+      @kind = "code".freeze
       @started_at = RorVsWild.clock_milliseconds
       location = RorVsWild.agent.locator.find_most_relevant_location(caller_locations)
       @file = RorVsWild.agent.locator.relative_path(location.path)

data/lib/rorvswild/version.rb

@@ -1,3 +1,3 @@
 module RorVsWild
-  VERSION = "1.5.0".freeze
+  VERSION = "1.5.5".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rorvswild
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.5
 platform: ruby
 authors:
 - Alexis Bernard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-14 00:00:00.000000000 Z
+date: 2020-05-29 00:00:00.000000000 Z
 dependencies: []
 description: Performances and quality insights for rails developers.
 email:
@@ -46,6 +46,7 @@ files:
 - lib/rorvswild/plugin/delayed_job.rb
 - lib/rorvswild/plugin/elasticsearch.rb
 - lib/rorvswild/plugin/faktory.rb
+- lib/rorvswild/plugin/middleware.rb
 - lib/rorvswild/plugin/mongo.rb
 - lib/rorvswild/plugin/net_http.rb
 - lib/rorvswild/plugin/redis.rb