mustwin-sentry-raven 0.11.2

data/lib/raven/base.rb

@@ -0,0 +1,225 @@
+require 'raven/version'
+require 'raven/backtrace'
+require 'raven/configuration'
+require 'raven/context'
+require 'raven/client'
+require 'raven/event'
+require 'raven/logger'
+require 'raven/rack'
+require 'raven/interfaces/message'
+require 'raven/interfaces/exception'
+require 'raven/interfaces/stack_trace'
+require 'raven/interfaces/http'
+require 'raven/processor'
+require 'raven/processor/sanitizedata'
+require 'raven/processor/removecircularreferences'
+require 'raven/processor/utf8conversion'
+
+module Raven
+  class << self
+    # The client object is responsible for delivering formatted data to the Sentry server.
+    # Must respond to #send. See Raven::Client.
+    attr_writer :client
+
+    # A Raven configuration object. Must act like a hash and return sensible
+    # values for all Raven configuration options. See Raven::Configuration.
+    attr_writer :configuration
+
+    def context
+      Context.current
+    end
+
+    def logger
+      @logger ||= Logger.new
+    end
+
+    # The configuration object.
+    # @see Raven.configure
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # The client object is responsible for delivering formatted data to the Sentry server.
+    def client
+      @client ||= Client.new(configuration)
+    end
+
+    # Tell the log that the client is good to go
+    def report_ready
+      self.logger.info "Raven #{VERSION} ready to catch errors"
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Raven.configure do |config|
+    #     config.server = 'http://...'
+    #   end
+    def configure(silent = false)
+      yield(configuration) if block_given?
+
+      self.client = Client.new(configuration)
+      report_ready unless silent
+      self.client
+    end
+
+    # Send an event to the configured Sentry server
+    #
+    # @example
+    #   evt = Raven::Event.new(:message => "An error")
+    #   Raven.send(evt)
+    def send(evt)
+      client.send(evt)
+    end
+
+    # Capture and process any exceptions from the given block, or globally if
+    # no block is given
+    #
+    # @example
+    #   Raven.capture do
+    #     MyApp.run
+    #   end
+    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
+
+    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
+
+    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
+
+    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
+
+    # 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.
+    #
+    # @example
+    #   begin
+    #     raise "Hello"
+    #   rescue => exc
+    #     Raven.annotate_exception(exc, :user => { 'id' => 1,
+    #                              'email' => 'foo@example.com' })
+    #   end
+    def annotate_exception(exc, options = {})
+      notes = exc.instance_variable_get(:@__raven_context) || {}
+      notes.merge!(options)
+      exc.instance_variable_set(:@__raven_context, notes)
+      exc
+    end
+
+    # 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.
+    #
+    # @example
+    #   Raven.user_context('id' => 1, 'email' => 'foo@example.com')
+    def user_context(options = {})
+      self.context.user = options
+    end
+
+    # 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.
+    #
+    # @example
+    #   Raven.tags_context('my_custom_tag' => 'tag_value')
+    def tags_context(options = {})
+      self.context.tags.merge!(options)
+    end
+
+    # Bind extra context. Merges with existing context (if any).
+    #
+    # Extra context shows up as Additional Data within Sentry, and is completely arbitrary.
+    #
+    # @example
+    #   Raven.tags_context('my_custom_data' => 'value')
+    def extra_context(options = {})
+      self.context.extra.merge!(options)
+    end
+
+    def rack_context(env)
+      if env.empty?
+        env = nil
+      end
+      self.context.rack_env = env
+    end
+
+    # Injects various integrations
+    def inject
+      require 'raven/integrations/delayed_job' if defined?(::Delayed::Plugin)
+      require 'raven/railtie' if defined?(::Rails::Railtie)
+      require 'raven/sidekiq' if defined?(Sidekiq)
+      if defined?(Rake)
+        require 'raven/rake'
+        require 'raven/tasks'
+      end
+    end
+
+    # For cross-language compat
+    alias :captureException :capture_exception
+    alias :captureMessage :capture_message
+    alias :annotateException :annotate_exception
+    alias :annotate :annotate_exception
+  end
+end

data/lib/raven/better_attr_accessor.rb

@@ -0,0 +1,44 @@
+require 'set'
+
+module Raven
+  module BetterAttrAccessor
+
+    def attributes
+      Hash[
+        self.class.attributes.map do |attr|
+          [attr, send(attr)]
+        end
+      ]
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def attributes
+        @attributes ||= Set.new
+
+        if superclass.include? BetterAttrAccessor
+          @attributes + superclass.attributes
+        else
+          @attributes
+        end
+      end
+
+      def attr_accessor(attr, options = {})
+        @attributes ||= Set.new
+        @attributes << attr.to_s
+
+        define_method attr do
+          if instance_variable_defined? "@#{attr}"
+            instance_variable_get "@#{attr}"
+          elsif options.key? :default
+            instance_variable_set "@#{attr}", options[:default].dup
+          end
+        end
+        attr_writer attr
+      end
+    end
+  end
+end

