bugsnag 1.1.5 → 1.2.0.beta

data/Gemfile

@@ -3,7 +3,7 @@ source "http://rubygems.org"
 # Example:
 #   gem "activesupport", ">= 2.3.5"
 gem "multi_json", "~> 1.0"
-gem "httparty", "~> 0.8.3"
+gem "httparty", ">= 0.5", "< 1.0"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/Gemfile.lock

@@ -1,14 +1,14 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (3.2.6)
+    activesupport (3.2.8)
       i18n (~> 0.6)
       multi_json (~> 1.0)
     git (1.2.5)
-    httparty (0.8.3)
+    httparty (0.9.0)
       multi_json (~> 1.0)
       multi_xml
-    i18n (0.6.0)
+    i18n (0.6.1)
     jeweler (1.6.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
@@ -21,14 +21,14 @@ GEM
       shoulda-context (~> 1.0)
       shoulda-matchers (~> 1.2)
     shoulda-context (1.0.0)
-    shoulda-matchers (1.2.0)
+    shoulda-matchers (1.3.0)
       activesupport (>= 3.0.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  httparty (~> 0.8.3)
+  httparty (>= 0.5, < 1.0)
   jeweler (~> 1.6.4)
   multi_json (~> 1.0)
   rcov

data/README.md

@@ -12,8 +12,19 @@ as fast as possible. [Create a free account](http://bugsnag.com) to start
 capturing exceptions from your applications.
 
 
-How to Install (Rails)
-----------------------
+Contents
+--------
+
+- [How to Install](#how-to-install)
+- [Sending Custom Data With Exceptions](#sending-custom-data-with-exceptions)
+- [Sending Non-Fatal Exceptions](#sending-non-fatal-exceptions)
+- [Configuration](#configuration)
+- [Bugsnag Middleware](#bugsnag-middleware)
+- [Deploy Tracking](#deploy-tracking)
+
+
+How to Install
+--------------
 
 1.  Add the `bugsnag` gem to your `Gemfile`
 
@@ -27,7 +38,9 @@ How to Install (Rails)
     bundle install
     ```
 
-3.  Copy the following code to a new file at `config/initializers/bugsnag.rb`
+3.  Configure the Bugsnag module with your API key.
+
+    In rails apps, put this code to a new file at `config/initializers/bugsnag.rb`
 
     ```ruby
     Bugsnag.configure do |config|
@@ -35,45 +48,87 @@ How to Install (Rails)
     end
     ```
 
-How to Install (Sinatra)
-------------------------
+4.  **Rack/Sinatra apps only**: Activate the Bugsnag Rack middleware
 
-```ruby
-require "bugsnag"
+    ```ruby
+    use Bugsnag::Rack
+    ```
 
-Bugsnag.configure do |config|
-  config.api_key = "YOUR_API_KEY_HERE"
+
+Sending Custom Data With Exceptions
+-----------------------------------
+
+It is often useful to send additional meta-data about your app, such as 
+information about the currently logged in user, along with any
+exceptions, to help debug problems. 
+
+### Rails Apps
+
+In any rails controller you can define a `before_bugsnag_notify` callback, 
+which allows you to add this additional data by calling `add_tab` on the
+exception notification object.
+
+```ruby
+class MyController < ApplicationController
+  # Define the filter
+  before_bugsnag_notify :add_user_info_to_bugsnag
+
+  # Your controller code here
+
+  private
+  def add_user_info_to_bugsnag(notif)
+    # Add some app-specific data which will be displayed on a custom
+    # "User Info" tab on each error page on bugsnag.com
+    notif.add_tab(:user_info, {
+      name: current_user.name
+    })
+  end
 end
+```
+
+### Other Ruby Apps
+
+In other ruby apps, you can provide lambda functions to execute before any 
+`Bugsnag.notify` calls as follows. Don't forget to clear the callbacks at the
+end of each request or session.
+
+```ruby
+# Set a before notify callback
+Bugsnag.before_notify_callbacks << lambda {|notif|
+  notif.add_tab(:user_info, {
+    name: current_user.name
+  })
+}
 
-use Bugsnag::Rack
+# Your app code here
+
+# Clear the callbacks
+Bugsnag.before_notify_callbacks.clear
 ```
 
+You can read more about how callbacks work in the
+[Bugsnag Middleware](#bugsnag-middleware) documentation below.
+
 
-Send Non-Fatal Exceptions to Bugsnag
-------------------------------------
+Sending Non-Fatal Exceptions
+----------------------------
 
-If you would like to send non-fatal exceptions to Bugsnag, there are two 
-ways of doing so. From a rails controller, you can call `notify_bugsnag`:
+If you would like to send non-fatal exceptions to Bugsnag, you can call
+`Bugsnag.notify`:
 
 ```ruby
-notify_bugsnag(RuntimeError.new("Something broke"))
+Bugsnag.notify(RuntimeError.new("Something broke"))
 ```
 
 You can also send additional meta-data with your exception:
 
 ```ruby
-notify_bugsnag(RuntimeError.new("Something broke"), {
+Bugsnag.notify(RuntimeError.new("Something broke"), {
   :username => "bob-hoskins",
   :registered_user => true
 })
 ```
 
-Anywhere else in your ruby code, you can call `Bugsnag.notify`:
-
-```ruby
-Bugsnag.notify(RuntimeError.new("Something broke"));
-```
-
 
 Configuration
 -------------
@@ -195,6 +250,61 @@ By default, `ignore_classes` contains the following classes:
 ]
 ```
 
+###logger
+
+Sets which logger to use for Bugsnag log messages. In rails apps, this is 
+automatically set to use `Rails.logger`, otherwise it will be set to
+`Logger.new(STDOUT)`.
+
+###middleware
+
+Provides access to the middleware stack, see the
+[Bugsnag Middleware](#bugsnag-middleware) section below for details.
+
+
+Bugsnag Middleware
+------------------
+
+The Bugsnag Notifier for Ruby provides its own middleware system, similar to 
+the one used in Rack applications. Middleware allows you to execute code 
+before and after an exception is sent to bugsnag.com, so you can do things 
+such as:
+
+-   Send application-specific information along with exceptions, eg. the name 
+    of the currently logged in user,
+-   Write exception information to your internal logging system.
+
+To make your own middleware, create a class that looks like this:
+
+```ruby
+class MyMiddleware
+  def initialize(bugsnag)
+    @bugsnag = bugsnag
+  end
+
+  def call(notification)
+    # Your custom "before notify" code
+
+    @bugsnag.call(notification)
+
+    # Your custom "after notify" code
+  end
+end
+```
+
+You can then add your middleware to the middleware stack as follows:
+
+```ruby
+Bugsnag.configure do |config|
+  config.middleware.use MyMiddleware
+end
+```
+
+You can also view the order of the currently activated middleware by running `rake bugsnag:middleware`.
+
+Check out Bugsnag's [built in middleware classes](https://github.com/bugsnag/bugsnag-ruby/tree/master/lib/bugsnag/middleware)
+for some real examples of middleware in action.
+
 
 Deploy Tracking
 ---------------

data/VERSION

@@ -1 +1 @@
-1.1.5
+1.2.0.beta

data/bugsnag.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "bugsnag"
-  s.version = "1.1.5"
+  s.version = "1.2.0.beta"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["James Smith"]
-  s.date = "2012-09-21"
+  s.date = "2012-09-29"
   s.description = "Ruby notifier for bugsnag.com"
   s.email = "james@bugsnag.com"
   s.extra_rdoc_files = [
@@ -28,8 +28,13 @@ Gem::Specification.new do |s|
     "lib/bugsnag.rb",
     "lib/bugsnag/capistrano.rb",
     "lib/bugsnag/configuration.rb",
-    "lib/bugsnag/delay/resque.rb",
     "lib/bugsnag/helpers.rb",
+    "lib/bugsnag/middleware/callbacks.rb",
+    "lib/bugsnag/middleware/rack_request.rb",
+    "lib/bugsnag/middleware/rails2_request.rb",
+    "lib/bugsnag/middleware/rails3_request.rb",
+    "lib/bugsnag/middleware/warden_user.rb",
+    "lib/bugsnag/middleware_stack.rb",
     "lib/bugsnag/notification.rb",
     "lib/bugsnag/rack.rb",
     "lib/bugsnag/rails.rb",
@@ -37,9 +42,9 @@ Gem::Specification.new do |s|
     "lib/bugsnag/rails/controller_methods.rb",
     "lib/bugsnag/railtie.rb",
     "lib/bugsnag/tasks.rb",
+    "lib/bugsnag/tasks/bugsnag.rake",
     "lib/bugsnag/version.rb",
     "lib/resque/failure/bugsnag.rb",
-    "lib/tasks/bugsnag.rake",
     "rails/init.rb",
     "test/helper.rb",
     "test/test_bugsnag.rb"
@@ -55,20 +60,20 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<multi_json>, ["~> 1.0"])
-      s.add_runtime_dependency(%q<httparty>, ["~> 0.8.3"])
+      s.add_runtime_dependency(%q<httparty>, ["< 1.0", ">= 0.5"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_development_dependency(%q<rcov>, [">= 0"])
     else
       s.add_dependency(%q<multi_json>, ["~> 1.0"])
-      s.add_dependency(%q<httparty>, ["~> 0.8.3"])
+      s.add_dependency(%q<httparty>, ["< 1.0", ">= 0.5"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_dependency(%q<rcov>, [">= 0"])
     end
   else
     s.add_dependency(%q<multi_json>, ["~> 1.0"])
-    s.add_dependency(%q<httparty>, ["~> 0.8.3"])
+    s.add_dependency(%q<httparty>, ["< 1.0", ">= 0.5"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
     s.add_dependency(%q<rcov>, [">= 0"])

data/lib/bugsnag.rb

@@ -14,12 +14,15 @@ module Bugsnag
   LOG_PREFIX = "** [Bugsnag] "
 
   class << self
-    # Configure the gem to send notifications, at the very least an api_key is required
-    def configure
-      yield(configuration)
+    # Configure the Bugsnag notifier application-wide settings.
+    def configure(config_hash=nil)
+      if config_hash
+        config_hash.each do |k,v|
+          configuration.send("#{k}=", v) rescue nil if configuration.respond_to?("#{k}=")
+        end
+      end
 
-      # Use resque for asynchronous notification if required
-      require "bugsnag/delay/resque" if configuration.delay_with_resque && defined?(Resque)
+      yield(configuration) if block_given?
 
       # Log that we are ready to rock
       if configuration.api_key && !@logged_ready
@@ -29,40 +32,58 @@ module Bugsnag
     end
 
     # Explicitly notify of an exception
-    def notify(exception, session_data={})
-      Notification.new(exception, configuration.merge(session_data)).deliver
+    def notify(exception, overrides=nil, request_data=nil)
+      Notification.new(exception, configuration, overrides, request_data).deliver
     end
 
     # Notify of an exception unless it should be ignored
-    def notify_or_ignore(exception, session_data={})
-      notification = Notification.new(exception, configuration.merge(session_data))
+    def notify_or_ignore(exception, overrides=nil, request_data=nil)
+      notification = Notification.new(exception, configuration, overrides, request_data)
       notification.deliver unless notification.ignore?
     end
 
     # Auto notify of an exception, called from rails and rack exception 
     # rescuers, unless auto notification is disabled, or we should ignore this
     # error class
-    def auto_notify(exception, session_data={})
-      notify_or_ignore(exception, session_data) if configuration.auto_notify
+    def auto_notify(exception, overrides=nil, request_data=nil)
+      notify_or_ignore(exception, overrides, request_data) if configuration.auto_notify
     end
 
     # Log wrapper
     def log(message)
-      configuration.logger.info(LOG_PREFIX + message) if configuration.logger
+      configuration.logger.info("#{LOG_PREFIX}#{message}")
     end
 
     # Warning logger
     def warn(message)
-      if configuration.logger
-        configuration.logger.warn(LOG_PREFIX + message)
-      else
-        puts "#{LOG_PREFIX}#{message}"
-      end
+      configuration.logger.warn("#{LOG_PREFIX}#{message}")
     end
 
-    # Configuration getter
+    # Configuration getters
     def configuration
       @configuration ||= Bugsnag::Configuration.new
     end
+
+    # Set "per-request" data, temporal data for use in bugsnag middleware
+    def set_request_data(key, value)
+      Bugsnag.configuration.set_request_data(key, value)
+    end
+
+    # Clear all "per-request" data, temporal data for use in bugsnag middleware    
+    # This method should be called after each distinct request or session ends
+    # Eg. After completing a page request in a web app
+    def clear_request_data
+      Bugsnag.configuration.clear_request_data
+    end
+
+    # Allow access to "before notify" callbacks
+    def before_notify_callbacks
+      Bugsnag.configuration.request_data[:before_callbacks] ||= []
+    end
+
+    # Allow access to "after notify" callbacks
+    def after_notify_callbacks
+      Bugsnag.configuration.request_data[:after_callbacks] ||= []
+    end
   end
 end

data/lib/bugsnag/configuration.rb

@@ -1,36 +1,27 @@
+require "set"
+require "logger"
+require "bugsnag/middleware_stack"
+
 module Bugsnag
   class Configuration
-    OPTIONS = [
-      :api_key, :release_stage, :notify_release_stages, :auto_notify,
-      :use_ssl, :project_root, :app_version,
-      :params_filters, :ignore_classes,
-      
-      :stacktrace_filters,
-      :framework, :endpoint, :logger,
-      :delay_with_resque
-    ]
-    OPTIONS.each {|o| attr_accessor o }
+    attr_accessor :api_key
+    attr_accessor :release_stage
+    attr_accessor :notify_release_stages
+    attr_accessor :auto_notify
+    attr_accessor :use_ssl
+    attr_accessor :project_root
+    attr_accessor :app_version
+    attr_accessor :params_filters
+    attr_accessor :ignore_classes
+    attr_accessor :endpoint
+    attr_accessor :logger
+    attr_accessor :middleware
 
-    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+    THREAD_LOCAL_NAME = "bugsnag_req_data"
 
-    DEFAULT_STACKTRACE_FILTERS = [
-      lambda { |line|
-        if defined?(Bugsnag.configuration.project_root) && Bugsnag.configuration.project_root.to_s != '' 
-          line.sub(/#{Bugsnag.configuration.project_root}\//, "")
-        else
-          line
-        end
-      },
-      lambda { |line| line.gsub(/^\.\//, "") },
-      lambda { |line|
-        if defined?(Gem)
-          Gem.path.inject(line) do |line, path|
-            line.gsub(/#{path}\//, "")
-          end
-        end
-      },
-      lambda { |line| line if line !~ %r{lib/bugsnag} }
-    ].freeze
+    DEFAULT_ENDPOINT = "notify.bugsnag.com"
+
+    DEFAULT_PARAMS_FILTERS = ["password"].freeze
 
     DEFAULT_IGNORE_CLASSES = [
       "ActiveRecord::RecordNotFound",
@@ -40,26 +31,46 @@ module Bugsnag
       "ActionController::UnknownAction",
       "AbstractController::ActionNotFound",
       "Mongoid::Errors::DocumentNotFound"
-    ]
-
+    ].freeze
 
     def initialize
-      @params_filters = DEFAULT_PARAMS_FILTERS.dup
-      @stacktrace_filters = DEFAULT_STACKTRACE_FILTERS.dup
-      @ignore_classes = DEFAULT_IGNORE_CLASSES.dup
-      @auto_notify = true
-      @release_stage = "production"
-      @notify_release_stages = ["production"]
+      # Set up the defaults
+      self.release_stage = "production"
+      self.notify_release_stages = ["production"]
+      self.auto_notify = true
+      self.use_ssl = false
+      self.params_filters = Set.new(DEFAULT_PARAMS_FILTERS)
+      self.ignore_classes = Set.new(DEFAULT_IGNORE_CLASSES)
+      self.endpoint = DEFAULT_ENDPOINT
+
+      # Set up logging
+      self.logger = Logger.new(STDOUT)
+      self.logger.level = Logger::WARN if self.release_stage == "production"
+
+      # Configure the bugsnag middleware stack
+      self.middleware = Bugsnag::MiddlewareStack.new
+      self.middleware.use Bugsnag::Middleware::Callbacks
+    end
+
+    def should_notify?
+      @notify_release_stages.include?(@release_stage)
+    end
+
+    def request_data
+      Thread.current[THREAD_LOCAL_NAME] ||= {}
+    end
+
+    def set_request_data(key, value)
+      Bugsnag.warn "Overwriting request data for key #{key.to_s}" if self.request_data[key]
+      self.request_data[key] = value
     end
     
-    def to_hash
-      OPTIONS.inject({}) do |hash, option|
-        hash.merge(option.to_sym => send(option))
-      end
+    def unset_request_data(key, value)
+      self.request_data.delete(key)
     end
 
-    def merge(hash)
-      to_hash.merge(hash)
+    def clear_request_data
+      Thread.current[THREAD_LOCAL_NAME] = nil
     end
   end
 end