honeybadger 5.0.2 → 5.1.0

data/lib/honeybadger/const.rb

@@ -1,20 +1,20 @@
-require 'honeybadger/version'
-
-module Honeybadger
-  module Rack
-    # Autoloading allows middleware classes to be referenced in applications
-    # which include the optional Rack dependency without explicitly requiring
-    # these files.
-    autoload :ErrorNotifier, 'honeybadger/rack/error_notifier'
-    autoload :UserFeedback, 'honeybadger/rack/user_feedback'
-    autoload :UserInformer, 'honeybadger/rack/user_informer'
-  end
-
-  # @api private
-  module Plugins
-  end
-
-  # @api private
-  module Util
-  end
-end
+require 'honeybadger/version'
+
+module Honeybadger
+  module Rack
+    # Autoloading allows middleware classes to be referenced in applications
+    # which include the optional Rack dependency without explicitly requiring
+    # these files.
+    autoload :ErrorNotifier, 'honeybadger/rack/error_notifier'
+    autoload :UserFeedback, 'honeybadger/rack/user_feedback'
+    autoload :UserInformer, 'honeybadger/rack/user_informer'
+  end
+
+  # @api private
+  module Plugins
+  end
+
+  # @api private
+  module Util
+  end
+end

data/lib/honeybadger/context_manager.rb

@@ -1,55 +1,55 @@
-require 'honeybadger/conversions'
-
-module Honeybadger
-  # @api private
-  class ContextManager
-    include Conversions
-
-    def self.current
-      Thread.current[:__hb_context_manager] ||= new
-    end
-
-    def initialize
-      @mutex = Mutex.new
-      _initialize
-    end
-
-    def clear!
-      _initialize
-    end
-
-    # Internal helpers
-
-
-    def set_context(hash)
-      @mutex.synchronize do
-        @context ||= {}
-        @context.update(Context(hash))
-      end
-    end
-
-    def get_context
-      @mutex.synchronize { @context }
-    end
-
-    def set_rack_env(env)
-      @mutex.synchronize { @rack_env = env }
-    end
-
-    def get_rack_env
-      @mutex.synchronize { @rack_env }
-    end
-
-    private
-
-    attr_accessor :custom, :rack_env
-
-    def _initialize
-      @mutex.synchronize do
-        @context = nil
-        @rack_env = nil
-      end
-    end
-
-  end
-end
+require 'honeybadger/conversions'
+
+module Honeybadger
+  # @api private
+  class ContextManager
+    include Conversions
+
+    def self.current
+      Thread.current[:__hb_context_manager] ||= new
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      _initialize
+    end
+
+    def clear!
+      _initialize
+    end
+
+    # Internal helpers
+
+
+    def set_context(hash)
+      @mutex.synchronize do
+        @context ||= {}
+        @context.update(Context(hash))
+      end
+    end
+
+    def get_context
+      @mutex.synchronize { @context }
+    end
+
+    def set_rack_env(env)
+      @mutex.synchronize { @rack_env = env }
+    end
+
+    def get_rack_env
+      @mutex.synchronize { @rack_env }
+    end
+
+    private
+
+    attr_accessor :custom, :rack_env
+
+    def _initialize
+      @mutex.synchronize do
+        @context = nil
+        @rack_env = nil
+      end
+    end
+
+  end
+end

data/lib/honeybadger/conversions.rb

@@ -1,16 +1,16 @@
-module Honeybadger
-  # @api private
-  module Conversions
-    module_function
-
-    # Convert context into a Hash.
-    #
-    # @param [Object] object The context object.
-    #
-    # @return [Hash] The hash context.
-    def Context(object)
-      object = object.to_honeybadger_context if object.respond_to?(:to_honeybadger_context)
-      Hash(object)
-    end
-  end
-end
+module Honeybadger
+  # @api private
+  module Conversions
+    module_function
+
+    # Convert context into a Hash.
+    #
+    # @param [Object] object The context object.
+    #
+    # @return [Hash] The hash context.
+    def Context(object)
+      object = object.to_honeybadger_context if object.respond_to?(:to_honeybadger_context)
+      Hash(object)
+    end
+  end
+end

data/lib/honeybadger/init/rails.rb