data/lib/raven/cli.rb

@@ -0,0 +1,63 @@
+require 'raven'
+
+module Raven
+  class CLI
+    def self.test(dsn = nil)
+      require 'logger'
+
+      logger = ::Logger.new(STDOUT)
+      logger.level = ::Logger::ERROR
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "-> #{msg}\n"
+      end
+
+      Raven.configuration.logger = logger
+      Raven.configuration.timeout = 5
+      Raven.configuration.dsn = dsn if dsn
+
+      # wipe out env settings to ensure we send the event
+      unless Raven.configuration.send_in_current_environment?
+        environments = Raven.configuration.environments
+        env_name = (environments && environments[0]) || 'production'
+        puts "Setting environment to #{env_name}"
+        Raven.configuration.current_environment = env_name
+      end
+
+      unless Raven.configuration.server
+        puts "Your client is not configured!"
+        exit 1
+      end
+
+      puts "Client configuration:"
+      ['server', 'project_id', 'public_key', 'secret_key'].each do |key|
+        unless Raven.configuration[key]
+          puts "Missing configuration for #{key}"
+          exit 1
+        end
+        puts "-> #{key}: #{Raven.configuration[key]}"
+      end
+      puts ""
+
+      puts "Sending a test event:"
+
+      begin
+        1 / 0
+      rescue ZeroDivisionError => exception
+        evt = Raven.capture_exception(exception)
+      end
+
+      if evt && !(evt.is_a? Thread)
+        puts "-> event ID: #{evt.id}"
+      elsif evt #async configuration
+        puts "-> event ID: #{evt.value.id}"
+      else
+        puts ""
+        puts "An error occurred while attempting to send the event."
+        exit 1
+      end
+
+      puts ""
+      puts "Done!"
+    end
+  end
+end

data/lib/raven/client.rb

@@ -0,0 +1,104 @@
+require 'zlib'
+require 'base64'
+
+require 'raven/version'
+require 'raven/okjson'
+require 'raven/transports/http'
+require 'raven/transports/udp'
+
+module Raven
+
+  class Client
+
+    PROTOCOL_VERSION = '5'
+    USER_AGENT = "raven-ruby/#{Raven::VERSION}"
+    CONTENT_TYPE = 'application/json'
+
+    attr_accessor :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+      @processors = configuration.processors.map { |v| v.new(self) }
+    end
+
+    def send(event)
+      unless configuration.send_in_current_environment?
+        configuration.log_excluded_environment_message
+        return
+      end
+
+      # Set the project ID correctly
+      event.project = self.configuration.project_id
+      Raven.logger.debug "Sending event #{event.id} to Sentry"
+
+      content_type, encoded_data = encode(event)
+      begin
+        transport.send(generate_auth_header(encoded_data), encoded_data,
+                       :content_type => content_type)
+      rescue => e
+        Raven.logger.error "Unable to record event with remote Sentry server (#{e.class} - #{e.message})"
+        e.backtrace[0..10].each { |line| Raven.logger.error(line) }
+        return
+      end
+
+      event
+    end
+
+    private
+
+    def encode(event)
+      hash = event.to_hash
+
+      # apply processors
+      hash = @processors.reduce(hash) do |memo, processor|
+        processor.process(memo)
+      end
+
+      encoded = OkJson.encode(hash)
+
+      case self.configuration.encoding
+      when 'gzip'
+        gzipped = Zlib::Deflate.deflate(encoded)
+        b64_encoded = strict_encode64(gzipped)
+        return 'application/octet-stream', b64_encoded
+      else
+        return 'application/json', encoded
+      end
+    end
+
+    def transport
+      @transport ||=
+        case self.configuration.scheme
+        when 'udp'
+          Transports::UDP.new self.configuration
+        when 'http', 'https'
+          Transports::HTTP.new self.configuration
+        else
+          raise Error.new("Unknown transport scheme '#{self.configuration.scheme}'")
+        end
+    end
+
+    def generate_auth_header(data)
+      now = Time.now.to_i.to_s
+      fields = {
+        'sentry_version' => PROTOCOL_VERSION,
+        'sentry_client' => USER_AGENT,
+        'sentry_timestamp' => now,
+        'sentry_key' => self.configuration.public_key,
+        'sentry_secret' => self.configuration.secret_key,
+      }
+      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
+    end
+
+    private
+
+    def strict_encode64(string)
+      if Base64.respond_to? :strict_encode64
+        Base64.strict_encode64 string
+      else # Ruby 1.8
+        Base64.encode64(string)[0..-2]
+      end
+    end
+
+  end
+end

