Module: Raven

Defined in:
lib/raven/okjson.rb,
lib/raven/cli.rb,
lib/raven/base.rb,
lib/raven/error.rb,
lib/raven/event.rb,
lib/raven/client.rb,
lib/raven/logger.rb,
lib/raven/context.rb,
lib/raven/version.rb,
lib/raven/backtrace.rb,
lib/raven/linecache.rb,
lib/raven/processor.rb,
lib/raven/interfaces.rb,
lib/raven/transports.rb,
lib/raven/configuration.rb,
lib/raven/transports/udp.rb,
lib/raven/interfaces/http.rb,
lib/raven/transports/http.rb,
lib/raven/integrations/rack.rb,
lib/raven/integrations/rails.rb,
lib/raven/interfaces/message.rb,
lib/raven/better_attr_accessor.rb,
lib/raven/integrations/sidekiq.rb,
lib/raven/interfaces/exception.rb,
lib/raven/interfaces/stack_trace.rb,
lib/raven/processor/sanitizedata.rb,
lib/raven/processor/utf8conversion.rb,
lib/raven/processor/removestacktrace.rb,
lib/raven/processor/removecircularreferences.rb,
lib/raven/integrations/rails/controller_methods.rb,
lib/raven/integrations/rails/middleware/debug_exceptions_catcher.rb

Overview

A much simpler source line cacher because linecache sucks at platform compat

Defined Under Namespace

Modules: BetterAttrAccessor, OkJson, Transports Classes: Backtrace, CLI, Client, ClientState, Configuration, Context, Error, Event, ExceptionInterface, HttpInterface, Interface, LineCache, Logger, MessageInterface, Processor, Rack, Rails, Sidekiq, StacktraceInterface

Constant Summary collapse

VERSION = 
"0.12.3"
INTERFACES = 
{}

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.client ⇒ Object

The client object is responsible for delivering formatted data to the Sentry server.



47
48
49
 
# File 'lib/raven/base.rb', line 47

def client
  @client ||= Client.new(configuration)
end

.configuration ⇒ Object

The configuration object.

See Also:



42
43
44
 
# File 'lib/raven/base.rb', line 42

def configuration
  @configuration ||= Configuration.new
end

Class Method Details

.annotate_exception(exc, options = {}) ⇒ Object Also known as: annotateException, annotate

Provides extra context to the exception prior to it being handled by Raven. An exception can have multiple annotations, which are merged together.

The options (annotation) is treated the same as the “options“ parameter to “capture_exception“ or “Event.from_exception“, and can contain the same “:user“, “:tags“, etc. options as these methods.

These will be merged with the “options“ parameter to “Event.from_exception“ at the top of execution.

Examples:

begin
  raise "Hello"
rescue => exc
  Raven.annotate_exception(exc, :user => { 'id' => 1,
                           'email' => '[email protected]' })
end


166
167
168
169
170
171
 
# File 'lib/raven/base.rb', line 166

def annotate_exception(exc, options = {})
  notes = exc.instance_variable_get(:@__raven_context) || {}
  notes.merge!(options)
  exc.instance_variable_set(:@__raven_context, notes)
  exc
end

.capture(options = {}, &block) ⇒ Object

Capture and process any exceptions from the given block, or globally if no block is given

Examples:

Raven.capture do
  MyApp.run
end


86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/raven/base.rb', line 86

def capture(options = {}, &block)
  if block
    begin
      block.call
    rescue Error
      raise # Don't capture Raven errors
    rescue Exception => e
      capture_exception(e, options)
      raise
    end
  else
    # Install at_exit hook
    at_exit do
      if $ERROR_INFO
        logger.debug "Caught a post-mortem exception: #{$ERROR_INFO.inspect}"
        capture_exception($ERROR_INFO, options)
      end
    end
  end
end

.capture_exception(exception, options = {}) ⇒ Object Also known as: captureException 



107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/raven/base.rb', line 107

def capture_exception(exception, options = {})
  send_or_skip(exception) do
    if (evt = Event.from_exception(exception, options))
      yield evt if block_given?
      if configuration.async?
        configuration.async.call(evt)
      else
        send(evt)
      end
    end
  end
end

.capture_message(message, options = {}) ⇒ Object Also known as: captureMessage 



120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/raven/base.rb', line 120