@@ -1,38 +1,38 @@
-require 'rails'
-require 'yaml'
-
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Init
-    module Rails
-      class Railtie < ::Rails::Railtie
-        rake_tasks do
-          load 'honeybadger/tasks.rb'
-        end
-
-        initializer 'honeybadger.install_middleware' do |app|
-          app.config.middleware.insert(0, Honeybadger::Rack::ErrorNotifier)
-          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer)
-          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback)
-        end
-
-        config.before_initialize do
-          Honeybadger.init!({
-            :root           => ::Rails.root.to_s,
-            :env            => ::Rails.env,
-            :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
-            :logger         => Logging::FormattedLogger.new(::Rails.logger),
-            :framework      => :rails
-          })
-        end
-
-        config.after_initialize do
-          Honeybadger.load_plugins!
-        end
-      end
-    end
-  end
-end
-
-Honeybadger.install_at_exit_callback
+require 'rails'
+require 'yaml'
+
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Init
+    module Rails
+      class Railtie < ::Rails::Railtie
+        rake_tasks do
+          load 'honeybadger/tasks.rb'
+        end
+
+        initializer 'honeybadger.install_middleware' do |app|
+          app.config.middleware.insert(0, Honeybadger::Rack::ErrorNotifier)
+          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer)
+          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback)
+        end
+
+        config.before_initialize do
+          Honeybadger.init!({
+            :root           => ::Rails.root.to_s,
+            :env            => ::Rails.env,
+            :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
+            :logger         => Logging::FormattedLogger.new(::Rails.logger),
+            :framework      => :rails
+          })
+        end
+
+        config.after_initialize do
+          Honeybadger.load_plugins!
+        end
+      end
+    end
+  end
+end
+
+Honeybadger.install_at_exit_callback

data/lib/honeybadger/init/rake.rb

@@ -1,66 +1,66 @@
-require 'honeybadger/ruby'
-
-module Honeybadger
-  # @api private
-  # Patch Rake::Application to handle errors with Honeybadger
-  module RakeHandler
-    def self.included(klass)
-      klass.class_eval do
-        include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= '0.9.0'
-        alias_method :display_error_message_without_honeybadger, :display_error_message
-        alias_method :display_error_message, :display_error_message_with_honeybadger
-      end
-    end
-
-    def display_error_message_with_honeybadger(ex)
-      Honeybadger.notify(ex, origin: :rake, component: reconstruct_command_line)
-      display_error_message_without_honeybadger(ex)
-    ensure
-      Honeybadger.clear!
-    end
-
-    def reconstruct_command_line
-      "rake #{ARGV.join( ' ' )}"
-    end
-
-    # This module brings Rake 0.8.7 error handling to 0.9.0 standards
-    module Rake087Methods
-      # Method taken from Rake 0.9.0 source
-      #
-      # Provide standard exception handling for the given block.
-      def standard_exception_handling
-        begin
-          yield
-        rescue SystemExit => ex
-          # Exit silently with current status
-          raise
-        rescue OptionParser::InvalidOption => ex
-          $stderr.puts ex.message
-          exit(false)
-        rescue Exception => ex
-          # Exit with error message
-          display_error_message(ex)
-          exit(false)
-        end
-      end
-
-      # Method extracted from Rake 0.8.7 source
-      def display_error_message(ex)
-        $stderr.puts "#{name} aborted!"
-        $stderr.puts ex.message
-        if options.trace
-          $stderr.puts ex.backtrace.join("\n")
-        else
-          $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
-          $stderr.puts "(See full trace by running task with --trace)"
-        end
-      end
-    end
-  end
-end
-
-Rake.application.instance_eval do
-  class << self
-    include Honeybadger::RakeHandler
-  end
-end
+require 'honeybadger/ruby'
+
+module Honeybadger
+  # @api private
+  # Patch Rake::Application to handle errors with Honeybadger
+  module RakeHandler
+    def self.included(klass)
+      klass.class_eval do
+        include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= '0.9.0'
+        alias_method :display_error_message_without_honeybadger, :display_error_message
+        alias_method :display_error_message, :display_error_message_with_honeybadger
+      end
+    end
+
+    def display_error_message_with_honeybadger(ex)
+      Honeybadger.notify(ex, origin: :rake, component: reconstruct_command_line)
+      display_error_message_without_honeybadger(ex)
+    ensure
+      Honeybadger.clear!
+    end
+
+    def reconstruct_command_line
+      "rake #{ARGV.join( ' ' )}"
+    end
+
+    # This module brings Rake 0.8.7 error handling to 0.9.0 standards
+    module Rake087Methods
+      # Method taken from Rake 0.9.0 source
+      #
+      # Provide standard exception handling for the given block.
+      def standard_exception_handling
+        begin
+          yield
+        rescue SystemExit => ex
+          # Exit silently with current status
+          raise
+        rescue OptionParser::InvalidOption => ex
+          $stderr.puts ex.message
+          exit(false)
+        rescue Exception => ex
+          # Exit with error message
+          display_error_message(ex)
+          exit(false)
+        end
+      end
+
+      # Method extracted from Rake 0.8.7 source
+      def display_error_message(ex)
+        $stderr.puts "#{name} aborted!"
+        $stderr.puts ex.message
+        if options.trace
+          $stderr.puts ex.backtrace.join("\n")
+        else
+          $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+          $stderr.puts "(See full trace by running task with --trace)"
+        end
+      end
+    end
+  end
+end
+
+Rake.application.instance_eval do
+  class << self
+    include Honeybadger::RakeHandler
+  end
+end

