rorvswild 1.9.2 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97a87e145dfb9f5da27bda89cc828855af232f03a268d7caa7ca89be40c09bd0
-  data.tar.gz: f883c96fdf00e036ca750984ef64ce87318ba8d1ea353ea0b39cc1bd5c3dc71e
+  metadata.gz: ec6464a7193ffe1e78cc6d84804a74e37dd66e20f086b357215e143cca8e3339
+  data.tar.gz: 0547a433e44c778c2f7199be0e6532325e572ac868f85b2209dd99eea1ba4593
 SHA512:
-  metadata.gz: 6728519bcc2ecb291180d6aa1b57947c1b81b845c35ceea401ffe769af3aad83899b17bdd43da5da0f393d42f0f82340fc6376d0fb8aac02c43f9f14c74e0b1d
-  data.tar.gz: 612cd0e042075ebc1249ac05932c9657590d71a783a6e9532ec2d0d85337ed3aeb7869c01f7f1ae82532a75bd29c1a5c1c9d9ddba21b8b72af5dc1b59604076d
+  metadata.gz: 5929a6e6deb9fab72c05e5446363ed3cab3368c2b3c7a2e68ef9e4fa58b0fcc1736421936b6153a8eab650f33a4337bb691744af4739bd99dad63db9c1dbdb2d
+  data.tar.gz: d5533fe4bc53ec97eed6d52e8637a7f231ffed0d56af0716d7e1713d0d3042d88620c201d50edb61e29af26bd786d666d30a403d54ff9b64d046b15ae180fb71

data/lib/rorvswild/agent.rb

@@ -15,7 +15,7 @@ module RorVsWild
     end
 
     def self.default_ignored_exceptions
-      if defined?(Rails)
+      if defined?(ActionDispatch::ExceptionWrapper)
         ActionDispatch::ExceptionWrapper.rescue_responses.keys
       else
         []
@@ -48,7 +48,7 @@ module RorVsWild
         next if config[:ignore_plugins] && config[:ignore_plugins].include?(name.to_s)
         if (plugin = RorVsWild::Plugin.const_get(name)).respond_to?(:setup)
           RorVsWild.logger.debug("Setup RorVsWild::Plugin::#{name}")
-          plugin.setup
+          plugin.setup(self)
         end
       end
     end
@@ -58,7 +58,7 @@ module RorVsWild
     end
 
     def measure_block(name = nil, kind = "code".freeze, &block)
-      current_data ? measure_section(name, kind: kind, &block) : measure_job(name, &block)
+      current_execution ? measure_section(name, kind: kind, &block) : measure_job(name, &block)
     end
 
     def measure_method(method)
@@ -85,7 +85,7 @@ module RorVsWild
     end
 
     def measure_section(name, kind: "code", &block)
-      return block.call unless current_data
+      return block.call unless current_execution
       begin
         RorVsWild::Section.start do |section|
           section.commands << name
@@ -98,32 +98,32 @@ module RorVsWild
     end
 
     def measure_job(name, parameters: nil, &block)
-      return measure_section(name, &block) if current_data # For recursive jobs
+      return measure_section(name, &block) if current_execution # For recursive jobs
       return block.call if ignored_job?(name)
-      initialize_data[:name] = name
+      start_execution(Execution::Job.new(name, parameters))
       begin
         block.call
       rescue Exception => ex
-        push_exception(ex, parameters: parameters, job: {name: name})
+        current_execution.add_exception(ex)
         raise
       ensure
-        gc = Section.stop_gc_timing(current_data[:gc_section])
-        current_data[:sections] << gc if gc.calls > 0
-        current_data[:runtime] = RorVsWild.clock_milliseconds - current_data[:started_at]
-        queue_job
+        stop_execution
       end
     end
 
-    def start_request(queue_time_ms = 0)
-      current_data || initialize_data(queue_time_ms)
+    def start_execution(execution)
+      Thread.current[:rorvswild_execution] ||= execution
+      RorVsWild::Section.start
     end
 
-    def stop_request
-      return unless data = current_data
-      gc = Section.stop_gc_timing(data[:gc_section])
-      data[:sections] << gc if gc.calls > 0 && gc.total_ms > 0
-      data[:runtime] = RorVsWild.clock_milliseconds - current_data[:started_at]
-      queue_request
+    def stop_execution
+      return unless execution = current_execution
+      RorVsWild::Section.stop
+      execution.stop
+      case execution
+      when Execution::Job then queue_job
+      when Execution::Request then queue_request
+      end
     end
 
     def catch_error(context = nil, &block)
@@ -136,44 +136,21 @@ module RorVsWild
     end
 
     def record_error(exception, context = nil)
