honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/agent.rb

@@ -0,0 +1,136 @@
+require 'forwardable'
+
+require 'honeybadger/version'
+require 'honeybadger/config'
+require 'honeybadger/worker'
+require 'honeybadger/notice'
+require 'honeybadger/plugin'
+require 'honeybadger/logging'
+
+module Honeybadger
+  # Internal: A broker for the configuration and the worker.
+  class Agent
+    extend Forwardable
+
+    include Logging::Helper
+
+    class << self
+      extend Forwardable
+
+      def_delegators :callbacks, :exception_filter, :exception_fingerprint, :backtrace_filter
+
+      def callbacks
+        @callbacks ||= Config::Callbacks.new
+      end
+    end
+
+    private
+
+    def self.load_plugins(config)
+      Dir[File.expand_path('../plugins/*.rb', __FILE__)].each do |plugin|
+        require plugin
+      end
+      Plugin.load!(config)
+    end
+
+    public
+
+    def self.instance
+      @instance
+    end
+
+    def self.running?
+      !instance.nil?
+    end
+
+    def self.start(config = {})
+      return true if running?
+
+      unless config.kind_of?(Config)
+        config = Config.new(config)
+      end
+
+      if !config[:enabled]
+        config.logger.info('Unable to start Honeybadger -- disabled by configuration.')
+        return false
+      elsif !config.valid?
+        config.logger.warn('Unable to start Honeybadger -- invalid configuration.')
+        return false
+      elsif !config.ping
+        config.logger.warn('Unable to start Honeybadger -- failed to connect to server.')
+        return false
+      end
+
+      config.logger.info("Starting Honeybadger version #{VERSION}")
+      load_plugins(config)
+      @instance = new(config)
+      @instance.start
+    end
+
+    def self.stop(*args)
+      @instance.stop(*args) if @instance
+      @instance = nil
+    end
+
+    def self.fork(*args)
+      self.instance ? self.instance.fork(*args) : false
+    end
+
+    def self.trace(*args)
+      self.instance ? self.instance.trace(*args) : false
+    end
+
+    def self.timing(*args)
+      self.instance ? self.instance.timing(*args) : false
+    end
+
+    def self.increment(*args)
+      self.instance ? self.instance.increment(*args) : false
+    end
+
+    # Internal: Callback to perform after agent has been stopped at_exit.
+    #
+    # block - An optional block to execute.
+    #
+    # Returns Proc callback.
+    def self.at_exit(&block)
+      @at_exit = Proc.new if block_given?
+      @at_exit
+    end
+
+    def initialize(config)
+      @config = config
+      @worker = Worker.new(config)
+
+      at_exit do
+        stop
+        self.class.at_exit.call if self.class.at_exit
+      end
+    end
+
+    def_delegators :@worker, :start, :fork, :trace, :timing, :increment
+
+    def stop(force = false)
+      info("Shutting down Honeybadger version #{VERSION}")
+      worker.stop(force)
+    end
+
+    def notice(opts)
+      opts.merge!(callbacks: self.class.callbacks)
+      notice = Notice.new(config, opts)
+
+      if notice.ignore?
+        debug { sprintf('ignore notice feature=notices id=%s', notice.id) }
+        false
+      else
+        debug { sprintf('notice feature=notices id=%s', notice.id) }
+        worker.notice(notice)
+        notice.id
+      end
+    end
+
+    private
+
+    attr_reader :worker, :config
+  end
+end

data/lib/honeybadger/backend.rb

@@ -0,0 +1,26 @@
+require 'forwardable'
+
+module Honeybadger
+  module Backend
+    class BackendError < StandardError; end
+
+    def self.mapping
+      @@mapping ||= {
+        server: Server,
+        test: Test,
+        null: Null,
+        debug: Debug
+      }.freeze
+    end
+
+    def self.for(backend)
+      mapping[backend] or raise(BackendError, "Unable to locate backend: #{backend}")
+    end
+
+    autoload :Base, 'honeybadger/backend/base'
+    autoload :Server, 'honeybadger/backend/server'
+    autoload :Test, 'honeybadger/backend/test'
+    autoload :Null, 'honeybadger/backend/null'
+    autoload :Debug, 'honeybadger/backend/debug'
+  end
+end

data/lib/honeybadger/backend/base.rb

