bugsnag 1.1.5 → 1.2.0.beta

data/lib/bugsnag/helpers.rb

@@ -1,34 +1,48 @@
+module HTTParty
+  class Parser
+    def json
+      Bugsnag::Helpers.load_json(body)
+    end
+  end
+end
+
 module Bugsnag
   module Helpers
     MAX_STRING_LENGTH = 4096
 
-    def self.cleanup_hash(hash)
-      return nil unless hash
-      hash.inject({}) do |h, (k, v)|
-        h[k.to_s.gsub(/\./, "-")] = v.to_s.slice(0, MAX_STRING_LENGTH)
-        h
-      end
-    end
-    
-    def self.apply_filters(hash, filters)
-      return nil unless hash
-      return hash unless filters
+    def self.cleanup_obj(obj, filters = nil)
+      return nil unless obj
 
-      hash.each do |k, v|
-        if filters.any? {|f| k.to_s.include?(f.to_s) }
-          hash[k] = "[FILTERED]"
-        elsif v.respond_to?(:to_hash)
-          apply_filters(hash[k])
+      if obj.is_a?(Hash)
+        clean_hash = {}
+        obj.each do |k,v| 
+          if filters && filters.any? {|f| k.to_s.include?(f.to_s)}
+            clean_hash[k] = "[FILTERED]"
+          else
+            clean_obj = cleanup_obj(v, filters)
+            clean_hash[k] = clean_obj unless clean_obj.nil?
+          end
         end
+        clean_hash
+      elsif obj.is_a?(Array) || obj.is_a?(Set)
+        obj.map { |el| cleanup_obj(el, filters) }.compact
+      elsif obj.is_a?(Integer) || obj.is_a?(Float)
+        obj
+      else
+        obj.to_s unless obj.to_s =~ /#<.*>/
       end
     end
     
-    def self.param_context(params)
-      "#{params[:controller]}##{params[:action]}" if params && params[:controller] && params[:action]
-    end
+    def self.reduce_hash_size(hash)
+      hash.inject({}) do |h, (k,v)|
+        if v.is_a?(Hash)
+          h[k] = reduce_hash_size(v)
+        else
+          h[k] = v.to_s.slice(0, MAX_STRING_LENGTH)
+        end
 
-    def self.request_context(request)
-      "#{request.request_method} #{request.path}" if request
+        h
+      end
     end
 
     # Helper functions to work around MultiJson changes in 1.3+

data/lib/bugsnag/middleware/callbacks.rb

@@ -0,0 +1,19 @@
+module Bugsnag::Middleware
+  class Callbacks
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(notification)
+      if notification.request_data[:before_callbacks]
+        notification.request_data[:before_callbacks].each {|c| c.call(*[notification][0...c.arity]) }
+      end
+
+      @bugsnag.call(notification)
+
+      if notification.request_data[:after_callbacks]
+        notification.request_data[:after_callbacks].each {|c| c.call(*[notification][0...c.arity]) }
+      end
+    end
+  end
+end

data/lib/bugsnag/middleware/rack_request.rb

@@ -0,0 +1,48 @@
+module Bugsnag::Middleware
+  class RackRequest
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+      
+    def call(notification)
+      if notification.request_data[:rack_env]
+        env = notification.request_data[:rack_env]
+
+        request = ::Rack::Request.new(env)
+        params = request.params
+        session = env["rack.session"]
+
+        # Set the context
+        notification.context = "#{request.request_method} #{request.path}"
+
+        # Set a sensible default for user_id
+        notification.user_id = request.ip
+
+        # Build the clean url (hide the port if it is obvious)
+        url = "#{request.scheme}://#{request.host}"
+        url << ":#{request.port}" unless [80, 443].include?(request.port)
+        url << request.fullpath
+
+        # Add a request tab
+        notification.add_tab(:request, {
+          :url => url,
+          :params => params.to_hash,
+          :userAgent => request.user_agent,
+          :clientIp => request.ip
+        })
+          
+        # Add an environment tab
+        notification.add_tab(:environment, env)
+
+        # Add a session tab
+        notification.add_tab(:session, session) if session
+
+        # Add a cookies tab
+        cookies = request.cookies
+        notification.add_tab(:cookies, cookies) if cookies
+      end
+
+      @bugsnag.call(notification)
+    end
+  end
+end

data/lib/bugsnag/middleware/rails2_request.rb

