bugsnag 6.2.0 → 6.3.0.beta.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 115e70bf10e40eb20d373f99d89703779a3ab9d4
-  data.tar.gz: f147bcba11749fb91ec9ff6c2ece8ef458c022ad
+  metadata.gz: b0643f03a70da437fa3983ee21f1f9ec4466085e
+  data.tar.gz: bdcdb50f10d93babed837ad0f6ec3ad174c765b6
 SHA512:
-  metadata.gz: 3c733148ef6e837b4494627fdcbfdc3ebeac294d5cf77e0c52587ca865cbefaae6c7bfe503e90002cf36dc217b8597aac7848007fbdc74b1a2a4f9afd6f82b29
-  data.tar.gz: 287eb4af362032892fea941b3dc360a59ac37fa20f86edc11a25e17ba1afaac5210d6cd3faf39585209c44fc208fe5f5b566819abd4f661554e71bb761935ede
+  metadata.gz: 4d4341b5a7e9566d16c4f9fee869d570824ee89a8092260f54c19791984241f163237beb564622850cb163479f5dff81d34860917f91f16eb639461bcca755f7
+  data.tar.gz: 541e02bf501da119d9ddb4acde6ca3df1c2805c4513c7ab201a837d5d18e54a9eefbf95205fa5dd433b0f811d56c801fec3b53d871a696e9c7b8738db1b12c35

data/VERSION

@@ -1 +1 @@
-6.2.0
+6.3.0.beta.0

data/lib/bugsnag.rb

@@ -7,6 +7,7 @@ require "bugsnag/meta_data"
 require "bugsnag/report"
 require "bugsnag/cleaner"
 require "bugsnag/helpers"
+require "bugsnag/session_tracker"
 
 require "bugsnag/delivery"
 require "bugsnag/delivery/synchronous"
@@ -38,6 +39,8 @@ module Bugsnag
         configuration.warn("No valid API key has been set, notifications will not be sent")
         @key_warning = true
       end
+
+      session_tracker.config = configuration
     end
 
     # Explicitly notify of an exception
@@ -108,8 +111,8 @@ module Bugsnag
 
         # Deliver
         configuration.info("Notifying #{configuration.endpoint} of #{report.exceptions.last[:errorClass]}")
-        payload_string = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(report.as_json))
-        Bugsnag::Delivery[configuration.delivery_method].deliver(configuration.endpoint, payload_string, configuration)
+        options = {:headers => report.headers, :trim_payload => true}
+        Bugsnag::Delivery[configuration.delivery_method].deliver(configuration.endpoint, report.as_json, configuration, options)
       end
     end
 
@@ -119,6 +122,11 @@ module Bugsnag
       @configuration || LOCK.synchronize { @configuration ||= Bugsnag::Configuration.new }
     end
 
+    def session_tracker
+      @session_tracker = nil unless defined?(@session_tracker)
+      @session_tracker || LOCK.synchronize { @session_tracker ||= Bugsnag::SessionTracker.new(configuration)}
+    end
+
     # Allow access to "before notify" callbacks
     def before_notify_callbacks
       Bugsnag.configuration.request_data[:before_callbacks] ||= []

data/lib/bugsnag/configuration.rb

@@ -7,6 +7,7 @@ require "bugsnag/middleware/exception_meta_data"
 require "bugsnag/middleware/ignore_error_class"
 require "bugsnag/middleware/suggestion_data"
 require "bugsnag/middleware/classify_error"
+require "bugsnag/middleware/session_data"
 
 module Bugsnag
   class Configuration
@@ -22,7 +23,7 @@ module Bugsnag
     attr_accessor :app_type
     attr_accessor :meta_data_filters
     attr_accessor :endpoint
-    attr_accessor :logger
+    attr_accessor :logger 
     attr_accessor :middleware
     attr_accessor :internal_middleware
     attr_accessor :proxy_host
@@ -32,10 +33,13 @@ module Bugsnag
     attr_accessor :timeout
     attr_accessor :hostname
     attr_accessor :ignore_classes
+    attr_accessor :track_sessions
+    attr_accessor :session_endpoint
 
     API_KEY_REGEX = /[0-9a-f]{32}/i
     THREAD_LOCAL_NAME = "bugsnag_req_data"
     DEFAULT_ENDPOINT = "https://notify.bugsnag.com"
