bugsnag-maglev- 2.8.12

data/lib/bugsnag/delivery.rb

@@ -0,0 +1,18 @@
+module Bugsnag
+  module Delivery
+    class << self
+      def register(name, delivery_method)
+        delivery_methods[name.to_sym] = delivery_method
+      end
+
+      def [](name)
+        delivery_methods[name.to_sym]
+      end
+
+      private
+      def delivery_methods
+        @delivery_methods ||= {}
+      end
+    end
+  end
+end

data/lib/bugsnag/delivery/synchronous.rb

@@ -0,0 +1,51 @@
+require "net/https"
+require "uri"
+
+module Bugsnag
+  module Delivery
+    class Synchronous
+      HEADERS = {"Content-Type" => "application/json"}
+
+      class << self
+        def deliver(url, body, configuration)
+          begin
+            response = request(url, body, configuration)
+            Bugsnag.debug("Notification to #{url} finished, response was #{response.code}, payload was #{body}")
+          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)
+          end
+        end
+
+        private
+
+        def request(url, body, configuration)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port, configuration.proxy_host, configuration.proxy_port, configuration.proxy_user, configuration.proxy_password)
+          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)
+          request.body = body
+          http.request(request)
+        end
+
+        def path(uri)
+          uri.path == "" ? "/" : uri.path
+        end
+      end
+    end
+  end
+end
+
+Bugsnag::Delivery.register(:synchronous, Bugsnag::Delivery::Synchronous)

data/lib/bugsnag/delivery/thread_queue.rb

@@ -0,0 +1,53 @@
+require "thread"
+
+module Bugsnag
+  module Delivery
+    class ThreadQueue < Synchronous
+      MAX_OUTSTANDING_REQUESTS = 100
+      STOP = Object.new
+      MUTEX = Mutex.new
+
+      class << self
+        def deliver(url, body, configuration)
+          start_once!
+
+          if queue.length > MAX_OUTSTANDING_REQUESTS
+            Bugsnag.warn("Dropping notification, #{queue.length} outstanding requests")
+            return
+          end
+
+          # Add delivery to the worker thread
+          queue.push proc { super(url, body, configuration) }
+        end
+
+        private
+
+        attr_reader :queue
+
+        def start_once!
+          MUTEX.synchronize do
+            return if @started
+            @started = true
+
+            @queue = Queue.new
+
+            worker_thread = Thread.new do
+              while x = queue.pop
+                break if x == STOP
+                x.call
+              end
+            end
+
+            at_exit do
+              Bugsnag.warn("Waiting for #{queue.length} outstanding request(s)") unless queue.empty?
+              queue.push STOP
+              worker_thread.join
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Bugsnag::Delivery.register(:thread_queue, Bugsnag::Delivery::ThreadQueue)

data/lib/bugsnag/deploy.rb

@@ -0,0 +1,35 @@
+require "bugsnag"
+require "json"
+
+module Bugsnag
+  class Deploy
+    def self.notify(opts = {})
+
+      configuration = Bugsnag.configuration.dup
+
+      # update configuration based on parameters passed in
+      [:api_key, :app_version, :release_stage, :endpoint, :use_ssl,
+       :proxy_host, :proxy_port, :proxy_user, :proxy_password].each do |param|
+        unless opts[param].nil?
+          configuration.send :"#{param}=", opts[param]
+        end
+      end
+
+      endpoint = (configuration.use_ssl ? "https://" : "http://") + configuration.endpoint + "/deploy"
+
+      parameters = {
+        "apiKey" => configuration.api_key,
+        "releaseStage" => configuration.release_stage,
+        "appVersion" => configuration.app_version,
+        "revision" => opts[:revision],
+        "repository" => opts[:repository],
+        "branch" => opts[:branch]
+      }.reject {|k,v| v == nil}
+
+      raise RuntimeError.new("No API key found when notifying of deploy") if !parameters["apiKey"] || parameters["apiKey"].empty?
+
+      payload_string = ::JSON.dump(parameters)
+      Bugsnag::Delivery::Synchronous.deliver(endpoint, payload_string, configuration)
+    end
+  end
+end

data/lib/bugsnag/helpers.rb