@@ -0,0 +1,45 @@
+module Bugsnag::Middleware
+  class Rails2Request
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+      
+    def call(notification)
+      if notification.request_data[:rails2_request]
+        request = notification.request_data[:rails2_request]
+        params = request.parameters || {}
+        session_data = request.session.respond_to?(:to_hash) ? request.session.to_hash : request.session.data
+
+        # Set the context
+        notification.context = "#{params[:controller]}##{params[:action]}"
+
+        # Set a sensible default for user_id
+        notification.user_id = request.remote_ip if request.respond_to?(:remote_ip)
+
+        # Build the clean url
+        url = "#{request.protocol}#{request.host}"
+        url << ":#{request.port}" unless [80, 443].include?(request.port)
+        url << request.fullpath
+
+        # Add a request tab
+        notification.add_tab(:request, {
+          :url => url,
+          :params => params.to_hash,
+          :controller => params[:controller],
+          :action => params[:action]
+        })
+
+        # Add an environment tab
+        notification.add_tab(:environment, request.env) if request.env
+
+        # Add a session tab
+        notification.add_tab(:session, session_data) if session_data
+
+        # Add a cookies tab
+        notification.add_tab(:cookies, request.cookies) if request.cookies
+      end
+
+      @bugsnag.call(notification)
+    end
+  end
+end

data/lib/bugsnag/middleware/rails3_request.rb

@@ -0,0 +1,27 @@
+module Bugsnag::Middleware
+  class Rails3Request
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+      
+    def call(notification)
+      if notification.request_data[:rack_env]
+        env = notification.request_data[:rack_env]
+        params = env["action_dispatch.request.parameters"]
+
+        # Set the context
+        notification.context = "#{params[:controller]}##{params[:action]}"
+
+        # Augment the request tab
+        if params
+          notification.add_tab(:request, {
+            :railsAction => "#{params[:controller]}##{params[:action]}",
+            :params => params
+          })
+        end
+      end
+
+      @bugsnag.call(notification)
+    end
+  end
+end

data/lib/bugsnag/middleware/warden_user.rb

@@ -0,0 +1,47 @@
+module Bugsnag::Middleware
+  class WardenUser
+    SCOPE_PATTERN = /^warden\.user\.([^.]+)\.key$/
+    COMMON_USER_FIELDS = [:email, :name, :first_name, :last_name, :created_at]
+
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(notification)
+      if notification.request_data[:rack_env] && notification.request_data[:rack_env]["warden"]
+        env = notification.request_data[:rack_env]
+        session = env["rack.session"] || {}
+
+        # Find all warden user scopes
+        warden_scopes = session.keys.select {|k| k.match(SCOPE_PATTERN)}.map {|k| k.gsub(SCOPE_PATTERN, '\1')}
+        unless warden_scopes.empty?
+          # Pick the best scope for unique id (the default is "user")
+          best_scope = warden_scopes.include?("user") ? "user" : warden_scopes.first
+
+          # Set the user_id
+          if best_scope
+            user_id = session[best_scope][1][0] rescue nil
+            notification.user_id = user_id unless user_id.nil?
+          end
+
+          # Extract useful user information
+          warden_tab = {}
+          warden_scopes.each do |scope|
+            user_object = env["warden"].user({:scope => scope, :run_callbacks => false}) rescue nil
+            if user_object
+              # Build the user info for this scope
+              scope_hash = warden_tab["Warden #{scope.capitalize}"] = {}
+              COMMON_USER_FIELDS.each do |field|
+                scope_hash[field] = user_object.send(field) if user_object.respond_to?(field)
+              end
+            end
+          end
+
+          notification.add_tab(:user, warden_tab) unless warden_tab.empty?
+        end
+      end
+
+      @bugsnag.call(notification)
+    end
+  end
+end

data/lib/bugsnag/middleware_stack.rb

@@ -0,0 +1,64 @@
+module Bugsnag
+  class MiddlewareStack
+    def initialize
+      @middlewares = []
+    end
+  
+    def use(new_middleware)
+      @middlewares << new_middleware
+    end
+
+    def delete(middleware)
+      @middlewares.delete(middleware)
+    end
+  
+    def insert_after(after, new_middleware)
+      index = (@middlewares.rindex(after) + 1)
+      if index >= @middlewares.length
+        @middlewares << new_middleware
+      else
+        @middlewares.insert index, new_middleware
+      end
+    end
+  
+    def insert_before(before, new_middleware)
+      index = @middlewares.index(before) || @middlewares.length
+      @middlewares.insert index, new_middleware
+    end
+    
+    # This allows people to proxy methods to the array if they want to do more complex stuff
+    def method_missing(method, *args, &block)
+      @middlewares.send(method, *args, &block)
+    end
+    
+    # Runs the middleware stack and calls 
+    def run(notification)
+      # The final lambda is the termination of the middleware stack. It calls deliver on the notification
+      lambda_has_run = false
+      notify_lambda = lambda do |notification|
+        lambda_has_run = true        
+        yield
+      end
+
+      begin
+        # We reverse them, so we can call "call" on the first middleware
+        middleware_procs.reverse.inject(notify_lambda) { |n,e| e[n] }.call(notification)
+      rescue Exception => e
+        # We dont notify, as we dont want to loop forever in the case of really broken middleware, we will
+        # still send this notify
+        Bugsnag.warn "Bugsnag middleware error: #{e}"
+        Bugsnag.log "Middleware error stacktrace: #{e.backtrace.inspect}"
+      end
+      
+      # Ensure that the deliver has been performed, and no middleware has botched it
+      notify_lambda.call(notification) unless lambda_has_run
+    end
+
+    private
+    # Generates a list of middleware procs that are ready to be run
+    # Pass each one a reference to the next in the queue
+    def middleware_procs
+      @middlewares.map{|middleware| proc { |next_middleware| middleware.new(next_middleware) } }
+    end
+  end
+end

