influx_reporter 1.0.0

data/spec/influx_reporter/integration/redis_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+if defined?(Redis)
+  RSpec.describe 'Redis integration', start_without_worker: true do
+    let(:redis) { Redis.new }
+
+    describe '#call' do
+      it 'adds a trace to current transaction' do
+        transaction = InfluxReporter.transaction 'Redis' do
+          redis.lrange('some:where', 0, -1)
+        end
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq 'lrange'
+      end
+    end
+  end
+end

data/spec/influx_reporter/integration/resque_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# :nocov:
+begin
+  require 'resque'
+rescue LoadError
+  puts 'Skipping Resque specs'
+end
+# :nocov:
+
+if defined? Resque
+  RSpec.describe 'Resque integration', start_without_worker: true do
+    before do
+      # using fakeredis
+      Resque.redis = Redis.new
+
+      require 'resque/failure/multiple'
+      Resque::Failure::Multiple.classes = [InfluxReporter::Integration::Resque]
+      Resque::Failure.backend = Resque::Failure::Multiple
+    end
+
+    class MyWorker
+      @queue = :default
+
+      def self.perform(txt)
+        raise Exception, txt
+      end
+    end
+
+    it 'captures and reports exceptions' do
+      Resque.enqueue MyWorker, 'BOOM'
+
+      worker = Resque::Worker.new(:default)
+      job = worker.reserve
+      worker.perform job
+
+      expect(InfluxReporter::Client.inst.queue.length).to be 1
+    end
+  end
+end

data/spec/influx_reporter/integration/sidekiq_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# :nocov:
+begin
+  require 'sidekiq'
+rescue LoadError
+  puts 'Skipping Sidekiq specs'
+end
+# :nocov:
+
+if defined?(Sidekiq)
+  require 'sidekiq/testing'
+
+  Sidekiq::Testing.inline!
+  Sidekiq::Testing.server_middleware do |chain|
+    chain.add InfluxReporter::Integration::SidekiqException
+  end
+
+  RSpec.describe InfluxReporter::Integration::SidekiqException, start_without_worker: true do
+    class MyWorker
+      include Sidekiq::Worker
+
+      def perform(ex)
+        raise ex
+      end
+    end
+
+    it 'captures and reports exceptions to influx_reporter' do
+      exception = Exception.new('BOOM')
+
+      expect do
+        MyWorker.perform_async exception
+      end.to raise_error(Exception)
+
+      expect(InfluxReporter::Client.inst.queue.length).to be 1
+    end
+  end
+end

data/spec/influx_reporter/integration/sinatra_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'sinatra'
+
+module InfluxReporter
+  RSpec.describe 'sinatra integration' do
+    include Rack::Test::Methods
+
+    def config
+      @config ||= InfluxReporter::Configuration.new do |c|
+        c.disable_worker = true
+      end
+    end
+
+    around do |example|
+      InfluxReporter.start! config
+      example.call
+      InfluxReporter.stop!
+    end
+
+    class TestApp < ::Sinatra::Base
+      disable :show_exceptions
+      use InfluxReporter::Middleware
+
+      get '/' do
+        erb 'I am an inline template!'
+      end
+
+      template :tmpl do
+        'I am a template!'
+      end
+
+      get '/tmpl' do
+        erb :tmpl
+      end
+    end
+
+    def app
+      TestApp
+    end
+
+    it 'wraps routes in transactions' do
+      get '/'
+
+      transaction = InfluxReporter::Client.inst.pending_transactions.last
+      expect(transaction.endpoint).to eq 'GET /'
+    end
+
+    it 'traces templates' do
+      get '/tmpl'
+
+      transaction = InfluxReporter::Client.inst.pending_transactions.last
+      expect(transaction.traces.last.signature).to eq 'tmpl'
+    end
+
+    it 'traces inline templates' do
+      get '/'
+
+      transaction = InfluxReporter::Client.inst.pending_transactions.last
+      expect(transaction.traces.last.signature).to eq 'Inline erb'
+    end
+  end
+
+  RSpec.describe 'sinatra integration without perfomance' do
+    include Rack::Test::Methods
+
+    def config
+      @config ||= InfluxReporter::Configuration.new do |c|
+        c.disable_worker = true
+        c.disable_performance = true
+      end
+    end
+
+    around do |example|
+      InfluxReporter.start! config
+      example.call
+      InfluxReporter.stop!
+    end
+
+    class TestApp < ::Sinatra::Base
+      disable :show_exceptions
+      use InfluxReporter::Middleware
+
+      get '/' do
+        erb 'I am an inline template!'
+      end
+    end
+
+    def app
+      TestApp
+    end
+
+    it 'wraps routes in transactions' do
+      get '/'
+      expect(InfluxReporter::Client.inst.pending_transactions.last).to be_nil
+    end
+  end
+end

