class Raven::Configuration

Constants

DEFAULT_PROCESSORS

Note the order - we have to remove circular references and bad characters before passing to other processors.

IGNORE_DEFAULT

Attributes

app_dirs_pattern[RW]

Directories to be recognized as part of your app. e.g. if you have an `engines` dir at the root of your project, you may want to set this to something like /(app|config|engines|lib)/

async[R]

Provide an object that responds to `call` to send events asynchronously. E.g.: lambda { |event| Thread.new { Raven.send_event(event) } }

async?[R]

Provide an object that responds to `call` to send events asynchronously. E.g.: lambda { |event| Thread.new { Raven.send_event(event) } }

context_lines[RW]

Number of lines of code context to capture, or nil for none

current_environment[R]

RACK_ENV by default.

encoding[R]

Encoding type for event bodies. Must be :json or :gzip.

environments[RW]

Whitelist of environments that will send notifications to Sentry. Array of Strings.

exclude_loggers[RW]

Logger 'progname's to exclude from breadcrumbs

excluded_exceptions[RW]

Array of exception classes that should never be sent. See IGNORE_DEFAULT. You should probably append to this rather than overwrite it.

host[RW]

DSN component - set automatically if DSN provided

http_adapter[RW]

The Faraday adapter to be used. Will default to Net::HTTP when not set.

logger[RW]

Logger used by Raven. In Rails, this is the Rails logger, otherwise Raven provides its own Raven::Logger.

open_timeout[RW]

Timeout waiting for the Sentry server connection to open in seconds

path[RW]

DSN component - set automatically if DSN provided

port[RW]

DSN component - set automatically if DSN provided

processors[RW]

Processors to run on data before sending upstream. See DEFAULT_PROCESSORS. You should probably append to this rather than overwrite it.

project_id[RW]

Project ID number to send to the Sentry server If you provide a DSN, this will be set automatically.

project_root[R]

Project directory root for in_app detection. Could be Rails root, etc. Set automatically for Rails.

proxy[RW]

Proxy information to pass to the HTTP adapter (via Faraday)

public_key[RW]

Public key for authentication with the Sentry server If you provide a DSN, this will be set automatically.

rails_activesupport_breadcrumbs[RW]

Turns on ActiveSupport breadcrumbs integration

rails_report_rescued_exceptions[RW]

Rails catches exceptions in the ActionDispatch::ShowExceptions or ActionDispatch::DebugExceptions middlewares, depending on the environment. When `rails_report_rescued_exceptions` is true (it is by default), Raven will report exceptions even when they are rescued by these middlewares.

release[RW]

Release tag to be passed with every event sent to Sentry. We automatically try to set this to a git SHA or Capistrano release.

sanitize_credit_cards[RW]

Boolean - sanitize values that look like credit card numbers

sanitize_fields[RW]

By default, Sentry censors Hash values when their keys match things like “secret”, “password”, etc. Provide an array of Strings that, when matched in a hash key, will be censored and not sent to Sentry.

sanitize_http_headers[RW]

Sanitize additional HTTP headers - only Authorization is removed by default.

scheme[RW]

DSN component - set automatically if DSN provided. Otherwise, can be one of “http”, “https”, or “dummy”

secret_key[RW]

Secret key for authentication with the Sentry server If you provide a DSN, this will be set automatically.

send_modules[RW]

Include module versions in reports - boolean.

server[R]

Simple server string - set this to the DSN found on your Sentry settings.

server_name[RW]
should_capture[RW]

Provide a configurable callback to determine event capture. Note that the object passed into the block will be a String (messages) or an exception. e.g. lambda { |exc_or_msg| exc_or_msg.some_attr == false }

silence_ready[RW]

Silences ready message when true.

ssl[RW]

SSL settings passed directly to Faraday's ssl option

ssl_ca_file[RW]

The path to the SSL certificate file

ssl_verification[RW]

Should the SSL certificate of the server be verified?

tags[RW]

Default tags for events. Hash.

timeout[RW]

Timeout when waiting for the server to return data in seconds.

transport_failure_callback[R]

Optional Proc, called when the Sentry server cannot be contacted for any reason E.g. lambda { |event| Thread.new { MyJobProcessor.send_email(event) } }

