sentry-raven 3.0.1 → 3.1.1

data/sentry-ruby/lib/sentry.rb

@@ -0,0 +1,16 @@
+require "sentry/configuration"
+require "sentry/logger"
+require "sentry/event"
+require "sentry/client"
+
+module Sentry
+  class Error < StandardError
+  end
+
+  def self.sys_command(command)
+    result = `#{command} 2>&1` rescue nil
+    return if result.nil? || result.empty? || ($CHILD_STATUS && $CHILD_STATUS.exitstatus != 0)
+
+    result.strip
+  end
+end

data/sentry-ruby/lib/sentry/backtrace.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+## Inspired by Rails' and Airbrake's backtrace parsers.
+
+module Sentry
+  # Front end to parsing the backtrace for each notice
+  class Backtrace
+    # Handles backtrace parsing line by line
+    class Line
+      RB_EXTENSION = ".rb"
+      # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
+      RUBY_INPUT_FORMAT = /
+        ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
+        (\d+)
+        (?: :in \s `([^']+)')?$
+      /x.freeze
+
+      # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
+      JAVA_INPUT_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/.freeze
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # The module name (JRuby)
+      attr_reader :module_name
+
+      attr_reader :in_app_pattern
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line, in_app_pattern)
+        ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
+        if ruby_match
+          _, file, number, method = ruby_match.to_a
+          file.sub!(/\.class$/, RB_EXTENSION)
+          module_name = nil
+        else
+          java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
+          _, module_name, method, file, number = java_match.to_a
+        end
+        new(file, number, method, module_name, in_app_pattern)
+      end
+
+      def initialize(file, number, method, module_name, in_app_pattern)
+        @file = file
+        @module_name = module_name
+        @number = number.to_i
+        @method = method
+        @in_app_pattern = in_app_pattern
+      end
+
+      def in_app
+        if file =~ in_app_pattern
+          true
+        else
+          false
+        end
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{self}>"
+      end
+    end
+
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test)/.freeze
+
+    # holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+    attr_reader :configuration
+
+    def self.parse(backtrace, configuration:)
+      ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
+
+      ruby_lines = configuration.backtrace_cleanup_callback.call(ruby_lines) if configuration&.backtrace_cleanup_callback
+
+      in_app_pattern ||= begin
+        project_root = configuration.project_root&.to_s
+        Regexp.new("^(#{project_root}/)?#{configuration.app_dirs_pattern || APP_DIRS_PATTERN}")
+      end
+
+      lines = ruby_lines.to_a.map do |unparsed_line|
+        Line.parse(unparsed_line, in_app_pattern)
+      end
+
+      new(lines)
+    end
+
+    def initialize(lines)
+      @lines = lines
+    end
+
+    def inspect
+      "<Backtrace: " + lines.map(&:inspect).join(", ") + ">"
+    end
+
+    def to_s
+      content = []
+      lines.each do |line|
+        content << line
+      end
+      content.join("\n")
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+  end
+end

data/sentry-ruby/lib/sentry/client.rb

@@ -0,0 +1,162 @@
+require "json"
+require "base64"
+require "sentry/transports"
+require "sentry/client/state"
+require 'sentry/utils/deep_merge'
+
+module Sentry
+  class Client
+    PROTOCOL_VERSION = '5'
+    USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
+    CONTENT_TYPE = 'application/json'
+
+    attr_reader :transport, :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+      @state = State.new
+      @transport = case configuration.scheme
+        when 'http', 'https'
+          Transports::HTTP.new(configuration)
+        when 'stdout'
+          Transports::Stdout.new(configuration)
+        when 'dummy'
+          Transports::Dummy.new(configuration)
+        else
+          fail "Unknown transport scheme '#{configuration.scheme}'"
+        end
+    end
+
+    def event_from_exception(exception, message: nil, extra: {}, backtrace: [], checksum: nil, release: nil, fingerprint: [])
+      options = {
+        message: message,
+        extra: extra,
+        backtrace: backtrace,
+        checksum: checksum,
+        fingerprint: fingerprint,
+        configuration: configuration,
+        release: release
+      }
+
+      exception_context =
+        if exception.instance_variable_defined?(:@__sentry_context)
+          exception.instance_variable_get(:@__sentry_context)
+        elsif exception.respond_to?(:sentry_context)
+          exception.sentry_context
+        else
+          {}
+        end
+
+      options = Utils::DeepMergeHash.deep_merge(exception_context, options)
+
+      return unless @configuration.exception_class_allowed?(exception)
+
+      Event.new(**options) do |evt|
+        evt.add_exception_interface(exception)
+      end
+    end
+
+    def event_from_message(message, extra: {}, backtrace: [], level: :error)
+      options = {
+        message: message,
+        extra: extra,
+        backtrace: backtrace,
+        configuration: configuration,
+        level: level
+      }
+      Event.new(**options)
+    end
+
+    def generate_auth_header
+      now = Time.now.to_i.to_s
+      fields = {
+        'sentry_version' => PROTOCOL_VERSION,
+        'sentry_client' => USER_AGENT,
+        'sentry_timestamp' => now,
+        'sentry_key' => configuration.public_key
+      }
+      fields['sentry_secret'] = configuration.secret_key unless configuration.secret_key.nil?
+      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
+    end
+
+    def send_event(event, hint = nil)
+      return false unless configuration.sending_allowed?(event)
+
+      event = configuration.before_send.call(event, hint) if configuration.before_send
+      if event.nil?
+        configuration.logger.info "Discarded event because before_send returned nil"
+        return
+      end
+
+      # Convert to hash
+      event = event.to_hash
+
+      unless @state.should_try?
+        failed_send(nil, event)
+        return
+      end
+
+      event_id = event[:event_id] || event['event_id']
+      configuration.logger.info "Sending event #{event_id} to Sentry"
+
+      content_type, encoded_data = encode(event)
+
+      begin
+        transport.send_event(generate_auth_header, encoded_data,
+                             :content_type => content_type)
+        successful_send
+      rescue => e
+        failed_send(e, event)
+        return
+      end
+
+      event
+    end
+
+    private
+
+    def encode(event)
+      encoded = JSON.fast_generate(event.to_hash)
+
+      case configuration.encoding
+      when 'gzip'
+        ['application/octet-stream', Base64.strict_encode64(Zlib::Deflate.deflate(encoded))]
+      else
+        ['application/json', encoded]
+      end
+    end
+
+    def successful_send
+      @state.success
+    end
+
+    def failed_send(e, event)
+      if e # exception was raised
+        @state.failure
+        configuration.logger.warn "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}"
+      else
+        configuration.logger.warn "Not sending event due to previous failure(s)."
+      end
+      configuration.logger.warn("Failed to submit event: #{get_log_message(event)}")
+
+      # configuration.transport_failure_callback can be false & nil
+      configuration.transport_failure_callback.call(event, e) if configuration.transport_failure_callback # rubocop:disable Style/SafeNavigation
+    end
+
+    def get_log_message(event)
+      (event && event[:message]) || (event && event['message']) || get_message_from_exception(event) || '<no message value>'
+    end
+
+    def get_message_from_exception(event)
+      (
+        event &&
+        event[:exception] &&
+        event[:exception][:values] &&
+        event[:exception][:values][0] &&
+        event[:exception][:values][0][:type] &&
+        event[:exception][:values][0][:value] &&
+        "#{event[:exception][:values][0][:type]}: #{event[:exception][:values][0][:value]}"
+      )
+    end
+  end
+end

data/sentry-ruby/lib/sentry/client/state.rb

@@ -0,0 +1,40 @@
+module Sentry
+  class Client
+    class State
+      def initialize
+        reset
+      end
+
+      def should_try?
+        return true if @status == :online
+
+        interval = @retry_after || [@retry_number, 6].min**2
+        return true if Time.now - @last_check >= interval
+
+        false
+      end
+
+      def failure(retry_after = nil)
+        @status = :error
+        @retry_number += 1
+        @last_check = Time.now
+        @retry_after = retry_after
+      end
+
+      def success
+        reset
+      end
+
+      def reset
+        @status = :online
+        @retry_number = 0
+        @last_check = nil
+        @retry_after = nil
+      end
+
+      def failed?
+        @status == :error
+      end
+    end
+  end
+end

data/sentry-ruby/lib/sentry/configuration.rb

@@ -0,0 +1,533 @@
+require "uri"
+require "sentry/utils/exception_cause_chain"
+require "sentry/linecache"
+
+module Sentry
+  class Configuration
+    # 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)/
+    attr_accessor :app_dirs_pattern
+
+    # Provide an object that responds to `call` to send events asynchronously.
+    # E.g.: lambda { |event| Thread.new { Sentry.send_event(event) } }
+    attr_reader :async
+    alias async? async
+
+    # An array of breadcrumbs loggers to be used. Available options are:
+    # - :sentry_logger
+    # - :active_support_logger
+    attr_reader :breadcrumbs_logger
+
+    # Number of lines of code context to capture, or nil for none
+    attr_accessor :context_lines
+
+    # RACK_ENV by default.
+    attr_reader :current_environment
+
+    # Encoding type for event bodies. Must be :json or :gzip.
+    attr_reader :encoding
+
+    # Whitelist of environments that will send notifications to Sentry. Array of Strings.
+    attr_accessor :environments
+
+    # Logger 'progname's to exclude from breadcrumbs
+    attr_accessor :exclude_loggers
+
+    # Array of exception classes that should never be sent. See IGNORE_DEFAULT.
+    # You should probably append to this rather than overwrite it.
+    attr_accessor :excluded_exceptions
+
+    # Boolean to check nested exceptions when deciding if to exclude. Defaults to false
+    attr_accessor :inspect_exception_causes_for_exclusion
+    alias inspect_exception_causes_for_exclusion? inspect_exception_causes_for_exclusion
+
+    # DSN component - set automatically if DSN provided
+    attr_accessor :host
+
+    # The Faraday adapter to be used. Will default to Net::HTTP when not set.
+    attr_accessor :http_adapter
+
+    # A Proc yeilding the faraday builder allowing for further configuration
+    # of the faraday adapter
+    attr_accessor :faraday_builder
+
+    # 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 Sentry::LineCache for the required interface you must implement.
+    attr_accessor :linecache
+
+    # Logger used by Sentry. In Rails, this is the Rails logger, otherwise
+    # Sentry provides its own Sentry::Logger.
+    attr_accessor :logger
+
+    # Timeout waiting for the Sentry server connection to open in seconds
+    attr_accessor :open_timeout
+
+    # DSN component - set automatically if DSN provided
+    attr_accessor :path
+
+    # DSN component - set automatically if DSN provided
+    attr_accessor :port
+
+    # Project ID number to send to the Sentry server
+    # If you provide a DSN, this will be set automatically.
+    attr_accessor :project_id
+
+    # Project directory root for in_app detection. Could be Rails root, etc.
+    # Set automatically for Rails.
+    attr_reader :project_root
+
+    # Proxy information to pass to the HTTP adapter (via Faraday)
+    attr_accessor :proxy
+
+    # Public key for authentication with the Sentry server
+    # If you provide a DSN, this will be set automatically.
+    attr_accessor :public_key
+
+    # Turns on ActiveSupport breadcrumbs integration
+    attr_reader :rails_activesupport_breadcrumbs
+
+    # 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), Sentry
+    # will report exceptions even when they are rescued by these middlewares.
+    attr_accessor :rails_report_rescued_exceptions
+
+    # Release tag to be passed with every event sent to Sentry.
+    # We automatically try to set this to a git SHA or Capistrano release.
+    attr_accessor :release
+
+    # The sampling factor to apply to events. A value of 0.0 will not send
+    # any events, and a value of 1.0 will send 100% of events.
+    attr_accessor :sample_rate
+
+    # Boolean - sanitize values that look like credit card numbers
+    attr_accessor :sanitize_credit_cards
+
+    # 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.
+    attr_accessor :sanitize_fields
+
+    # 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)
+    attr_accessor :sanitize_fields_excluded
+
+    # Sanitize additional HTTP headers - only Authorization is removed by default.
+    attr_accessor :sanitize_http_headers
+
+    # DSN component - set automatically if DSN provided.
+    # Otherwise, can be one of "http", "https", or "dummy"
+    attr_accessor :scheme
+
+    # a proc/lambda that takes an array of stack traces
+    # it'll be used to silence (reduce) backtrace of the exception
+    #
+    # for example:
+    #
+    # ```ruby
+    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+    #   Rails.backtrace_cleaner.clean(backtrace)
+    # end
+    # ```
+    #
+    attr_accessor :backtrace_cleanup_callback
+
+    # Secret key for authentication with the Sentry server
+    # If you provide a DSN, this will be set automatically.
+    #
+    # This is deprecated and not necessary for newer Sentry installations any more.
+    attr_accessor :secret_key
+
+    # Include module versions in reports - boolean.
+    attr_accessor :send_modules
+
+    # Simple server string - set this to the DSN found on your Sentry settings.
+    attr_reader :server
+
+    attr_accessor :server_name
+
+    # 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 }
+    attr_reader :should_capture
+
+    # Silences ready message when true.
+    attr_accessor :silence_ready
+
+    # SSL settings passed directly to Faraday's ssl option
+    attr_accessor :ssl
+
+    # The path to the SSL certificate file
+    attr_accessor :ssl_ca_file
+
+    # Should the SSL certificate of the server be verified?
+    attr_accessor :ssl_verification
+
+    # Default tags for events. Hash.
+    attr_accessor :tags
+
+    # Timeout when waiting for the server to return data in seconds.
+    attr_accessor :timeout
+
+    # Optional Proc, called when the Sentry server cannot be contacted for any reason
+    # E.g. lambda { |event| Thread.new { MyJobProcessor.send_email(event) } }
+    attr_reader :transport_failure_callback
+
+    # Optional Proc, called before sending an event to the server/
+    # E.g.: lambda { |event, hint| event }
+    # E.g.: lambda { |event, hint| nil }
+    # E.g.: lambda { |event, hint|
+    #   event[:message] = 'a'
+    #   event
+    # }
+    attr_reader :before_send
+
+    # Errors object - an Array that contains error messages. See #
+    attr_reader :errors
+
+    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
+    attr_reader :dsn
+
+    # Most of these errors generate 4XX responses. In general, Sentry clients
+    # only automatically report 5xx responses.
+    IGNORE_DEFAULT = [
+      'AbstractController::ActionNotFound',
+      'ActionController::BadRequest',
+      'ActionController::InvalidAuthenticityToken',
+      'ActionController::InvalidCrossOriginRequest',
+      'ActionController::MethodNotAllowed',
+      'ActionController::NotImplemented',
+      'ActionController::ParameterMissing',
+      'ActionController::RoutingError',
+      'ActionController::UnknownAction',
+      'ActionController::UnknownFormat',
+      'ActionController::UnknownHttpMethod',
+      'ActionDispatch::Http::Parameters::ParseError',
+      'ActionView::MissingTemplate',
+      'ActiveJob::DeserializationError', # Can cause infinite loops
+      'ActiveRecord::RecordNotFound',
+      'CGI::Session::CookieStore::TamperedWithCookie',
+      'Mongoid::Errors::DocumentNotFound',
+      'Rack::QueryParser::InvalidParameterError',
+      'Rack::QueryParser::ParameterTypeError',
+      'Sinatra::NotFound'
+    ].freeze
+
+    HEROKU_DYNO_METADATA_MESSAGE = "You are running on Heroku but haven't enabled Dyno Metadata. For Sentry's "\
+    "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`".freeze
+
+    LOG_PREFIX = "** [Sentry] ".freeze
+    MODULE_SEPARATOR = "::".freeze
+
+    AVAILABLE_BREADCRUMBS_LOGGERS = [:sentry_logger, :active_support_logger].freeze
+
+    def initialize
+      self.async = false
+      self.breadcrumbs_logger = []
+      self.context_lines = 3
+      self.current_environment = current_environment_from_env
+      self.encoding = 'gzip'
+      self.environments = []
+      self.exclude_loggers = []
+      self.excluded_exceptions = IGNORE_DEFAULT.dup
+      self.inspect_exception_causes_for_exclusion = false
+      self.linecache = ::Sentry::LineCache.new
+      self.logger = ::Sentry::Logger.new(STDOUT)
+      self.open_timeout = 1
+      self.project_root = detect_project_root
+      @rails_activesupport_breadcrumbs = false
+
+      self.rails_report_rescued_exceptions = true
+      self.release = detect_release
+      self.sample_rate = 1.0
+      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']
+      self.server_name = server_name_from_env
+      self.should_capture = false
+      self.ssl_verification = true
+      self.tags = {}
+      self.timeout = 2
+      self.transport_failure_callback = false
+      self.before_send = false
+    end
+
+    def server=(value)
+      return if value.nil?
+
+      @dsn = 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.nil? || uri.password.empty?) ? uri.password : nil
+      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
+    alias dsn= server=
+
+    def encoding=(encoding)
+      raise(Error, 'Unsupported encoding') unless %w(gzip json).include? encoding
+
+      @encoding = encoding
+    end
+
+    def async=(value)
+      unless value == false || value.respond_to?(:call)
+        raise(ArgumentError, "async must be callable (or false to disable)")
+      end
+
+      @async = value
+    end
+
+    def breadcrumbs_logger=(logger)
+      loggers =
+        if logger.is_a?(Array)
+          logger
+        else
+          unless AVAILABLE_BREADCRUMBS_LOGGERS.include?(logger)
+            raise Sentry::Error, "Unsupported breadcrumbs logger. Supported loggers: #{AVAILABLE_BREADCRUMBS_LOGGERS}"
+          end
+
+          Array(logger)
+        end
+
+      require "raven/breadcrumbs/sentry_logger" if loggers.include?(:sentry_logger)
+
+      @breadcrumbs_logger = logger
+    end
+
+    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
+
+    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
+
+    def before_send=(value)
+      unless value == false || value.respond_to?(:call)
+        raise ArgumentError, "before_send must be callable (or false to disable)"
+      end
+
+      @before_send = value
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      public_send(option)
+    end
+
+    def current_environment=(environment)
+      @current_environment = environment.to_s
+    end
+
+    def capture_allowed?(message_or_exc = nil)
+      @errors = []
+
+      valid? &&
+        capture_in_current_environment? &&
+        capture_allowed_by_callback?(message_or_exc) &&
+        sample_allowed?
+    end
+    # If we cannot capture, we cannot send.
+    alias sending_allowed? capture_allowed?
+
+    def error_messages
+      @errors = [errors[0]] + errors[1..-1].map(&:downcase) # fix case of all but first
+      errors.join(", ")
+    end
+
+    def project_root=(root_dir)
+      @project_root = root_dir
+    end
+
+    def rails_activesupport_breadcrumbs=(val)
+      DeprecationHelper.deprecate_old_breadcrumbs_configuration(:active_support_logger)
+      @rails_activesupport_breadcrumbs = val
+    end
+
+    def exception_class_allowed?(exc)
+      if exc.is_a?(Sentry::Error)
+        # Try to prevent error reporting loops
+        logger.debug "Refusing to capture Sentry error: #{exc.inspect}"
+        false
+      elsif excluded_exception?(exc)
+        logger.debug "User excluded error: #{exc.inspect}"
+        false
+      else
+        true
+      end
+    end
+
+    def enabled_in_current_env?
+      environments.empty? || environments.include?(current_environment)
+    end
+
+    private
+
+    def detect_project_root
+      if defined? Rails.root # we are in a Rails application
+        Rails.root.to_s
+      else
+        Dir.pwd
+      end
+    end
+
+    def detect_release
+      detect_release_from_env ||
+        detect_release_from_git ||
+        detect_release_from_capistrano ||
+        detect_release_from_heroku
+    rescue => e
+      logger.error "Error detecting release: #{e.message}"
+    end
+
+    def excluded_exception?(incoming_exception)
+      excluded_exceptions.any? do |excluded_exception|
+        matches_exception?(get_exception_class(excluded_exception), incoming_exception)
+      end
+    end
+
+    def get_exception_class(x)
+      x.is_a?(Module) ? x : qualified_const_get(x)
+    end
+
+    def matches_exception?(excluded_exception_class, incoming_exception)
+      if inspect_exception_causes_for_exclusion?
+        Sentry::Utils::ExceptionCauseChain.exception_to_array(incoming_exception).any? { |cause| excluded_exception_class === cause }
+      else
+        excluded_exception_class === incoming_exception
+      end
+    end
+
+    # In Ruby <2.0 const_get can't lookup "SomeModule::SomeClass" in one go
+    def qualified_const_get(x)
+      x = x.to_s
+      if !x.match(/::/)
+        Object.const_get(x)
+      else
+        x.split(MODULE_SEPARATOR).reject(&:empty?).inject(Object) { |a, e| a.const_get(e) }
+      end
+    rescue NameError # There's no way to safely ask if a constant exist for an unknown string
+      nil
+    end
+
+    def detect_release_from_heroku
+      return unless running_on_heroku?
+      return if ENV['CI']
+      logger.warn(HEROKU_DYNO_METADATA_MESSAGE) && return unless ENV['HEROKU_SLUG_COMMIT']
+
+      ENV['HEROKU_SLUG_COMMIT']
+    end
+
+    def running_on_heroku?
+      File.directory?("/etc/heroku")
+    end
+
+    def detect_release_from_capistrano
+      revision_file = File.join(project_root, 'REVISION')
+      revision_log = File.join(project_root, '..', 'revisions.log')
+
+      if File.exist?(revision_file)
+        File.read(revision_file).strip
+      elsif File.exist?(revision_log)
+        File.open(revision_log).to_a.last.strip.sub(/.*as release ([0-9]+).*/, '\1')
+      end
+    end
+
+    def detect_release_from_git
+      Sentry.sys_command("git rev-parse --short HEAD") if File.directory?(".git")
+    end
+
+    def detect_release_from_env
+      ENV['SENTRY_RELEASE']
+    end
+
+    def capture_in_current_environment?
+      return true if enabled_in_current_env?
+
+      @errors << "Not configured to send/capture in environment '#{current_environment}'"
+      false
+    end
+
+    def capture_allowed_by_callback?(message_or_exc)
+      return true if !should_capture || message_or_exc.nil? || should_capture.call(message_or_exc)
+
+      @errors << "should_capture returned false"
+      false
+    end
+
+    def valid?
+      return true if %w(server host path public_key project_id).all? { |k| public_send(k) }
+
+      if server
+        %w(server host path public_key project_id).map do |key|
+          @errors << "No #{key} specified" unless public_send(key)
+        end
+      else
+        @errors << "DSN not set"
+      end
+      false
+    end
+
+    def sample_allowed?
+      return true if sample_rate == 1.0
+
+      if Random::DEFAULT.rand >= sample_rate
+        @errors << "Excluded by random sample"
+        false
+      else
+        true
+      end
+    end
+
+    # Try to resolve the hostname to an FQDN, but fall back to whatever
+    # the load name is.
+    def resolve_hostname
+      Socket.gethostname ||
+        Socket.gethostbyname(hostname).first rescue server_name
+    end
+
+    def current_environment_from_env
+      ENV['SENTRY_CURRENT_ENV'] || ENV['SENTRY_ENVIRONMENT'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
+    end
+
+    def server_name_from_env
+      if running_on_heroku?
+        ENV['DYNO']
+      else
+        resolve_hostname
+      end
+    end
+  end
+end