@@ -0,0 +1,127 @@
+require 'uri'
+
+module Bugsnag
+  module Helpers
+    MAX_STRING_LENGTH = 4096
+    ENCODING_OPTIONS = {:invalid => :replace, :undef => :replace}.freeze
+
+    def self.cleanup_obj(obj, filters = nil, seen = {})
+      return nil unless obj
+
+      # Protect against recursion of recursable items
+      protection = if obj.is_a?(Hash) || obj.is_a?(Array) || obj.is_a?(Set)
+        return seen[obj] if seen[obj]
+        seen[obj] = '[RECURSION]'.freeze
+      end
+
+      value = case obj
+      when Hash
+        clean_hash = {}
+        obj.each do |k,v|
+          if filters_match?(k, filters)
+            clean_hash[k] = '[FILTERED]'.freeze
+          else
+            clean_obj = cleanup_obj(v, filters, seen)
+            clean_hash[k] = clean_obj
+          end
+        end
+        clean_hash
+      when Array, Set
+        obj.map { |el| cleanup_obj(el, filters, seen) }.compact
+      when Numeric, TrueClass, FalseClass
+        obj
+      when String
+        cleanup_string(obj)
+      else
+        str = obj.to_s
+        # avoid leaking potentially sensitive data from objects' #inspect output
+        if str =~ /#<.*>/
+          '[OBJECT]'.freeze
+        else
+          cleanup_string(str)
+        end
+      end
+
+      seen[obj] = value if protection
+      value
+    end
+
+    def self.cleanup_string(str)
+      if defined?(str.encoding) && defined?(Encoding::UTF_8)
+        if str.encoding == Encoding::UTF_8
+          str.valid_encoding? ? str : str.encode('utf-16', ENCODING_OPTIONS).encode('utf-8')
+        else
+          str.encode('utf-8', ENCODING_OPTIONS)
+        end
+      elsif defined?(Iconv)
+        Iconv.conv('UTF-8//IGNORE', 'UTF-8', str) || str
+      else
+        str
+      end
+    end
+
+    def self.cleanup_obj_encoding(obj)
+      cleanup_obj(obj, nil)
+    end
+
+    def self.filters_match?(object, filters)
+      str = object.to_s
+
+      Array(filters).any? do |f|
+        case f
+        when Regexp
+          str.match(f)
+        else
+          str.include?(f.to_s)
+        end
+      end
+    end
+
+    def self.cleanup_url(url, filters = [])
+      return url if filters.empty?
+
+      uri = URI(url)
+      return url unless uri.query
+
+      query_params = uri.query.split('&').map { |pair| pair.split('=') }
+      query_params.map! do |key, val|
+        if filters_match?(key, filters)
+          "#{key}=[FILTERED]"
+        else
+          "#{key}=#{val}"
+        end
+      end
+
+      uri.query = query_params.join('&')
+      uri.to_s
+    end
+
+    def self.reduce_hash_size(hash)
+      return {} unless hash.is_a?(Hash)
+      hash.inject({}) do |h, (k,v)|
+        if v.is_a?(Hash)
+          h[k] = reduce_hash_size(v)
+        elsif v.is_a?(Array) || v.is_a?(Set)
+          h[k] = v.map {|el| reduce_hash_size(el) }
+        else
+          val = v.to_s
+          val = val.slice(0, MAX_STRING_LENGTH) + "[TRUNCATED]" if val.length > MAX_STRING_LENGTH
+          h[k] = val
+        end
+
+        h
+      end
+    end
+
+    def self.flatten_meta_data(overrides)
+      return nil unless overrides
+
+      meta_data = overrides.delete(:meta_data)
+      if meta_data.is_a?(Hash)
+        overrides.merge(meta_data)
+      else
+        overrides
+      end
+    end
+  end
+end

data/lib/bugsnag/mailman.rb

@@ -0,0 +1,28 @@
+require 'mailman'
+
+module Bugsnag
+  class Mailman
+    def call(mail)
+      begin
+
+        Bugsnag.set_request_data :mailman_msg, mail.to_s
+
+        yield
+      rescue Exception => ex
+        raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
+        Bugsnag.auto_notify(ex)
+        raise
+      ensure
+        Bugsnag.clear_request_data
+      end
+    end
+  end
+end
+
+
+if Mailman.config.respond_to?(:middleware)
+  Mailman.config.middleware.add ::Bugsnag::Mailman
+end
+
+Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Mailman)
+Bugsnag.configuration.app_type = "mailman"

data/lib/bugsnag/meta_data.rb

@@ -0,0 +1,7 @@
+module Bugsnag
+  module MetaData
+    attr_accessor :bugsnag_meta_data
+    attr_accessor :bugsnag_user_id
+    attr_accessor :bugsnag_context
+  end
+end

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/mailman.rb

@@ -0,0 +1,13 @@
+module Bugsnag::Middleware
+  class Mailman
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(notification)
+      mailman_msg = notification.request_data[:mailman_msg]
+      notification.add_tab(:mailman, {"message" => mailman_msg}) if mailman_msg
+      @bugsnag.call(notification)
+    end
+  end
+end

data/lib/bugsnag/middleware/rack_request.rb

@@ -0,0 +1,72 @@
+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 rescue {}
+
+        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 << Bugsnag::Helpers.cleanup_url(request.fullpath, notification.configuration.params_filters)
+
+        headers = {}
+
+        env.each_pair do |key, value|
+          if key.to_s.start_with?("HTTP_")
+            header_key = key[5..-1]
+          elsif ["CONTENT_TYPE", "CONTENT_LENGTH"].include?(key)
+            header_key = key
+          else
+            next
+          end
+
+          headers[header_key.split("_").map {|s| s.capitalize}.join("-")] = value
+        end
+
+        # Add a request tab
+        notification.add_tab(:request, {
+          :url => url,
+          :httpMethod => request.request_method,
+          :params => params.to_hash,
+          :referer => request.referer,
+          :clientIp => request.ip,
+          :headers => headers
+        })
+
+        # Add an environment tab
+        if notification.configuration.send_environment
+          notification.add_tab(:environment, env)
+        end
+
+        # Add a session tab
+        if session
+          if session.is_a?(Hash)
+            # Rails 3
+            notification.add_tab(:session, session)
+          elsif session.respond_to?(:to_hash)
+            # Rails 4
+            notification.add_tab(:session, session.to_hash)
+          end
+        end
+      end
+
+      @bugsnag.call(notification)
+    end
+  end
+end

data/lib/bugsnag/middleware/rails2_request.rb

@@ -0,0 +1,52 @@
+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 << Bugsnag::Helpers.cleanup_url(request.fullpath, notification.configuration.params_filters)
+
+        # Add a request tab
+        notification.add_tab(:request, {
+          :url => url,
+          :params => params.to_hash,
+          :controller => params[:controller],
+          :action => params[:action]
+        })
+
+        # Add an environment tab
+        if request.env && notification.configuration.send_environment
+          notification.add_tab(:environment, request.env)
+        end
+
+        # 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
+
+        # Add the rails version
+        notification.add_tab(:environment, {
+          :railsVersion => Rails::VERSION::STRING
+        })
+      end
+
+      @bugsnag.call(notification)
+    end
+  end
+end