batbugger 0.0.1 → 1.2.0

data/.gitignore

@@ -14,3 +14,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*~

data/Gemfile.lock

@@ -1,14 +1,12 @@
 PATH
   remote: .
   specs:
-    batbugger (0.0.1)
-      honeybadger (>= 1.6.0)
+    batbugger (1.1.0)
+      json
 
 GEM
   remote: https://rubygems.org/
   specs:
-    honeybadger (1.6.0)
-      json
     json (1.7.7)
     rake (10.0.3)
 

data/README.md

@@ -1,7 +1,7 @@
 BatBugger
 ===============
 
-This is the notifier gem for integrating apps with the :zap: [BatBugger Exception Notifier for Ruby and Rails](http://batbugger.io).
+This is the notifier gem for integrating apps with the : [BatBugger Exception Notifier for Ruby and Rails](http://batbugger.io).
 Developed and Maintained by grepruby team: [Ruby and Rails Expert Team](http://grepruby.com).
 
 ## Installation

data/batbugger.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "honeybadger", ">=1.6.0"
   spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_dependency('json')
   spec.add_development_dependency "rake"
 end

data/lib/batbugger/backtrace.rb

@@ -0,0 +1,136 @@
+module Batbugger
+  class Backtrace
+
+    class Line
+      INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+      attr_reader :file
+
+      attr_reader :number
+
+      attr_reader :method
+
+      attr_reader :filtered_file, :filtered_number, :filtered_method
+
+      def self.parse(unparsed_line, opts = {})
+        filters = opts[:filters] || []
+        filtered_line = filters.inject(unparsed_line) do |line, proc|
+          proc.call(line)
+        end
+
+        if filtered_line
+          _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+          _, *filtered_args = filtered_line.match(INPUT_FORMAT).to_a
+          new(file, number, method, *filtered_args)
+        else
+          nil
+        end
+      end
+
+      def initialize(file, number, method, filtered_file = file,
+                     filtered_number = number, filtered_method = method)
+        self.filtered_file   = filtered_file
+        self.filtered_number = filtered_number
+        self.filtered_method = filtered_method
+        self.file            = file
+        self.number          = number
+        self.method          = method
+      end
+
+      def to_s
+        "#{filtered_file}:#{filtered_number}:in `#{filtered_method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{to_s}>"
+      end
+
+      def application?
+        (filtered_file =~ /^\[PROJECT_ROOT\]/i) && !(filtered_file =~ /^\[PROJECT_ROOT\]\/vendor/i)
+      end
+
+      def source(radius = 2)
+        @source ||= get_source(file, number, radius)
+      end
+
+      private
+
+      attr_writer :file, :number, :method, :filtered_file, :filtered_number, :filtered_method
+
+      def get_source(file, number, radius = 2)
+        if file && File.exists?(file)
+          before = after = radius
+          start = (number.to_i - 1) - before
+          start = 0 and before = 1 if start <= 0
+          duration = before + 1 + after
+
+          l = 0
+          File.open(file) do |f|
+            start.times { f.gets ; l += 1 }
+            return Hash[duration.times.map { (line = f.gets) ? [(l += 1), line] : nil }.compact]
+          end
+        else
+          {}
+        end
+      end
+    end
+
+    attr_reader :lines, :application_lines
+
+    def self.parse(ruby_backtrace, opts = {})
+      ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+      lines = ruby_lines.collect do |unparsed_line|
+        Line.parse(unparsed_line, opts)
+      end.compact
+
+      instance = new(lines)
+    end
+
+    def initialize(lines)
+      self.lines = lines
+      self.application_lines = lines.select(&:application?)
+    end
+
+    def to_ary
+      lines.map { |l| { :number => l.filtered_number, :file => l.filtered_file, :method => l.filtered_method } }
+    end
+    alias :to_a :to_ary
+
+    def as_json(options = {})
+      to_ary
+    end
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+
+    def inspect
+      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+    end
+
+    def ==(other)
+      if other.respond_to?(:to_json)
+        to_json == other.to_json
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_writer :lines, :application_lines
+
+    def self.split_multiline_backtrace(backtrace)
+      if backtrace.to_a.size == 1
+        backtrace.to_a.first.split(/\n\s*/)
+      else
+        backtrace
+      end
+    end
+  end
+end

data/lib/batbugger/configuration.rb

@@ -0,0 +1,204 @@
+module Batbugger
+  class Configuration
+    OPTIONS = [:api_key, :backtrace_filters, :development_environments, :environment_name,
+               :host, :http_open_timeout, :http_read_timeout, :ignore, :ignore_by_filters,
+               :ignore_user_agent, :notifier_name, :notifier_url, :notifier_version,
+               :params_filters, :project_root, :port, :protocol, :proxy_host, :proxy_pass,
+               :proxy_port, :proxy_user, :secure, :use_system_ssl_cert_chain, :framework,
+               :user_information, :rescue_rake_exceptions, :source_extract_radius,
+               :send_request_session, :debug].freeze
+
+    attr_accessor :api_key
+
+    attr_accessor :host
+
+    attr_accessor :port
+
+    attr_accessor :secure
+
+    attr_accessor :use_system_ssl_cert_chain
+
+    attr_accessor :http_open_timeout
+
+    attr_accessor :http_read_timeout
+
+    attr_accessor :proxy_host
+
+    attr_accessor :proxy_port
+
+    attr_accessor :proxy_user
+
+    attr_accessor :proxy_pass
+
+    attr_reader :params_filters
+
+    attr_reader :backtrace_filters
+
+    attr_reader :ignore_by_filters
+
+    attr_reader :ignore
+
+    attr_reader :ignore_user_agent
+
+    attr_accessor :development_environments
+
+    attr_accessor :environment_name
+
+    attr_accessor :project_root
+
+    attr_accessor :notifier_name
+
+    attr_accessor :notifier_version
+
+    attr_accessor :notifier_url
+
+    attr_accessor :logger
+
+    attr_accessor :user_information
+
+    attr_accessor :framework
+
+    attr_accessor :rescue_rake_exceptions
+
+    attr_accessor :source_extract_radius
+
+    attr_accessor :send_request_session
+
+    attr_accessor :debug
+
+    attr_writer :async
+
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(Batbugger.configuration.project_root) && Batbugger.configuration.project_root.to_s != ''
+          line.sub(/#{Batbugger.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/batbugger} }
+    ].freeze
+
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound']
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+    def initialize
+      @secure                    = true
+      @use_system_ssl_cert_chain = false
+      @host                      = 'batbugger.io'
+      @http_open_timeout         = 2
+      @http_read_timeout         = 5
+      @params_filters            = DEFAULT_PARAMS_FILTERS.dup
+      @backtrace_filters         = DEFAULT_BACKTRACE_FILTERS.dup
+      @ignore_by_filters         = []
+      @ignore                    = IGNORE_DEFAULT.dup
+      @ignore_user_agent         = []
+      @development_environments  = %w(development test cucumber)
+      @notifier_name             = 'Batbugger Notifier'
+      @notifier_version          = VERSION
+      @notifier_url              = 'https://github.com/grepruby/batbugger'
+      @framework                 = 'Standalone'
+      @user_information          = 'Batbugger Error {{error_id}}'
+      @rescue_rake_exceptions    = nil
+      @source_extract_radius     = 2
+      @send_request_session      = true
+      @debug                     = false
+    end
+
+    def filter_backtrace(&block)
+      self.backtrace_filters << block
+    end
+
+    def ignore_by_filter(&block)
+      self.ignore_by_filters << block
+    end
+
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    def ignore_user_agent_only=(names)
+      @ignore_user_agent = [names].flatten
+    end
+
+    def [](option)
+      send(option)
+    end
+
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    def public?
+      !development_environments.include?(environment_name)
+    end
+
+    def async
+      @async = Proc.new if block_given?
+      @async
+    end
+    alias :async? :async
+
+    def port
+      @port || default_port
+    end
+
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def ca_bundle_path
+      if use_system_ssl_cert_chain? && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        OpenSSL::X509::DEFAULT_CERT_FILE
+      else
+        local_cert_path 
+      end
+    end
+
+    def local_cert_path
+      File.expand_path(File.join("..", "..", "..", "resources", "ca-bundle.crt"), __FILE__)
+    end
+
+    def current_user_method=(null) ; end
+
+    private
+
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+  end
+end
+

data/lib/batbugger/notice.rb

@@ -0,0 +1,306 @@
+require 'socket'
+
+module Batbugger
+  class Notice
+    attr_reader :exception
+
+    attr_reader :backtrace
+
+    attr_reader :error_class
+
+    attr_reader :source_extract
+
+    attr_reader :source_extract_radius
+
+    attr_reader :environment_name
+
+    attr_reader :cgi_data
+
+    attr_reader :error_message
+
+    attr_reader :send_request_session
+
+    attr_reader :backtrace_filters
+
+    attr_reader :params_filters
+
+    attr_reader :parameters
+    alias_method :params, :parameters
+
+    attr_reader :component
+    alias_method :controller, :component
+
+    attr_reader :action
+
+    attr_reader :session_data
+
+    attr_reader :context
+
+    attr_reader :project_root
+
+    attr_reader :url
+
+    attr_reader :ignore
+
+    attr_reader :ignore_by_filters
+
+    attr_reader :notifier_name
+
+    attr_reader :notifier_version
+
+    attr_reader :notifier_url
+
+    attr_reader :hostname
+
+    def initialize(args)
+      self.args         = args
+      self.exception    = args[:exception]
+      self.project_root = args[:project_root]
+      self.url          = args[:url] || rack_env(:url)
+
+      self.notifier_name    = args[:notifier_name]
+      self.notifier_version = args[:notifier_version]
+      self.notifier_url     = args[:notifier_url]
+
+      self.ignore              = args[:ignore]              || []
+      self.ignore_by_filters   = args[:ignore_by_filters]   || []
+      self.backtrace_filters   = args[:backtrace_filters]   || []
+      self.params_filters      = args[:params_filters]      || []
+      self.parameters          = args[:parameters] ||
+                                   action_dispatch_params ||
+                                   rack_env(:params) ||
+                                   {}
+      self.component           = args[:component] || args[:controller] || parameters['controller']
+      self.action              = args[:action] || parameters['action']
+
+      self.environment_name = args[:environment_name]
+      self.cgi_data         = args[:cgi_data] || args[:rack_env]
+      self.backtrace        = Backtrace.parse(exception_attribute(:backtrace, caller), :filters => self.backtrace_filters)
+      self.error_class      = exception_attribute(:error_class) {|exception| exception.class.name }
+      self.error_message    = exception_attribute(:error_message, 'Notification') do |exception|
+        "#{exception.class.name}: #{exception.message}"
+      end
+
+      self.hostname         = local_hostname
+
+      self.source_extract_radius = args[:source_extract_radius] || 2
+      self.source_extract        = extract_source_from_backtrace
+
+      self.send_request_session     = args[:send_request_session].nil? ? true : args[:send_request_session]
+
+      also_use_rack_params_filters
+      find_session_data
+      clean_params
+      clean_rack_request_data
+      set_context
+    end
+
+    def deliver
+      Batbugger.sender.send_to_batbugger(self)
+    end
+
+    def as_json(options = {})
+      {
+        :notifier => {
+          :name => notifier_name,
+          :url => notifier_url,
+          :version => notifier_version,
+          :language => 'ruby'
+        },
+        :error => {
+          :class => error_class,
+          :message => error_message,
+          :backtrace => backtrace,
+          :source => source_extract
+        },
+        :request => {
+          :url => url,
+          :component => component,
+          :action => action,
+          :params => parameters,
+          :session => session_data,
+          :cgi_data => cgi_data,
+          :context => context
+        },
+        :server => {
+          :project_root => project_root,
+          :environment_name => environment_name,
+          :hostname => hostname
+        }
+      }
+    end
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+
+    def ignore_by_class?(ignored_class = nil)
+      @ignore_by_class ||= Proc.new do |ignored_class|
+        case error_class
+        when (ignored_class.respond_to?(:name) ? ignored_class.name : ignored_class)
+          true
+        else
+          exception && ignored_class.is_a?(Class) && exception.class < ignored_class
+        end
+      end
+
+      ignored_class ? @ignore_by_class.call(ignored_class) : @ignore_by_class
+    end
+
+    def ignore?
+      ignore.any?(&ignore_by_class?) ||
+        ignore_by_filters.any? {|filter| filter.call(self) }
+    end
+
+    def [](method)
+      case method
+      when :request
+        self
+      else
+        send(method)
+      end
+    end
+
+    private
+
+    attr_writer :exception, :backtrace, :error_class, :error_message,
+      :backtrace_filters, :parameters, :params_filters, :environment_filters,
+      :session_data, :project_root, :url, :ignore, :ignore_by_filters,
+      :notifier_name, :notifier_url, :notifier_version, :component, :action,
+      :cgi_data, :environment_name, :hostname, :context, :source_extract,
+      :source_extract_radius, :send_request_session
+
+    attr_accessor :args
+
+    def exception_attribute(attribute, default = nil, &block)
+      (exception && from_exception(attribute, &block)) || args[attribute] || default
+    end
+
+    def from_exception(attribute)
+      if block_given?
+        yield(exception)
+      else
+        exception.send(attribute)
+      end
+    end
+
+    def clean_unserializable_data_from(attribute)
+      self.send(:"#{attribute}=", clean_unserializable_data(send(attribute)))
+    end
+
+    def clean_unserializable_data(data, stack = [])
+      return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
+
+      if data.respond_to?(:to_hash)
+        data.to_hash.inject({}) do |result, (key, value)|
+          result.merge(key => clean_unserializable_data(value, stack + [data.object_id]))
+        end
+      elsif data.respond_to?(:to_ary)
+        data.to_ary.collect do |value|
+          clean_unserializable_data(value, stack + [data.object_id])
+        end
+      else
+        data.to_s
+      end
+    end
+
+    def clean_params
+      clean_unserializable_data_from(:parameters)
+      filter(parameters)
+      if cgi_data
+        clean_unserializable_data_from(:cgi_data)
+        filter(cgi_data)
+      end
+      if session_data
+        clean_unserializable_data_from(:session_data)
+        filter(session_data)
+      end
+    end
+
+    def clean_rack_request_data
+      if cgi_data
+        cgi_data.delete("rack.request.form_vars")
+      end
+    end
+
+    def extract_source_from_backtrace
+      if backtrace.lines.empty?
+        nil
+      else
+        if exception.respond_to?(:source_extract)
+          Hash[exception_attribute(:source_extract).split("\n").map do |line|
+            parts = line.split(': ')
+            [parts[0].strip, parts[1] || '']
+          end]
+        elsif backtrace.application_lines.any?
+          backtrace.application_lines.first.source(source_extract_radius)
+        else
+          backtrace.lines.first.source(source_extract_radius)
+        end
+      end
+    end
+
+    def filter(hash)
+      if params_filters
+        hash.each do |key, value|
+          if filter_key?(key)
+            hash[key] = "[FILTERED]"
+          elsif value.respond_to?(:to_hash)
+            filter(hash[key])
+          end
+        end
+      end
+    end
+
+    def filter_key?(key)
+      params_filters.any? do |filter|
+        key.to_s.eql?(filter.to_s)
+      end
+    end
+
+    def find_session_data
+      if send_request_session
+        self.session_data = args[:session_data] || args[:session] || rack_session || {}
+        self.session_data = session_data[:data] if session_data[:data]
+      end
+    end
+
+    def set_context
+      self.context = Thread.current[:batbugger_context] || {}
+      self.context.merge!(args[:context]) if args[:context]
+      self.context = nil if context.empty?
+    end
+
+    def rack_env(method)
+      rack_request.send(method) if rack_request
+    end
+
+    def rack_request
+      @rack_request ||= if args[:rack_env]
+        ::Rack::Request.new(args[:rack_env])
+      end
+    end
+
+    def action_dispatch_params
+      args[:rack_env]['action_dispatch.request.parameters'] if args[:rack_env]
+    end
+
+    def rack_session
+      args[:rack_env]['rack.session'] if args[:rack_env]
+    end
+
+    # Private: (Rails 3+) Adds params filters to filter list
+    #
+    # Returns nothing
+    def also_use_rack_params_filters
+      if cgi_data
+        @params_filters ||= []
+        @params_filters += cgi_data['action_dispatch.parameter_filter'] || []
+      end
+    end
+
+    def local_hostname
+      Socket.gethostname
+    end
+  end
+end

data/lib/batbugger/rack.rb

@@ -0,0 +1,57 @@
+module Batbugger
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Batbugger and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'batbugger'
+  #
+  #   Batbugger.configure do |config|
+  #     config.api_key = 'my_api_key'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  #   use Batbugger::Rack
+  #   run app
+  #
+  # Use a standard Batbugger.configure call to configure your api key.
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def ignored_user_agent?(env)
+      true if Batbugger.
+        configuration.
+        ignore_user_agent.
+        flatten.
+        any? { |ua| ua === env['HTTP_USER_AGENT'] }
+    end
+
+    def notify_batbugger(exception,env)
+      Batbugger.notify_or_ignore(exception, :rack_env => env) unless ignored_user_agent?(env)
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        env['batbugger.error_id'] = notify_batbugger(raised, env)
+        raise
+      ensure
+        Batbugger.context.clear!
+      end
+
+      framework_exception = env['rack.exception'] || env['sinatra.error']
+      if framework_exception
+        env['batbugger.error_id'] = notify_batbugger(framework_exception, env)
+      end
+
+      response
+    end
+  end
+end

data/lib/batbugger/rails/controller_methods.rb

@@ -0,0 +1,70 @@
+module Batbugger
+  module Rails
+    module ControllerMethods
+      def batbugger_request_data
+        { :parameters       => batbugger_filter_if_filtering(params.to_hash),
+          :session_data     => batbugger_filter_if_filtering(batbugger_session_data),
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => batbugger_request_url,
+          :cgi_data         => batbugger_filter_if_filtering(request.env) }
+      end
+
+      private
+
+      # This method should be used for sending manual notifications while you are still
+      # inside the controller. Otherwise it works like Batbugger.notify.
+      def notify_batbugger(hash_or_exception)
+        unless batbugger_local_request?
+          Batbugger.notify(hash_or_exception, batbugger_request_data)
+        end
+      end
+
+      def batbugger_local_request?
+        if defined?(::Rails.application.config)
+          ::Rails.application.config.consider_all_requests_local || (request.local? && (!request.env["HTTP_X_FORWARDED_FOR"]))
+        else
+          consider_all_requests_local || (local_request? && (!request.env["HTTP_X_FORWARDED_FOR"]))
+        end
+      end
+
+      def batbugger_ignore_user_agent? #:nodoc:
+        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
+        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
+        Batbugger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+
+      def batbugger_filter_if_filtering(hash)
+        return hash if ! hash.is_a?(Hash)
+
+        # Rails 2 filters parameters in the controller
+        # In Rails 3+ we use request.env['action_dispatch.parameter_filter']
+        # to filter parameters in Batbugger::Notice (avoids filtering twice)
+        if respond_to?(:filter_parameters)
+          filter_parameters(hash)
+        else
+          hash
+        end
+      end
+
+      def batbugger_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def batbugger_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.fullpath
+        url
+      end
+    end
+  end
+end

data/lib/batbugger/rails/middleware/exceptions_catcher.rb

@@ -0,0 +1,29 @@
+module Batbugger
+  module Rails
+    module Middleware
+      module ExceptionsCatcher
+        def self.included(base)
+          base.send(:alias_method_chain,:render_exception,:batbugger)
+        end
+
+        def skip_user_agent?(env)
+          user_agent = env["HTTP_USER_AGENT"]
+          ::Batbugger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+        rescue
+          false
+        end
+
+        def render_exception_with_batbugger(env,exception)
+          controller = env['action_controller.instance']
+          env['batbugger.error_id'] = Batbugger.
+            notify_or_ignore(exception,
+                   (controller.respond_to?(:batbugger_request_data) ? controller.batbugger_request_data : {:rack_env => env})) unless skip_user_agent?(env)
+          if defined?(controller.rescue_action_in_public_without_batbugger)
+            controller.rescue_action_in_public_without_batbugger(exception)
+          end
+          render_exception_without_batbugger(env,exception)
+        end
+      end
+    end
+  end
+end

data/lib/batbugger/railtie.rb

@@ -0,0 +1,33 @@
+require 'batbugger'
+require 'rails'
+
+module Batbugger
+  class Railtie < Rails::Railtie
+    initializer "batbugger.use_rack_middleware" do |app|
+      app.config.middleware.insert 0, "Batbugger::Rack"
+    end
+
+    config.after_initialize do
+      Batbugger.configure(true) do |config|
+        config.logger           ||= ::Rails.logger
+        config.environment_name ||= ::Rails.env
+        config.project_root     ||= ::Rails.root
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        require 'batbugger/rails/controller_methods'
+
+        include Batbugger::Rails::ControllerMethods
+      end
+
+      if defined?(::ActionDispatch::DebugExceptions)
+        require 'batbugger/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::DebugExceptions.send(:include,Batbugger::Rails::Middleware::ExceptionsCatcher)
+      elsif defined?(::ActionDispatch::ShowExceptions)
+        require 'batbugger/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::ShowExceptions.send(:include,Batbugger::Rails::Middleware::ExceptionsCatcher)
+      end
+    end
+  end
+end

data/lib/batbugger/sender.rb

@@ -0,0 +1,114 @@
+module Batbugger
+  class Sender
+    NOTICES_URI = '/v1/notices/'.freeze
+    HTTP_ERRORS = [Timeout::Error,
+                   Errno::EINVAL,
+                   Errno::ECONNRESET,
+                   EOFError,
+                   Net::HTTPBadResponse,
+                   Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError,
+                   Errno::ECONNREFUSED].freeze
+
+    def initialize(options = {})
+      [ :api_key,
+        :proxy_host,
+        :proxy_port,
+        :proxy_user,
+        :proxy_pass,
+        :protocol,
+        :host,
+        :port,
+        :secure,
+        :use_system_ssl_cert_chain,
+        :http_open_timeout,
+        :http_read_timeout
+      ].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    def send_to_batbugger(notice)
+      data = notice.is_a?(String) ? notice : notice.to_json
+
+      http     = setup_http_connection
+      headers  = HEADERS
+
+      headers.merge!({ 'X-API-Key' => api_key}) unless api_key.nil?
+
+      response = begin
+                   http.post(url.path, data, headers)
+                 rescue *HTTP_ERRORS => e
+                   log(:error, "Unable to contact the Batbugger server. HTTP Error=#{e}")
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        log(Batbugger.configuration.debug ? :info : :debug, "Success: #{response.class}", response, data)
+        JSON.parse(response.body)['id']
+      else
+        log(:error, "Failure: #{response.class}", response, data)
+        nil
+      end
+    rescue => e
+      log(:error, "[Batbugger::Sender#send_to_batbugger] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+      nil
+    end
+
+    attr_reader :api_key,
+      :proxy_host,
+      :proxy_port,
+      :proxy_user,
+      :proxy_pass,
+      :protocol,
+      :host,
+      :port,
+      :secure,
+      :use_system_ssl_cert_chain,
+      :http_open_timeout,
+      :http_read_timeout
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+    private
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    end
+
+    def log(level, message, response = nil, data = nil)
+      # Log result:
+      Batbugger.write_verbose_log(message, level)
+
+      # Log debug information:
+      Batbugger.report_environment_info
+      Batbugger.report_response_body(response.body) if response && response.respond_to?(:body)
+      Batbugger.write_verbose_log("Notice: #{data}", :debug) if data && Batbugger.configuration.debug
+    end
+
+    def setup_http_connection
+      http =
+        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
+          new(url.host, url.port)
+
+      http.read_timeout = http_read_timeout
+      http.open_timeout = http_open_timeout
+
+      if secure?
+        http.use_ssl     = true
+
+        http.ca_file      = Batbugger.configuration.ca_bundle_path
+        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.use_ssl     = false
+      end
+
+      http
+    rescue => e
+      log(:error, "[Batbugger::Sender#setup_http_connection] Failure initializing the HTTP connection.\nError: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+      raise e
+    end
+  end
+end

data/lib/batbugger/version.rb

@@ -1,3 +1,3 @@
 module Batbugger
-  VERSION = "0.0.1"
+  VERSION = "1.2.0"
 end

data/lib/batbugger.rb

@@ -1,14 +1,129 @@
-require "batbugger/version"
-require "honeybadger"
+require 'net/http'
+require 'net/https'
+require 'json'
+require 'logger'
+
+require 'batbugger/configuration'
+require 'batbugger/backtrace'
+require 'batbugger/notice'
+require 'batbugger/rack'
+require 'batbugger/sender'
+
+require 'batbugger/railtie' if defined?(Rails::Railtie)
 
 module Batbugger
-  def self.configure(options)
-    Honeybadger.configure do |config|
-     config.api_key = options[:api_key]
-     config.secure  = false
-     config.environment_name = options[:environment_name]
-     config.host = "batbugger.herokuapp.com"
+  VERSION = '1.6.0'
+  LOG_PREFIX = "** [Batbugger] "
+
+  HEADERS = {
+    'Content-type'             => 'application/json',
+    'Accept'                   => 'text/json, application/json'
+  }
+
+  class << self
+    attr_accessor :sender
+    attr_writer :configuration
+
+    def report_ready
+      write_verbose_log("Notifier #{VERSION} ready to catch errors", :info)
+    end
+
+    def report_environment_info
+      write_verbose_log("Environment Info: #{environment_info}")
+    end
+
+    def report_response_body(response)
+      write_verbose_log("Response from Batbugger: \n#{response}")
+    end
+
+    def environment_info
+      info = "[Ruby: #{RUBY_VERSION}]"
+      info << " [#{configuration.framework}]" if configuration.framework
+      info << " [Env: #{configuration.environment_name}]" if configuration.environment_name
+    end
+
+    def write_verbose_log(message, level = Batbugger.configuration.debug ? :info : :debug)
+      logger.send(level, LOG_PREFIX + message) if logger
+    end
+
+    def logger
+      self.configuration.logger
+    end
+
+    def configure(silent = false)
+      yield(configuration)
+      self.sender = Sender.new(configuration)
+      report_ready unless silent
+      self.sender
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def notify(exception, options = {})
+      send_notice(build_notice_for(exception, options))
+    end
+
+    def notify_or_ignore(exception, opts = {})
+      notice = build_notice_for(exception, opts)
+      send_notice(notice) unless notice.ignore?
+    end
+
+    def build_lookup_hash_for(exception, options = {})
+      notice = build_notice_for(exception, options)
+
+      result = {}
+      result[:action]           = notice.action      rescue nil
+      result[:component]        = notice.component   rescue nil
+      result[:error_class]      = notice.error_class if notice.error_class
+      result[:environment_name] = 'production'
+
+      unless notice.backtrace.lines.empty?
+        result[:file]        = notice.backtrace.lines[0].file
+        result[:line_number] = notice.backtrace.lines[0].number
+      end
+
+      result
+    end
+
+    def context(hash = {})
+      Thread.current[:batbugger_context] ||= {}
+      Thread.current[:batbugger_context].merge!(hash)
+      self
+    end
+
+    def clear!
+      Thread.current[:batbugger_context] = nil
+    end
+
+    private
+
+    def send_notice(notice)
+      if configuration.public?
+        if configuration.async?
+          configuration.async.call(notice)
+        else
+          notice.deliver
+        end
+      end
+    end
+
+    def build_notice_for(exception, opts = {})
+      exception = unwrap_exception(exception)
+      opts = opts.merge(:exception => exception) if exception.is_a?(Exception)
+      opts = opts.merge(exception.to_hash) if exception.respond_to?(:to_hash)
+      Notice.new(configuration.merge(opts))
+    end
+
+    def unwrap_exception(exception)
+      if exception.respond_to?(:original_exception)
+        exception.original_exception
+      elsif exception.respond_to?(:continued_exception)
+        exception.continued_exception
+      else
+        exception
+      end
     end
   end
 end
-

metadata

@@ -2,7 +2,7 @@
 name: batbugger
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 1.2.0
 platform: ruby
 authors: 
 - Kumar
@@ -10,29 +10,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-03-13 00:00:00 Z
+date: 2013-09-11 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: honeybadger
+  name: bundler
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.6.0
-  type: :runtime
+        version: "1.3"
+  type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: json
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: "1.3"
-  type: :development
+        version: "0"
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -63,6 +63,14 @@ files:
 - Rakefile
 - batbugger.gemspec
 - lib/batbugger.rb
+- lib/batbugger/backtrace.rb
+- lib/batbugger/configuration.rb
+- lib/batbugger/notice.rb
+- lib/batbugger/rack.rb
+- lib/batbugger/rails/controller_methods.rb
+- lib/batbugger/rails/middleware/exceptions_catcher.rb
+- lib/batbugger/railtie.rb
+- lib/batbugger/sender.rb
 - lib/batbugger/version.rb
 homepage: ""
 licenses: