bugsnag 4.2.1 → 6.27.1

data/lib/bugsnag/delivery/synchronous.rb

@@ -1,51 +1,68 @@
 require "net/https"
-require "uri"
 
 module Bugsnag
   module Delivery
     class Synchronous
-      HEADERS = {"Content-Type" => "application/json"}
-
       class << self
-        def deliver(url, body, configuration)
+        ##
+        # Attempts to deliver a payload to the given endpoint synchronously.
+        def deliver(url, body, configuration, options={})
           begin
-            response = request(url, body, configuration)
-            Bugsnag.debug("Notification to #{url} finished, response was #{response.code}, payload was #{body}")
+            response = request(url, body, configuration, options)
+            configuration.debug("Request to #{url} completed, status: #{response.code}")
+            if response.code[0] != "2"
+              configuration.warn("Notifications to #{url} was reported unsuccessful with code #{response.code}")
+            end
           rescue StandardError => e
             # KLUDGE: Since we don't re-raise http exceptions, this breaks rspec
             raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"
 
-            Bugsnag.warn("Notification to #{url} failed, #{e.inspect}")
-            Bugsnag.warn(e.backtrace)
+            configuration.error("Unable to send information to Bugsnag (#{url}), #{e.inspect}")
+            configuration.error(e.backtrace)
           end
         end
 
         private
 
-        def request(url, body, configuration)
+        def request(url, body, configuration, options)
           uri = URI.parse(url)
-          http = Net::HTTP.new(uri.host, uri.port, configuration.proxy_host, configuration.proxy_port, configuration.proxy_user, configuration.proxy_password)
+
+          if configuration.proxy_host
+            http = Net::HTTP.new(uri.host, uri.port, configuration.proxy_host, configuration.proxy_port, configuration.proxy_user, configuration.proxy_password)
+          else
+            http = Net::HTTP.new(uri.host, uri.port)
+          end
+
           http.read_timeout = configuration.timeout
           http.open_timeout = configuration.timeout
 
           if uri.scheme == "https"
             http.use_ssl = true
-            # the default in 1.9+, but required for 1.8
-            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
             http.ca_file = configuration.ca_file if configuration.ca_file
           end
 
-          request = Net::HTTP::Post.new(path(uri), HEADERS)
+          headers = options.key?(:headers) ? options[:headers] : {}
+          headers.merge!(default_headers)
+
+          request = Net::HTTP::Post.new(path(uri), headers)
           request.body = body
+
           http.request(request)
         end
 
         def path(uri)
           uri.path == "" ? "/" : uri.path
         end
+
+        def default_headers
+          {
+            "Content-Type" => "application/json",
+            "Bugsnag-Sent-At" => Time.now.utc.iso8601(3)
+          }
+        end
       end
     end
   end
 end
 
-Bugsnag::Delivery.register(:synchronous, Bugsnag::Delivery::Synchronous)
+Bugsnag::Delivery.register(:synchronous, Bugsnag::Delivery::Synchronous)

data/lib/bugsnag/delivery/thread_queue.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Bugsnag
   module Delivery
     class ThreadQueue < Synchronous
@@ -8,16 +6,35 @@ module Bugsnag
       MUTEX = Mutex.new
 
       class << self
-        def deliver(url, body, configuration)
+        ##
+        # Queues a given payload to be delivered asynchronously
+        #
+        # @param url [String]
+        # @param get_payload [Proc] A Proc that will return the payload.
+        # @param configuration [Bugsnag::Configuration]
+        # @param options [Hash]
+        # @return [void]
+        def serialize_and_deliver(url, get_payload, configuration, options={})
+          @configuration = configuration
+
           start_once!
 
           if @queue.length > MAX_OUTSTANDING_REQUESTS
-            Bugsnag.warn("Dropping notification, #{@queue.length} outstanding requests")
+            @configuration.warn("Dropping notification, #{@queue.length} outstanding requests")
             return
           end
 
           # Add delivery to the worker thread
-          @queue.push proc { super(url, body, configuration) }
+          @queue.push(proc do
+            begin
+              payload = get_payload.call
+            rescue StandardError => e
+              configuration.error("Unable to send information to Bugsnag (#{url}), #{e.inspect}")
+              configuration.error(e.backtrace)
+            end
+
+            Synchronous.deliver(url, payload, configuration, options) unless payload.nil?
+          end)
         end
 
         private