@@ -0,0 +1,66 @@
+require 'forwardable'
+require 'net/http'
+
+require 'honeybadger/logging'
+
+module Honeybadger
+  module Backend
+    class Response
+      attr_reader :code, :body, :message
+
+      # Public: Initializes the Response instance.
+      #
+      # response - With 1 argument Net::HTTPResponse, the code, body, and
+      #            message will be determined automatically. (optional)
+      # code      - The Integer status code. May also be :error for requests which
+      #             failed to reach the server.
+      # body      - The String body of the response.
+      # message   - The String message returned by the server (or set by the
+      #             backend in the case of an :error code).
+      #
+      # Returns nothing
+      def initialize(*args)
+        if (response = args.first).kind_of?(Net::HTTPResponse)
+          @code, @body, @message = response.code.to_i, response.body.to_s, response.message
+        else
+          @code, @body, @message = args
+        end
+
+        @success = (200..299).cover?(@code)
+      end
+
+      def success?
+        @success
+      end
+    end
+
+    class Base
+      extend Forwardable
+
+      include Honeybadger::Logging::Helper
+
+      def initialize(config)
+        @config = config
+      end
+
+      # Internal: Process payload for feature.
+      #
+      # feature - A Symbol feature name (corresponds to HTTP endpoint). Current
+      #           options are: :notices, :metrics, :traces.
+      # payload - Any Object responding to #to_json.
+      #
+      # Examples:
+      #
+      #   backend.notify(:notices, Notice.new(...))
+      #
+      # Raises NotImplementedError
+      def notify(feature, payload)
+        raise NotImplementedError, 'must define #notify on subclass.'
+      end
+
+      private
+
+      attr_reader :config
+    end
+  end
+end

data/lib/honeybadger/backend/debug.rb

@@ -0,0 +1,12 @@
+require 'honeybadger/backend/null'
+
+module Honeybadger
+  module Backend
+    class Debug < Null
+      def notify(feature, payload)
+        logger.debug("notifying debug backend of feature=#{feature}\n\t#{payload.to_json}")
+        super
+      end
+    end
+  end
+end

data/lib/honeybadger/backend/null.rb

@@ -0,0 +1,16 @@
+require 'honeybadger/backend/base'
+
+module Honeybadger
+  module Backend
+    class Null < Base
+      def initialize(*args)
+        super
+        logger.warn('Initializing development backend: data will not be reported.')
+      end
+
+      def notify(feature, payload)
+        Response.new(201, '{}')
+      end
+    end
+  end
+end

data/lib/honeybadger/backend/server.rb

@@ -0,0 +1,51 @@
+require 'net/http'
+require 'json'
+require 'zlib'
+require 'openssl'
+
+require 'honeybadger/backend/base'
+require 'honeybadger/util/http'
+
+module Honeybadger
+  module Backend
+    class Server < Base
+      ENDPOINTS = {
+        ping: '/v1/ping'.freeze,
+        notices: '/v1/notices'.freeze,
+        metrics: '/v1/metrics'.freeze,
+        traces: '/v1/traces'.freeze,
+        deploys: '/v1/deploys'.freeze
+      }.freeze
+
+      HTTP_ERRORS = [Timeout::Error,
+                     Errno::EINVAL,
+                     Errno::ECONNRESET,
+                     EOFError,
+                     Net::HTTPBadResponse,
+                     Net::HTTPHeaderSyntaxError,
+                     Net::ProtocolError,
+                     Errno::ECONNREFUSED,
+                     SocketError].freeze
+
+      def initialize(config)
+        @http = Util::HTTP.new(config)
+        super
+      end
+
+      # Internal: Post payload to endpoint for feature.
+      #
+      # feature - The feature which is being notified.
+      # payload - The payload to send, responding to `#to_json`.
+      #
+      # Returns Response.
+      def notify(feature, payload)
+        ENDPOINTS[feature] or raise(BackendError, "Unknown feature: #{feature}")
+        Response.new(@http.post(ENDPOINTS[feature], payload))
+      rescue *HTTP_ERRORS => e
+        Response.new(:error, nil, "HTTP Error: #{e.class}").tap do |response|
+          error { sprintf('http error class=%s message=%s', e.class, e.message.dump) }
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/backend/test.rb

@@ -0,0 +1,24 @@
+require 'honeybadger/backend/null'
+
+module Honeybadger
+  module Backend
+    class Test < Null
+      # Public: The notification list.
+      #
+      # Examples:
+      #
+      #   backend.notifications[:notices] # => [Notice, Notice, ...]
+      #
+      # Returns the Hash notifications.
+      def notifications
+        @notifications ||= Hash.new([])
+      end
+
+      def notify(feature, payload)
+        notifications[feature] = [] unless notifications.include?(feature)
+        notifications[feature] << payload
+        super
+      end
+    end
+  end
+end

