honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/dependency.rb

@@ -1,65 +0,0 @@
-module Honeybadger
-  class Dependency
-    class << self
-      @@instances = []
-
-      def instances
-        @@instances
-      end
-
-      def register
-        instances << new.tap { |d| d.instance_eval(&Proc.new) }
-      end
-
-      def inject!
-        instances.each do |dependency|
-          dependency.inject! if dependency.ok?
-        end
-      end
-
-      def reset!
-        instances.each(&:reset!)
-      end
-    end
-
-    def initialize
-      @injected     = false
-      @requirements = []
-      @injections   = []
-    end
-
-    def requirement
-      @requirements << Proc.new
-    end
-
-    def injection
-      @injections << Proc.new
-    end
-
-    def ok?
-      !@injected && @requirements.all?(&:call)
-    rescue => e
-      Honeybadger.write_verbose_log("Exception caught while verifying dependency: #{e.class} -- #{e.message}", :error)
-      false
-    end
-
-    def inject!
-      @injections.each(&:call)
-    rescue => e
-      Honeybadger.write_verbose_log("Exception caught while injecting dependency: #{e.class} -- #{e.message}", :error)
-      false
-    ensure
-      @injected = true
-    end
-
-    def reset!
-      @injected = false
-    end
-
-    def injected?
-      @injected
-    end
-
-    attr_reader :requirements, :injections
-  end
-end

data/lib/honeybadger/integrations.rb

@@ -1,9 +0,0 @@
-module Honeybadger::Integrations; end
-
-require 'honeybadger/integrations/delayed_job'
-require 'honeybadger/integrations/sidekiq'
-require 'honeybadger/integrations/thor'
-require 'honeybadger/integrations/net_http'
-require 'honeybadger/integrations/passenger'
-require 'honeybadger/integrations/unicorn'
-require 'honeybadger/integrations/local_variables'

data/lib/honeybadger/integrations/delayed_job.rb

@@ -1,20 +0,0 @@
-module Honeybadger
-  Dependency.register do
-    requirement { defined?(::Delayed::Plugin) }
-    requirement { defined?(::Delayed::Worker.plugins) }
-    requirement do
-      if delayed_job_honeybadger = defined?(::Delayed::Plugins::Honeybadger)
-        Honeybadger.write_verbose_log("Support for Delayed Job has been moved " \
-                                      "to the honeybadger gem. Please remove " \
-                                      "delayed_job_honeybadger from your " \
-                                      "Gemfile.", :warn)
-      end
-      !delayed_job_honeybadger
-    end
-
-    injection do
-      require 'honeybadger/integrations/delayed_job/plugin'
-      ::Delayed::Worker.plugins << Integrations::DelayedJob::Plugin
-    end
-  end
-end

data/lib/honeybadger/integrations/passenger.rb

@@ -1,18 +0,0 @@
-module Honeybadger
-  Dependency.register do
-    requirement { defined?(::PhusionPassenger) }
-    requirement { defined?(::Honeybadger::Monitor) }
-
-    injection do
-      ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
-        Honeybadger.write_verbose_log('Starting passenger worker process')
-        Honeybadger::Monitor.worker.fork if forked
-      end
-
-      ::PhusionPassenger.on_event(:stopping_worker_process) do
-        Honeybadger.write_verbose_log('Stopping passenger worker process')
-        Honeybadger::Monitor.worker.stop
-      end
-    end
-  end
-end

data/lib/honeybadger/integrations/sidekiq.rb

@@ -1,37 +0,0 @@
-module Honeybadger
-  module Integrations
-    module Sidekiq
-      class Middleware
-        def call(worker, msg, queue)
-          Honeybadger.context.clear!
-          Honeybadger::Monitor::Trace.instrument("#{msg['class']}#perform", { :source => 'sidekiq', :jid => msg['jid'], :class => msg['class'] }) do
-            yield
-          end
-        end
-      end
-    end
-  end
-
-  Dependency.register do
-    requirement { defined?(::Sidekiq) }
-    requirement { defined?(::Honeybadger::Monitor) }
-
-    injection do
-      ::Sidekiq.configure_server do |config|
-        config.server_middleware do |chain|
-          chain.add Integrations::Sidekiq::Middleware
-        end
-      end
-    end
-  end
-
-  Dependency.register do
-    requirement { defined?(::Sidekiq::VERSION) && ::Sidekiq::VERSION > '3' }
-
-    injection do
-      ::Sidekiq.configure_server do |config|
-        config.error_handlers << Proc.new {|ex,context| Honeybadger.notify_or_ignore(ex, :parameters => context) }
-      end
-    end
-  end
-end

data/lib/honeybadger/monitor.rb