-      queue_error(exception_to_hash(exception, context)) if !ignored_exception?(exception)
-    end
-
-    def push_exception(exception, options = nil)
-      return if ignored_exception?(exception)
-      return unless current_data
-      current_data[:error] = exception_to_hash(exception)
-      current_data[:error].merge!(options) if options
-      current_data[:error]
+      if !ignored_exception?(exception) && current_execution&.error&.exception != exception
+        queue_error(Error.new(exception, context).as_json)
+      end
     end
 
     def merge_error_context(hash)
-      self.error_context = error_context ? error_context.merge(hash) : hash
-    end
-
-    def error_context
-      current_data[:error_context] if current_data
-    end
-
-    def error_context=(hash)
-      current_data[:error_context] = hash if current_data
-    end
-
-    def send_server_timing=(boolean)
-      current_data[:send_server_timing] = boolean if current_data
+      current_execution && current_execution.merge_error_context(hash)
     end
 
     def current_data
       Thread.current[:rorvswild_data]
     end
 
-    def add_section(section)
-      return unless current_data[:sections]
-      if sibling = current_data[:sections].find { |s| s.sibling?(section) }
-        sibling.merge(section)
-      else
-        current_data[:sections] << section
-      end
+    def current_execution
+      Thread.current[:rorvswild_execution]
     end
 
     def ignored_request?(name)
@@ -186,7 +163,8 @@ module RorVsWild
 
     def ignored_exception?(exception)
       return false unless config[:ignore_exceptions]
-      config[:ignore_exceptions].any? { |str_or_regex| str_or_regex === exception.class.to_s }
+      class_name = exception.class.to_s
+      config[:ignore_exceptions].any? { |str_or_regex| str_or_regex === class_name }
     end
 
     #######################
@@ -195,47 +173,24 @@ module RorVsWild
 
     private
 
-    def initialize_data(queue_time_ms = 0)
-      Thread.current[:rorvswild_data] = {
-        started_at: RorVsWild.clock_milliseconds - queue_time_ms,
-        gc_section: Section.start_gc_timing,
-        environment: Host.to_h,
-        section_stack: [],
-        sections: [],
-      }
-    end
-
     def cleanup_data
-      result = Thread.current[:rorvswild_data]
-      Thread.current[:rorvswild_data] = nil
+      result = Thread.current[:rorvswild_execution]
+      Thread.current[:rorvswild_execution] = nil
       result
     end
 
     def queue_request
-      (data = cleanup_data) && data[:name] && queue.push_request(data)
-      data
+      if (execution = cleanup_data) && execution.name
+        queue.push_request(execution.as_json)
+      end
     end
 
     def queue_job
-      queue.push_job(cleanup_data)
+      queue.push_job(cleanup_data.as_json)
     end
 
     def queue_error(hash)
       queue.push_error(hash)
     end
-
-    def exception_to_hash(exception, context = nil)
-      file, line = locator.find_most_relevant_file_and_line_from_exception(exception)
-      context = context ? error_context.merge(context) : error_context if error_context
-      {
-        line: line.to_i,
-        file: locator.relative_path(file),
-        message: exception.message[0,1_000_000],
-        backtrace: exception.backtrace || ["No backtrace"],
-        exception: exception.class.to_s,
-        context: context,
-        environment: Host.to_h,
-      }
-    end
   end
 end

data/lib/rorvswild/client.rb

@@ -36,7 +36,7 @@ module RorVsWild
       uri = URI(api_url + path)
       post = Net::HTTP::Post.new(uri.path, @headers)
       post.basic_auth(nil, api_key)
-      post.body = data.to_json
+      post.body = JSON.generate(data)
       transmit(post)
     end
 

data/lib/rorvswild/deployment.rb

@@ -4,6 +4,8 @@ require "open3"
 
 module RorVsWild
   module Deployment
+    @revision = @description = @author = @email = nil
+
     def self.load_config(config)
       read
       if hash = config[:deployment]
@@ -35,7 +37,7 @@ module RorVsWild
     end
 
     def self.rails
-      Rails.version if defined?(Rails)
+      Rails.version if defined?(Rails) && Rails.respond_to?(:version)
     end
 
     def self.rorvswild
@@ -47,7 +49,7 @@ module RorVsWild
     end
 
     def self.read
-      read_from_heroku || read_from_scalingo || read_from_git || read_from_capistrano
+      read_from_heroku || read_from_scalingo || read_from_kamal || read_from_git || read_from_capistrano
     end
 
     private
@@ -65,10 +67,7 @@ module RorVsWild
     def self.read_from_git
       return unless @revision = normalize_string(shell("git rev-parse HEAD"))
       return @revision unless log_stdout = shell("git log -1 --pretty=%an%n%ae%n%B")
-      lines = log_stdout.lines
-      @author = normalize_string(lines[0])
-      @email = normalize_string(lines[1])
-      @description = lines[2..-1] && normalize_string(lines[2..-1].join)
+      parse_git_log(log_stdout.lines)
       @revision
     end
 
