honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/rack/metrics_reporter.rb

@@ -0,0 +1,41 @@
+require 'honeybadger'
+
+module Honeybadger
+  module Rack
+    class MetricsReporter
+      GC_TIME_METRIC = 'app.gc.time'.freeze
+      GC_COLLECTIONS_METRIC = 'app.gc.collections'.freeze
+
+      def initialize(app, config)
+        @app = app
+        @config = config
+      end
+
+      def call(env)
+        start = Time.now
+        track_gc? and GC::Profiler.clear
+        status, headers, body = app.call(env)
+        duration = (Time.now - start) * 1000
+        report_metrics(status, duration)
+        [status, headers, body]
+      end
+
+      private
+
+      attr_reader :app, :config
+
+      def track_gc?
+        config[:'metrics.gc_profiler']
+      end
+
+      def report_metrics(status, duration)
+        Agent.timing("app.request.#{status}", duration)
+
+        if track_gc? && GC::Profiler.total_time > 0
+          Agent.timing(GC_TIME_METRIC, GC::Profiler.total_time * 1000)
+          Agent.increment(GC_COLLECTIONS_METRIC, GC::Profiler.result[/\d+/].to_i)
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/rack/request_hash.rb

@@ -0,0 +1,50 @@
+require 'rack/request'
+
+module Honeybadger
+  module Rack
+    # Internal: Constructs a request hash from a Rack::Request matching the
+    # /v1/notices API specification.
+    class RequestHash < ::Hash
+      def initialize(request)
+        unless request.kind_of?(::Rack::Request)
+          raise ArgumentError, "Expected Rack::Request, got #{request.class.name}"
+        end
+
+        self[:url] = extract_url(request)
+        self[:params] = extract_params(request)
+        self[:component] = self[:params]['controller']
+        self[:action] = self[:params]['action']
+        self[:session] = extract_session(request)
+        self[:cgi_data] = extract_cgi_data(request)
+      end
+
+      private
+
+      def extract_url(request)
+        request.url
+      rescue => e
+        # TODO: Log these errors
+        "Error: #{e.message}"
+      end
+
+      def extract_params(request)
+        (request.env['action_dispatch.request.parameters'] || request.params).to_hash || {}
+      rescue => e
+        { error: "Failed to access params -- #{e.message}" }
+      end
+
+      def extract_session(request)
+        request.session.to_hash
+      rescue => e
+        # Rails raises ArgumentError when `config.secret_token` is missing, and
+        # ActionDispatch::Session::SessionRestoreError when the session can't be
+        # restored.
+        { error: "Failed to access session data -- #{e.message}" }
+      end
+
+      def extract_cgi_data(request)
+        request.env.reject {|k,_| k == 'QUERY_STRING' || !k.match(/\A[A-Z_]+\Z/) }
+      end
+    end
+  end
+end

data/lib/honeybadger/rack/user_feedback.rb

@@ -1,5 +1,7 @@
 require 'erb'
 require 'uri'
+require 'forwardable'
+require 'rack'
 
 begin
   require 'i18n'
@@ -16,8 +18,11 @@ end
 module Honeybadger
   module Rack
     class UserFeedback
-      def initialize(app)
+      extend Forwardable
+
+      def initialize(app, config)
         @app = app
+        @config = config
       end
 
       def call(env)
@@ -34,28 +39,23 @@ module Honeybadger
         [status, headers, body]
       end
 
-      def config
-        Honeybadger.configuration
-      end
-
       def enabled?
-        config.feedback && config.features['feedback']
+        config[:'feedback.enabled']
       end
 
       def action
-        URI.parse("#{config.protocol}://#{config.host}:#{config.port}/v1/feedback/").to_s
+        URI.parse("#{config.connection_protocol}://#{config[:'connection.host']}:#{config.connection_port}/v1/feedback/").to_s
       rescue URI::InvalidURIError
         nil
       end
 
-      def render_form(error_id, action = action())
+      def render_form(error_id, action = action)
         return unless action
         ERB.new(@template ||= File.read(template_file)).result(binding)
       end
 
       def custom_template_file
-        @custom_template_file ||= config.project_root &&
-          File.join(config.project_root, 'lib', 'honeybadger', 'templates', 'feedback_form.erb')
+        @custom_template_file ||= File.join(config[:root], 'lib', 'honeybadger', 'templates', 'feedback_form.erb')
       end
 
       def custom_template_file?
