influx_reporter 1.0.0

data/spec/influx_reporter/error_message/stacktrace_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe ErrorMessage::Stacktrace do
+    def real_exception
+      1 / 0
+    rescue => e
+      e
+    end
+
+    let(:config) { Configuration.new }
+    let(:exception) { real_exception }
+
+    describe '.from' do
+      it 'initializes from an exception' do
+        stacktrace = ErrorMessage::Stacktrace.from config, exception
+        expect(stacktrace.frames).to_not be_empty
+
+        # so meta
+        last_frame = stacktrace.frames.last
+        expect(last_frame.filename).to eq 'influx_reporter/error_message/stacktrace_spec.rb'
+        expect(last_frame.lineno).to be 8
+        expect(last_frame.abs_path).to_not be_nil
+        expect(last_frame.function).to eq '/'
+        expect(last_frame.vars).to be_nil
+
+        expect(last_frame.pre_context.last).to match(/def real_exception/)
+        expect(last_frame.context_line).to match(/1 \/ 0/)
+        expect(last_frame.post_context.first).to match(/rescue/)
+      end
+
+      context 'when context lines are off' do
+        let(:config) { Configuration.new context_lines: nil }
+        it 'initializes too' do
+          stacktrace = ErrorMessage::Stacktrace.from config, exception
+          expect(stacktrace.frames).to_not be_empty
+
+          last_frame = stacktrace.frames.last
+          expect(last_frame.pre_context).to be_nil
+          expect(last_frame.context_line).to be_nil
+          expect(last_frame.post_context).to be_nil
+        end
+      end
+    end
+
+    describe '#to_h' do
+      it 'is a hash' do
+        hsh = ErrorMessage::Stacktrace.from(config, exception).to_h
+        expect(hsh).to be_a Hash
+        expect(hsh.keys).to eq [:frames]
+      end
+    end
+  end
+end

data/spec/influx_reporter/error_message/user_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe ErrorMessage::User do
+    let(:config) { Configuration.new }
+
+    class Controller
+      def current_user
+        Struct.new(:id, :email, :username).new(1, 'john@example.com', 'leroy')
+      end
+    end
+
+    describe '.from_rack_env' do
+      it 'initializes from rack env' do
+        env = Rack::MockRequest.env_for '/', 'action_controller.instance' => Controller.new
+        user = ErrorMessage::User.from_rack_env config, env
+
+        expect(user.id).to be 1
+        expect(user.email).to eq 'john@example.com'
+        expect(user.username).to eq 'leroy'
+      end
+    end
+  end
+end

data/spec/influx_reporter/error_message_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe ErrorMessage do
+    let(:config) { Configuration.new }
+
+    def real_exception
+      1 / 0
+    rescue => e
+      e
+    end
+
+    describe '#initialize' do
+      it 'sets attrs by hash' do
+        error = ErrorMessage.new config, 'Error', level: :warn
+        expect(error.level).to eq :warn
+      end
+      it 'yields itself' do
+        error = ErrorMessage.new(config, 'Error') { |m| m.level = :warn }
+        expect(error.level).to eq :warn
+      end
+    end
+
+    describe '.from_exception' do
+      it 'initializes from an exception' do
+        error = ErrorMessage.from_exception config, real_exception
+        expect(error.message).to eq 'ZeroDivisionError: divided by 0'
+        expect(error.level).to eq :error
+
+        expect(error.exception.type).to eq 'ZeroDivisionError'
+        expect(error.exception.value).to eq 'divided by 0'
+        expect(error.exception.module).to eq ''
+
+        expect(error.stacktrace.frames.length).to_not be 0
+        expect(error.stacktrace.frames.map(&:class).uniq)
+            .to eq [ErrorMessage::Stacktrace::Frame]
+        expect(error.culprit).to eq "influx_reporter/error_message_spec.rb:10:in `/'"
+      end
+
+      it 'skips excluded exceptions' do
+        class ::SleepDeprivationError < StandardError; end
+        exception = SleepDeprivationError.new('so tired')
+        config.excluded_exceptions += %w[SleepDeprivationError]
+
+        error = ErrorMessage.from_exception config, exception
+        expect(error).to be_nil
+      end
+
+      context 'with a rack env' do
+        it 'adds rack env to message' do
+          env = Rack::MockRequest.env_for '/'
+          error = ErrorMessage.from_exception config, real_exception, rack_env: env
+
+          expect(error.http).to be_a(ErrorMessage::HTTP)
+          expect(error.http.url).to eq 'http://example.org/'
+        end
+
+        it 'uses proper filter options' do
+          env = Rack::MockRequest.env_for '/nested/path?foo=bar&password=SECRET'
+          error = ErrorMessage.from_exception config, real_exception, rack_env: env
+          expect(error.http.query_string).to eq 'foo=bar&password=[FILTERED]'
+        end
+
+        class DummyController
+          def current_user
+            Struct.new(:id, :email, :username).new(1, 'john@example.com', 'leroy')
+          end
+        end
+
+        it 'adds user from controller' do
+          env = Rack::MockRequest.env_for '/', 'action_controller.instance' => DummyController.new
+          error = ErrorMessage.from_exception config, real_exception, rack_env: env
+
+          expect(error.user).to be_a(ErrorMessage::User)
+          expect(error.user.id).to be 1
+        end
+
+        it 'adds extra data to message' do
+          error = ErrorMessage.from_exception config, real_exception, extra: { 'test' => 1 }
+
+          expect(error.extra).to eq('test' => 1)
+        end
+      end
+    end
+
+    describe '#add_extra' do
+      it 'adds extra info from hash' do
+        error_message = ErrorMessage.new config, 'Message'
+        error_message.add_extra(thing: 1)
+        expect(error_message.extra).to eq(thing: 1)
+      end
+      it 'merges with current' do
+        error_message = ErrorMessage.new config, 'Message'
+        error_message.extra = { other_thing: 2 }
+        error_message.add_extra(thing: 1)
+        expect(error_message.extra).to eq(thing: 1, other_thing: 2)
+      end
+    end
+  end
+end