@@ -76,13 +75,15 @@ module RorVsWild
       return unless File.readable?("REVISION")
       return unless @revision = File.read("REVISION")
       return unless stdout = shell("git --git-dir ../../repo log --format=%an%n%ae%n%B -n 1 #{@revision}")
-      lines = stdout.lines
-      @author = normalize_string(lines[0])
-      @email = normalize_string(lines[1])
-      @description = lines[2..-1] && normalize_string(lines[2..-1].join)
+      parse_git_log(stdout.lines)
       @revision
     end
 
+    def self.read_from_kamal
+      return unless ENV["KAMAL_VERSION"]
+      @revision = ENV["KAMAL_VERSION"]
+    end
+
     def self.normalize_string(string)
       if string
         string = string.strip
@@ -94,5 +95,11 @@ module RorVsWild
       stdout, _, process = Open3.capture3(command) rescue nil
       stdout if process && process.success?
     end
+
+    def self.parse_git_log(lines)
+      @author = normalize_string(lines[0])
+      @email = normalize_string(lines[1])
+      @description = lines[2..-1] && normalize_string(lines[2..-1].join)
+    end
   end
 end

data/lib/rorvswild/error.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RorVsWild
+  class Error
+    attr_reader :exception
+
+    attr_accessor :details
+
+    def initialize(exception, context = nil)
+      @exception = exception
+      @file, @line = locator.find_most_relevant_file_and_line_from_exception(exception)
+      @context = extract_context(context)
+    end
+
+    def locator
+      RorVsWild.agent.locator
+    end
+
+    def as_json(options = nil)
+      hash = {
+        line: @line.to_i,
+        file: locator.relative_path(@file),
+        message: exception.message[0,1_000_000],
+        backtrace: exception.backtrace || ["No backtrace"],
+        exception: exception.class.to_s,
+        context: @context,
+        environment: Host.to_h,
+      }
+      hash.merge!(details) if details
+      hash
+    end
+
+    def extract_context(given_context)
+      hash = defined?(ActiveSupport::ExecutionContext) ? ActiveSupport::ExecutionContext.to_h : {}
+      hash.merge!(RorVsWild.agent&.current_execution&.error_context || {})
+      hash.merge!(given_context) if given_context.is_a?(Hash)
+      hash
+    end
+  end
+end

data/lib/rorvswild/execution.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RorVsWild
+  class Execution
+    attr_reader :parameters, :sections, :section_stack, :error_context, :runtime
+
+    attr_accessor :error, :name
+
+    def initialize(name, parameters)
+      @name = name
+      @parameters = parameters
+      @runtime = nil
+      @error = nil
+      @error_context = nil
+
+      @started_at = RorVsWild.clock_milliseconds
+      @gc_section = Section.start_gc_timing
+      @environment = Host.to_h
+      @section_stack = []
+      @sections = []
+    end
+
+    def add_section(section)
+      if sibling = @sections.find { |s| s.sibling?(section) }
+        sibling.merge(section)
+      else
+        @sections << section
+      end
+    end
+
+    def add_queue_time(queue_time_ms)
+      return unless queue_time_ms
+      @started_at -= queue_time_ms
+      section = Section.new
+      section.total_ms = queue_time_ms
+      section.gc_time_ms = 0
+      section.file = "queue"
+      section.line = 0
+      section.kind = "queue"
+      add_section(section)
+    end
+
+    def stop
+      Section.stop_gc_timing(@gc_section)
+      @sections << @gc_section if @gc_section.calls > 0 && @gc_section.total_ms > 0
+      @runtime = RorVsWild.clock_milliseconds - @started_at
+    end
+
+    def as_json(options = nil)
+      {
+        name: name,
+        runtime: @runtime,
+        error: @error && @error.as_json(options),
+        sections: @sections.map(&:as_json),
+        environment: Host.to_h,
+      }
+    end
+
+    def add_exception(exception)
+      @error = Error.new(exception) if !RorVsWild.agent.ignored_exception?(exception) && !@error
+    end
+
+    def merge_error_context(hash)
+      @error_context = @error_context ? @error_context.merge(hash) : hash
+    end
+
+    private
+
+    def start_gc_timing
+      section = Section.new
+      section.calls = GC.count
+      section.file, section.line = "ruby/gc.c", 0
+      section.add_command("GC.start")
+      section.kind = "gc"
+      section
+    end
+
+    if GC.respond_to?(:total_time)
+      def gc_total_ms
+        GC.total_time / 1_000_000.0 # nanosecond -> millisecond
+      end
+    else
+      def gc_total_ms
+        GC::Profiler.total_time * 1000 # second -> millisecond
+      end
+    end
+
+    class Job < Execution
+      def add_exception(exception)
+        super(exception)
+        @error && @error.details = {parameters: parameters, job: {name: name}}
+        @error
+      end
+    end
+
+    class Request < Execution
+      attr_reader :path
+
+      attr_accessor :controller
+
+      def initialize(path)
+        @path = path
+        super(nil, nil)
+      end
+
+      def add_exception(exception)
+        super(exception)
+        @error && @error.details = {
+          parameters: controller.request.filtered_parameters,
+          request: {
+            headers: headers,
+            name: "#{controller.class}##{controller.action_name}",
+            method: controller.request.method,
+            url: controller.request.url,
+          }
+        }
+        @error
+      end
+
+      def headers
+        controller.request.filtered_env.reduce({}) do |hash, (name, value)|
+          if name.start_with?("HTTP_") && name != "HTTP_COOKIE"
+            hash[name.delete_prefix("HTTP_").split("_").each(&:capitalize!).join("-")] = value
+          end
+          hash
+        end
+      end
+
+      def as_json(options = nil)
+        super(options).merge(path: @path)
+      end
+    end
+  end
+end