data/lib/bugsnag/notification.rb

@@ -1,5 +1,6 @@
 require "httparty"
 require "multi_json"
+require "pathname"
 
 module Bugsnag
   class Notification
@@ -9,37 +10,43 @@ module Bugsnag
     NOTIFIER_VERSION = Bugsnag::VERSION
     NOTIFIER_URL = "http://www.bugsnag.com"
 
-    DEFAULT_ENDPOINT = "notify.bugsnag.com"
-
     # HTTParty settings
     headers  "Content-Type" => "application/json"
     default_timeout 5
-
-    # Basic notification attributes
-    attr_accessor :exceptions
-
-    # Attributes from session
-    attr_accessor :user_id, :context, :meta_data
-
-    # Attributes from configuration
-    attr_accessor :api_key, :params_filters, :stacktrace_filters, 
-                  :ignore_classes, :endpoint, :app_version, :release_stage,
-                  :notify_release_stages, :project_root, :use_ssl
-
-
-    def self.deliver_exception_payload(endpoint, payload_string)
-      begin
-        response = post(endpoint, {:body => payload_string})
-      rescue Exception => e
-        Bugsnag.log("Notification to #{endpoint} failed, #{e.inspect}")
+    
+    attr_accessor :context
+    attr_accessor :user_id
+    
+    class << self
+      def deliver_exception_payload(endpoint, payload)
+        begin
+          payload_string = Bugsnag::Helpers.dump_json(payload)
+        
+          # If the payload is going to be too long, we trim the hashes to send 
+          # a minimal payload instead
+          if payload_string.length > 512000
+            payload = Bugsnag::Helpers.reduce_hash_size(payload)
+            payload_string = Bugsnag::Helpers.dump_json(payload)
+          end
+
+          response = post(endpoint, {:body => payload_string})
+        rescue Exception => e
+          Bugsnag.log("Notification to #{endpoint} failed, #{e.inspect}")
+        end
       end
     end
 
-    def initialize(exception, opts={})
-      self.exceptions = []
+    def initialize(exception, configuration, overrides = nil, request_data = nil)
+      @configuration = configuration
+      @overrides = overrides || {}
+      @request_data = request_data
+      @meta_data = {}
+      
+      # Unwrap exceptions
+      @exceptions = []
       ex = exception
       while ex != nil
-        self.exceptions << ex
+        @exceptions << ex
 
         if ex.respond_to?(:continued_exception) && ex.continued_exception
           ex = ex.continued_exception
@@ -49,60 +56,126 @@ module Bugsnag
           ex = nil
         end
       end
+    end
+    
+    # Add a single value as custom data, to this notification
+    def add_custom_data(name, value)
+      @meta_data[:custom] ||= {}
+      @meta_data[:custom][name.to_sym] = value
+    end
+
+    # Add a new tab to this notification
+    def add_tab(name, value)
+      return if name.nil?
 
-      opts.reject! {|k,v| v.nil?}.each do |k,v|
-        self.send("#{k}=", v) if self.respond_to?("#{k}=")
+      if value.is_a? Hash
+        @meta_data[name.to_sym] ||= {}
+        @meta_data[name.to_sym].merge! value
+      else
+        self.add_custom_data(name, value)
+        Bugsnag.warn "Adding a tab requires a hash, adding to custom tab instead (name=#{name})"
       end
     end
 
+    # Remove a tab from this notification
+    def remove_tab(name)
+      return if name.nil?
+
+      @meta_data.delete(name.to_sym)
+    end
+
+    # Deliver this notification to bugsnag.com Also runs through the middleware as required.
     def deliver
-      return unless self.notify_release_stages.include?(self.release_stage)
-      
-      unless self.api_key
+      return unless @configuration.should_notify?
+
+      # Check we have at least and api_key
+      unless @configuration.api_key
         Bugsnag.warn "No API key configured, couldn't notify"
         return
       end
       