@@ -38,7 +55,7 @@ module Bugsnag
             end
 
             at_exit do
-              Bugsnag.warn("Waiting for #{@queue.length} outstanding request(s)") unless @queue.empty?
+              @configuration.warn("Waiting for #{@queue.length} outstanding request(s)") unless @queue.empty?
               @queue.push STOP
               worker_thread.join
             end

data/lib/bugsnag/delivery.rb

@@ -1,10 +1,23 @@
 module Bugsnag
   module Delivery
     class << self
+      ##
+      # Add a delivery method to the list of supported methods. Any registered
+      # method can then be used by name in Configuration.
+      #
+      # ```
+      # require 'bugsnag'
+      # Bugsnag::Delivery.register(:my_delivery_queue, MyDeliveryQueue)
+      # Bugsnag.configure do |config|
+      #   config.delivery_method = :my_delivery_queue
+      # end
+      # ```
       def register(name, delivery_method)
         delivery_methods[name.to_sym] = delivery_method
       end
 
+      ##
+      # Reference a delivery method by name
       def [](name)
         delivery_methods[name.to_sym]
       end

data/lib/bugsnag/endpoint_configuration.rb

@@ -0,0 +1,11 @@
+module Bugsnag
+  class EndpointConfiguration
+    attr_reader :notify
+    attr_reader :sessions
+
+    def initialize(notify, sessions)
+      @notify = notify
+      @sessions = sessions
+    end
+  end
+end

data/lib/bugsnag/endpoint_validator.rb

@@ -0,0 +1,80 @@
+module Bugsnag
+  # @api private
+  class EndpointValidator
+    def self.validate(endpoints)
+      # ensure we have an EndpointConfiguration object
+      return Result.missing_urls unless endpoints.is_a?(EndpointConfiguration)
+
+      # check for missing URLs
+      return Result.missing_urls if endpoints.notify.nil? && endpoints.sessions.nil?
+      return Result.missing_notify if endpoints.notify.nil?
+      return Result.missing_session if endpoints.sessions.nil?
+
+      # check for empty URLs
+      return Result.invalid_urls if endpoints.notify.empty? && endpoints.sessions.empty?
+      return Result.invalid_notify if endpoints.notify.empty?
+      return Result.invalid_session if endpoints.sessions.empty?
+
+      Result.valid
+    end
+
+    # @api private
+    class Result
+      # rubocop:disable Layout/LineLength
+      MISSING_URLS = "Invalid configuration. endpoints must be set with both a notify and session URL. Bugsnag will not send any requests.".freeze
+      MISSING_NOTIFY_URL = "Invalid configuration. endpoints.sessions cannot be set without also setting endpoints.notify. Bugsnag will not send any requests.".freeze
+      MISSING_SESSION_URL = "Invalid configuration. endpoints.notify cannot be set without also setting endpoints.sessions. Bugsnag will not send any sessions.".freeze
+
+      INVALID_URLS = "Invalid configuration. endpoints should be valid URLs, got empty strings. Bugsnag will not send any requests.".freeze
+      INVALID_NOTIFY_URL = "Invalid configuration. endpoints.notify should be a valid URL, got empty string. Bugsnag will not send any requests.".freeze
+      INVALID_SESSION_URL = "Invalid configuration. endpoints.sessions should be a valid URL, got empty string. Bugsnag will not send any sessions.".freeze
+      # rubocop:enable Layout/LineLength
+
+      attr_reader :reason
+
+      def initialize(valid, keep_events_enabled_for_backwards_compatibility = true, reason = nil)
+        @valid = valid
+        @keep_events_enabled_for_backwards_compatibility = keep_events_enabled_for_backwards_compatibility
+        @reason = reason
+      end
+
+      def valid?
+        @valid
+      end
+
+      def keep_events_enabled_for_backwards_compatibility?
+        @keep_events_enabled_for_backwards_compatibility
+      end
+
+      # factory functions
+
+      def self.valid
+        new(true)
+      end
+
+      def self.missing_urls
+        new(false, false, MISSING_URLS)
+      end
+
+      def self.missing_notify
+        new(false, false, MISSING_NOTIFY_URL)
+      end
+
+      def self.missing_session
+        new(false, true, MISSING_SESSION_URL)
+      end
+
+      def self.invalid_urls
+        new(false, false, INVALID_URLS)
+      end
+
+      def self.invalid_notify
+        new(false, false, INVALID_NOTIFY_URL)
+      end
+
+      def self.invalid_session
+        new(false, true, INVALID_SESSION_URL)
+      end
+    end
+  end
+end