@@ -69,6 +69,11 @@ module Honeybadger
           File.expand_path('../../templates/feedback_form.erb', __FILE__)
         end
       end
+
+      private
+
+      attr_reader :config
+      def_delegator :@config, :logger
     end
   end
 end

data/lib/honeybadger/rack/user_informer.rb

@@ -1,17 +1,23 @@
+require 'rack'
+require 'forwardable'
+
 module Honeybadger
   module Rack
     class UserInformer
-      def initialize(app)
+      extend Forwardable
+
+      def initialize(app, config)
         @app = app
+        @config = config
       end
 
       def replacement(with)
-        Honeybadger.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
+        config[:'user_informer.info'].gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
       end
 
       def call(env)
         status, headers, body = @app.call(env)
-        if env['honeybadger.error_id'] && Honeybadger.configuration.user_information
+        if env['honeybadger.error_id'] && config[:'user_informer.enabled']
           new_body = []
           replace  = replacement(env['honeybadger.error_id'])
           body.each do |chunk|
@@ -23,6 +29,11 @@ module Honeybadger
         end
         [status, headers, body]
       end
+
+      private
+
+      attr_reader :config
+      def_delegator :@config, :logger
     end
   end
 end

data/lib/honeybadger/trace.rb

@@ -0,0 +1,185 @@
+require 'securerandom'
+
+require 'honeybadger/agent'
+
+module Honeybadger
+  class Trace
+    attr_reader :id, :duration, :key
+
+    def self.current
+      Thread.current[:__hb_trace]
+    end
+
+    def self.create(id)
+      Thread.current[:__hb_trace] = new(id)
+    end
+
+    def self.instrument(key, payload = {}, &block)
+      new(SecureRandom.uuid).instrument(key, payload, &block)
+    end
+
+    def initialize(id)
+      @id = id
+      @events = []
+      @meta = {}
+      @fast_queries = {}
+      @duration = 0
+    end
+
+    def add(event)
+      ce = clean_event(event)
+      @events << ce.to_a if ce.render?
+    end
+
+    def add_query(event)
+      if event.duration < 6
+        ce = clean_event(event)
+        return unless ce.render?
+        query = ce.to_s
+        if @fast_queries[query]
+          @fast_queries[query][:duration] += ce.event.duration
+          @fast_queries[query][:count] += 1
+        else
+          @fast_queries[query] = { :duration => ce.event.duration, :count => 1 }
+        end
+      else
+        add(event)
+      end
+    end
+
+    def complete(event)
+      @meta = clean_event(event).to_h
+      @duration = event.duration
+      @key = "#{event.payload[:controller]}##{event.payload[:action]}"
+      Thread.current[:__hb_trace] = nil
+      Agent.trace(self)
+    end
+
+    def instrument(key, payload)
+      @key = key
+      @meta = payload
+      started = Time.now
+      yield
+    rescue Exception => e
+      @meta[:exception] = [e.class.name, e.message]
+      raise e
+    ensure
+      @meta.merge!(:duration => @duration = 1000.0 * (Time.now - started))
+      Agent.trace(self)
+    end
+
+    def to_h
+      @meta.merge({ :events => @events, :key => @key, :fast_queries => @fast_queries.map {|k,v| [ k, v[:duration], v[:count] ] } })
+    end
+
+    protected
+
+    def clean_event(event)
+      TraceCleaner.create(event)
+    end
+
+  end
+
+  module TraceCleaner
+
+    def self.create(event)
+      Classes[event.name].new(event)
+    end
+
+    class Base
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def render?
+        true
+      end
+
+      def payload
+        event.payload
+      end
+
+      def to_s
+        payload[:path] || payload[:key] || payload.inspect
+      end
+
+      def to_h
+        { :name => event.name, :desc => to_s, :duration => event.duration }
+      end
+
+      def to_a
+        [ event.name, event.duration, to_s ]
+      end
+
+    end
+
+    class NetHttpRequest < Base
+      Replacement = "..."
+      def to_s
+        uri = payload[:uri]
+        uri.user = Replacement if uri.user
+        uri.password = Replacement if uri.password
+        uri.query = Replacement if uri.query
+        "#{payload[:method]} #{uri}"
+      end
+    end
+
+    class ActiveRecord < Base
+      Schema = "SCHEMA".freeze
+      SchemaMigrations = /schema_migrations/.freeze
+      EscapedQuotes = /(\\"|\\')/.freeze
+      SQuotedData = /'(?:[^']|'')*'/.freeze
+      DQuotedData = /"(?:[^"]|"")*"/.freeze
+      NumericData = /\b\d+\b/.freeze
+      Newline = /\n/.freeze
+      Replacement = "?".freeze
+      EmptyReplacement = "".freeze
+      DoubleQuoters = /(postgres|sqlite|postgis)/.freeze
+
+      def render?
+        event.payload[:name] != Schema && !event.payload[:sql].match(SchemaMigrations)
+      end
+
+      def to_s
+        return "Super long query" if event.payload[:sql].length > 1024
+        sql = event.payload[:sql]
+        sql = sql.gsub(EscapedQuotes, EmptyReplacement).gsub(SQuotedData, Replacement)
+        sql = sql.gsub(DQuotedData, Replacement) unless ::ActiveRecord::Base.connection_pool.spec.config[:adapter] =~ DoubleQuoters
+        sql.gsub(NumericData, Replacement).gsub(Newline, EmptyReplacement).squeeze(' ')
+      end
+    end
+
+    class ActionView < Base
+      EmptyReplacement = "".freeze
+
+      def to_s
+        event.payload[:identifier].to_s.gsub(::Rails.root.to_s + '/', EmptyReplacement)
+      end
+    end
+
+    class ActionController < Base
+      def payload
+        event.payload.reject {|k, v| k == :params }
+      end
+
+      def to_s
+        payload.inspect
+      end
+
+      def to_h
+        payload.merge({ :duration => event.duration })
+      end
+    end
+
+    Classes = Hash.new(Base).merge({
+      'sql.active_record' => ActiveRecord,
+      'render_template.action_view' => ActionView,
+      'render_partial.action_view' => ActionView,
+      'render_collection.action_view' => ActionView,
+      'process_action.action_controller' => ActionController,
+      'net_http.request' => NetHttpRequest
+    })
+  end
+end

