rorvswild 1.5.12 → 1.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48093e6f93439e8216bd5b0c631b6b56386281d9792f728312d227634834ee11
-  data.tar.gz: 9d7cc84527fc054d47e17ed8f8c736c119660f59d7f077a24b420588875e0685
+  metadata.gz: 29d23fa806fe2d9547169a35795b4b313bf7510264aba4d0f8f3471ae7acf047
+  data.tar.gz: 681d88bef1fb76ede952387ef1d8ffbdf4bfa4cbf08f990f7964624401ff71a9
 SHA512:
-  metadata.gz: 55d90ef1666a3e5696cfbf998a13446d8dc2cddeccf05d56d5dcc6aa3855e5bd5443eb0dccd0b2d54e6af00b1e5babce359fabd2899a4a624a0fcb9f5ab1a5c4
-  data.tar.gz: 909982650664ed49fed2103c7e031ae761ccea22eb5fd39bb82b85e2e3996fd7ec28b891b2151d41ebeadae6f2076ff3c14d895e0a552c006e444e6178d77754
+  metadata.gz: e54dba0143bdb8e94677519698857c7ddc62f91ecb0a876ecc9e0e2fb402e4d11055a59f03cca1c2ca5a2e73b82cf5380574d9e3e4c73d1a66e21c7ea54cfe6c
+  data.tar.gz: 92d4cb2e15015929ccc609b6b81837fb1a78ea12ebe4538555e0a023266fc852001d1aa17d7e620b50dd6ac3f856cbf08bba1d3cb9e4f24f10333b1faa26064d

data/README.md

@@ -89,24 +89,22 @@ If you are using `Rack::Deflater` middleware you won't see the small button in t
 *RoRvsWild.com* makes it easy to monitor requests, background jobs and errors in your production and staging environment.
 It also comes with some extra options listed below.
 
-#### Measure any code
+#### Measure any section of code
 
-You can measure any code like this (useful to monitor cronjobs):
+RorVsWild measures a lot of events such as SQL queries. But it might not be enough for you. There is a solution to measure any section of code to help you find the most hidden bottlenecks.
 
 ```ruby
-RorVsWild.measure_code("User.all.do_something_great")
-```
+# Measure a code given as a string
+RorVsWild.measure("bubble_sort(array)")
 
-Or like that:
+# Measure a code given as a block
+RorVsWild.measure { bubble_sort(array) }
 
-```ruby
-RorVsWild.measure_block("A great job name") { User.all.do_something_great }
+# Measure a code given as a block with an optional description
+RorVsWild.measure("Optional description") { bubble_sort(array) }
 ```
 
-Then it will appear in the jobs page.
-
-Note that Calling `measure_code` or `measure_block` inside or a request or a job will add a section.
-That is convenient to profile finely parts of your code.
+For each custom measure, a section is added with the file name and line number where it has been called.
 
 #### Send errors manually
 
@@ -136,6 +134,18 @@ RorVsWild.record_error(exception, {something: "important"})
 RorVsWild.catch_error(something: "important") { 1 / 0 }
 ```
 
+It is also possible to pre-fill this context data at the begining of each request or job :
+
+```ruby
+class ApplicationController < ActionController::Base
+  before_action :prefill_error_context
+
+  def prefill_error_context
+    RorVsWild.merge_error_context(something: "important")
+  end
+end
+```
+
 #### Ignore requests, jobs, exceptions and plugins
 
 From the configuration file, you can tell RorVsWild to skip monitoring some requests, jobs, exceptions and plugins.
@@ -208,6 +218,30 @@ In the case you want a custom logger such as Syslog, you can only do it by initi
 RorVsWild.start(api_key: "API_KEY", logger: Logger::Syslog.new)
 ```
 
+#### Server metrics monitoring
+
+We are adding server metrics as a beta feature.
+It monitors load average, CPU, memory, swap and disk space.
+For now, only Linux is supported.
+It has to be explicitly enabled with a feature flag :
+
+```yaml
+# config/rorvswild.yml
+production:
+  api_key: API_KEY
+  features:
+    - server_metrics
+```
+
+Here is the equivalent if you prefer initialising RorVsWild manually :
+
+```ruby
+# config/initializers/rorvswild.rb
+RorVsWild.start(api_key: "API_KEY", features: ["server_metrics"])
+```
+
+The data are available in a server tab beside requests and jobs.
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/rorvswild/fork )