data/spec/influx_reporter/line_cache_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe LineCache do
+    let(:path) { 'some/file.rb' }
+    let(:lines) { %w[these are the lines] }
+
+    describe '.all' do
+      it 'returns the lines of the file at path' do
+        allow(File).to receive(:readlines) { lines }
+        expect(LineCache.all(path)).to eq lines
+      end
+      it 'rescues any exception' do
+        allow(LineCache::CACHE).to receive(:[]) { nil }
+        allow(File).to receive(:readlines).and_raise 'BOOM'
+        expect(LineCache.all(path)).to eq []
+      end
+      it 'caches results' do
+        allow(File).to receive(:readlines) { lines }.once
+        LineCache.all path
+        LineCache.all path
+      end
+    end
+
+    describe '.find' do
+      it 'returns one line of the file at path' do
+        allow(File).to receive(:readlines) { lines }.once
+        allow(LineCache::CACHE).to receive(:[]) { nil }
+        expect(LineCache.find(path, 2)).to eq 'are'
+      end
+      it 'is nil when less than 1' do
+        expect(LineCache.find(path, 0)).to be_nil
+      end
+    end
+  end
+end

data/spec/influx_reporter/logging_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'influx_reporter'
+
+module InfluxReporter
+  describe Logging do
+    class FakeLogger
+      def method_missing(name, *args)
+        @calls ||= []
+        @calls << [name, *args]
+      end
+      attr_reader :calls
+    end
+
+    let(:logger) { FakeLogger.new }
+    let(:config) { Struct.new(:logger).new(logger) }
+
+    before :each do
+      extend Logging
+    end
+
+    %w[fatal error info debug warn].map(&:to_sym).each do |level|
+      it "does #{level} with args" do
+        send level, 'msg'
+        expect(logger.calls.last).to eq [level, '** [InfluxReporter] msg']
+      end
+      it "does #{level} with block" do
+        blck = -> { 'msg' }
+        send level, &blck
+        expect(logger.calls.last).to eq [level, '** [InfluxReporter] msg']
+      end
+    end
+
+    context 'without a backend logger' do
+      before do
+        config.logger = nil
+      end
+
+      it 'should not error' do
+        fatal 'fatalmsg'
+        error 'errormsg'
+        warn 'warnmsg'
+        info 'infomsg'
+        debug 'debugmsg'
+      end
+    end
+  end
+end

data/spec/influx_reporter/middleware_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'influx_reporter'
+
+module InfluxReporter
+  describe Middleware, start_without_worker: true do
+    it 'surrounds the request in a transaction' do
+      app = Middleware.new(lambda do |_env|
+        [200, {}, ['']]
+      end)
+      status, _, body = app.call(Rack::MockRequest.env_for('/'))
+      body.close
+
+      expect(status).to eq 200
+      expect(InfluxReporter::Client.inst.pending_transactions.length).to be 1
+      expect(InfluxReporter::Client.inst.current_transaction).to be_nil
+    end
+
+    it 'submits on exceptions' do
+      app = Middleware.new(lambda do |_env|
+        raise Exception, 'BOOM'
+      end)
+
+      expect { app.call(Rack::MockRequest.env_for('/')) }.to raise_error(Exception)
+      expect(InfluxReporter::Client.inst.queue.length).to be 1
+      expect(InfluxReporter::Client.inst.current_transaction).to be_nil
+
+      expect(InfluxReporter::Client.inst.queue.length).to be 1
+    end
+  end
+end

data/spec/influx_reporter/normalizers/action_controller_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Normalizers::ActionController do
+    let(:config) { Configuration.new payload_tags: %i(geohash), payload_values: %i(uuid) }
+    let(:normalizers) { Normalizers.build config }
+
+    describe Normalizers::ActionController::ProcessAction do
+      subject do
+        normalizers.normalizer_for('process_action.action_controller')
+      end
+
+      it 'registers' do
+        expect(subject).to be_a Normalizers::ActionController::ProcessAction
+      end
+
+      describe '#normalize' do
+        it 'normalizes input and updates transaction' do
+          transaction = Transaction.new(nil, nil, nil)
+          uuid = SecureRandom.uuid
+
+          result = subject.normalize(transaction, 'process_action.action_controller',
+                                     controller: 'SomeController',
+                                     action: 'index',
+                                     uuid: uuid,
+                                     geohash: 'foo')
+
+          expect(transaction.endpoint).to eq 'SomeController#index'
+          expect(result).to match ['SomeController#index', 'app.controller.action', nil]
+          expect(transaction.root_trace.extra).to eq( tags: { geohash: 'foo' }, values: { uuid: uuid } )
+        end
+      end
+    end
+  end
+end