data/spec/influx_reporter/filter_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Filter do
+    let(:config) do
+      Configuration.new filter_parameters: [/password/, 'pwd', :_secret, :int_secret, 'non_existing']
+    end
+
+    subject do
+      Filter.new config
+    end
+
+    describe '#apply' do
+      it 'filters a string' do
+        data = 'password=SECRET&foo=bar&_secret=abc&pwd=de1&int_secret=123'
+        filtered_data = 'password=[FILTERED]&foo=bar&_secret=[FILTERED]&pwd=[FILTERED]&int_secret=[FILTERED]'
+        expect(subject.apply(data)).to eq filtered_data
+      end
+
+      it 'filters a hash' do
+        data = { password: 'SECRET', foo: :bar, _secret: 'abc', pwd: 'de1', int_secret: 123 }
+        filtered_data = { password: '[FILTERED]',
+                          foo: :bar,
+                          _secret: '[FILTERED]',
+                          pwd: '[FILTERED]',
+                          int_secret: '[FILTERED]' }
+        expect(subject.apply(data)).to eq filtered_data
+      end
+    end
+  end
+end

data/spec/influx_reporter/injections/net_http_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'open-uri'
+
+module InfluxReporter
+  RSpec.describe 'net/http integration', start_without_worker: true do
+    it 'is installed' do
+      reg = InfluxReporter::Injections.installed['Net::HTTP']
+      expect(reg).to_not be_nil
+    end
+
+    it 'traces http calls' do
+      InfluxReporter::Injections.installed['Net::HTTP'].install
+
+      WebMock.stub_request :get, 'http://example.com:80'
+
+      transaction = InfluxReporter.transaction 'Test'
+
+      Net::HTTP.start('example.com') do |http|
+        http.get '/'
+      end
+
+      expect(WebMock).to have_requested(:get, 'http://example.com')
+      expect(transaction.traces.length).to be 2
+
+      http_trace = transaction.traces.last
+      expect(http_trace.signature).to eq 'example.com'
+      expect(http_trace.extra).to eq(tags: { scheme: 'http', port: 80, method: 'GET' },
+                                     values: { path: '/' }
+                                     )
+    end
+  end
+end

data/spec/influx_reporter/injections/sequel_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'sequel'
+
+module InfluxReporter
+  RSpec.describe Injections::Sequel do
+    it 'is installed' do
+      reg = InfluxReporter::Injections.installed['Sequel']
+      expect(reg).to_not be_nil
+    end
+
+    before do
+      @db = Sequel.sqlite # in-memory db
+
+      @db.create_table :tests do
+        primary_key :id
+        String :title
+      end
+
+      @db[:tests].count # warm it up
+    end
+
+    it 'traces db calls', start_without_worker: true do
+      t = InfluxReporter.transaction 'Test' do
+        @db[:tests].count
+      end.done(true)
+
+      expect(t.traces.length).to be 2
+      expect(t.traces.last.signature).to eq 'SELECT FROM `tests`'
+    end
+  end
+end

data/spec/influx_reporter/injections/sinatra_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'sinatra'
+
+module InfluxReporter
+  RSpec.describe Injections::Sinatra do
+    it 'is installed' do
+      reg = InfluxReporter::Injections.installed['Sinatra::Base']
+      expect(reg).to_not be_nil
+    end
+  end
+end

data/spec/influx_reporter/injections_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Injections do
+    class TestProbe
+      def initialize
+        @installations = 0
+      end
+
+      def install
+        @installations += 1
+      end
+      attr_reader :installations
+    end
+
+    let(:probe) { TestProbe.new }
+    subject { InfluxReporter::Injections }
+
+    it 'installs right away if constant is defined' do
+      subject.register 'InfluxReporter', 'influx_reporter', probe
+      expect(probe.installations).to be 1
+    end
+
+    it 'installs a require hook' do
+      subject.register 'SomeLib', 'influx_reporter', probe
+
+      expect(probe.installations).to be 0
+
+      class ::SomeLib; end
+      require 'influx_reporter'
+      expect(probe.installations).to be 1
+
+      require 'influx_reporter'
+      expect(probe.installations).to be 1
+    end
+
+    it "doesn't install something that never exists" do
+      subject.register 'SomethingElse', 'wut', probe
+      expect(probe.installations).to be 0
+    end
+
+    it "doesn't install when required but class is missing" do
+      subject.register 'SomethingElse', 'influx_reporter', probe
+      require 'influx_reporter'
+      expect(probe.installations).to be 0
+    end
+  end
+end