data/lib/rorvswild/agent.rb

@@ -16,7 +16,7 @@ module RorVsWild
 
     def self.default_ignored_exceptions
       if defined?(Rails)
-        %w[ActionController::RoutingError] + Rails.application.config.action_dispatch.rescue_responses.map { |(key,value)| key }
+        ActionDispatch::ExceptionWrapper.rescue_responses.keys
       else
         []
       end
@@ -26,6 +26,7 @@ module RorVsWild
 
     def initialize(config)
       @config = self.class.default_config.merge(config)
+      load_features
       @client = Client.new(@config)
       @queue = config[:queue] || Queue.new(client)
       @locator = RorVsWild::Locator.new
@@ -35,6 +36,12 @@ module RorVsWild
       cleanup_data
     end
 
+    def load_features
+      features = config[:features] || []
+      features.include?("server_metrics")
+      require "rorvswild/metrics" if features.include?("server_metrics")
+    end
+
     def setup_plugins
       for name in RorVsWild::Plugin.constants
         next if config[:ignore_plugins] && config[:ignore_plugins].include?(name.to_s)
@@ -49,7 +56,7 @@ module RorVsWild
       measure_block(code) { eval(code) }
     end
 
-    def measure_block(name, kind = "code".freeze, &block)
+    def measure_block(name = nil, kind = "code".freeze, &block)
       current_data ? measure_section(name, kind: kind, &block) : measure_job(name, &block)
     end
 
@@ -113,6 +120,18 @@ module RorVsWild
       current_data[:error]
     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 current_data
       Thread.current[:rorvswild_data]
     end
@@ -134,6 +153,12 @@ module RorVsWild
       config[:ignore_jobs].include?(name)
     end
 
+    def os_description
+      @os_description ||= `uname -sr`
+    rescue Exception => ex
+      @os_description = RbConfig::CONFIG["host_os"]
+    end
+
     #######################
     ### Private methods ###
     #######################
@@ -162,15 +187,16 @@ module RorVsWild
       client.post_async("/errors".freeze, error: hash)
     end
 
-    def exception_to_hash(exception, extra_details = nil)
+    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,
         backtrace: exception.backtrace || ["No backtrace"],
         exception: exception.class.to_s,