data/lib/rorvswild/installer.rb

@@ -52,7 +52,7 @@ production:
   # logger: log/rorvswild.log # By default it uses Rails.logger or Logger.new(STDOUT)
   #
   # # Deployment tracking is working without any actions from your part if the Rails app
-  # # is inside a Git repositoriy, is deployed via Capistrano.
+  # # is inside a Git repository, is deployed via Capistrano.
   # # In the other cases, you can provide the following details.
   # deployment:
   #   revision: <%= "Anything that will return the deployment version" %> # Mandatory

data/lib/rorvswild/local/local.html.erb

@@ -11,7 +11,7 @@
     <div class="rorvswild-local-panel__header">
       <div class="rorvswild-local-panel__width-limiter">
         <a href="https://www.rorvswild.com" class="rorvswild-local-panel__logo">
-          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 34.83 30.83">
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 34.83 30.83" fill="none" width="24px" height="24px">
             <polygon points="17.41 9.41 13.41 9.41 9.41 13.41 17.41 21.41 25.41 13.41 21.41 9.41 17.41 9.41"/>
             <polyline points="1.41 21.41 9.41 29.41 17.41 21.41 25.41 29.41 33.41 21.41"/>
             <polyline points="9.41 5.41 5.41 1.41 1.41 5.41"/>

data/lib/rorvswild/local/queue.rb

@@ -3,6 +3,13 @@
 module RorVsWild
   module Local
     class Queue
+      def initialize(config = {})
+        @config = config
+        dir = File.directory?("tmp") ? "tmp" : Dir.tmpdir
+        @directoy = File.join(dir, "rorvswild", @config[:prefix].to_s)
+        FileUtils.mkpath(@directoy)
+      end
+
       def push_job(data)
         push_to(data, "jobs")
         push_error(data[:error]) if data[:error]
@@ -34,23 +41,30 @@ module RorVsWild
       def push_to(data, name)
         data[:queued_at] = Time.now
         data[:uuid] = SecureRandom.uuid
-        array = load_data(name)
-        array.unshift(data)
-        array.pop if array.size > 100
-        save_data(array, name)
-      end
-
-      def save_data(data, name)
-        File.open(File.join(directoy, "#{name}.json"), "w") { |file| JSON.dump(data, file) }
+        File.open(File.join(@directoy, "#{name}.ndjson"), "a") { |file| file.write(JSON.dump(data) + "\n") }
       end
 
       def load_data(name)
-        JSON.load_file(File.join(directoy, "#{name}.json"), symbolize_names: true) rescue []
+        return [] unless File.readable?(path = File.join(@directoy, "#{name}.ndjson"))
+        return [] unless lines = read_last_lines(path, 100)
+        lines.reverse.map { |line| JSON.parse(line, symbolize_names: true) }
       end
 
-      def directoy
-        dir = File.directory?("tmp") ? "tmp" : Dir.tmpdir
-        FileUtils.mkpath(File.join(dir, "rorvswild"))[0]
+      def read_last_lines(path, desired_lines, max_read_size = 4096 * desired_lines)
+        read_lines, buffer = 0, []
+        File.open(path, "rb") do |file|
+          file.seek(0, IO::SEEK_END)
+          pos = file.pos
+          while pos > 0 && read_lines <= desired_lines
+            read_size = max_read_size < pos ? max_read_size : pos
+            file.seek(pos -= read_size, IO::SEEK_SET)
+            buffer << file.read(read_size)
+            read_lines += buffer.last.count("\n")
+          end
+        end
+        lines = buffer.reverse.join.lines
+        offset = [lines.size - 1, desired_lines].min
+        lines[-offset..-1]
       end
     end
   end

data/lib/rorvswild/local.rb

@@ -4,7 +4,8 @@ require "rorvswild/local/queue"
 module RorVsWild
   module Local
     def self.start(config = {})
