lib/rorvswild.rb in rorvswild-0.2.1 vs lib/rorvswild.rb in rorvswild-0.2.2

@@ -1,6 +1,9 @@
 require "rorvswild/version"
+require "json/ext"
+require "net/http"
+require "uri"
 
 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
@@ -57,15 +60,17 @@
       RorVsWild.register_default_client(self)
     end
 
     def setup_callbacks
       client = self
-      ActiveSupport::Notifications.subscribe("sql.active_record", &method(:after_sql_query))
-      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) }
+      if defined?(Rails)
+        ActiveSupport::Notifications.subscribe("sql.active_record", &method(:after_sql_query))
+        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
 
       Resque::Job.send(:extend, ResquePlugin) if defined?(Resque::Job)
       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
@@ -85,11 +90,11 @@
     end
 
     def after_sql_query(name, start, finish, id, payload)
       return if !queries || payload[:name] == "EXPLAIN".freeze
       runtime, sql, plan = compute_duration(start, finish), nil, nil
-      file, line, method = extract_query_location(caller)
+      file, line, method = extract_most_relevant_location(caller)
       # I can't figure out the exact location which triggered the query, so at least the SQL is logged.
       sql, file, line, method = payload[:sql], "Unknow", 0, "Unknow" if !file
       sql = payload[:sql] if runtime >= log_sql_threshold
       plan = explain(payload[:sql], payload[:binds]) if runtime >= explain_sql_threshold
       push_query(file: file, line: line, method: method, sql: sql, plan: plan, runtime: runtime, times: 1)
@@ -216,11 +221,11 @@
     end
 
     SELECT_REGEX = /\Aselect/i.freeze
 
     def explain(sql, binds)
-      ActiveRecord::Base.connection.explain(sql, binds) if (sql =~ SELECT_REGEX) == 0
+      ActiveRecord::Base.connection.explain(sql, binds) if sql =~ SELECT_REGEX
     end
 
     def post_request
       attributes = request.merge(queries: slowest_queries, views: slowest_views)
       Thread.new { post("/requests".freeze, request: attributes) }
@@ -238,18 +243,15 @@
 
     def post_error(hash)
       post("/errors".freeze, error: hash)
     end
 
-    def extract_query_location(stack)
-      if location = stack.find { |str| str.include?(Rails.root.to_s) }
-        split_file_location(location.sub(Rails.root.to_s, "".freeze))
-      end
-    end
+    GEM_HOME_REGEX = ENV["GEM_HOME"] ? /\A#{ENV["GEM_HOME"]}/.freeze : nil
 
-    def extract_error_location(stack)
-      extract_query_location(stack) || split_file_location(stack.first)
+    def extract_most_relevant_location(stack)
+      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
@@ -266,15 +268,15 @@
     def compute_duration(start, finish)
       ((finish - start) * 1000)
     end
 
     def relative_path(path)
-      path.sub(Rails.root.to_s, "".freeze)
+      defined?(Rails) ? path.sub(Rails.root.to_s, "".freeze) : path
     end
 
     def exception_to_hash(exception, extra_details = nil)
-      file, line, method = extract_error_location(exception.backtrace)
+      file, line, method = extract_most_relevant_location(exception.backtrace)
       {
         method: method,
         line: line.to_i,
         file: relative_path(file),
         message: exception.message,
@@ -294,24 +296,29 @@
         http.request(post)
       end
     end
 
     def filter_sensitive_data(hash)
-      @sensitive_filter ||= ActionDispatch::Http::ParameterFilter.new(Rails.application.config.filter_parameters)
-      @sensitive_filter.filter(hash)
+      if defined?(Rails)
+        @sensitive_filter ||= ActionDispatch::Http::ParameterFilter.new(Rails.application.config.filter_parameters)
+        @sensitive_filter.filter(hash)
+      else
+        hash
+      end
     end
 
     def filter_environment_variables(hash)
       hash.clone.keep_if { |key,value| key == key.upcase }
     end
 
-    def logger
-      Rails.logger
-    end
-
     def log_error(exception)
-      logger.error("[RorVsWild] " + exception.inspect)
-      logger.error("[RorVsWild] " + exception.backtrace.join("\n[RorVsWild] "))
+      if defined?(Rails)
+        Rails.logger.error("[RorVsWild] " + exception.inspect)
+        Rails.logger.error("[RorVsWild] " + exception.backtrace.join("\n[RorVsWild] "))
+      else
+        $stderr.puts("[RorVsWild] " + exception.inspect)
+        $stderr.puts("[RorVsWild] " + exception.backtrace.join("\n[RorVsWild] "))
+      end
     end
   end
 
   DASH_PERFORM = "#perform".freeze