data/lib/honeybadger/backtrace.rb

@@ -1,33 +1,38 @@
+require 'json'
+
 module Honeybadger
-  # Public: Front end to parsing the backtrace for each notice
+  # Internal: Front end to parsing the backtrace for each notice
   class Backtrace
-
-    # Public: Handles backtrace parsing line by line
+    # Internal: Handles backtrace parsing line by line
     class Line
-      # regexp (optionally allowing leading X: for windows support)
+      # Backtrace line regexp (optionally allowing leading X: for windows support)
       INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
 
-      # Public: The file portion of the line (such as app/models/user.rb)
+      # The file portion of the line (such as app/models/user.rb)
       attr_reader :file
 
-      # Public: The line number portion of the line
+      # The line number portion of the line
       attr_reader :number
 
-      # Public: The method of the line (such as index)
+      # The method of the line (such as index)
       attr_reader :method
 
-      # Public: Filtered representations
+      # Filtered representations
       attr_reader :filtered_file, :filtered_number, :filtered_method
 
-      # Public: Parses a single line of a given backtrace
+      # Parses a single line of a given backtrace
       #
       # unparsed_line - The raw line from +caller+ or some backtrace
       #
       # Returns the parsed backtrace line
       def self.parse(unparsed_line, opts = {})
         filters = opts[:filters] || []
-        filtered_line = filters.inject(unparsed_line) do |line, proc|
-          proc.call(line)
+        filtered_line = filters.reduce(unparsed_line) do |line, proc|
+          if proc.arity == 2
+            proc.call(line, opts[:config])
+          else
+            proc.call(line)
+          end
         end
 
         if filtered_line
@@ -49,7 +54,7 @@ module Honeybadger
         self.method          = method
       end
 
-      # Public: Reconstructs the line in a readable fashion
+      # Reconstructs the line in a readable fashion.
       def to_s
         "#{filtered_file}:#{filtered_number}:in `#{filtered_method}'"
       end
@@ -62,13 +67,13 @@ module Honeybadger
         "<Line:#{to_s}>"
       end
 
-      # Public: Determines if this line is part of the application trace or not
+      # Determines if this line is part of the application trace or not.
       def application?
         (filtered_file =~ /^\[PROJECT_ROOT\]/i) && !(filtered_file =~ /^\[PROJECT_ROOT\]\/vendor/i)
       end
 
-      # Public: An excerpt from the source file, lazily loaded to preserve
-      # performance
+      # An excerpt from the source file, lazily loaded to preserve
+      # performance.
       def source(radius = 2)
         @source ||= get_source(file, number, radius)
       end
@@ -77,9 +82,9 @@ module Honeybadger
 
       attr_writer :file, :number, :method, :filtered_file, :filtered_number, :filtered_method
 
-      # Private: Open source file and read line(s)
+      # Open source file and read line(s).
       #
-      # Returns an array of line(s) from source file
+      # Returns an array of line(s) from source file.
       def get_source(file, number, radius = 2)
         if file && File.exists?(file)
           before = after = radius
@@ -98,7 +103,7 @@ module Honeybadger
       end
     end
 
-    # Public: holder for an Array of Backtrace::Line instances
+    # Holder for an Array of Backtrace::Line instances.
     attr_reader :lines, :application_lines
 
     def self.parse(ruby_backtrace, opts = {})
@@ -116,24 +121,24 @@ module Honeybadger
       self.application_lines = lines.select(&:application?)
     end
 
-    # Public
+    # Convert Backtrace to arry.
     #
-    # Returns array containing backtrace lines
+    # Returns array containing backtrace lines.
     def to_ary
       lines.map { |l| { :number => l.filtered_number, :file => l.filtered_file, :method => l.filtered_method } }
     end
     alias :to_a :to_ary
 
-    # Public: JSON support
+    # JSON support.
     #
-    # Returns JSON representation of backtrace
+    # Returns JSON representation of backtrace.
     def as_json(options = {})
       to_ary
     end
 
-    # Public: Creates JSON
+    # Creates JSON.
     #
-    # Returns valid JSON representation of backtrace
+    # Returns valid JSON representation of backtrace.
     def to_json(*a)
       as_json.to_json(*a)
     end