data/lib/honeybadger/util/http.rb

@@ -0,0 +1,79 @@
+require 'forwardable'
+require 'net/http'
+require 'json'
+require 'zlib'
+require 'openssl'
+
+require 'honeybadger/version'
+require 'honeybadger/logging'
+
+module Honeybadger
+  module Util
+    class HTTP
+      extend Forwardable
+
+      include Honeybadger::Logging::Helper
+
+      HEADERS = {
+        'Content-type'.freeze => 'application/json'.freeze,
+        'Content-Encoding'.freeze => 'deflate'.freeze,
+        'Accept'.freeze => 'text/json, application/json'.freeze,
+        'User-Agent'.freeze => "HB-Ruby #{VERSION}; #{RUBY_VERSION}; #{RUBY_PLATFORM}".freeze
+      }.freeze
+
+      def initialize(config)
+        @config = config
+      end
+
+      def post(endpoint, payload, headers = {})
+        response = http_connection.post(endpoint, compress(payload.to_json), http_headers(headers))
+        debug { sprintf("http method=POST path=%s code=%d", endpoint.dump, response.code) }
+        response
+      end
+
+      private
+
+      attr_reader :config
+
+      def http_connection
+        setup_http_connection
+      end
+
+      def http_headers(headers = nil)
+        {}.tap do |hash|
+          hash.merge!(HEADERS)
+          hash.merge!({'X-API-Key' => config[:api_key]})
+          hash.merge!(headers) if headers
+        end
+      end
+
+      def setup_http_connection
+        http_class = Net::HTTP::Proxy(config[:'connection.proxy_host'], config[:'connection.proxy_port'], config[:'connection.proxy_user'], config[:'connection.proxy_pass'])
+        http = http_class.new(config[:'connection.host'], config.connection_port)
+
+        http.read_timeout = config[:'connection.http_read_timeout']
+        http.open_timeout = config[:'connection.http_open_timeout']
+
+        if config[:'connection.secure']
+          http.use_ssl = true
+
+          http.ca_file = config.ca_bundle_path
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        else
+          http.use_ssl = false
+        end
+
+        http
+      rescue => e
+        error do
+          sprintf('http error class=%s message=%s location=%s', e.class, e.message.dump, e.backtrace.first.dump)
+        end
+        raise e
+      end
+
+      def compress(string, level = Zlib::DEFAULT_COMPRESSION)
+        Zlib::Deflate.deflate(string, level)
+      end
+    end
+  end
+end