+    DEFAULT_SESSION_ENDPOINT = "https://sessions.bugsnag.com"
 
     DEFAULT_META_DATA_FILTERS = [
       /authorization/i,
@@ -57,6 +61,8 @@ module Bugsnag
       self.hostname = default_hostname
       self.timeout = 15
       self.notify_release_stages = nil
+      self.track_sessions = false
+      self.session_endpoint = DEFAULT_SESSION_ENDPOINT
 
       # SystemExit and Interrupt are common Exception types seen with successful
       # exits and are not automatically reported to Bugsnag
@@ -81,6 +87,7 @@ module Bugsnag
       self.internal_middleware.use Bugsnag::Middleware::IgnoreErrorClass
       self.internal_middleware.use Bugsnag::Middleware::SuggestionData
       self.internal_middleware.use Bugsnag::Middleware::ClassifyError
+      self.internal_middleware.use Bugsnag::Middleware::SessionData
 
       self.middleware = Bugsnag::MiddlewareStack.new
       self.middleware.use Bugsnag::Middleware::Callbacks

data/lib/bugsnag/delivery/synchronous.rb

@@ -4,13 +4,19 @@ require "uri"
 module Bugsnag
   module Delivery
     class Synchronous
-      HEADERS = {"Content-Type" => "application/json"}
+      BACKOFF_THREADS = {}
+      BACKOFF_REQUESTS = {}
+      BACKOFF_LOCK = Mutex.new
 
       class << self
-        def deliver(url, body, configuration)
+        def deliver(url, body, configuration, options={})
           begin
-            response = request(url, body, configuration)
+            response = request(url, body, configuration, options)
             configuration.debug("Request to #{url} completed, status: #{response.code}")
+            success = options[:success] || '200'
+            if options[:backoff] && !(response.code == success)
+              backoff(url, body, configuration, options)
+            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"
@@ -22,9 +28,14 @@ module Bugsnag
 
         private
 
-        def request(url, body, configuration)
+        def request(url, body, configuration, options)
           uri = URI.parse(url)
 
+          if options[:trim_payload]
+            body = Bugsnag::Helpers.trim_if_needed(body)
+          end
+          payload = ::JSON.dump(body)
+
           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
@@ -39,14 +50,104 @@ module Bugsnag
             http.ca_file = configuration.ca_file if configuration.ca_file
           end
 
-          request = Net::HTTP::Post.new(path(uri), HEADERS)
-          request.body = body
+          headers = options.key?(:headers) ? options[:headers] : {}
+          headers.merge!(default_headers)
+
+          request = Net::HTTP::Post.new(path(uri), headers)
+          request.body = payload
+
           http.request(request)
         end
 
+        def backoff(url, body, configuration, options)
+          # Ensure we have the latest configuration for making these requests
+          @latest_configuration = configuration
+          
+          BACKOFF_LOCK.lock
+          begin
+            # Define an exit function once to handle outstanding requests
+            @registered_at_exit = false unless defined?(@registered_at_exit)
+            if !@registered_at_exit
+              @registered_at_exit = true
+              at_exit do
+                backoff_exit
+              end
+            end
+            if BACKOFF_REQUESTS[url] && !BACKOFF_REQUESTS[url].empty?
+              last_request = BACKOFF_REQUESTS[url].last
+              new_body_length = ::JSON.dump(body).length
+              old_body_length = ::JSON.dump(last_request[:body]).length
+              if new_body_length + old_body_length >= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+                BACKOFF_REQUESTS[url].push({:body => body, :options => options})
+              else
+                Bugsnag::Helpers::deep_merge!(last_request, {:body => body, :options => options})
+              end
+            else
+              BACKOFF_REQUESTS[url] = [{:body => body, :options => options}]
+            end
+            if !(BACKOFF_THREADS[url] && BACKOFF_THREADS[url].status)
+              spawn_backoff_thread(url)
+            end
+          ensure
+            BACKOFF_LOCK.unlock
+          end
+        end
+
+        def backoff_exit
+          # Kill existing threads
+          BACKOFF_THREADS.each do |url, thread|
+            thread.exit
+          end
+          # Retry outstanding requests once, then exit
+          BACKOFF_REQUESTS.each do |url, requests|
+            requests.map! do |req|
+              response = request(url, req[:body], @latest_configuration, req[:options])
+              success = req[:options][:success] || '200'
+              response.code == success
+            end
+            requests.reject! { |i| i }
+            @latest_configuration.warn("Requests to #{url} finished, #{requests.size} failed")
+          end
+        end
+        
+        def spawn_backoff_thread(url)
+          new_thread = Thread.new(url) do |url|
+            interval = 2
+            while BACKOFF_REQUESTS[url].size > 0
+              sleep(interval)
+              interval = interval * 2
+              interval = 600 if interval > 600
+              BACKOFF_LOCK.lock
+              begin
+                BACKOFF_REQUESTS[url].map! do |req|
+                  response = request(url, req[:body], @latest_configuration, req[:options])
+                  success = req[:options][:success] || '200'
+                  if response.code == success
+                    @latest_configuration.debug("Request to #{url} completed, status: #{response.code}")
+                    false
+                  else
+                    req
+                  end
+                end
+                BACKOFF_REQUESTS[url].reject! { |i| !i }
+              ensure
+                BACKOFF_LOCK.unlock
+              end
+            end
+          end
+          BACKOFF_THREADS[url] = new_thread
+        end
+
         def path(uri)
           uri.path == "" ? "/" : uri.path
         end
+
+        def default_headers
+          {
+            "Content-Type" => "application/json",
+            "Bugsnag-Sent-At" =>  Time.now().utc().strftime('%Y-%m-%dT%H:%M:%S')
+          }
+        end
       end
     end
   end

data/lib/bugsnag/delivery/thread_queue.rb

@@ -8,7 +8,7 @@ module Bugsnag
       MUTEX = Mutex.new
 
       class << self
-        def deliver(url, body, configuration)
+        def deliver(url, body, configuration, options={})
           @configuration = configuration
 
           start_once!
@@ -19,7 +19,7 @@ module Bugsnag
           end
 
           # Add delivery to the worker thread
-          @queue.push proc { super(url, body, configuration) }
+          @queue.push proc { super(url, body, configuration, options) }
         end
 
         private

data/lib/bugsnag/helpers.rb

@@ -23,6 +23,30 @@ module Bugsnag
       remove_metadata_from_events(reduced_value)
     end
 
+    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.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
+
     private
 
     TRUNCATION_INFO = '[TRUNCATED]'

data/lib/bugsnag/integrations/rack.rb

@@ -34,6 +34,7 @@ module Bugsnag
     def call(env)
       # Set the request data for bugsnag middleware to use
       Bugsnag.configuration.set_request_data(:rack_env, env)
+      Bugsnag.session_tracker.create_session
 
       begin
         response = @app.call(env)

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

@@ -5,6 +5,7 @@ module Bugsnag::Rails
     end
 
     module ClassMethods
+
       private
       def before_bugsnag_notify(*methods, &block)
         _add_bugsnag_notify_callback(:before_callbacks, *methods, &block)

data/lib/bugsnag/middleware/session_data.rb

@@ -0,0 +1,21 @@
+module Bugsnag::Middleware
+  class SessionData
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      session = Bugsnag::SessionTracker.get_current_session
+      unless session.nil?
+        if report.unhandled
+          session[:events][:unhandled] += 1
+        else
+          session[:events][:handled] += 1
+        end
+        report.session = session
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/report.rb

@@ -17,8 +17,9 @@ module Bugsnag
 
     MAX_EXCEPTIONS_TO_UNWRAP = 5
 
-    CURRENT_PAYLOAD_VERSION = "2"
+    CURRENT_PAYLOAD_VERSION = "4.0"
 
+    attr_reader   :unhandled
     attr_accessor :api_key
     attr_accessor :app_type
     attr_accessor :app_version
@@ -31,6 +32,7 @@ module Bugsnag
     attr_accessor :meta_data
     attr_accessor :raw_exceptions
     attr_accessor :release_stage
+    attr_accessor :session
     attr_accessor :severity
     attr_accessor :severity_reason
     attr_accessor :user
@@ -92,7 +94,7 @@ module Bugsnag
         },
         exceptions: exceptions,
         groupingHash: grouping_hash,
