sentry-raven 0.7.1 → 0.8.0

data/README.md

@@ -1,6 +1,8 @@
 # Raven-Ruby
 
-[![Gem Version](https://badge.fury.io/rb/sentry-raven.png)](http://badge.fury.io/rb/sentry-raven) [![Build Status](https://secure.travis-ci.org/getsentry/raven-ruby.png?branch=master)](http://travis-ci.org/getsentry/raven-ruby) [![Coverage Status](https://coveralls.io/repos/getsentry/raven-ruby/badge.png?branch=master)](https://coveralls.io/r/getsentry/raven-ruby)
+[![Gem Version](https://img.shields.io/gem/v/sentry-raven.svg)](https://rubygems.org/gems/sentry-raven)
+[![Build Status](https://img.shields.io/travis/getsentry/raven-ruby/master.svg)](https://travis-ci.org/getsentry/raven-ruby)
+[![Coverage Status](https://img.shields.io/coveralls/getsentry/raven-ruby/master.svg)](https://coveralls.io/r/getsentry/raven-ruby)
 
 A client and integration layer for the [Sentry](https://github.com/getsentry/sentry) error reporting API.
 
@@ -18,7 +20,7 @@ gem "sentry-raven" #, :github => "getsentry/raven-ruby"
 
 The easiest way to configure Raven is by setting the ``SENTRY_DSN`` environment variable.
 
-You'll find this value on your project settings page, and it should resemble something like ```https://secret:public@app.getsentry.com/9999```.
+You'll find this value on your project settings page, and it should resemble something like ```https://public:secret@app.getsentry.com/9999```.
 
 For alternative configuration methods, and other options see [Configuration](#configuration).
 
@@ -35,6 +37,30 @@ have mixed-in methods for capturing exceptions you've rescued yourself inside of
  end
 ```
 
+#### Delayed::Job
+
+The easiest way of enabling Raven for all your delayed jobs is to use [delayed-plugins-raven](https://github.com/qiushihe/delayed-plugins-raven) gem. First add it to  your application's Gemfile:
+
+```
+gem 'delayed-plugins-raven'
+```
+
+And then extend your Raven configuration (eg. in ```config/initializers/raven.rb``` file):
+
+```ruby
+require 'raven'
+require 'delayed-plugins-raven'
+
+Raven.configure do |config|
+    config.dsn = 'https://public:secret@app.getsentry.com/9999'
+    ...
+end
+
+Delayed::Worker.plugins << Delayed::Plugins::Raven::Plugin
+```
+
+For more configuration options check delayed-plugins-raven [documentation](https://github.com/qiushihe/delayed-plugins-raven).
+
 ### Rails 2
 
 No support for Rails 2 yet, but it is being worked on.
@@ -90,15 +116,14 @@ end
 Additional context can be passed to the capture methods.
 
 ```ruby
-Raven.capture_message("My event", {
-  :logger => 'logger',
-  :extra => {
-    'my_custom_variable' => 'value'
+Raven.capture_message "My event",
+  logger: 'logger',
+  extra: {
+    my_custom_variable: 'value'
   },
-  :tags => {
-    'environment' => 'production',
+  tags: {
+    environment: 'production'
   }
-})
 ```
 
 The following attributes are available:
@@ -121,13 +146,13 @@ There are three primary methods for providing request context:
 
 ```ruby
 # bind the logged in user
-Raven.user_context({'email' => 'foo@example.com'})
+Raven.user_context email: 'foo@example.com'
 
 # tag the request with something interesting
-Raven.tags_context({'interesting' => 'yes'})
+Raven.tags_context interesting: 'yes'
 
 # provide a bit of additional context
-Raven.extra_context({'happiness' => 'very'})
+Raven.extra_context happiness: 'very'
 ```
 
 Additionally, if you're using Rack (without the middleware), you can easily provide context with the ``rack_context`` helper:
@@ -139,11 +164,32 @@ Raven.rack_context(env)
 If you're using the Rack middleware, we've already taken care of cleanup for you, otherwise you'll need to ensure you perform it manually:
 
 ```ruby
-Raven.context.clear!
+Raven::Context.clear!
 ```
 
 Note: the rack and user context will perform a set operation, whereas tags and extra context will merge with any existing request context.
 
+### Authlogic
+
+When using Authlogic for authentication, you can provide user context by binding to session ```after_persisting``` and ```after_destroy``` events in ```user_session.rb```:
+
+```ruby
+class UserSession < Authlogic::Session::Base
+  # events binding
+  after_persisting :raven_set_user_context
+  after_destroy :raven_clear_user_context
+
+  def raven_set_user_context
+    Raven.user_context( { 'id' => self.user.id, 'email' => self.user.email, 'username' => self.user.username } )
+  end
+
+  def raven_clear_user_context
+    Raven.user_context({})
+  end
+end
+```
+
+
 ## Configuration
 
 ### SENTRY_DSN
@@ -213,8 +259,25 @@ flag:
 ```ruby
 Raven.configure do |config|
   config.ssl_verification = true
+end
 ```
 
+### Asynchronous Delivery
+
+When an error occurs, the notification is immediately sent to Sentry. Raven can be configured 
+to send notifications asynchronously:
+
+```ruby
+Raven.configure do |config|
+  config.async = lambda { |event|
+    Thread.new { Raven.send(event) }
+  }
+end
+```
+
+This example uses a thread, but other tools can be used (GirlFriday, Resque, Sidekiq, etc...) as 
+long as the `event` argument is eventually passed to `Raven.send`.
+
 ### Logging
 
 You can use any logger with Raven - just set config.logger. Raven respects logger

data/lib/raven.rb

@@ -1,192 +1,3 @@
-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/processors/sanitizedata'
+require 'raven/base'
 
-require 'raven/railtie' if defined?(Rails::Railtie)
-require 'raven/sidekiq' if defined?(Sidekiq)
-require 'raven/tasks' if defined?(Rake)
-
-
-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)
-      if block_given?
-        yield(configuration)
-      end
-
-      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 => e
-          raise # Don't capture Raven errors
-        rescue Exception => e
-          capture_exception(e, options)
-          raise
-        end
-      else
-        # Install at_exit hook
-        at_exit do
-          if $!
-            logger.debug "Caught a post-mortem exception: #{$!.inspect}"
-            capture_exception($!, options)
-          end
-        end
-      end
-    end
-
-    def capture_exception(exception, options={})
-      if evt = Event.from_exception(exception, options)
-        yield evt if block_given?
-        send(evt)
-      end
-    end
-
-    def capture_message(message, options={})
-      if evt = Event.from_message(message, options)
-        yield evt if block_given?
-        send(evt)
-      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
-
-    # For cross-language compat
-    alias :captureException :capture_exception
-    alias :captureMessage :capture_message
-    alias :annotateException :annotate_exception
-    alias :annotate :annotate_exception
-  end
-end
+Raven.inject

data/lib/raven/backtrace.rb

@@ -37,7 +37,8 @@ module Raven
       end
 
       def in_app
-        @in_app_pattern ||= Regexp.new("^(#{project_root}/)?#{APP_DIRS_PATTERN}")
+        app_dirs = Raven.configuration.app_dirs_pattern || APP_DIRS_PATTERN
+        @in_app_pattern ||= Regexp.new("^(#{project_root}/)?#{app_dirs}")
 
         if self.file =~ @in_app_pattern
           true
@@ -76,12 +77,12 @@ module Raven
 
       filters = opts[:filters] || []
       filtered_lines = ruby_lines.to_a.map do |line|
-        filters.inject(line) do |line, proc|
+        filters.reduce(line) do |line, proc|
           proc.call(line)
         end
       end.compact
 
-      lines = filtered_lines.collect do |unparsed_line|
+      lines = filtered_lines.map do |unparsed_line|
         Line.parse(unparsed_line)
       end
 
@@ -93,7 +94,7 @@ module Raven
     end
 
     def inspect
-      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+      "<Backtrace: " + lines.map { |line| line.inspect }.join(", ") + ">"
     end
 
     def to_s

data/lib/raven/base.rb

@@ -0,0 +1,212 @@
+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/processors/sanitizedata'
+
+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 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 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
+      if configuration.send_in_current_environment?
+        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 rails
+    def inject
+      require 'raven/railtie' if defined?(Rails::Railtie)
+      require 'raven/sidekiq' if defined?(Sidekiq)
+      require 'raven/tasks' if defined?(Rake)
+    end
+
+    # For cross-language compat
+    alias :captureException :capture_exception
+    alias :captureMessage :capture_message
+    alias :annotateException :annotate_exception
+    alias :annotate :annotate_exception
+  end
+end