data/lib/bugsnag/error.rb

@@ -0,0 +1,25 @@
+module Bugsnag
+  class Error
+    # @return [String] the error's class name
+    attr_accessor :error_class
+
+    # @return [String] the error's message
+    attr_accessor :error_message
+
+    # @return [Hash] the error's processed stacktrace
+    attr_reader :stacktrace
+
+    # @return [String] the type of error (always "ruby")
+    attr_accessor :type
+
+    # @api private
+    TYPE = "ruby".freeze
+
+    def initialize(error_class, error_message, stacktrace)
+      @error_class = error_class
+      @error_message = error_message
+      @stacktrace = stacktrace
+      @type = TYPE
+    end
+  end
+end

data/lib/bugsnag/event.rb

@@ -0,0 +1,5 @@
+module Bugsnag
+  # For now Event is just an alias of Report. This points to the same object so
+  # any changes to Report will also affect Event
+  Event = Report
+end

data/lib/bugsnag/feature_flag.rb

@@ -0,0 +1,74 @@
+module Bugsnag
+  class FeatureFlag
+    # Get the name of this feature flag
+    #
+    # @return [String]
+    attr_reader :name
+
+    # Get the variant of this feature flag
+    #
+    # @return [String, nil]
+    attr_reader :variant
+
+    # @param name [String] The name of this feature flags
+    # @param variant [String, nil] An optional variant for this flag
+    def initialize(name, variant = nil)
+      @name = name
+      @variant = coerce_variant(variant)
+    end
+
+    def ==(other)
+      self.class == other.class && @name == other.name && @variant == other.variant
+    end
+
+    def hash
+      [@name, @variant].hash
+    end
+
+    # Convert this flag to a hash
+    #
+    # @example With no variant
+    #   { "featureFlag" => "name" }
+    #
+    # @example With a variant
+    #   { "featureFlag" => "name", "variant" => "variant" }
+    #
+    # @return [Hash{String => String}]
+    def to_h
+      if @variant.nil?
+        { "featureFlag" => @name }
+      else
+        { "featureFlag" => @name, "variant" => @variant }
+      end
+    end
+
+    # Check if this flag is valid, i.e. has a name that's a String and a variant
+    # that's either nil or a String
+    #
+    # @return [Boolean]
+    def valid?
+      @name.is_a?(String) &&
+        !@name.empty? &&
+        (@variant.nil? || @variant.is_a?(String))
+    end
+
+    private
+
+    # Coerce this variant into a valid value (String or nil)
+    #
+    # If the variant is not already a string or nil, we use #to_s to coerce it.
+    # If #to_s raises, the variant will be set to nil
+    #
+    # @param variant [Object]
+    # @return [String, nil]
+    def coerce_variant(variant)
+      if variant.nil? || variant.is_a?(String)
+        variant
+      else
+        variant.to_s
+      end
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/bugsnag/helpers.rb

@@ -1,48 +1,134 @@
-require 'uri'
-require 'set' unless defined?(Set)
-require 'json' unless defined?(JSON)
-
-
 module Bugsnag
-  module Helpers
+  module Helpers # rubocop:todo Metrics/ModuleLength
     MAX_STRING_LENGTH = 3072
-    MAX_PAYLOAD_LENGTH = 128000
-    MAX_ARRAY_LENGTH = 40
+    MAX_PAYLOAD_LENGTH = 512000
+    MAX_ARRAY_LENGTH = 80
+    MAX_TRIM_STACK_FRAMES = 30
     RAW_DATA_TYPES = [Numeric, TrueClass, FalseClass]
 