-        payloadVersion: CURRENT_PAYLOAD_VERSION,
+        session: session,
         severity: severity,
         severityReason: severity_reason,
         unhandled: @unhandled,
@@ -108,7 +110,6 @@ module Bugsnag
 
       # return the payload hash
       {
-        :apiKey => api_key,
         :notifier => {
           :name => NOTIFIER_NAME,
           :version => NOTIFIER_VERSION,
@@ -118,6 +119,14 @@ module Bugsnag
       }
     end
 
+    def headers
+      {
+        "Bugsnag-Api-Key" => api_key,
+        "Bugsnag-Payload-Version" => CURRENT_PAYLOAD_VERSION,
+        "Bugsnag-Sent-At" => Time.now().utc().strftime('%Y-%m-%dT%H:%M:%S')
+      }
+    end
+
     def ignore?
       @should_ignore
     end

data/lib/bugsnag/session_tracker.rb

@@ -0,0 +1,157 @@
+require 'thread'
+require 'time'
+require 'securerandom'
+
+module Bugsnag
+  class SessionTracker
+
+    THREAD_SESSION = "bugsnag_session"
+    TIME_THRESHOLD = 60
+    FALLBACK_TIME = 300
+    MAXIMUM_SESSION_COUNT = 50
+    SESSION_PAYLOAD_VERSION = "1.0"
+
+    attr_reader :session_counts
+    attr_writer :config
+
+    def self.set_current_session(session)
+      Thread.current[THREAD_SESSION] = session
+    end
+
+    def self.get_current_session
+      Thread.current[THREAD_SESSION]
+    end
+
+    def initialize(configuration)
+      @session_counts = {}
+      @config = configuration
+      @mutex = Mutex.new
+      @last_sent = Time.now
+    end
+
+    def create_session
+      return unless @config.track_sessions
+      start_time = Time.now().utc().strftime('%Y-%m-%dT%H:%M:00')
+      new_session = {
+        :id => SecureRandom.uuid,
+        :startedAt => start_time,
+        :events => {
+          :handled => 0,
+          :unhandled => 0
+        }
+      }
+      SessionTracker.set_current_session(new_session)
+      add_thread = Thread.new { add_session(start_time) }
+      add_thread.join()
+    end
+
+    def send_sessions
+      @mutex.lock
+      begin
+        deliver_sessions
+      ensure
+        @mutex.unlock
+      end
+    end
+
+    private
+    def add_session(min)
+      @mutex.lock
+      begin
+        @registered_at_exit = false unless defined?(@registered_at_exit)
+        if !@registered_at_exit
+          @registered_at_exit = true
+          at_exit do
+            if !@deliver_fallback.nil? && @deliver_fallback.status == 'sleep'
+              @deliver_fallback.terminate
+            end
+            deliver_sessions
+          end
+        end
+        @session_counts[min] ||= 0
+        @session_counts[min] += 1
+        if Time.now() - @last_sent > TIME_THRESHOLD
+          deliver_sessions
+        end
+      ensure
+        @mutex.unlock
+      end
+    end
+
+    def deliver_sessions
+      return unless @config.track_sessions
+      sessions = []
+      @session_counts.each do |min, count|
+        sessions << {
+          :startedAt => min,
+          :sessionsStarted => count
+        }
+        if sessions.size >= MAXIMUM_SESSION_COUNT
+          deliver(sessions)
+          sessions = []
+        end
+      end
+      @session_counts = {}
+      reset_delivery_thread
+      deliver(sessions)
+    end
+
+    def reset_delivery_thread
+      if !@deliver_fallback.nil? && @deliver_fallback.status == 'sleep'
+        @deliver_fallback.terminate
+      end
+      @deliver_fallback = Thread.new do
+        sleep(FALLBACK_TIME)
+        deliver_sessions
+      end
+    end
+
+    def deliver(sessionCounts)
+      if sessionCounts.length == 0
+        @config.debug("No sessions to deliver")
+        return
+      end
+      
+      if !@config.valid_api_key?
+        @config.debug("Not delivering sessions due to an invalid api_key")
+        return
+      end
+      
+      if !@config.should_notify_release_stage?
+        @config.debug("Not delivering sessions due to notify_release_stages :#{@config.notify_release_stages.inspect}")
+        return
+      end
+
+      if @config.delivery_method != :thread_queue
+        @config.debug("Not delivering sessions due to asynchronous delivery being disabled")
+        return
+      end
+      
+      payload = {
+        :notifier => {
+          :name => Bugsnag::Report::NOTIFIER_NAME,
+          :url => Bugsnag::Report::NOTIFIER_URL,
+          :version => Bugsnag::Report::NOTIFIER_VERSION
+        },
+        :device => {
+          :hostname => @config.hostname
+        },
+        :app => {
+          :version => @config.app_version,
+          :releaseStage => @config.release_stage,
+          :type => @config.app_type
+        },
+        :sessionCounts => sessionCounts
+      }
+
+      headers = {
+        "Bugsnag-Api-Key" => @config.api_key,
+        "Bugsnag-Payload-Version" => SESSION_PAYLOAD_VERSION
+      }
+
+      options = {:headers => headers, :backoff => true, :success => '202'}
+      @last_sent = Time.now
+      Bugsnag::Delivery[@config.delivery_method].deliver(@config.session_endpoint, payload, @config, options)
+    end
+  end
+end