rorvswild 0.6.1 → 1.0.0.pre.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbf7691d74ad331f2e029ac10ae01a9539ee6214
-  data.tar.gz: 0185bc142951be856aa7d10652bf7d265adac424
+  metadata.gz: 1736359534ad385b3f94023b6f58aedeb80758d9
+  data.tar.gz: 7b3977b85d8cc46cf332bccd8ada6c8ed482a1a4
 SHA512:
-  metadata.gz: 506d3382ce683c60b22c18ac19479d150396051cce1f488e6229bcffd960c62e1b92739f29a11c78834542f83497757b1019ed59af59a92db4f19fd23dd133a8
-  data.tar.gz: c97447ef50720e3a7d8519370c6d8769a08fc3c7706ce656fe46aa82d4f960c6e7416003885167658fb26c777a3376fe7143cce45b9bab2bb68a316378137bb8
+  metadata.gz: 0851e785429d0263cdf0f0b98792db188a9616fc16bb98847dd2e1ccb979e3627a5a591f6282468c62e18ca46ccba79aaa10441c60f2b258d51b174d28c25489
+  data.tar.gz: 02e3b948d90d5fb378c6707d6e2d563348a1549bec9465e7a5dd2d00488d918d229e9d5ef0ef11dc3cf4453ea8d686539b8ff6c1e6695ae5ef768ab1e8b021b3

data/Gemfile

@@ -5,3 +5,11 @@ gemspec
 
 gem "mocha"
 gem "top_tests"
+
+gem "mongo"
+gem "redis"
+
+gem "actionpack"
+gem "activejob"
+
+gem "delayed_job"

data/README.md

