# 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
LOG_PREFIX

### 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.

errors[R]

Errors object - an Array that contains error messages. See #

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.

faraday_builder[RW]

A Proc yeilding the faraday builder allowing for further configuration of the faraday adapter

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.

linecache[RW]

You may provide your own LineCache for matching paths with source files. This may be useful if you need to get source code from places other than the disk. See Raven::LineCache for the required interface you must implement.

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_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_fields_excluded[RW]

If you're sure you want to override the default sanitization values, you can add to them to an array of Strings here, e.g. %w(authorization password)

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 180
    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.linecache = ::Raven::LineCache.new
      self.logger = ::Raven::Logger.new(STDOUT)
      self.open_timeout = 1
      self.processors = DEFAULT_PROCESSORS.dup
      self.project_root = detect_project_root
      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_fields_excluded = []
      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 263
    def [](option)
      public_send(option)
    end

async=(value) click to toggle source

    # File lib/raven/configuration.rb, line 239
    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 271
    def capture_allowed?(message_or_exc = nil)
      @errors = []

      valid? &&
        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 267
    def current_environment=(environment)
      @current_environment = environment.to_s
    end

detect_project_root() click to toggle source

    # File lib/raven/configuration.rb, line 299
    def detect_project_root
      if defined? Rails.root # we are in a Rails application
        Rails.root.to_s
      else
        Dir.pwd
      end
    end

detect_release() click to toggle source

    # File lib/raven/configuration.rb, line 291
    def detect_release
      detect_release_from_git ||
        detect_release_from_capistrano ||
        detect_release_from_heroku
    rescue => ex
      logger.error "Error detecting release: #{ex.message}"
    end

dsn=(value)
Alias for: server=
encoding=(encoding) click to toggle source

    # File lib/raven/configuration.rb, line 234
    def encoding=(encoding)
      raise(Error, 'Unsupported encoding') unless %w(gzip json).include? encoding
      @encoding = encoding
    end

error_messages() click to toggle source

    # File lib/raven/configuration.rb, line 281
    def error_messages
      @errors = [errors[0]] + errors[1..-1].map(&:downcase) # fix case of all but first
      errors.join(", ")
    end

project_root=(root_dir) click to toggle source

    # File lib/raven/configuration.rb, line 286
    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 211
    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 253
    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 246
    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