+    ##
     # Trim the size of value if the serialized JSON value is longer than is
     # accepted by Bugsnag
     def self.trim_if_needed(value)
-      sanitized_value = Bugsnag::Cleaner.clean_object_encoding(value)
-      return sanitized_value unless payload_too_long?(sanitized_value)
-      reduced_value = trim_strings_in_value(sanitized_value)
+      value = "" if value.nil?
+
+      return value unless payload_too_long?(value)
+
+      # Truncate exception messages
+      reduced_value = truncate_exception_messages(value)
       return reduced_value unless payload_too_long?(reduced_value)
-      reduced_value = truncate_arrays_in_value(reduced_value)
+
+      # Trim metadata
+      reduced_value = trim_metadata(reduced_value)
       return reduced_value unless payload_too_long?(reduced_value)
-      remove_metadata_from_events(reduced_value)
+
+      # Trim code from stacktrace
+      reduced_value = trim_stacktrace_code(reduced_value)
+      return reduced_value unless payload_too_long?(reduced_value)
+
+      # Remove metadata
+      reduced_value = remove_metadata_from_events(reduced_value)
+      return reduced_value unless payload_too_long?(reduced_value)
+
+      # Remove oldest functions in stacktrace
+      trim_stacktrace_functions(reduced_value)
+    end
+
+    ##
+    # Merges r_hash into l_hash recursively, favouring the values in r_hash.
+    #
+    # Returns a new array consisting of the merged values
+    def self.deep_merge(l_hash, r_hash)
+      l_hash.merge(r_hash) do |key, l_val, r_val|
+        if l_val.is_a?(Hash) && r_val.is_a?(Hash)
+          deep_merge(l_val, r_val)
+        elsif l_val.is_a?(Array) && r_val.is_a?(Array)
+          l_val.concat(r_val)
+        else
+          r_val
+        end
+      end
     end
 
-    def self.flatten_meta_data(overrides)
-      return nil unless overrides
+    ##
+    # Merges r_hash into l_hash recursively, favouring the values in r_hash.
+    #
+    # Overwrites the values in the existing l_hash
+    def self.deep_merge!(l_hash, r_hash)
+      l_hash.merge!(r_hash) do |key, l_val, r_val|
+        if l_val.is_a?(Hash) && r_val.is_a?(Hash)
+          deep_merge(l_val, r_val)
+        elsif l_val.is_a?(Array) && r_val.is_a?(Array)
+          l_val.concat(r_val)
+        else
+          r_val
+        end
+      end
+    end
 
-      meta_data = overrides.delete(:meta_data)
-      if meta_data.is_a?(Hash)
-        overrides.merge(meta_data)
-      else
-        overrides
+    private
+
+    TRUNCATION_INFO = '[TRUNCATED]'
+
+    ##
+    # Truncate exception messages
+    def self.truncate_exception_messages(payload)
+      extract_exception(payload) do |exception|
+        exception[:message] = trim_as_string(exception[:message])
       end
+      payload
     end
 
+    ##
+    # Remove all code from stacktraces
+    def self.trim_stacktrace_code(payload)
+      extract_exception(payload) do |exception|
+        exception[:stacktrace].each do |frame|
+          frame.delete(:code)
+        end
+      end
+      payload
+    end
+
+    ##
+    # Truncate stacktraces
+    def self.trim_stacktrace_functions(payload)
+      extract_exception(payload) do |exception|
+        stack = exception[:stacktrace]
+        exception[:stacktrace] = stack.take(MAX_TRIM_STACK_FRAMES)
+      end
+      payload
+    end
+
+    ##
+    # Wrapper for trimming stacktraces
+    def self.extract_exception(payload, &block)
+      valid_payload = payload.is_a?(Hash) && payload[:events].respond_to?(:map)
+      return unless valid_payload && block_given?
+      payload[:events].each do |event|
+        event[:exceptions].each(&block)
+      end
+    end
+
+    ##
+    # Take the metadata from the events and trim it down
+    def self.trim_metadata(payload)
+      return payload unless payload.is_a?(Hash) and payload[:events].respond_to?(:map)
+      payload[:events].map do |event|
+        event[:metaData] = truncate_arrays_in_value(event[:metaData])
+        event[:metaData] = trim_strings_in_value(event[:metaData])
+      end
+      payload
+    end
+
+    ##
     # Check if a value is a raw type which should not be trimmed, truncated
     # or converted to a string
     def self.is_json_raw_type?(value)
       RAW_DATA_TYPES.detect {|klass| value.is_a?(klass)} != nil
     end
 