-      RorVsWild.start(config.merge(queue: RorVsWild::Local::Queue.new))
+      queue = RorVsWild::Local::Queue.new(config[:queue] || {})
+      RorVsWild.start(config.merge(queue: queue))
       Rails.application.config.middleware.unshift(RorVsWild::Local::Middleware, nil)
     end
   end

data/lib/rorvswild/locator.rb

@@ -12,7 +12,9 @@ module RorVsWild
     end
 
     def find_most_relevant_location(locations)
-      locations.find { |l| relevant_path?(l.path) } || locations.find { |l| !l.path.start_with?(rorvswild_lib_path) } || locations.first
+      locations.find { |l| l.path && relevant_path?(l.path) } ||
+        locations.find { |l| l.path && !l.path.start_with?(rorvswild_lib_path) } ||
+        locations.first
     end
 
     def find_most_relevant_file_and_line_from_exception(exception)

data/lib/rorvswild/metrics.rb

@@ -3,6 +3,7 @@ module RorVsWild
     attr_reader :cpu, :memory, :storage, :updated_at
 
     def initialize
+      @updated_at = nil
       @cpu = RorVsWild::Metrics::Cpu.new
       @memory = RorVsWild::Metrics::Memory.new
       @storage = RorVsWild::Metrics::Storage.new

data/lib/rorvswild/plugin/action_controller.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module RorVsWild
   module Plugin
     class ActionController
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
         return unless defined?(::ActionController::Base)
         ::ActionController::Base.around_action(&method(:around_action))
-        ::ActionController::Base.rescue_from(StandardError) { |ex| RorVsWild::Plugin::ActionController.after_exception(ex, self) }
-
         if defined?(::ActionController::API) && ::ActionController::API.respond_to?(:around_action)
           ::ActionController::API.around_action(&method(:around_action))
-          ::ActionController::API.rescue_from(StandardError) { |ex| RorVsWild::Plugin::ActionController.after_exception(ex, self) }
         end
         @installed = true
       end
@@ -24,42 +25,19 @@ module RorVsWild
               section.file = RorVsWild.agent.locator.relative_path(section.file)
               section.commands << "#{controller.class}##{method_name}"
             end
-            RorVsWild.agent.current_data[:name] = controller_action if RorVsWild.agent.current_data
+            if execution = RorVsWild.agent.current_execution
+              execution.name = controller_action
+              execution.controller = controller
+            end
           end
           block.call
+        rescue => exception
+          RorVsWild.agent.current_execution&.add_exception(exception)
+          raise
         ensure
           RorVsWild::Section.stop
         end
       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[:request] = {
-            headers: extract_http_headers(controller.request.filtered_env),
-            name: "#{controller.class}##{controller.action_name}",
-            method: controller.request.method,
-            url: controller.request.url,
-          }
-        end
-        raise exception
-      end
-
-      def self.extract_http_headers(headers)
-        headers.reduce({}) do |hash, (name, value)|
-          if name.index("HTTP_".freeze) == 0 && name != "HTTP_COOKIE".freeze
-            hash[format_header_name(name)] = value
-          end
-          hash
-        end
-      end
-
-      HEADER_REGEX = /^HTTP_/.freeze
-
-      def self.format_header_name(name)
-        name.sub(HEADER_REGEX, ''.freeze).split("_".freeze).map(&:capitalize).join("-".freeze)
-      end
     end
   end
 end

data/lib/rorvswild/plugin/action_mailer.rb

@@ -1,9 +1,11 @@
 module RorVsWild
   module Plugin
     class ActionMailer
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
-        return unless defined?(::ActiveSupport::Notifications.subscribe)
+        return unless defined?(ActiveSupport::Notifications.subscribe)
         ActiveSupport::Notifications.subscribe("deliver.action_mailer", new)
         @installed = true
       end

data/lib/rorvswild/plugin/action_view.rb

@@ -3,9 +3,11 @@
 module RorVsWild
   module Plugin
     class ActionView
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
-        return unless defined?(::ActiveSupport::Notifications.subscribe)
+        return unless defined?(ActiveSupport::Notifications.subscribe)
         ActiveSupport::Notifications.subscribe("render_partial.action_view", plugin = new)
         ActiveSupport::Notifications.subscribe("render_template.action_view", plugin)
         ActiveSupport::Notifications.subscribe("render_collection.action_view", plugin)

data/lib/rorvswild/plugin/active_job.rb

@@ -1,7 +1,9 @@
 module RorVsWild
   module Plugin
     class ActiveJob
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
         return unless defined?(::ActiveJob::Base)
         ::ActiveJob::Base.around_perform(&method(:around_perform))

data/lib/rorvswild/plugin/active_record.rb

@@ -3,14 +3,16 @@
 module RorVsWild
   module Plugin
     class ActiveRecord
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
         setup_callback
         @installed = true
       end
 
       def self.setup_callback