-        extra_details: extra_details,
+        extra_details: context,
         environment: {
           os: os_description,
           user: Etc.getlogin,
@@ -186,11 +212,5 @@ module RorVsWild
     def ignored_exception?(exception)
       (config[:ignored_exceptions] || config[:ignore_exceptions]).include?(exception.class.to_s)
     end
-
-    def os_description
-      @os_description ||= `uname -a`
-    rescue Exception => ex
-      @os_description = RUBY_PLATFORM
-    end
   end
 end

data/lib/rorvswild/metrics/cpu.rb

@@ -0,0 +1,31 @@
+module RorVsWild
+  class Metrics
+    class Cpu
+      attr_reader :user, :system, :idle, :waiting, :stolen
+      attr_reader :load_average, :count
+
+      def update
+        if vmstat = execute(:vmstat)
+          vmstat = vmstat.split("\n").last.split
+          @user = vmstat[12].to_i
+          @system = vmstat[13].to_i
+          @idle = vmstat[14].to_i
+          @waiting = vmstat[15].to_i
+          @stolen = vmstat[16].to_i
+        end
+        if uptime = execute(:uptime)
+          @load_average = uptime.split[-3].to_f
+        end
+        if nproc = execute(:nproc)
+          @count = nproc.to_i
+        end
+      end
+
+      def execute(command)
+        `#{command}`
+      rescue => ex
+        nil
+      end
+    end
+  end
+end

data/lib/rorvswild/metrics/memory.rb

@@ -0,0 +1,57 @@
+module RorVsWild
+  class Metrics
+    class Memory
+      attr_reader :ram_total, :ram_free, :ram_available, :ram_buffers, :ram_cached
+      attr_reader :swap_total, :swap_free
+      attr_reader :storage_total, :storage_used
+
+      def ram_used
+        ram_total - ram_available
+      end
+
+      def swap_used
+        swap_total - swap_free
+      end
+
+      PROC_MEMINFO = "/proc/meminfo".freeze
+      MEM_TOTAL = "MemTotal" # Total usable RAM (i.e., physical RAM minus a few reserved bits and the kernel binary code).
+      MEM_FREE = "MemFree" # The sum of LowFree+HighFree.
+      MEM_AVAILABLE = "MemAvailable" # An estimate of how much memory is available for starting new applications, without swapping.
+      BUFFERS = "Buffers" # Relatively temporary storage for raw disk blocks that shouldn't get tremendously large (20MB or so).
+      CACHED = "Cached" # In-memory cache for files read from the disk (the page cache).  Doesn't include SwapCached.
+      SWAP_TOTAL = "SwapTotal" # Total amount of swap space available.
+      SWAP_FREE = "SwapFree" # Amount of swap space that is currently unused.
+
+      def update
+        info = read_meminfo
+        @ram_total = convert_to_bytes(info[MEM_TOTAL])
+        @ram_free = convert_to_bytes(info[MEM_FREE])
+        @ram_available = convert_to_bytes(info[MEM_AVAILABLE])
+        @ram_buffers = convert_to_bytes(info[BUFFERS])
+        @ram_cached = convert_to_bytes(info[CACHED])
+        @swap_total = convert_to_bytes(info[SWAP_TOTAL])
+        @swap_free = convert_to_bytes(info[SWAP_FREE])
+      end
+
+      private
+
+      def units
+        @units ||= {"kb" => 1000, "mb" => 1000 * 1000, "gb" => 1000 * 1000 * 1000}.freeze
+      end
+
+      def read_meminfo
+        return unless File.readable?(PROC_MEMINFO)
+        File.read(PROC_MEMINFO).split("\n").reduce({}) do |hash, line|
+          name, value = line.split(":")
+          hash[name] = value.strip
+          hash
+        end
+      end
+
+      def convert_to_bytes(string)
+        value, unit = string.split
+        value.to_i * units[unit.downcase]
+      end
+    end
+  end
+end

data/lib/rorvswild/metrics/storage.rb

@@ -0,0 +1,17 @@
+module RorVsWild
+  class Metrics
+    class Storage
+      attr_reader :used, :free
+
+      def update
+        array = `df -k | grep " /$"`.split
+        @used = array[2].to_i * 1000
+        @free = array[3].to_i * 1000
+      end
+
+      def total
+        used + free
+      end
+    end
+  end
+end

data/lib/rorvswild/metrics.rb

@@ -0,0 +1,54 @@
+module RorVsWild
+  class Metrics
+    UPDATE_INTERVAL_MS = 60_000 # One metric every minute
+
+    attr_reader :cpu, :memory, :storage, :updated_at
+
+    def initialize
+      @cpu = RorVsWild::Metrics::Cpu.new
+      @memory = RorVsWild::Metrics::Memory.new
+      @storage = RorVsWild::Metrics::Storage.new
+    end
+
+    def update
+      if staled?
+        cpu.update
+        memory.update
+        storage.update
+        @updated_at = RorVsWild.clock_milliseconds
+      end
+    end
+
+    def staled?
+      !updated_at || RorVsWild.clock_milliseconds - updated_at > UPDATE_INTERVAL_MS
+    end
+
+    def to_h
+      {
+        hostname: Socket.gethostname,
+        os: RorVsWild.agent.os_description,
+        cpu_user: cpu.user,
+        cpu_system: cpu.system,
+        cpu_idle: cpu.idle,
+        cpu_waiting: cpu.waiting,
+        cpu_stolen: cpu.stolen,
+        cpu_count: cpu.count,
+        load_average: cpu.load_average,
+        ram_total: memory.ram_total,
+        ram_free: memory.ram_free,
+        ram_used: memory.ram_used,
+        ram_cached: memory.ram_cached,
+        swap_total: memory.swap_total,
+        swap_used: memory.swap_used,
+        swap_free: memory.swap_free,
+        storage_total: storage.total,
+        storage_used: storage.used,
+        storage_free: storage.free,
+      }
+    end
+  end
+end
+
+require "rorvswild/metrics/cpu"
+require "rorvswild/metrics/memory"
+require "rorvswild/metrics/storage"

data/lib/rorvswild/plugin/net_http.rb

@@ -2,7 +2,6 @@ module RorVsWild
   module Plugin
     class NetHttp
       HTTP = "http".freeze
-      HTTPS = "https".freeze
 
       def self.setup
         return if !defined?(Net::HTTP)
@@ -21,9 +20,7 @@ module RorVsWild
 
           def request_with_rorvswild(req, body = nil, &block)
             return request_without_rorvswild(req, body, &block) if request_called_twice?
-            scheme = use_ssl? ? HTTPS : HTTP
-            url = "#{req.method} #{scheme}://#{address}#{req.path}"
-            RorVsWild.agent.measure_section(url, kind: HTTP) do
+            RorVsWild.agent.measure_section("#{req.method} #{address}", kind: HTTP) do
               request_without_rorvswild(req, body, &block)
             end
           end

data/lib/rorvswild/plugin/redis.rb

@@ -18,7 +18,7 @@ module RorVsWild
       end
 
       def self.commands_to_string(commands)
-        commands.map { |c| c[0] == :auth ? "auth *****".freeze : c.join(" ".freeze) }.join("\n".freeze)
+        commands.map { |c| c[0]  }.join("\n".freeze)
       end
 
       APPENDABLE_COMMANDS = [:auth, :select]

data/lib/rorvswild/queue.rb

@@ -1,6 +1,6 @@
 module RorVsWild
   class Queue
-    SLEEP_TIME = 10
+    SLEEP_TIME = 30
     FLUSH_TRESHOLD = 10
 
     attr_reader :mutex, :thread, :client
@@ -11,6 +11,7 @@ module RorVsWild
       @requests = []
       @client = client
       @mutex = Mutex.new
+      @metrics = RorVsWild::Metrics.new if defined?(Metrics)
       Kernel.at_exit { flush }
     end
 
@@ -50,6 +51,10 @@ module RorVsWild
       result
     end
 
+    def pull_server_metrics
+      @metrics && @metrics.update && @metrics.to_h
+    end
+
     def flush_indefinetely
       sleep(SLEEP_TIME) and flush while true
     rescue Exception => ex
@@ -60,6 +65,7 @@ module RorVsWild
     def flush
       data = pull_jobs and client.post("/jobs", jobs: data)
       data = pull_requests and client.post("/requests", requests: data)
+      data = pull_server_metrics and client.post("/metrics", metrics: data)
     end
 
     def start_thread

data/lib/rorvswild/version.rb

@@ -1,3 +1,3 @@
 module RorVsWild
-  VERSION = "1.5.12".freeze
+  VERSION = "1.5.15".freeze
 end

data/lib/rorvswild.rb

@@ -23,6 +23,10 @@ module RorVsWild
     @logger ||= initialize_logger
   end
 
+  def self.measure(code_or_name = nil, &block)
+    block ? measure_block(code_or_name, &block) : measure_code(code_or_name)
+  end
+
   def self.measure_code(code)
     agent ? agent.measure_code(code) : eval(code)
   end
@@ -39,6 +43,10 @@ module RorVsWild
     agent.record_error(exception, extra_details) if agent
   end
 
+  def self.merge_error_context(hash)
+    agent.merge_error_context(hash) if agent
+  end
+
   def self.initialize_logger(destination = nil)
     if destination.respond_to?(:info) && destination.respond_to?(:warn) && destination.respond_to?(:error)
       destination

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rorvswild
 version: !ruby/object:Gem::Version
-  version: 1.5.12
+  version: 1.5.15
 platform: ruby
 authors:
 - Alexis Bernard
 - Antoine Marguerie
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-22 00:00:00.000000000 Z
+date: 2022-08-17 00:00:00.000000000 Z
 dependencies: []
 description: Performances and errors insights for rails developers.
 email:
@@ -40,6 +40,10 @@ files:
 - lib/rorvswild/local/stylesheet/local.css
 - lib/rorvswild/local/stylesheet/vendor/prism.css
 - lib/rorvswild/locator.rb
+- lib/rorvswild/metrics.rb
+- lib/rorvswild/metrics/cpu.rb
+- lib/rorvswild/metrics/memory.rb
+- lib/rorvswild/metrics/storage.rb
 - lib/rorvswild/plugin/action_controller.rb
 - lib/rorvswild/plugin/action_mailer.rb
 - lib/rorvswild/plugin/action_view.rb
@@ -62,8 +66,10 @@ files:
 homepage: https://www.rorvswild.com
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  source_code_uri: https://github.com/BaseSecrete/rorvswild
+  changelog_uri: https://github.com/BaseSecrete/rorvswild/blob/master/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -78,8 +84,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Ruby on Rails applications monitoring
 test_files: []