lib/rorvswild.rb in rorvswild-0.0.4 vs lib/rorvswild.rb in rorvswild-0.0.5

@@ -25,29 +25,31 @@
       @app_id = config[:app_id]
       setup_callbacks
     end
 
     def setup_callbacks
-      ApplicationController.rescue_from(StandardError, &method(:after_exception))
       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))
+
+      this = self
+      ApplicationController.rescue_from(StandardError) { |exception| this.after_exception(exception, self) }
     end
 
     def before_http_request(name, start, finish, id, payload)
       @request = {controller: payload[:controller], action: payload[:action], path: payload[:path]}
       @queries = []
-      @views = []
+      @views = {}
       @error = nil
     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[:params] = params_filter.filter(payload[:params]) if error
+      error[:parameters] = filter_sensitive_data(payload[:params]) if error
       Thread.new { post_request }
     rescue => exception
       log_error(exception)
     end
 
@@ -63,22 +65,33 @@
     rescue => exception
       log_error(exception)
     end
 
     def after_view_rendering(name, start, finish, id, payload)
-      views << {file: relative_path(payload[:identifier]), runtime: compute_duration(start, finish)} if views
+      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)
-      file, line = exception.backtrace.first.split(":")
-      @error = {
-        exception: exception.class.to_s,
-        backtrace: exception.backtrace,
-        message: exception.message,
-        file: relative_path(file),
-        line: line.to_i
-      }
+    def after_exception(exception, controller)
+      if !exception.is_a?(ActionController::RoutingError)
+        file, line = exception.backtrace.first.split(":")
+        @error = {
+          line: line.to_i,
+          file: relative_path(file),
+          message: exception.message,
+          backtrace: exception.backtrace,
+          exception: exception.class.to_s,
+          session: controller.session.to_hash,
+          environment_variables: filter_sensitive_data(filter_environment_variables(controller.request.env))
+        }
+      end
       raise exception
     end
 
     #######################
     ### Private methods ###
@@ -93,11 +106,11 @@
     def views
       @views
     end
 
     def slowest_views
-      views.sort { |h1, h2| h2[:runtime] <=> h1[:runtime] }[0, 25]
+      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
@@ -128,11 +141,11 @@
       method.sub!("'", "")
       method.index("_app_views_") == 0 ? nil : method
     end
 
     def compute_duration(start, finish)
-      ((finish - start) * 1000).round
+      ((finish - start) * 1000)
     end
 
     def relative_path(path)
       path.sub(Rails.root.to_s, "")
     end
@@ -146,11 +159,16 @@
         post.body = data.to_json
         http.request(post)
       end
     end
 
-    def params_filter
-      @params_filter ||= ActionDispatch::Http::ParameterFilter.new(Rails.application.config.filter_parameters)
+    def filter_sensitive_data(hash)
+      @sensitive_filter ||= ActionDispatch::Http::ParameterFilter.new(Rails.application.config.filter_parameters)
+      @sensitive_filter.filter(hash)
+    end
+
+    def filter_environment_variables(hash)
+      hash.clone.keep_if { |key,value| key == key.upcase }
     end
 
     def logger
       Rails.logger
     end