-        return unless defined?(::ActiveSupport::Notifications.subscribe)
+        return unless defined?(ActiveSupport::Notifications.subscribe)
         ActiveSupport::Notifications.subscribe("sql.active_record", new)
       end
 
@@ -38,7 +40,7 @@ module RorVsWild
         section.commands << normalize_sql_query(event.payload[:sql])
         section.kind = "sql"
         (parent = Section.current) && parent.children_ms += section.total_ms
-        RorVsWild.agent.add_section(section)
+        execution = RorVsWild.agent.current_execution and execution.add_section(section)
       end
 
       SQL_STRING_REGEX = /'((?:''|\\'|[^'])*)'/

data/lib/rorvswild/plugin/delayed_job.rb

@@ -3,7 +3,9 @@
 module RorVsWild
   module Plugin
     module DelayedJob
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
         return unless defined?(Delayed::Plugin)
         Delayed::Worker.plugins << Class.new(Delayed::Plugin) do

data/lib/rorvswild/plugin/elasticsearch.rb

@@ -1,7 +1,7 @@
 module RorVsWild
   module Plugin
     class Elasticsearch
-      def self.setup
+      def self.setup(agent)
         return if !defined?(::Elasticsearch::Transport)
         return if ::Elasticsearch::Transport::Client.method_defined?(:perform_request_without_rorvswild)
 

data/lib/rorvswild/plugin/faktory.rb

@@ -1,7 +1,7 @@
 module RorVsWild
   module Plugin
     class Faktory
-      def self.setup
+      def self.setup(agent)
         if defined?(::Faktory)
           ::Faktory.configure_worker do |config|
             config.worker_middleware { |chain| chain.add(Faktory) }

data/lib/rorvswild/plugin/middleware.rb

@@ -46,7 +46,9 @@ module RorVsWild
 
       include RequestQueueTime
 
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
         Rails.application.config.middleware.unshift(RorVsWild::Plugin::Middleware, nil) if defined?(Rails)
         @installed = true
@@ -57,10 +59,9 @@ module RorVsWild
       end
 
       def call(env)
-        queue_time_ms = calculate_queue_time(env)
-        RorVsWild.agent.start_request(queue_time_ms || 0)
-        RorVsWild.agent.current_data[:path] = env["ORIGINAL_FULLPATH"]
-        add_queue_time_section(queue_time_ms)
+        execution = RorVsWild::Execution::Request.new(env["ORIGINAL_FULLPATH"])
+        execution.add_queue_time(calculate_queue_time(env))
+        RorVsWild.agent.start_execution(execution)
         section = RorVsWild::Section.start
         section.file, section.line = rails_engine_location
         section.commands << "Rails::Engine#call"
@@ -68,24 +69,11 @@ module RorVsWild
         [code, headers, body]
       ensure
         RorVsWild::Section.stop
-        inject_server_timing(RorVsWild.agent.stop_request, headers)
+        RorVsWild.agent.stop_execution
       end
 
       private
 
-      def add_queue_time_section(queue_time_ms)
-        return unless queue_time_ms
-
-        section = Section.new
-        section.stop
-        section.total_ms = queue_time_ms
-        section.gc_time_ms = 0
-        section.file = "request-queue"
-        section.line = 0
-        section.kind = "queue"
-        RorVsWild.agent.add_section(section)
-      end
-
       def calculate_queue_time(env)
         queue_time_from_header = parse_queue_time_header(env)
 
@@ -95,49 +83,6 @@ module RorVsWild
       def rails_engine_location
         @rails_engine_location = ::Rails::Engine.instance_method(:call).source_location
       end
-
-      def format_server_timing_header(sections)
-        sections.map do |section|
-          if section.kind == "view"
-            "#{section.kind};dur=#{section.self_ms.round};desc=\"#{section.file}\""
-          else
-            "#{section.kind};dur=#{section.self_ms.round};desc=\"#{section.file}:#{section.line}\""
-          end
-        end.join(", ")
-      end
-
-      def format_server_timing_ascii(sections, total_width = 80)
-        max_time = sections.map(&:self_ms).max
-        chart_width = (total_width * 0.25).to_i
-        rows = sections.map { |section|
-          [
-            section.kind == "view" ? section.file : "#{section.file}:#{section.line}",
-            "█" * (section.self_ms * (chart_width-1) / max_time),
-            "%.1fms" % section.self_ms,
-          ]
-        }
-        time_width = rows.map { |cols| cols[2].size }.max + 1
-        label_width = total_width - chart_width - time_width
-        rows.each { |cols| cols[0] = truncate_backwards(cols[0], label_width) }
-        template = "%-#{label_width}s%#{chart_width}s%#{time_width}s"
-        rows.map { |cols| format(template, *cols) }.join("\n")
-      end
-
-      def truncate_backwards(string, width)
-        string.size > width ? "…" + string[-(width - 1)..-1] : string
-      end
-
-      def inject_server_timing(data, headers)
-        return if !data || !data[:send_server_timing] || !(sections = data[:sections])
-        sections = sections.sort_by(&:self_ms).reverse[0,10]
-        headers["Server-Timing"] = format_server_timing_header(sections)
-        if data[:name] && RorVsWild.logger.level <= Logger::Severity::DEBUG
-          RorVsWild.logger.debug(["┤ #{data[:name]} ├".center(80, "─"),
-            format_server_timing_ascii(sections),
-            "─" * 80, nil].join("\n")
-          )
-        end
-      end
     end
   end
 end

data/lib/rorvswild/plugin/mongo.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module RorVsWild
   module Plugin
     class Mongo
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
         return if !defined?(::Mongo::Monitoring::Global)
         ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, Mongo.new)
