Class: NewRelic::Rack::ErrorCollector

Inherits:
Object
  • Object
show all
Defined in:
lib/new_relic/rack/error_collector.rb

Instance Method Summary collapse

Constructor Details

#initialize(app, options = {}) ⇒ ErrorCollector

Returns a new instance of ErrorCollector.



7
8
9
 
# File 'lib/new_relic/rack/error_collector.rb', line 7

def initialize(app, options={})
  @app = app
end

Instance Method Details

#call(env) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/new_relic/rack/error_collector.rb', line 42

def call(env)
  @app.call(env)
rescue Exception => exception
  NewRelic::Agent.logger.debug "collecting %p: %s" % [ exception.class, exception.message ]
  if !should_ignore_error?(exception, env)
    NewRelic::Agent.notice_error(exception,
                                 :uri => uri_from_env(env),
                                 :referer => referrer_from_env(env),
                                 :request_params => params_from_env(env))
  end
  raise exception
end

#ignored_in_controller?(exception, env) ⇒ Boolean

Returns:

  • (Boolean) 


60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/new_relic/rack/error_collector.rb', line 60

def ignored_in_controller?(exception, env)
  return true if env['newrelic.ignored']

  if env['action_dispatch.request.parameters']
    ignore_actions = newrelic_ignore_for_controller(env['action_dispatch.request.parameters']['controller'])
    action_name = env['action_dispatch.request.parameters']['action']

    case ignore_actions
    when nil; false
    when Hash
      only_actions = Array(ignore_actions[:only])
      except_actions = Array(ignore_actions[:except])
      only_actions.include?(action_name.to_sym) ||
        (except_actions.any? &&
         !except_actions.include?(action_name.to_sym))
    else
      true
    end
  end
end

#newrelic_ignore_for_controller(controller_name) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/new_relic/rack/error_collector.rb', line 81

def newrelic_ignore_for_controller(controller_name)
  if controller_name
    controller_constant_name = (controller_name + "_controller").camelize
    if Object.const_defined?(controller_constant_name)
      controller = controller_constant_name.constantize
      controller.instance_variable_get(:@do_not_trace)
    end
  end
rescue NameError
  nil
end

#params_from_env(env) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/new_relic/rack/error_collector.rb', line 11

def params_from_env(env)
  if defined?(ActionDispatch::Request)
    # We use ActionDispatch::Request if it's available so that we can get
    # the parameter filtering supplied by Rails via filtered_parameters.
    # The action and controller params are synthesized by
    # ActionDispatch::Request, so we strip them for consistency with Rack::Request
    params = ActionDispatch::Request.new(env).filtered_parameters
    params.delete('action')
    params.delete('controller')
    params
  else
    Rack::Request.new(env).params
  end
rescue => e
  warning = "failed to capture request parameters: %p: %s" % [ e.class, e.message ]
  NewRelic::Agent.logger.warn(warning)
  { 'error' => warning }
end

#referrer_from_env(env) ⇒ Object 



38
39
40
 
# File 'lib/new_relic/rack/error_collector.rb', line 38

def referrer_from_env(env)
  strip_query_string(env['HTTP_REFERER'].to_s)
end

#should_ignore_error?(error, env) ⇒ Boolean

Returns:

  • (Boolean) 


55
56
57
58
 
# File 'lib/new_relic/rack/error_collector.rb', line 55

def should_ignore_error?(error, env)
  NewRelic::Agent.instance.error_collector.error_is_ignored?(error) ||
    ignored_in_controller?(error, env)
end

#strip_query_string(s) ⇒ Object 



30
31
32
 
# File 'lib/new_relic/rack/error_collector.rb', line 30

def strip_query_string(s)
  s.gsub(/\?.*/, '')
end

#uri_from_env(env) ⇒ Object 



34
35
36
 
# File 'lib/new_relic/rack/error_collector.rb', line 34

def uri_from_env(env)
  strip_query_string("#{env['SCRIPT_NAME']}#{env['PATH_INFO']}")
end