data/lib/honeybadger/init/ruby.rb

@@ -1,11 +1,11 @@
-require 'honeybadger/ruby'
-
-Honeybadger.init!({
-  :framework      => :ruby,
-  :env            => ENV['RUBY_ENV'] || ENV['RACK_ENV'],
-  :'logging.path' => 'STDOUT'
-})
-
-Honeybadger.load_plugins!
-
-Honeybadger.install_at_exit_callback
+require 'honeybadger/ruby'
+
+Honeybadger.init!({
+  :framework      => :ruby,
+  :env            => ENV['RUBY_ENV'] || ENV['RACK_ENV'],
+  :'logging.path' => 'STDOUT'
+})
+
+Honeybadger.load_plugins!
+
+Honeybadger.install_at_exit_callback

data/lib/honeybadger/init/sinatra.rb

@@ -1,51 +1,51 @@
-require 'sinatra/base'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Init
-    module Sinatra
-      ::Sinatra::Base.class_eval do
-        class << self
-          def build_with_honeybadger(*args, &block)
-            configure_honeybadger
-            install_honeybadger
-            # Sinatra is a special case. Sinatra starts the web application in an at_exit
-            # handler. And, since we require sinatra before requiring HB, the only way to
-            # setup our at_exit callback is in the sinatra build callback honeybadger/init/sinatra.rb
-            Honeybadger.install_at_exit_callback
-            build_without_honeybadger(*args, &block)
-          end
-          alias :build_without_honeybadger :build
-          alias :build :build_with_honeybadger
-
-          def configure_honeybadger
-            return unless defined?(honeybadger_api_key)
-            Honeybadger.configure do |config|
-              config.api_key = honeybadger_api_key
-            end
-          end
-
-          def install_honeybadger
-            config = Honeybadger.config
-            return unless config[:'sinatra.enabled']
-            install_honeybadger_middleware(Honeybadger::Rack::ErrorNotifier) if config[:'exceptions.enabled']
-          end
-
-          def install_honeybadger_middleware(klass)
-            return if middleware.any? {|m| m[0] == klass }
-            use(klass)
-          end
-
-        end
-      end
-    end
-  end
-end
-
-Honeybadger.init!({
-  env: ENV['APP_ENV'] || ENV['RACK_ENV'],
-  framework: :sinatra,
-  :'logging.path' => 'STDOUT'
-})
-
-Honeybadger.load_plugins!
+require 'sinatra/base'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Init
+    module Sinatra
+      ::Sinatra::Base.class_eval do
+        class << self
+          def build_with_honeybadger(*args, &block)
+            configure_honeybadger
+            install_honeybadger
+            # Sinatra is a special case. Sinatra starts the web application in an at_exit
+            # handler. And, since we require sinatra before requiring HB, the only way to
+            # setup our at_exit callback is in the sinatra build callback honeybadger/init/sinatra.rb
+            Honeybadger.install_at_exit_callback
+            build_without_honeybadger(*args, &block)
+          end
+          alias :build_without_honeybadger :build
+          alias :build :build_with_honeybadger
+
+          def configure_honeybadger
+            return unless defined?(honeybadger_api_key)
+            Honeybadger.configure do |config|
+              config.api_key = honeybadger_api_key
+            end
+          end
+
+          def install_honeybadger
+            config = Honeybadger.config
+            return unless config[:'sinatra.enabled']
+            install_honeybadger_middleware(Honeybadger::Rack::ErrorNotifier) if config[:'exceptions.enabled']
+          end
+
+          def install_honeybadger_middleware(klass)
+            return if middleware.any? {|m| m[0] == klass }
+            use(klass)
+          end
+
+        end
+      end
+    end
+  end
+end
+
+Honeybadger.init!({
+  env: ENV['APP_ENV'] || ENV['RACK_ENV'],
+  framework: :sinatra,
+  :'logging.path' => 'STDOUT'
+})
+
+Honeybadger.load_plugins!