-      endpoint = (self.use_ssl ? "https://" : "http://") + (self.endpoint || DEFAULT_ENDPOINT)
+      @meta_data = {}
+      
+      # Run the middleware here, at the end of the middleware stack, execute the actual delivery
+      @configuration.middleware.run(self) do
+        # Now override the required fields
+        [:user_id, :context].each do |symbol|
+          if @overrides[symbol]
+            self.send("#{symbol}=", @overrides[symbol] )
+            @overrides.delete symbol
+          end
+        end
 
-      Bugsnag.log("Notifying #{endpoint} of exception")
+        # Build the endpoint url
+        endpoint = (@configuration.use_ssl ? "https://" : "http://") + @configuration.endpoint
+        Bugsnag.log("Notifying #{endpoint} of #{@exceptions.last.class}")
 
-      payload = {
-        :apiKey => self.api_key,
-        :notifier => notifier_identification,
-        :events => [{
-          :userId => self.user_id,
-          :appVersion => self.app_version,
-          :releaseStage => self.release_stage,
+        # Build the payload's exception event
+        payload_event = {
+          :releaseStage => @configuration.release_stage,
+          :appVersion => @configuration.app_version,
           :context => self.context,
+          :userId => self.user_id,
           :exceptions => exception_list,
-          :metaData => self.meta_data
-        }.reject {|k,v| v.nil? }]
-      }
+          :metaData => Bugsnag::Helpers.cleanup_obj(generate_meta_data(@overrides), @configuration.params_filters)
+        }.reject {|k,v| v.nil? }
+
+        # Build the payload hash
+        payload = {
+          :apiKey => @configuration.api_key,
+          :notifier => {
+            :name => NOTIFIER_NAME,
+            :version => NOTIFIER_VERSION,
+            :url => NOTIFIER_URL
+          },
+          :events => [payload_event]
+        }
 
-      self.class.deliver_exception_payload(endpoint, Bugsnag::Helpers.dump_json(payload))
+        self.class.deliver_exception_payload(endpoint, payload)
+      end
     end
 
     def ignore?
-      self.ignore_classes.include?(error_class(self.exceptions.last))
+      @configuration.ignore_classes.include?(error_class(@exceptions.last))
     end
 
+    def request_data
+      @request_data || Bugsnag.configuration.request_data
+    end
+    
+    def exceptions
+      @exceptions
+    end
 
     private
-    def notifier_identification
-      unless @notifier
-        @notifier = {
-          :name => NOTIFIER_NAME,
-          :version => NOTIFIER_VERSION,
-          :url => NOTIFIER_URL
-        }
+    # Generate the meta data from both the request configuration and the overrides for this notification
+    def generate_meta_data(overrides)
+      # Copy the request meta data so we dont edit it by mistake
+      meta_data = @meta_data.dup
+      
+      overrides.each do |key, value|
+        # If its a hash, its a tab so we can just add it providing its not reserved
+        if value.is_a? Hash
+          key = key.to_sym
+          
+          if meta_data[key]
+            # If its a clash, merge with the existing data
+            meta_data[key].merge! value
+          else
+            # Add it as is if its not special
+            meta_data[key] = value
+          end
+        else
+          meta_data[:custom] ||= {}
+          meta_data[:custom][key] = value
+        end
       end
-
-      @notifier
+      
+      meta_data
     end
-
-    def exception_list
-      self.exceptions.map do |exception|
+    
+    def exception_list      
+      @exceptions.map do |exception|
         {
           :errorClass => error_class(exception),
           :message => exception.message,
@@ -118,16 +191,32 @@ module Bugsnag
     end
 
     def stacktrace(exception)
-      (exception.backtrace || caller).map do |trace|
+      (exception.backtrace || caller).map do |trace|        
         method = nil
         file, line_str, method_str = trace.split(":")
 
+        next(nil) if file =~ %r{lib/bugsnag}
+
+        # Expand relative paths
+        file = Pathname.new(file).realpath.to_s rescue file
+
         # Generate the stacktrace line hash
         trace_hash = {}
-        trace_hash[:inProject] = true if self.project_root && file.match(/^#{self.project_root}/) && !file.match(/vendor\//)
-        trace_hash[:file] = self.stacktrace_filters.inject(file) {|file, proc| proc.call(file) }
+        trace_hash[:inProject] = true if @configuration.project_root && file.match(/^#{@configuration.project_root}/) && !file.match(/vendor\//)
         trace_hash[:lineNumber] = line_str.to_i
 
+        # Clean up the file path in the stacktrace
+        if defined?(Bugsnag.configuration.project_root) && Bugsnag.configuration.project_root.to_s != '' 
+          file.sub!(/#{Bugsnag.configuration.project_root}\//, "")
+        end
+
+        # Strip common gem path prefixes
+        if defined?(Gem)
+          file = Gem.path.inject(file) {|line, path| line.sub(/#{path}\//, "") }
+        end
+
+        trace_hash[:file] = file
+
         # Add a method if we have it
         if method_str
           method_match = /in `([^']+)'/.match(method_str)