bugsnag 6.15.0 → 6.27.1

data/lib/bugsnag/delivery/synchronous.rb

@@ -1,5 +1,4 @@
 require "net/https"
-require "uri"
 
 module Bugsnag
   module Delivery
@@ -18,8 +17,8 @@ module Bugsnag
             # KLUDGE: Since we don't re-raise http exceptions, this breaks rspec
             raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"
 
-            configuration.warn("Notification to #{url} failed, #{e.inspect}")
-            configuration.warn(e.backtrace)
+            configuration.error("Unable to send information to Bugsnag (#{url}), #{e.inspect}")
+            configuration.error(e.backtrace)
           end
         end
 
@@ -58,7 +57,7 @@ module Bugsnag
         def default_headers
           {
             "Content-Type" => "application/json",
-            "Bugsnag-Sent-At" =>  Time.now().utc().strftime('%Y-%m-%dT%H:%M:%S')
+            "Bugsnag-Sent-At" => Time.now.utc.iso8601(3)
           }
         end
       end

data/lib/bugsnag/delivery/thread_queue.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Bugsnag
   module Delivery
     class ThreadQueue < Synchronous
@@ -9,8 +7,14 @@ module Bugsnag
 
       class << self
         ##
-        # Queues a given payload to be delivered asynchronously.
-        def deliver(url, body, configuration, options={})
+        # 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!
@@ -21,7 +25,16 @@ module Bugsnag
           end
 
           # Add delivery to the worker thread
-          @queue.push proc { super(url, body, configuration, options) }
+          @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

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,10 +1,5 @@
-require 'uri'
-require 'set'
-require 'json'
-
-
 module Bugsnag
-  module Helpers
+  module Helpers # rubocop:todo Metrics/ModuleLength
     MAX_STRING_LENGTH = 3072
     MAX_PAYLOAD_LENGTH = 512000
     MAX_ARRAY_LENGTH = 80
@@ -19,8 +14,12 @@ module Bugsnag
 
       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)
+
       # Trim metadata
-      reduced_value = trim_metadata(value)
+      reduced_value = trim_metadata(reduced_value)
       return reduced_value unless payload_too_long?(reduced_value)
 
       # Trim code from stacktrace
@@ -71,6 +70,15 @@ module Bugsnag
 
     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)
@@ -94,11 +102,11 @@ module Bugsnag
 
     ##
     # Wrapper for trimming stacktraces
-    def self.extract_exception(payload)
+    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 { |exception| yield exception }
+        event[:exceptions].each(&block)
       end
     end
 

data/lib/bugsnag/integrations/delayed_job.rb

@@ -10,11 +10,23 @@ end
 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.app_type = 'delayed_job'
+            ::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|

data/lib/bugsnag/integrations/mailman.rb

@@ -11,7 +11,8 @@ module Bugsnag
 
     def initialize
       Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Mailman)
-      Bugsnag.configuration.app_type = "mailman"
+      Bugsnag.configuration.detected_app_type = "mailman"
+      Bugsnag.configuration.runtime_versions["mailman"] = ::Mailman::VERSION
     end
 
     ##

data/lib/bugsnag/integrations/mongo.rb

@@ -1,5 +1,4 @@
 require 'mongo'
-require 'bugsnag/breadcrumbs/breadcrumbs'
 
 module Bugsnag
   ##
@@ -127,6 +126,8 @@ module Bugsnag
   end
 end
 
-##
-# Add the subscriber to the global Mongo monitoring object
-Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, Bugsnag::MongoBreadcrumbSubscriber.new)
+if defined?(Mongo::Monitoring)
+  ##
+  # Add the subscriber to the global Mongo monitoring object
+  Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, Bugsnag::MongoBreadcrumbSubscriber.new)
+end

data/lib/bugsnag/integrations/que.rb

@@ -37,7 +37,8 @@ if defined?(::Que)
     end
   end
 
-  Bugsnag.configuration.app_type ||= "que"
+  Bugsnag.configuration.detected_app_type = "que"
+
   if defined?(::Que::Version)
     Bugsnag.configuration.runtime_versions["que"] = ::Que::Version
   elsif defined?(::Que::VERSION)

data/lib/bugsnag/integrations/rack.rb

@@ -25,12 +25,14 @@ module Bugsnag
         end
 
         # Hook up rack-based notification middlewares