Public Class Methods

new() click to toggle source
# File lib/raven/configuration.rb, line 163
def initialize
  self.async = false
  self.context_lines = 3
  self.current_environment = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
  self.encoding = 'gzip'
  self.environments = []
  self.exclude_loggers = []
  self.excluded_exceptions = IGNORE_DEFAULT.dup
  self.open_timeout = 1
  self.processors = DEFAULT_PROCESSORS.dup
  self.proxy = nil
  self.rails_activesupport_breadcrumbs = false
  self.rails_report_rescued_exceptions = true
  self.release = detect_release
  self.sanitize_credit_cards = true
  self.sanitize_fields = []
  self.sanitize_http_headers = []
  self.send_modules = true
  self.server = ENV['SENTRY_DSN'] if ENV['SENTRY_DSN']
  self.server_name = resolve_hostname
  self.should_capture = false
  self.ssl_verification = true
  self.tags = {}
  self.timeout = 2
  self.transport_failure_callback = false
end

Public Instance Methods

[](option) click to toggle source

Allows config options to be read like a hash

@param [Symbol] option Key for a given attribute

# File lib/raven/configuration.rb, line 242
def [](option)
  public_send(option)
end
async=(value) click to toggle source
# File lib/raven/configuration.rb, line 218
def async=(value)
  unless value == false || value.respond_to?(:call)
    raise(ArgumentError, "async must be callable (or false to disable)")
  end
  @async = value
end
capture_allowed?(message_or_exc = nil) click to toggle source
# File lib/raven/configuration.rb, line 250
def capture_allowed?(message_or_exc = nil)
  capture_in_current_environment? &&
    capture_allowed_by_callback?(message_or_exc)
end
Also aliased as: sending_allowed?
current_environment=(environment) click to toggle source
# File lib/raven/configuration.rb, line 246
def current_environment=(environment)
  @current_environment = environment.to_s
end
detect_release() click to toggle source
# File lib/raven/configuration.rb, line 269
def detect_release
  detect_release_from_git ||
    detect_release_from_capistrano ||
    detect_release_from_heroku
end
dsn=(value)
Alias for: server=
encoding=(encoding) click to toggle source
# File lib/raven/configuration.rb, line 213
def encoding=(encoding)
  raise(Error, 'Unsupported encoding') unless %w(gzip json).include? encoding
  @encoding = encoding
end
project_root=(root_dir) click to toggle source
# File lib/raven/configuration.rb, line 264
def project_root=(root_dir)
  @project_root = root_dir
  Backtrace::Line.instance_variable_set(:@in_app_pattern, nil) # blow away cache
end
sending_allowed?(message_or_exc = nil)

If we cannot capture, we cannot send.

Alias for: capture_allowed?
server=(value) click to toggle source
# File lib/raven/configuration.rb, line 190
def server=(value)
  uri = URI.parse(value)
  uri_path = uri.path.split('/')

  if uri.user
    # DSN-style string
    self.project_id = uri_path.pop
    self.public_key = uri.user
    self.secret_key = uri.password
  end

  self.scheme = uri.scheme
  self.host = uri.host
  self.port = uri.port if uri.port
  self.path = uri_path.join('/')

  # For anyone who wants to read the base server string
  @server = "#{scheme}://#{host}"
  @server << ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
  @server << path
end
Also aliased as: dsn=
should_capture=(value) click to toggle source
# File lib/raven/configuration.rb, line 232
def should_capture=(value)
  unless value == false || value.respond_to?(:call)
    raise ArgumentError, "should_capture must be callable (or false to disable)"
  end
  @should_capture = value
end
transport_failure_callback=(value) click to toggle source
# File lib/raven/configuration.rb, line 225
def transport_failure_callback=(value)
  unless value == false || value.respond_to?(:call)
    raise(ArgumentError, "transport_failure_callback must be callable (or false to disable)")
  end
  @transport_failure_callback = value
end
verify!() click to toggle source
# File lib/raven/configuration.rb, line 258
def verify!
  %w(server public_key secret_key project_id).each do |key|
    raise(Error, "No #{key} specified") unless public_send key
  end
end