data/lib/raven/configuration.rb

@@ -0,0 +1,173 @@
+require 'logger'
+
+module Raven
+  class Configuration
+
+    # Simple server string (setter provided below)
+    attr_reader :server
+
+    # Public key for authentication with the Sentry server
+    attr_accessor :public_key
+
+    # Secret key for authentication with the Sentry server
+    attr_accessor :secret_key
+
+    # Accessors for the component parts of the DSN
+    attr_accessor :scheme
+    attr_accessor :host
+    attr_accessor :port
+    attr_accessor :path
+
+    # Project ID number to send to the Sentry server
+    attr_accessor :project_id
+
+    # Project directory root
+    attr_accessor :project_root
+
+    # Encoding type for event bodies
+    attr_reader :encoding
+
+    # Logger to use internally
+    attr_accessor :logger
+
+    # Number of lines of code context to capture, or nil for none
+    attr_accessor :context_lines
+
+    # Whitelist of environments that will send notifications to Sentry
+    attr_accessor :environments
+
+    # Include module versions in reports?
+    attr_accessor :send_modules
+
+    # Which exceptions should never be sent
+    attr_accessor :excluded_exceptions
+
+    # Processors to run on data before sending upstream
+    attr_accessor :processors
+
+    # Timeout when waiting for the server to return data in seconds
+    attr_accessor :timeout
+
+    # Timeout waiting for the connection to open in seconds
+    attr_accessor :open_timeout
+
+    # Should the SSL certificate of the server be verified?
+    attr_accessor :ssl_verification
+
+    # Ssl settings passed direactly to faraday's ssl option
+    attr_accessor :ssl
+
+    attr_reader :current_environment
+
+    # The Faraday adapter to be used. Will default to Net::HTTP when not set.
+    attr_accessor :http_adapter
+
+    attr_accessor :server_name
+
+    # DEPRECATED: This option is now ignored as we use our own adapter.
+    attr_accessor :json_adapter
+
+    # Default tags for events
+    attr_accessor :tags
+
+    # Optional Proc to be used to send events asynchronously.
+    attr_reader :async
+
+    # Exceptions from these directories to be ignored
+    attr_accessor :app_dirs_pattern
+
+    # Catch exceptions before they're been processed by
+    # ActionDispatch::ShowExceptions or ActionDispatch::DebugExceptions
+    attr_accessor :catch_debugged_exceptions
+
+    # Provide a configurable callback to block or send events
+    attr_accessor :should_send
+
+    # additional fields to sanitize
+    attr_accessor :sanitize_fields
+
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound']
+
+    def initialize
+      self.server = ENV['SENTRY_DSN'] if ENV['SENTRY_DSN']
+      @context_lines = 3
+      self.current_environment = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
+      self.send_modules = true
+      self.excluded_exceptions = IGNORE_DEFAULT
+      self.processors = [Raven::Processor::RemoveCircularReferences, Raven::Processor::UTF8Conversion, Raven::Processor::SanitizeData]
+      self.ssl_verification = false
+      self.encoding = 'gzip'
+      self.timeout = 1
+      self.open_timeout = 1
+      self.tags = {}
+      self.async = false
+      self.catch_debugged_exceptions = true
+      self.sanitize_fields = []
+    end
+
+    def server=(value)
+      uri = URI.parse(value)
+      uri_path = uri.path.split('/')
+
+      if uri.user
+        # DSN-style string
+        @project_id = uri_path.pop
+        @public_key = uri.user
+        @secret_key = uri.password
+      end
+
+      @scheme = uri.scheme
+      @host = uri.host
+      @port = uri.port if uri.port
+      @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
+
+    def encoding=(encoding)
+      raise Error.new('Unsupported encoding') unless ['gzip', 'json'].include? encoding
+      @encoding = encoding
+    end
+
+    alias_method :dsn=, :server=
+
+    def async=(value)
+      raise ArgumentError.new("async must be callable (or false to disable)") unless (value == false || value.respond_to?(:call))
+      @async = value
+    end
+
+    alias_method :async?, :async
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    def current_environment=(environment)
+      @current_environment = environment.to_s
+    end
+
+    def send_in_current_environment?
+      if environments
+        environments.include?(current_environment)
+      else
+        true
+      end
+    end
+
+    def log_excluded_environment_message
+      Raven.logger.debug "Event not sent due to excluded environment: #{current_environment}"
+    end
+  end
+end