@@ -10,13 +14,10 @@ module RorVsWild
 
       attr_reader :commands
 
-      def initialize
-        @commands = {}
-      end
-
       def started(event)
-        RorVsWild::Section.start
-        commands[event.request_id] = event.command
+        section = RorVsWild::Section.start
+        section.kind = "mongo"
+        section.commands << normalize_query(event.command).to_json
       end
 
       def failed(event)
@@ -28,9 +29,40 @@ module RorVsWild
       end
 
       def after_query(event)
-        RorVsWild::Section.stop do |section|
-          section.kind = "mongo".freeze
-          section.command = commands.delete(event.request_id).to_s
+        RorVsWild::Section.stop
+      end
+
+      QUERY_ROOT_KEYS = %w[
+        insert update delete findAndModify bulkWrite
+        find aggregate count distinct
+        create drop listCollections listDatabases dropDatabase
+        startSession commitTransaction abortTransaction
+        filter getMore collection sort
+      ]
+
+      def normalize_query(query)
+        query = query.slice(*QUERY_ROOT_KEYS)
+        query["filter"] = normalize_hash(query["filter"]) if query["filter"]
+        query["getMore"] = normalize_value(query["getMore"]) if query["getMore"]
+        query
+      end
+
+      def normalize_hash(hash)
+        (hash = hash.to_h).each { |key, val| hash[key] = normalize_value(val) }
+      end
+
+      def normalize_array(array)
+        array.map { |value| normalize_value(value) }
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash then normalize_hash(value.to_h)
+        when Array then normalize_array(value)
+        when FalseClass then false
+        when TrueClass then true
+        when NilClass then nil
+        else "?"
         end
       end
     end

data/lib/rorvswild/plugin/net_http.rb

@@ -3,7 +3,7 @@ module RorVsWild
     class NetHttp
       HTTP = "http".freeze
 
-      def self.setup
+      def self.setup(agent)
         return if !defined?(Net::HTTP)
         return if Net::HTTP.method_defined?(:request_without_rorvswild)
 

data/lib/rorvswild/plugin/rails_cache.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RorVsWild
+  module Plugin
+    class RailsCache
+      @installed = false
+
+      def self.setup(agent)
+        return if @installed
+        return unless defined?(ActiveSupport::Notifications.subscribe)
+        plugin = new
+        for name in ["write", "read", "delete", "write_multi", "read_multi", "delete_multi", "increment", "decrement"]
+          ActiveSupport::Notifications.subscribe("cache_#{name}.active_support", plugin)
+        end
+        @installed = true
+      end
+
+      def start(name, id, payload)
+        RorVsWild::Section.start do |section|
+          section.commands << name.split(".")[0].delete_prefix("cache_")
+          section.kind = "cache"
+        end
+      end
+
+      def finish(name, id, payload)
+        RorVsWild::Section.stop
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/rails_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RorVsWild
+  module Plugin
+    class RailsError
+      @installed = false
+
+      def self.setup(agent)
+        return if @installed
+        return if !defined?(Rails.error)
+        return if !defined?(ActiveSupport::ErrorReporter)
+        Rails.error.subscribe(new)
+        @installed = true
+      end
+
+      def report(error, handled: nil, severity: nil, context: nil, source: nil)
+        RorVsWild.record_error(error, context)
+      end
+    end
+  end
+end

data/lib/rorvswild/plugin/redis.rb

@@ -3,7 +3,7 @@
 module RorVsWild
   module Plugin
     class Redis
-      def self.setup
+      def self.setup(agent)
         return if !defined?(::Redis)
         if ::Redis::Client.method_defined?(:process)
           ::Redis::Client.prepend(V4)

data/lib/rorvswild/plugin/resque.rb

@@ -1,7 +1,9 @@
 module RorVsWild
   module Plugin
     module Resque
-      def self.setup
+      @installed = false
+
+      def self.setup(agent)
         return if @installed
         ::Resque::Job.send(:extend, Resque) if defined?(::Resque::Job)
         @installed = true

data/lib/rorvswild/plugin/sidekiq.rb