@@ -1,17 +0,0 @@
-require "honeybadger/array"
-require "honeybadger/monitor/sender"
-require "honeybadger/monitor/worker"
-require "honeybadger/monitor/trace"
-require "honeybadger/monitor/railtie" if defined?(Rails::Railtie)
-
-module Honeybadger
-  module Monitor
-    class << self
-
-      def worker
-        Worker.instance
-      end
-
-    end
-  end
-end

data/lib/honeybadger/monitor/railtie.rb

@@ -1,53 +0,0 @@
-module Honeybadger
-  module Monitor
-    class Railtie < ::Rails::Railtie
-
-      config.after_initialize do
-        if Honeybadger.configuration.traces?
-          ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |name, started, finished, id, data|
-            Trace.create(id)
-          end
-
-          ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
-            event = ActiveSupport::Notifications::Event.new(*args)
-            Monitor.worker.trace.add_query(event) if Monitor.worker.trace and event.name != 'SCHEMA'
-          end
-
-          ActiveSupport::Notifications.subscribe(/^render_(template|action|collection)\.action_view/) do |*args|
-            event = ActiveSupport::Notifications::Event.new(*args)
-            Monitor.worker.trace.add(event) if Monitor.worker.trace
-          end
-
-          ActiveSupport::Notifications.subscribe('net_http.request') do |*args|
-            event = ActiveSupport::Notifications::Event.new(*args)
-            Monitor.worker.trace.add(event) if Monitor.worker.trace
-          end
-
-          ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
-            event = ActiveSupport::Notifications::Event.new(*args)
-            if event.payload[:controller] && event.payload[:action] && Monitor.worker.trace
-              Monitor.worker.trace.complete(event)
-            end
-          end
-        end
-
-        if Honeybadger.configuration.metrics?
-          ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
-            event = ActiveSupport::Notifications::Event.new(*args)
-            status = event.payload[:exception] ? 500 : event.payload[:status]
-            Monitor.worker.timing("app.request.#{status}", event.duration)
-
-            controller = event.payload[:controller]
-            action = event.payload[:action]
-            if controller && action
-              Monitor.worker.timing("app.controller.#{controller}.#{action}.total", event.duration)
-              Monitor.worker.timing("app.controller.#{controller}.#{action}.view", event.payload[:view_runtime]) if event.payload[:view_runtime]
-              Monitor.worker.timing("app.controller.#{controller}.#{action}.db", event.payload[:db_runtime]) if event.payload[:db_runtime]
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/honeybadger/monitor/sender.rb

@@ -1,44 +0,0 @@
-module Honeybadger
-  module Monitor
-    class Sender < Honeybadger::Sender
-      def send_metrics(data)
-        return unless Honeybadger.configuration.metrics?
-        return unless Honeybadger.configuration.features['metrics']
-
-        response = send_request('/v1/metrics', data.to_json)
-
-        if Net::HTTPSuccess === response
-          log(:info, "Metrics Success: #{response.class}", response) if Honeybadger.configuration.debug
-          true
-        else
-          Honeybadger.configuration.features['metrics'] = false if Net::HTTPForbidden === response
-          log(:error, "Metrics Failure: #{response.class}", response, data)
-          false
-        end
-      rescue => e
-        log(:error, "[Honeybadger::Monitor::Sender#send_metrics] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-        true
-      end
-
-      def send_traces(data)
-        return unless Honeybadger.configuration.traces?
-        return unless Honeybadger.configuration.features['traces']
-
-        response = send_request('/v1/traces', data.to_json)
-
-        if Net::HTTPSuccess === response
-          log(:info, "Traces Success: #{response.class}", response) if Honeybadger.configuration.debug
-          true
-        else
-          Honeybadger.configuration.features['traces'] = false if Net::HTTPForbidden === response
-          log(:error, "Traces Failure: #{response.class}", response, data)
-          false
-        end
-      rescue => e
-        log(:error, "[Honeybadger::Monitor::Sender#send_traces] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-        true
-      end
-
-    end
-  end
-end

data/lib/honeybadger/monitor/trace.rb

@@ -1,187 +0,0 @@
-require 'securerandom'
-
-module Honeybadger
-  module Monitor
-    class Trace
-      UUIDS_ENABLED = SecureRandom.respond_to?(:uuid).freeze
-
-      attr_reader :id, :duration, :key
-
-      def self.create(id)
-        Thread.current[:hb_trace_id] = id
-        Monitor.worker.pending_traces[id] = new(id)
-      end
-
-      def self.instrument(key, payload = {}, &block)
-        create(generate_secure_id).instrument(key, payload, &block)
-      end
-
-      def self.generate_secure_id
-        UUIDS_ENABLED ? SecureRandom.uuid : SecureRandom.hex
-      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]}"
-        Monitor.worker.queue_trace
-      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))
-        Monitor.worker.queue_trace
-      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
-          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(' ')
-          sql.bytesize < 1024 ? sql : sql[0..1023] + '...'
-        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
-end