def capture_message(message, options = {})
  send_or_skip(message) do
    if (evt = Event.from_message(message, options))
      yield evt if block_given?
      if configuration.async?
        configuration.async.call(evt)
      else
        send(evt)
      end
    end
  end
end

.configure(silent = false) {|configuration| ... } ⇒ Object

Call this method to modify defaults in your initializers.

Examples:

Raven.configure do |config|
  config.server = 'http://...'
end

Yields:



62
63
64
65
66
67
68
 
# File 'lib/raven/base.rb', line 62

def configure(silent = false)
  yield(configuration) if block_given?

  self.client = Client.new(configuration)
  report_ready unless silent
  self.client
end

.context ⇒ Object 



32
33
34
 
# File 'lib/raven/base.rb', line 32

def context
  Context.current
end

.extra_context(options = {}) ⇒ Object

Bind extra context. Merges with existing context (if any).

Extra context shows up as Additional Data within Sentry, and is completely arbitrary.

Examples:

Raven.extra_context('my_custom_data' => 'value')


201
202
203
 
# File 'lib/raven/base.rb', line 201

def extra_context(options = {})
  self.context.extra.merge!(options)
end

.find_interface(name) ⇒ Object 



31
32
33
 
# File 'lib/raven/interfaces.rb', line 31

def self.find_interface(name)
  INTERFACES[name.to_s]
end

.inject ⇒ Object

Injects various integrations



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/raven/base.rb', line 213

def inject
  available_integrations = %w[delayed_job rails sidekiq rack rake]
  integrations_to_load = available_integrations & Gem.loaded_specs.keys
  # TODO(dcramer): integrations should have some additional checks baked-in
  # or we should break them out into their own repos. Specifically both the
  # rails and delayed_job checks are not always valid (i.e. Rails 2.3) and
  # https://github.com/getsentry/raven-ruby/issues/180
  integrations_to_load.each do |integration|
    begin
      require "raven/integrations/#{integration}"
    rescue Exception => error
      self.logger.warn "Unable to load raven/integrations/#{integration}: #{error}"
    end
  end
end

.logger ⇒ Object 



36
37
38
 
# File 'lib/raven/base.rb', line 36

def logger
  @logger ||= Logger.new
end

.rack_context(env) ⇒ Object 



205
206
207
208
209
210
 
# File 'lib/raven/base.rb', line 205

def rack_context(env)
  if env.empty?
    env = nil
  end
  self.context.rack_env = env
end

.register_interface(mapping) ⇒ Object 



24
25
26
27
28
29
 
# File 'lib/raven/interfaces.rb', line 24

def self.register_interface(mapping)
  mapping.each_pair do |key, klass|
    INTERFACES[key.to_s] = klass
    INTERFACES[klass.name] = klass
  end
end

.report_ready ⇒ Object

Tell the log that the client is good to go



52
53
54
 
# File 'lib/raven/base.rb', line 52

def report_ready
  self.logger.info "Raven #{VERSION} ready to catch errors"
end

.send(evt) ⇒ Object

Send an event to the configured Sentry server

Examples:

evt = Raven::Event.new(:message => "An error")
Raven.send(evt)


75
76
77
 
# File 'lib/raven/base.rb', line 75

def send(evt)
  client.send(evt)
end

.send_or_skip(exc) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/raven/base.rb', line 133

def send_or_skip(exc)
  should_send = if configuration.should_send
    configuration.should_send.call(*[exc])
  else
    true
  end

  if configuration.send_in_current_environment? && should_send
    yield if block_given?
  else
    configuration.log_excluded_environment_message
  end
end

.tags_context(options = {}) ⇒ Object

Bind tags context. Merges with existing context (if any).

Tags are key / value pairs which generally represent things like application version, environment, role, and server names.

Examples:

Raven.tags_context('my_custom_tag' => 'tag_value')


191
192
193
 
# File 'lib/raven/base.rb', line 191

def tags_context(options = {})
  self.context.tags.merge!(options)
end

.user_context(options = {}) ⇒ Object

Bind user context. Merges with existing context (if any).

It is recommending that you send at least the “id“ and “email“ values. All other values are arbitrary.

Examples:

Raven.user_context('id' => 1, 'email' => '[email protected]')


180
181
182
 
# File 'lib/raven/base.rb', line 180

def user_context(options = {})
  self.context.user = options
end