@@ -1,18 +1,33 @@
+# frozen_string_literal: true
+
 module RorVsWild
   module Plugin
     class Sidekiq
-      def self.setup
+      INTERNAL_EXCEPTIONS = ["Sidekiq::JobRetry::Handled", "Sidekiq::JobRetry::Skip"]
+
+      def self.setup(agent)
         if defined?(::Sidekiq)
           ::Sidekiq.configure_server do |config|
             config.server_middleware { |chain| chain.add(Sidekiq) }
           end
+          # Prevent RailsError plugin from sending internal Sidekiq exceptions captured by ActiveSupport::ErrorReporter.
+          agent.config[:ignore_exceptions].concat(INTERNAL_EXCEPTIONS)
         end
       end
 
       def call(worker, item, queue, &block)
         # Wrapped contains the real class name of the ActiveJob wrapper
         name = item["wrapped".freeze] || item["class".freeze]
-        RorVsWild.agent.measure_job(name, parameters: item["args".freeze], &block)
+        RorVsWild.agent.measure_job(name, parameters: item["args".freeze]) do
+          section = RorVsWild::Section.start
+          section.commands << "#{name}#perform"
+          if perform_method = worker.method(:perform)
+            section.file, section.line = worker.method(:perform).source_location
+            section.file = RorVsWild.agent.locator.relative_path(section.file)
+          end
+          block.call
+          RorVsWild::Section.stop
+        end
       end
     end
   end

data/lib/rorvswild/rails_loader.rb

@@ -15,6 +15,10 @@ module RorVsWild
       elsif Rails.env.development?
         require "rorvswild/local"
         RorVsWild::Local.start(config || {})
+      elsif Rails.env.test?
+        require "rorvswild/local"
+        path = "tests/#{DateTime.now.iso8601}"
+        RorVsWild::Local.start({widget: "hidden", queue: {prefix: path}}.merge(config || {}))
       end
     end
 

data/lib/rorvswild/section.rb

@@ -13,15 +13,15 @@ module RorVsWild
     end
 
     def self.stop(&block)
-      return unless stack && section = stack.pop
+      return if !(sections = stack) || !(section = sections.pop)
       block.call(section) if block_given?
       section.stop
       current.children_ms += section.total_ms if current
-      RorVsWild.agent.add_section(section)
+      execution = RorVsWild.agent.current_execution and execution.add_section(section)
     end
 
     def self.stack
-      (data = RorVsWild.agent.current_data) && data[:section_stack]
+      execution = RorVsWild.agent.current_execution and execution.section_stack
     end
 
     def self.current
@@ -94,7 +94,7 @@ module RorVsWild
     end
 
     def as_json(options = nil)
-      {calls: calls, total_runtime: total_ms, children_runtime: children_ms, async_runtime: async_ms, kind: kind, started_at: start_ms, file: file, line: line, command: command}
+      {calls: calls, total_runtime: total_ms, children_runtime: children_ms, async_runtime: async_ms, kind: kind, file: file, line: line, command: command}
     end
 
     def to_json(options = {})

data/lib/rorvswild/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RorVsWild
-  VERSION = "1.9.2".freeze
+  VERSION = "1.10.1"
 end

data/lib/rorvswild.rb

@@ -7,6 +7,8 @@ require "rorvswild/section"
 require "rorvswild/client"
 require "rorvswild/plugins"
 require "rorvswild/queue"
+require "rorvswild/error"
+require "rorvswild/execution"
 require "rorvswild/agent"
 
 module RorVsWild
@@ -61,7 +63,7 @@ module RorVsWild
   end
 
   def self.send_server_timing=(boolean)
-    agent.send_server_timing = boolean if agent
+    warn "[DEPRECATION] `RorVsWild.send_server_timing=` is deprecated and is no longer supported."
   end
 
   def self.initialize_logger(destination = nil)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rorvswild
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.10.1
 platform: ruby
 authors:
 - Alexis Bernard
@@ -27,6 +27,8 @@ files:
 - lib/rorvswild/agent.rb
 - lib/rorvswild/client.rb
 - lib/rorvswild/deployment.rb
+- lib/rorvswild/error.rb
+- lib/rorvswild/execution.rb
 - lib/rorvswild/host.rb
 - lib/rorvswild/installer.rb
 - lib/rorvswild/local.rb
@@ -56,6 +58,8 @@ files:
 - lib/rorvswild/plugin/middleware.rb
 - lib/rorvswild/plugin/mongo.rb
 - lib/rorvswild/plugin/net_http.rb
+- lib/rorvswild/plugin/rails_cache.rb
+- lib/rorvswild/plugin/rails_error.rb
 - lib/rorvswild/plugin/redis.rb
 - lib/rorvswild/plugin/resque.rb
 - lib/rorvswild/plugin/sidekiq.rb
@@ -84,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby on Rails applications monitoring
 test_files: []