@@ -16,9 +16,78 @@ 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)
+RorVsWild.start(api_key: API_KEY)
 ```
 
+## Measure any code
+
+You can measure any code like this (useful to monitor cronjobs):
+
+```ruby
+RorVsWild.measure_code("User.all.do_something_great")
+```
+
+Or like that:
+
+```ruby
+RorVsWild.measure_block("A great job name") { User.all.do_something_great }
+```
+
+Then it will appears 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.
+
+## Send errors manually
+
+When you already have a begin / rescue block, this manner suits well:
+
+```ruby
+begin
+  # Your code ...
+rescue => exception
+  RorVsWild.record_error(exception)
+end
+```
+
+If you prefer to be concise, just run the code from a block:
+
+```ruby
+RorVsWild.catch_error { 1 / 0 }  # => #<ZeroDivisionError: divided by 0>
+```
+
+Moreover, you can provide extra details when capturing errors:
+
+```ruby
+RorVsWild.record_error(exception, {something: "important"})
+```
+
+```ruby
+RorVsWild.catch_error(something: "important") { 1 / 0 }
+```
+
+## Ignore exceptions
+
+By using the ignored_exceptions parameter you can prevent RorVsWild from recording specific exceptions.
+
+```yaml
+# config/rorvswild.yml
+production:
+  api_key: API_KEY
+  ignored_exceptions:
+    - ActionController::RoutingError
+    - ZeroDivisionError
+```
+
+```ruby
+# config/initializers/rorvswild.rb
+RorVsWild::Client.new(
+  api_key: "API_KEY",
+  ignored_exceptions: ["ActionController::RoutingError", "ZeroDivisionError"])
+```
+
+By default ActionController::RoutingError is ignored in order to not be flooded with 404.
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/rorvswild/fork )

data/lib/rorvswild.rb

@@ -1,35 +1,33 @@
 require "rorvswild/version"
 require "rorvswild/location"
-require "rorvswild/plugin/redis"
-require "rorvswild/plugin/mongo"
-require "rorvswild/plugin/resque"
-require "rorvswild/plugin/sidekiq"
-require "rorvswild/plugin/net_http"
+require "rorvswild/section"
 require "rorvswild/client"
+require "rorvswild/plugins"
+require "rorvswild/agent"
 
 module RorVsWild
-  def self.measure_code(code)
-    client ? client.measure_code(code) : eval(code)
+  def self.start(config)
+    @agent = Agent.new(config)
   end
 
-  def self.measure_block(name, &block)
-    client ? client.measure_block(name , &block) : block.call
+  def self.agent
+    @agent
   end
 
-  def self.catch_error(extra_details = nil, &block)
-    client ? client.catch_error(extra_details, &block) : block.call
+  def self.measure_code(code)
+    agent ? agent.measure_code(code) : eval(code)
   end
 
-  def self.record_error(exception, extra_details = nil)
-    client.record_error(exception, extra_details) if client
+  def self.measure_block(name, &block)
+    agent ? agent.measure_block(name , &block) : block.call
   end
 
-  def self.register_client(client)
-    @client = client
+  def self.catch_error(extra_details = nil, &block)
+    agent ? agent.catch_error(extra_details, &block) : block.call
   end
 
-  def self.client
-    @client
+  def self.record_error(exception, extra_details = nil)
+    agent.record_error(exception, extra_details) if agent
   end
 end
 

data/lib/rorvswild/agent.rb

@@ -0,0 +1,180 @@
+require "logger"
+
+module RorVsWild
+  class Agent
+    include RorVsWild::Location
+
+    def self.default_config
+      {
+        api_url: "https://www.rorvswild.com/api",
+        ignored_exceptions: [],
+      }
+    end
+
+    attr_reader :api_url, :api_key, :app_id, :app_root, :ignored_exceptions
+
+    attr_reader :app_root_regex, :client
+
+    def initialize(config)
+      config = self.class.default_config.merge(config)
+      @ignored_exceptions = config[:ignored_exceptions]
+      @app_root = config[:app_root]
+      @logger = config[:logger]
+      @data = {}
+      @client = Client.new(config)
+
+      if defined?(Rails)
+        @logger ||= Rails.logger
+        @app_root ||= Rails.root.to_s
+        config = Rails.application.config
+        @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_plugins
+    end
+
+    def setup_plugins
+      Plugin::NetHttp.setup
+
+      Plugin::Redis.setup
+      Plugin::Mongo.setup
+
+      Plugin::Resque.setup
+      Plugin::Sidekiq.setup
+      Plugin::ActiveJob.setup
+      Plugin::DelayedJob.setup
+
+      Plugin::ActionView.setup
+      Plugin::ActiveRecord.setup
+      Plugin::ActionMailer.setup
+      Plugin::ActionController.setup
+    end
+
+    def measure_code(code)
+      measure_block(code) { eval(code) }
+    end
+
+    def measure_block(name, kind = "code", &block)
+      data[:name] ? measure_section(name, kind, &block) : measure_job(name, &block)
+    end
+
+    def measure_section(name, kind = "code", &block)
+      return block.call unless data[:name]
+      begin
+        RorVsWild::Section.start do |section|
+          section.command = name
+          section.kind = kind
+        end
+        block.call
+      ensure
+        RorVsWild::Section.stop
+      end
+    end
+
+    def measure_job(name, &block)
+      return block.call if data[:name] # Prevent from recursive jobs
+      initialize_data(name)
+      begin
+        block.call
+      rescue Exception => ex
+        data[:error] = exception_to_hash(ex) if !ignored_exception?(ex)
+        raise
+      ensure
+        data[:runtime] = (Time.now - data[:started_at]) * 1000
+        post_job
+      end
+    end
+
+    def start_request(payload)
+      return if data[:name]
+      initialize_data(payload[:name])
+      data[:path] = payload[:path]
+    end
+
+    def stop_request
+      return unless data[:name]
+      data[:runtime] = (Time.now.utc - data[:started_at]) * 1000
+      post_request
+    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 push_exception(exception)
+      return if ignored_exception?(exception)
+      data[:error] = exception_to_hash(exception)
+    end
+
+    def data
+      @data[Thread.current.object_id] ||= {}
+    end
+
+    def add_section(section)
+      return unless data[:sections]
+      if sibling = data[:sections].find { |s| s.sibling?(section) }
+        sibling.merge(section)
+      else
+        data[:sections] << section
+      end
+    end
+
+    #######################
+    ### Private methods ###
+    #######################
+
+    private
+
+    def initialize_data(name)
+      data[:name] = name
+      data[:sections] = []
+      data[:section_stack] = []
+      data[:started_at] = Time.now.utc
+    end
+
+    def cleanup_data
+      @data.delete(Thread.current.object_id)
+    end
+
+    def post_request
+      client.post_async("/requests".freeze, request: cleanup_data)
+    end
+
+    def post_job
+      client.post_async("/jobs".freeze, job: cleanup_data)
+    end
+
+    def post_error(hash)
+      post_async("/errors".freeze, error: hash)
+    end
+
+    def exception_to_hash(exception, extra_details = nil)
+      file, line, method = extract_most_relevant_file_and_line(exception.backtrace_locations)
+      {
+        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
+
+    def ignored_exception?(exception)
+      ignored_exceptions.include?(exception.class.to_s)
+    end
+  end
+end

data/lib/rorvswild/client.rb

@@ -1,281 +1,22 @@
-require "json/ext"
-require "net/http"
-require "logger"
-require "uri"
 require "set"
+require "uri"
+require "net/http"
+require "json/ext"
 
 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
+    HTTPS = "https".freeze
+    CERTIFICATE_AUTHORITIES_PATH = File.expand_path("../../../cacert.pem", __FILE__)
 
-    attr_reader :threads, :app_root_regex
+    attr_reader :api_url, :api_key, :threads
 
     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]
+      Kernel.at_exit(&method(:at_exit))
       @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::Redis.setup
-      Plugin::Mongo.setup
-      Plugin::Resque.setup
-      Plugin::Sidekiq.setup
-      Plugin::NetHttp.setup
-      Kernel.at_exit(&method(:at_exit))
-      ActiveJob::Base.around_perform(&method(:around_active_job)) if defined?(ActiveJob::Base)
-      Delayed::Worker.lifecycle.around(:invoke_job, &method(:around_delayed_job)) if defined?(Delayed::Worker)
-    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(kind: "sql", file: file, line: line, method: method, command: 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 measure_query(kind, command, &block)
-      return block.call if @query_started_at  # Prevent from recursive queries
-      @query_started_at = Time.now.utc
-      begin
-        result = block.call
-        runtime = (Time.now.utc - @query_started_at) * 1000
-        file, line, method = extract_most_relevant_location(caller)
-        push_query(kind: kind, command: command, file: file, line: line, method: method, runtime: runtime)
-        result
-      ensure
-        @query_started_at = nil
-      end
-    end
-
-    def catch_error(extra_details = nil, &block)
-      begin
-        block.call
-      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)
-      return if !queries
-      hash = queries.find { |hash| hash[:line] == query[:line] && hash[:file] == query[:file] && hash[:kind] == query[:kind] }
-      queries << hash = {kind: query[:kind], file: query[:file], line: query[:line], runtime: 0, times: 0} if !hash
-      hash[:runtime] += query[:runtime]
-      if !MEANINGLESS_QUERIES.include?(query[:command])
-        hash[:times] += 1
-        hash[:command] ||= query[:command]
-        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)
@@ -286,9 +27,9 @@ module RorVsWild
         http.use_ssl = true
       end
 
-      post = Net::HTTP::Post.new(uri.path)
+      post = Net::HTTP::Post.new(uri.path, "X-Gem-Version".freeze => RorVsWild::VERSION)
       post.content_type = "application/json".freeze
-      post.basic_auth(app_id, api_key)
+      post.basic_auth(nil, api_key)
       post.body = data.to_json
       http.request(post)
     end
@@ -307,22 +48,5 @@ module RorVsWild
     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