-        config.middleware.insert_before([Bugsnag::Middleware::Rails3Request,Bugsnag::Middleware::Callbacks], Bugsnag::Middleware::RackRequest) if defined?(::Rack)
-        config.middleware.insert_before(Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::WardenUser) if defined?(Warden)
-        config.middleware.insert_before(Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::ClearanceUser) if defined?(Clearance)
+        config.internal_middleware.insert_before(Bugsnag::Middleware::Rails3Request, Bugsnag::Middleware::RackRequest) if defined?(::Rack)
+        config.internal_middleware.use(Bugsnag::Middleware::WardenUser) if defined?(Warden)
+        config.internal_middleware.use(Bugsnag::Middleware::ClearanceUser) if defined?(Clearance)
 
         # Set environment data for payload
-        config.app_type ||= "rack"
+        # Note we only set the detected app_type if it's not already set. This
+        # ensures we don't overwrite the value set by the Railtie
+        config.detected_app_type ||= "rack"
         config.runtime_versions["rack"] = ::Rack.release if defined?(::Rack)
         config.runtime_versions["sinatra"] = ::Sinatra::VERSION if defined?(::Sinatra)
       end

data/lib/bugsnag/integrations/rails/active_job.rb

@@ -0,0 +1,100 @@
+module Bugsnag::Rails
+  module ActiveJob
+    SEVERITY = 'error'
+    SEVERITY_REASON = {
+      type: Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      attributes: { framework: 'Active Job' }
+    }
+
+    EXISTING_INTEGRATIONS = Set[
+      'ActiveJob::QueueAdapters::DelayedJobAdapter',
+      'ActiveJob::QueueAdapters::QueAdapter',
+      'ActiveJob::QueueAdapters::ResqueAdapter',
+      'ActiveJob::QueueAdapters::ShoryukenAdapter',
+      'ActiveJob::QueueAdapters::SidekiqAdapter'
+    ]
+
+    INLINE_ADAPTER = 'ActiveJob::QueueAdapters::InlineAdapter'
+
+    # these methods were added after the first Active Job release so
+    # may not be present, depending on the Rails version
+    MAYBE_MISSING_METHODS = [
+      :provider_job_id,
+      :priority,
+      :executions,
+      :enqueued_at,
+      :timezone
+    ]
+
+    def self.included(base)
+      base.class_eval do
+        around_perform do |job, block|
+          adapter = _bugsnag_get_adapter_name(job)
+
+          # if we have an integration for this queue adapter already then we should
+          # leave this job alone or we'll end up with duplicate metadata
+          next block.call if EXISTING_INTEGRATIONS.include?(adapter)
+
+          Bugsnag.configuration.detected_app_type = 'active job'
+
+          begin
+            Bugsnag.configuration.set_request_data(:active_job, _bugsnag_extract_metadata(job))
+
+            block.call
+          rescue Exception => e
+            Bugsnag.notify(e, true) do |report|
+              report.severity = SEVERITY
+              report.severity_reason = SEVERITY_REASON
+            end
+
+            # when using the "inline" adapter the job is run immediately, which
+            # will result in our Rack integration catching the re-raised error
+            # and reporting it a second time if it's run in a web request
+            if adapter == INLINE_ADAPTER
+              e.instance_eval do
+                def skip_bugsnag
+                  true
+                end
+              end
+            end
+
+            raise
+          ensure
+            Bugsnag.configuration.clear_request_data
+          end
+        end
+      end
+    end
+
+    private
+
+    def _bugsnag_get_adapter_name(job)
+      adapter = job.class.queue_adapter
+
+      # in Rails 4 queue adapters were references to a class. In Rails 5+
+      # they are an instance of that class instead
+      return adapter.name if adapter.is_a?(Class)
+
+      adapter.class.name
+    end
+
+    def _bugsnag_extract_metadata(job)
+      metadata = {
+        job_id: job.job_id,
+        job_name: job.class.name,
+        queue: job.queue_name,
+        arguments: job.arguments,
+        locale: job.locale
+      }
+
+      MAYBE_MISSING_METHODS.each do |method_name|
+        next unless job.respond_to?(method_name)
+
+        metadata[method_name] = job.send(method_name)
+      end
+
+      metadata.compact!
+      metadata
+    end
+  end
+end

data/lib/bugsnag/integrations/rails/rails_breadcrumbs.rb

@@ -1,5 +1,3 @@
-require "bugsnag/breadcrumbs/breadcrumbs"
-
 module Bugsnag::Rails
   DEFAULT_RAILS_BREADCRUMBS = [
     {
@@ -38,6 +36,8 @@ module Bugsnag::Rails
       :type => Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE,
       :allowed_data => [
         :name,
+        # :connection_id is no longer provided in Rails 6.1+ but we can get it
+        # from the :connection key of the event instead
         :connection_id,
         :cached
       ]