bugsnag 5.5.0 → 6.0.0

data/lib/bugsnag/middleware/rake.rb

@@ -4,20 +4,20 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      task = notification.request_data[:bugsnag_running_task]
+    def call(report)
+      task = report.request_data[:bugsnag_running_task]
 
       if task
-        notification.add_tab(:rake_task, {
+        report.add_tab(:rake_task, {
           :name => task.name,
           :description => task.full_comment,
           :arguments => task.arg_description
         })
 
-        notification.context ||= task.name
+        report.context ||= task.name
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/sidekiq.rb

@@ -4,13 +4,13 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      sidekiq = notification.request_data[:sidekiq]
+    def call(report)
+      sidekiq = report.request_data[:sidekiq]
       if sidekiq
-        notification.add_tab(:sidekiq, sidekiq)
-        notification.context ||= "#{sidekiq[:msg]['wrapped'] || sidekiq[:msg]['class']}@#{sidekiq[:msg]['queue']}"
+        report.add_tab(:sidekiq, sidekiq)
+        report.context ||= "#{sidekiq[:msg]['wrapped'] || sidekiq[:msg]['class']}@#{sidekiq[:msg]['queue']}"
       end
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/suggestion_data.rb

@@ -0,0 +1,30 @@
+module Bugsnag::Middleware
+  class SuggestionData
+
+    CAPTURE_REGEX = /Did you mean\?([\s\S]+)$/
+    DELIMITER = "\n"
+
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      matches = []
+      report.raw_exceptions.each do |exception|
+        match = CAPTURE_REGEX.match(exception.message)
+        next unless match
+
+        suggestions = match.captures[0].split(DELIMITER)
+        matches.concat suggestions.map{ |suggestion| suggestion.strip }
+      end
+
+      if matches.size == 1
+        report.add_tab(:error, {:suggestion => matches.first})
+      elsif matches.size > 1
+        report.add_tab(:error, {:suggestions => matches})
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/warden_user.rb

@@ -7,9 +7,9 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:rack_env] && notification.request_data[:rack_env]["warden"]
-        env = notification.request_data[:rack_env]
+    def call(report)
+      if report.request_data[:rack_env] && report.request_data[:rack_env]["warden"]
+        env = report.request_data[:rack_env]
         session = env["rack.session"] || {}
 
         # Find all warden user scopes
@@ -29,11 +29,11 @@ module Bugsnag::Middleware
           end
 
           # We merge the first warden scope down, so that it is the main "user" for the request
-          notification.user = user unless user.empty?
+          report.user = user unless user.empty?
         end
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
-end
+end

data/lib/bugsnag/middleware_stack.rb

@@ -63,7 +63,7 @@ module Bugsnag
     end
 
     # Runs the middleware stack and calls
-    def run(notification)
+    def run(report)
       # The final lambda is the termination of the middleware stack. It calls deliver on the notification
       lambda_has_run = false
       notify_lambda = lambda do |notif|
@@ -73,19 +73,19 @@ module Bugsnag
 
       begin
         # We reverse them, so we can call "call" on the first middleware
-        middleware_procs.reverse.inject(notify_lambda) { |n,e| e.call(n) }.call(notification)
+        middleware_procs.reverse.inject(notify_lambda) { |n,e| e.call(n) }.call(report)
       rescue StandardError => e
         # KLUDGE: Since we don't re-raise middleware exceptions, this breaks rspec
         raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"
 
         # 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}"
+        Bugsnag.configuration.warn "Bugsnag middleware error: #{e}"
+        Bugsnag.configuration.warn "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
+      notify_lambda.call(report) unless lambda_has_run
     end
 
     private

data/lib/bugsnag/report.rb

@@ -0,0 +1,187 @@
+require "json"
+require "pathname"
+require "bugsnag/stacktrace"
+
+module Bugsnag
+  class Report
+    NOTIFIER_NAME = "Ruby Bugsnag Notifier"
+    NOTIFIER_VERSION = Bugsnag::VERSION
+    NOTIFIER_URL = "http://www.bugsnag.com"
+
+    UNHANDLED_EXCEPTION = "unhandledException"
+    UNHANDLED_EXCEPTION_MIDDLEWARE = "unhandledExceptionMiddleware"
+    ERROR_CLASS = "errorClass"
+    HANDLED_EXCEPTION = "handledException"
+    USER_SPECIFIED_SEVERITY = "userSpecifiedSeverity"
+    USER_CALLBACK_SET_SEVERITY = "userCallbackSetSeverity"
+
+    MAX_EXCEPTIONS_TO_UNWRAP = 5
+
+    CURRENT_PAYLOAD_VERSION = "2"
+
+    attr_accessor :api_key
+    attr_accessor :app_type
+    attr_accessor :app_version
+    attr_accessor :configuration
+    attr_accessor :context
+    attr_accessor :delivery_method
+    attr_accessor :exceptions
+    attr_accessor :hostname
+    attr_accessor :grouping_hash
+    attr_accessor :meta_data
+    attr_accessor :raw_exceptions
+    attr_accessor :release_stage
+    attr_accessor :severity
+    attr_accessor :severity_reason
+    attr_accessor :user
+
+    def initialize(exception, passed_configuration, auto_notify=false)
+      @should_ignore = false
+      @unhandled = auto_notify
+
+      self.configuration = passed_configuration
+
+      self.raw_exceptions = generate_raw_exceptions(exception)
+      self.exceptions = generate_exception_list
+
+      self.api_key = configuration.api_key
+      self.app_type = configuration.app_type
+      self.app_version = configuration.app_version
+      self.delivery_method = configuration.delivery_method
+      self.hostname = configuration.hostname
+      self.meta_data = {}
+      self.release_stage = configuration.release_stage
+      self.severity = auto_notify ? "error" : "warning"
+      self.severity_reason = auto_notify ? {:type => UNHANDLED_EXCEPTION} : {:type => HANDLED_EXCEPTION}
+      self.user = {}
+    end
+
+    # Add a new tab to this notification
+    def add_tab(name, value)
+      return if name.nil?
+
+      if value.is_a? Hash
+        meta_data[name] ||= {}
+        meta_data[name].merge! value
+      else
+        meta_data["custom"] = {} unless meta_data["custom"]
+
+        meta_data["custom"][name.to_s] = value
+      end
+    end
+
+    # Remove a tab from this notification
+    def remove_tab(name)
+      return if name.nil?
+
+      meta_data.delete(name)
+    end
+
+    # Build an exception payload
+    def as_json
+      # Build the payload's exception event
+      payload_event = {
+        app: {
+          version: app_version,
+          releaseStage: release_stage,
+          type: app_type
+        },
+        context: context,
+        device: {
+          hostname: hostname
+        },
+        exceptions: exceptions,
+        groupingHash: grouping_hash,
+        payloadVersion: CURRENT_PAYLOAD_VERSION,
+        severity: severity,
+        severityReason: severity_reason,
+        unhandled: @unhandled,
+        user: user
+      }
+
+      # cleanup character encodings
+      payload_event = Bugsnag::Cleaner.clean_object_encoding(payload_event)
+
+      # filter out sensitive values in (and cleanup encodings) metaData
+      payload_event[:metaData] = Bugsnag::Cleaner.new(configuration.meta_data_filters).clean_object(meta_data)
+      payload_event.reject! {|k,v| v.nil? }
+
+      # return the payload hash
+      {
+        :apiKey => api_key,
+        :notifier => {
+          :name => NOTIFIER_NAME,
+          :version => NOTIFIER_VERSION,
+          :url => NOTIFIER_URL
+        },
+        :events => [payload_event]
+      }
+    end
+
+    def ignore?
+      @should_ignore
+    end
+
+    def request_data
+      configuration.request_data
+    end
+
+    def ignore!
+      @should_ignore = true
+    end
+
+    private
+
+    def generate_exception_list
+      raw_exceptions.map do |exception|
+        {
+          errorClass: error_class(exception),
+          message: exception.message,
+          stacktrace: Stacktrace.new(exception.backtrace, configuration).to_a
+        }
+      end
+    end
+
+    def error_class(exception)
+      # The "Class" check is for some strange exceptions like Timeout::Error
+      # which throw the error class instead of an instance
+      (exception.is_a? Class) ? exception.name : exception.class.name
+    end
+
+    def generate_raw_exceptions(exception)
+      exceptions = []
+
+      ex = exception
+      while ex != nil && !exceptions.include?(ex) && exceptions.length < MAX_EXCEPTIONS_TO_UNWRAP
+
+        unless ex.is_a? Exception
+          if ex.respond_to?(:to_exception)
+            ex = ex.to_exception
+          elsif ex.respond_to?(:exception)
+            ex = ex.exception
+          end
+        end
+
+        unless ex.is_a?(Exception) || (defined?(Java::JavaLang::Throwable) && ex.is_a?(Java::JavaLang::Throwable))
+          configuration.warn("Converting non-Exception to RuntimeError: #{ex.inspect}")
+          ex = RuntimeError.new(ex.to_s)
+          ex.set_backtrace caller
+        end
+
+        exceptions << ex
+
+        if ex.respond_to?(:cause) && ex.cause
+          ex = ex.cause
+        elsif ex.respond_to?(:continued_exception) && ex.continued_exception
+          ex = ex.continued_exception
+        elsif ex.respond_to?(:original_exception) && ex.original_exception
+          ex = ex.original_exception
+        else
+          ex = nil
+        end
+      end
+
+      exceptions
+    end
+  end
+end

data/lib/bugsnag/stacktrace.rb

@@ -0,0 +1,113 @@
+module Bugsnag
+  class Stacktrace
+
+    # e.g. "org/jruby/RubyKernel.java:1264:in `catch'"
+    BACKTRACE_LINE_REGEX = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$/
+
+    # e.g. "org.jruby.Ruby.runScript(Ruby.java:807)"
+    JAVA_BACKTRACE_REGEX = /^(.*)\((.*)(?::([0-9]+))?\)$/
+
+    def initialize(backtrace, configuration)
+      @configuration = configuration
+
+      backtrace = caller if !backtrace || backtrace.empty?
+      @processed_backtrace = backtrace.map do |trace|
+        if trace.match(BACKTRACE_LINE_REGEX)
+          file, line_str, method = [$1, $2, $3]
+        elsif trace.match(JAVA_BACKTRACE_REGEX)
+          method, file, line_str = [$1, $2, $3]
+        end
+
+        # Parse the stacktrace line
+
+        # Skip stacktrace lines inside lib/bugsnag
+        next(nil) if file.nil? || file =~ %r{lib/bugsnag(/|\.rb)}
+
+        # Expand relative paths
+        p = Pathname.new(file)
+        if p.relative?
+          file = p.realpath.to_s rescue file
+        end
+
+        # Generate the stacktrace line hash
+        trace_hash = {}
+        trace_hash[:inProject] = true if in_project?(file)
+        trace_hash[:lineNumber] = line_str.to_i
+
+        if configuration.send_code
+          trace_hash[:code] = code(file, trace_hash[:lineNumber])
+        end
+
+        # Clean up the file path in the stacktrace
+        if defined?(@configuration.project_root) && @configuration.project_root.to_s != ''
+          file.sub!(/#{@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
+        trace_hash[:method] = method if method && (method =~ /^__bind/).nil?
+
+        if trace_hash[:file] && !trace_hash[:file].empty?
+          trace_hash
+        else
+          nil
+        end
+      end.compact
+    end
+
+    def to_a
+      @processed_backtrace
+    end
+
+    private
+
+    def in_project?(line)
+      @configuration.project_root && line.start_with?(@configuration.project_root.to_s)
+    end
+
+    def code(file, line_number, num_lines = 7)
+      code_hash = {}
+
+      from_line = [line_number - num_lines, 1].max
+
+      # don't try and open '(irb)' or '-e'
+      return unless File.exist?(file)
+
+      # Populate code hash with line numbers and code lines
+      File.open(file) do |f|
+        current_line_number = 0
+        f.each_line do |line|
+          current_line_number += 1
+
+          next if current_line_number < from_line
+
+          code_hash[current_line_number] = line[0...200].rstrip
+
+          break if code_hash.length >= ( num_lines * 1.5 ).ceil
+        end
+      end
+
+      while code_hash.length > num_lines
+        last_line = code_hash.keys.max
+        first_line = code_hash.keys.min
+
+        if (last_line - line_number) > (line_number - first_line)
+          code_hash.delete(last_line)
+        else
+          code_hash.delete(first_line)
+        end
+      end
+
+      code_hash
+    rescue
+      @configuration.warn("Error fetching code: #{$!.inspect}")
+      nil
+    end
+  end
+end

data/lib/bugsnag/tasks/bugsnag.rake

@@ -1,82 +1,14 @@
 require "bugsnag"
 
 namespace :bugsnag do
-  desc "Notify Bugsnag of a new deploy."
-  task :deploy do
-    api_key = ENV["BUGSNAG_API_KEY"]
-    release_stage = ENV["BUGSNAG_RELEASE_STAGE"]
-    app_version = ENV["BUGSNAG_APP_VERSION"]
-    revision = ENV["BUGSNAG_REVISION"]
-    repository = ENV["BUGSNAG_REPOSITORY"]
-    branch = ENV["BUGSNAG_BRANCH"]
-
-    Rake::Task["load"].invoke unless api_key
-
-    Bugsnag::Deploy.notify({
-      :api_key => api_key,
-      :release_stage => release_stage,
-      :app_version => app_version,
-      :revision => revision,
-      :repository => repository,
-      :branch => branch
-    })
-  end
-
   desc "Send a test exception to Bugsnag."
   task :test_exception => :load do
     begin
       raise RuntimeError.new("Bugsnag test exception")
     rescue => e
-      Bugsnag.notify(e, {:context => "rake#test_exception"})
-    end
-  end
-
-  desc "Show the bugsnag middleware stack"
-  task :middleware => :load do
-    Bugsnag.configuration.middleware.each {|m| puts m.to_s}
-  end
-
-  namespace :heroku do
-    desc "Add a heroku deploy hook to notify Bugsnag of deploys"
-    task :add_deploy_hook => :load do
-      # Wrapper to run command safely even in bundler
-      run_command = lambda { |command|
-        defined?(Bundler.with_clean_env) ? Bundler.with_clean_env { `#{command}` } : `#{command}`
-      }
-
-      # Fetch heroku config settings
-      config_command = "heroku config --shell"
-      config_command += " --app #{ENV["HEROKU_APP"]}" if ENV["HEROKU_APP"]
-      heroku_env = run_command.call(config_command).split(/[\n\r]/).each_with_object({}) do |c, obj|
-        k,v = c.split("=")
-        obj[k] = (v.nil? || v.strip.empty?) ? nil : v
-      end
-
-      # Check for Bugsnag API key (required)
-      api_key = heroku_env["BUGSNAG_API_KEY"] || Bugsnag.configuration.api_key || ENV["BUGSNAG_API_KEY"]
-      unless api_key
-        puts "Error: No API key found, have you run 'heroku config:set BUGSNAG_API_KEY=your-api-key'?"
-        next
+      Bugsnag.notify(e) do |report|
+        report.context = "rake#test_exception"
       end
-
-      # Build the request, making use of deploy hook variables
-      # (https://devcenter.heroku.com/articles/deploy-hooks#customizing-messages)
-      params = {
-        :apiKey => api_key,
-        :branch => "master",
-        :revision => "{{head_long}}",
-        :releaseStage => heroku_env["RAILS_ENV"] || ENV["RAILS_ENV"] || "production"
-      }
-      repo = `git config --get remote.origin.url`.strip
-      params[:repository] = repo unless repo.empty?
-
-      # Add the hook
-      url = "https://notify.bugsnag.com/deploy?" + params.map {|k,v| "#{k}=#{v}"}.join("&")
-      command = "heroku addons:add deployhooks:http --url=\"#{url}\""
-      command += " --app #{ENV["HEROKU_APP"]}" if ENV["HEROKU_APP"]
-
-      puts "$ #{command}"
-      run_command.call(command)
     end
   end
 end