data/spec/influx_reporter/normalizers/action_view_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Normalizers::ActionView do
+    let(:config) { Configuration.new view_paths: ['/var/www/app/views'] }
+    let(:normalizers) { Normalizers.build config }
+
+    shared_examples_for :a_render_normalizer do |key|
+      describe '#normalize' do
+        it 'normalizes an unknown template' do
+          expect(normalize(key, {})).to eq ['Unknown template', described_class.const_get(:KIND), nil]
+        end
+
+        it 'returns a local template' do
+          path = 'somewhere/local.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq 'somewhere/local.html.erb'
+        end
+
+        it 'looks up a template in config.view_paths' do
+          path = '/var/www/app/views/users/index.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq 'users/index.html.erb'
+        end
+
+        it 'truncates gem path' do
+          path = Gem.path[0] + '/some/template.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq '$GEM_PATH/some/template.html.erb'
+        end
+
+        it 'returns absolute if not found in known dirs' do
+          path = '/somewhere/else.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq 'Absolute path'
+        end
+
+        def normalize(key, payload)
+          subject.normalize nil, key, payload
+        end
+      end
+    end
+
+    describe Normalizers::ActionView::RenderTemplate do
+      subject do
+        normalizers.normalizer_for 'render_template.action_view'
+      end
+
+      it 'registers' do
+        expect(subject).to be_a Normalizers::ActionView::RenderTemplate
+      end
+
+      it_should_behave_like :a_render_normalizer
+    end
+
+    describe Normalizers::ActionView::RenderPartial do
+      subject do
+        normalizers.normalizer_for 'render_partial.action_view'
+      end
+
+      it 'registers' do
+        expect(subject).to be_a Normalizers::ActionView::RenderPartial
+      end
+
+      it_should_behave_like :a_render_normalizer
+    end
+
+    describe Normalizers::ActionView::RenderCollection do
+      subject do
+        normalizers.normalizer_for 'render_collection.action_view'
+      end
+
+      it 'registers' do
+        expect(subject).to be_a Normalizers::ActionView::RenderCollection
+      end
+
+      it_should_behave_like :a_render_normalizer
+    end
+  end
+end

data/spec/influx_reporter/normalizers/active_record_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Normalizers::ActionView do
+    let(:config) { Configuration.new view_paths: ['/var/www/app/views'] }
+    let(:normalizers) { Normalizers.build config }
+
+    describe Normalizers::ActiveRecord::SQL do
+      subject { normalizers.normalizer_for 'sql.active_record' }
+
+      it 'registers' do
+        expect(subject).to be_a Normalizers::ActiveRecord::SQL
+      end
+
+      describe '#normalize' do
+        it 'skips SCHEMA queries' do
+          expect(normalize(name: 'SCHEMA')).to be :skip
+        end
+
+        it 'skips CACHE queries' do
+          expect(normalize(name: 'CACHE', sql: 'select * from tables')).to be :skip
+        end
+
+        it 'normalizes SELECT queries' do
+          sql = 'SELECT  "hotdogs".* FROM "hotdogs" WHERE "hotdogs"."topping" = $1 LIMIT 1'
+          signature, kind, extra = normalize(name: 'Hotdogs load', sql: sql)
+          expect(signature).to eq 'SELECT FROM "hotdogs"'
+          expect(kind).to eq 'db.unknown.sql'
+          expect(extra[:values]).to eq sql: sql
+        end
+
+        it 'normalizes INSERT queries' do
+          sig, = normalize(name: 'Hotdogs create',
+                           sql: 'insert into "hotdogs" (kind, topping) values ($1, $2)')
+          expect(sig).to eq 'INSERT INTO "hotdogs"'
+        end
+
+        it 'normalizes UPDATE queries' do
+          sig, = normalize(name: 'Hotdogs update',
+                           sql: 'update "hotdogs" (topping) values ($1) where id=1')
+          expect(sig).to eq 'UPDATE "hotdogs"'
+        end
+
+        it 'normalizes DELETE queries' do
+          sig, = normalize(name: 'Hotdogs delete',
+                           sql: 'delete from "hotdogs" where id=1')
+          expect(sig).to eq 'DELETE FROM "hotdogs"'
+        end
+
+        context 'inside AR' do
+          before do
+            module ::ActiveRecord; class Base; end; end unless defined? ActiveRecord
+            allow(::ActiveRecord::Base).to receive(:connection) { double(adapter_name: 'MySQL') }
+          end
+          it 'knows the ar adapter' do
+            _, kind, = normalize(name: 'Hotdogs load',
+                                 sql: 'select * from "hotdogs"')
+            expect(kind).to eq 'db.mysql.sql'
+          end
+        end
+
+        def normalize(payload)
+          subject.normalize nil, 'sql.active_record', payload
+        end
+      end
+    end
+  end
+end