data/spec/influx_reporter/integration/delayed_job_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# :nocov:
+begin
+  require 'delayed_job'
+rescue LoadError
+  puts 'Skipping delayed_job specs'
+end
+# :nocov:
+
+if defined?(Delayed)
+  # so nasty
+  load File.join(
+      Gem::Specification.find_by_name('delayed_job').gem_dir,
+      'spec', 'delayed', 'backend', 'test.rb'
+  )
+  Delayed::Worker.backend = Delayed::Backend::Test::Job
+
+  describe Delayed::Plugins::InfluxReporter, start_without_worker: true do
+    class MyJob
+      def blow_up(e)
+        raise e
+      end
+    end
+
+    it 'reports exceptions to InfluxReporter' do
+      exception = Exception.new('BOOM')
+
+      MyJob.new.delay.blow_up exception
+
+      expect(Delayed::Worker.new.work_off).to eq [0, 1]
+      expect(InfluxReporter::Client.inst.queue.length).to be 1
+    end
+  end
+end

data/spec/influx_reporter/integration/json_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'json'
+
+RSpec.describe 'JSON integration', start_without_worker: true do
+  if false # turned off for now
+    describe '#parse' do
+      it 'adds a trace to current transaction' do
+        transaction = InfluxReporter.transaction 'JSON' do
+          JSON.parse('[{"something":1}]')
+        end.done(true)
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq 'JSON#parse'
+      end
+    end
+
+    describe '#parse' do
+      it 'adds a trace to current transaction' do
+        transaction = InfluxReporter.transaction 'JSON' do
+          JSON.parse!('[{"something":1}]')
+        end.done(true)
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq 'JSON#parse!'
+      end
+    end
+
+    describe '#generate' do
+      it 'adds a trace to current transaction' do
+        transaction = InfluxReporter.transaction 'JSON' do
+          JSON.generate([{ something: 1 }])
+        end.done(true)
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq 'JSON#generate'
+      end
+    end
+  end
+end

data/spec/influx_reporter/integration/rails_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'rails'
+require 'action_controller/railtie'
+require 'influx_reporter/integration/railtie'
+
+describe 'Rails integration' do
+  include Rack::Test::Methods
+
+  def boot
+    TinderButForHotDogs.initialize!
+    TinderButForHotDogs.routes.draw do
+      get 'error', to: 'users#error'
+      get 'json', to: 'users#other'
+      root to: 'users#index'
+    end
+  end
+
+  before :all do
+    class TinderButForHotDogs < ::Rails::Application
+      config.secret_key_base = '__secret_key_base'
+
+      config.logger = Logger.new(DEBUG ? STDOUT : nil)
+      config.logger.level = Logger::DEBUG
+
+      config.eager_load = false
+
+      config.influx_reporter.database = 'APP_ID'
+      config.influx_reporter.disable_worker = true
+    end
+
+    class UsersController < ActionController::Base
+      def index
+        if Rails.version.to_i >= 5
+          render plain: 'HOT DOGS!'
+        else
+          render text: 'HOT DOGS!'
+        end
+      end
+
+      def other
+        json = InfluxReporter.trace('JSON.dump') { sleep 0.1; { result: :ok } }
+        render json: json
+      end
+
+      def error
+        raise Exception, 'NO KETCHUP!'
+      end
+    end
+
+    boot
+  end
+
+  after :all do
+    Object.send(:remove_const, :TinderButForHotDogs)
+    Object.send(:remove_const, :UsersController)
+    Rails.application = nil
+    InfluxReporter.stop!
+  end
+
+  def app
+    @app ||= Rails.application
+  end
+
+  before :each do
+    InfluxReporter::Client.inst.queue.clear
+    InfluxReporter::Client.inst.instance_variable_set :@pending_transactions, []
+  end
+
+  it 'adds an exception handler and handles exceptions' do
+    get '/error'
+
+    expect(InfluxReporter::Client.inst.queue.length).to be 1
+  end
+
+  it 'traces actions and enqueues transaction' do
+    get '/'
+
+    expect(InfluxReporter::Client.inst.pending_transactions.length).to be 1
+  end
+
+  it 'logs when failing to report error' do
+    allow(InfluxReporter::Client.inst).to receive(:report).and_raise
+    allow(Rails.logger).to receive(:error)
+
+    get '/404'
+
+    expect(Rails.logger).to have_received(:error).with(/\*\* \[InfluxReporter\] Error capturing/)
+  end
+end