-    private
-
-    TRUNCATION_INFO = '[TRUNCATED]'
-
+    ##
     # Shorten array until it fits within the payload size limit when serialized
     def self.truncate_array(array)
       return [] unless array.respond_to?(:slice)
@@ -51,6 +137,7 @@ module Bugsnag
       end
     end
 
+    ##
     # Trim all strings to be less than the maximum allowed string length
     def self.trim_strings_in_value(value)
       return value if is_json_raw_type?(value)
@@ -64,10 +151,19 @@ module Bugsnag
       end
     end
 
+    ##
     # Validate that the serialized JSON string value is below maximum payload
     # length
     def self.payload_too_long?(value)
-      ::JSON.dump(value).length >= MAX_PAYLOAD_LENGTH
+      get_payload_length(value) >= MAX_PAYLOAD_LENGTH
+    end
+
+    def self.get_payload_length(value)
+      if value.is_a?(String)
+        value.length
+      else
+        ::JSON.dump(value).length
+      end
     end
 
     def self.trim_strings_in_hash(hash)

data/lib/bugsnag/integrations/delayed_job.rb

@@ -0,0 +1,51 @@
+require 'delayed_job'
+
+# See Issue #99
+unless defined?(Delayed::Plugin)
+  raise LoadError, "bugsnag requires delayed_job > 3.x"
+end
+
+::Bugsnag.configuration.internal_middleware.use(::Bugsnag::Middleware::DelayedJob)
+
+module Delayed
+  module Plugins
+    class Bugsnag < ::Delayed::Plugin
+      ##
+      # DelayedJob doesn't have an easy way to fetch its version, but we can use
+      # Gem.loaded_specs to get the version instead
+      def self.delayed_job_version
+        ::Gem.loaded_specs['delayed_job'].version.to_s
+      rescue StandardError
+        # Explicitly return nil to prevent Rubocop complaining of a suppressed exception
+        nil
+      end
+
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          begin
+            ::Bugsnag.configuration.detected_app_type = 'delayed_job'
+            ::Bugsnag.configuration.runtime_versions['delayed_job'] = delayed_job_version if defined?(::Gem)
+            ::Bugsnag.configuration.set_request_data(:delayed_job, job)
+
+            block.call(job, *args)
+          rescue Exception => exception
+            ::Bugsnag.notify(exception, true) do |report|
+              report.severity = "error"
+              report.severity_reason = {
+                :type => ::Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+                :attributes => {
+                  :framework => "DelayedJob"
+                }
+              }
+            end
+            raise exception
+          ensure
+            ::Bugsnag.configuration.clear_request_data
+          end
+        end
+      end
+    end
+  end
+end
+
+Delayed::Worker.plugins << Delayed::Plugins::Bugsnag

data/lib/bugsnag/integrations/mailman.rb

@@ -0,0 +1,43 @@
+require 'mailman'
+
+module Bugsnag
+  ##
+  # Extracts and appends mailman message information to error reports
+  class Mailman
+
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Mailman"
+    }
+
+    def initialize
+      Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Mailman)
+      Bugsnag.configuration.detected_app_type = "mailman"
+      Bugsnag.configuration.runtime_versions["mailman"] = ::Mailman::VERSION
+    end
+
+    ##
+    # Calls the mailman middleware.
+    def call(mail)
+      begin
+        Bugsnag.configuration.set_request_data :mailman_msg, mail.to_s
+        yield
+      rescue Exception => ex
+        Bugsnag.notify(ex, true) do |report|
+          report.severity = "error"
+          report.severity_reason = {
+            :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+            :attributes => FRAMEWORK_ATTRIBUTES
+          }
+        end
+        raise
+      ensure
+        Bugsnag.configuration.clear_request_data
+      end
+    end
+  end
+end
+
+
+if Mailman.config.respond_to?(:middleware)
+  Mailman.config.middleware.add ::Bugsnag::Mailman
+end