influx_reporter 1.0.0

data/spec/influx_reporter/client_spec.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Client do
+    let(:config) { Configuration.new influx_db: { host: :localhost }}
+
+    describe '.start!' do
+      it "set's up an instance and only one" do
+        first_instance = Client.start! config
+        expect(Client.inst).to_not be_nil
+        expect(Client.start!(config)).to be first_instance
+      end
+    end
+
+    describe '.stop!' do
+      it 'kills the instance but flushes before' do
+        Client.start! config
+        Client.inst.submit_transaction Transaction.new(Client.inst, 'Test').done(200)
+        Client.stop!
+        expect(WebMock).to have_requested(:post, %r{\/write})
+        expect(Client.inst).to be_nil
+      end
+    end
+
+    context 'without worker spec setting', start_without_worker: true do
+      it "doesn't start a Worker" do
+        expect(Thread).to_not receive(:new)
+        Client.start! config
+        expect(Client.inst).to_not be_nil
+      end
+    end
+
+    context 'with a running client', start_without_worker: true do
+      subject { Client.inst }
+
+      describe '#transaction' do
+        it 'returns a new transaction and sets it as current' do
+          transaction = subject.transaction 'Test'
+          expect(transaction).to_not be_nil
+          expect(subject.current_transaction).to be transaction
+        end
+        it 'returns the current transaction if present' do
+          transaction = subject.transaction 'Test'
+          expect(subject.transaction('Test')).to eq transaction
+        end
+        context 'with a block' do
+          it 'yields transaction' do
+            blck = ->(*args) {}
+            allow(blck).to receive(:call)
+            subject.transaction('Test') { |t| blck.call(t) }
+            expect(blck).to have_received(:call).with(Transaction)
+          end
+          it 'returns transaction' do
+            result = subject.transaction('Test') { "DON'T RETURN ME" }
+            expect(result).to be_a Transaction
+          end
+        end
+      end
+
+      describe '#trace' do
+        it 'delegates to current transaction' do
+          subject.current_transaction = double('transaction', trace: true)
+          subject.trace 1, 2, 3
+          expect(subject.current_transaction).to have_received(:trace).with(1, 2, 3)
+          subject.current_transaction = nil
+        end
+
+        it 'ignores when outside transaction' do
+          blk = proc {}
+          allow(blk).to receive(:call)
+          subject.trace { blk.call }
+          expect(blk).to have_received(:call)
+        end
+      end
+
+      describe '#submit_transaction' do
+        it "doesn't send right away" do
+          transaction = Transaction.new(subject, 'test')
+
+          subject.submit_transaction transaction
+
+          expect(subject.queue.length).to be 0
+          expect(WebMock).to_not have_requested(:post, %r{/transactions/$})
+        end
+
+        it "sends if it's long enough ago that we sent last" do
+          transaction = Transaction.new(subject, 'test')
+          subject.instance_variable_set :@last_sent_transactions, Time.now.utc - 61
+
+          subject.submit_transaction transaction
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+
+        it 'sends if interval is disabled' do
+          transaction = Transaction.new(subject, 'test')
+          subject.config.transaction_post_interval = nil
+          subject.submit_transaction transaction
+          expect(subject.queue.length).to be 1
+        end
+      end
+
+      describe '#set_context' do
+        it 'sets context for future errors' do
+          subject.set_context(tags: { additional_information: 'remember me' })
+
+          exception = Exception.new('BOOM')
+          subject.report exception
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop.data[:tags][:additional_information]).to eq('remember me')
+        end
+      end
+
+      describe '#with_context' do
+        it 'sets context for future errors' do
+          subject.with_context(tags: { additional_information: 'remember me' }) do
+            exception = Exception.new('BOOM')
+            subject.report exception
+          end
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop.data[:tags][:additional_information]).to eq('remember me')
+        end
+
+        it 'supports nested contexts' do
+          subject.with_context(values: { info: 'a' }) do
+            subject.with_context(values: { more_info: 'b' }) do
+              exception = Exception.new('BOOM')
+              subject.report exception
+            end
+          end
+
+          expect(subject.queue.length).to be 1
+          data = subject.queue.pop.data
+          expect(data[:values][:info]).to eq('a')
+          expect(data[:values][:more_info]).to eq('b')
+        end
+
+        it 'restores context for future errors' do
+          subject.set_context(values: { info: 'hello' })
+
+          subject.with_context(values: { additional_information: 'remember me' }) do
+          end
+
+          exception = Exception.new('BOOM')
+          subject.report exception
+
+          expect(subject.queue.length).to be 1
+          data = subject.queue.pop.data
+          expect(data[:values][:info]).to eq('hello')
+          expect(data[:values][:additional_information]).not_to be
+        end
+
+        it 'returns what is yielded' do
+          result = subject.with_context(additional_information: 'remember me') do
+            42
+          end
+
+          expect(result).to be 42
+        end
+      end
+
+      describe '#report' do
+        it 'builds and posts an exception' do
+          exception = Exception.new('BOOM')
+
+          subject.report exception
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+
+        it 'skips nil exceptions' do
+          subject.report nil
+          expect(WebMock).to_not have_requested(:post, %r{/errors/$})
+        end
+      end
+
+      describe '#report_message' do
+        it 'builds and posts an exception' do
+          subject.report_message 'Massage message'
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+      end
+
+      describe '#capture' do
+        it 'captures exceptions and sends them off then raises them again' do
+          exception = Exception.new('BOOM')
+
+          expect do
+            subject.capture do
+              raise exception
+            end
+          end.to raise_exception(Exception)
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+      end
+    end
+
+    context 'with performance disabled' do
+      subject do
+        InfluxReporter::Client.inst
+      end
+
+      before do
+        config.disable_performance = true
+        InfluxReporter.start! config
+      end
+      after { InfluxReporter.stop! }
+
+      describe '#transaction' do
+        it 'yields' do
+          block = -> {}
+          expect(block).to receive(:call)
+          Client.inst.transaction('Test') { block.call }
+        end
+        it 'returns nil' do
+          expect(Client.inst.transaction('Test')).to be_nil
+        end
+      end
+
+      describe '#trace' do
+        it 'yields' do
+          block = -> {}
+          expect(block).to receive(:call)
+          Client.inst.trace('Test', 'trace') { block.call }
+        end
+        it 'returns nil' do
+          expect(Client.inst.trace('Test', 'test')).to be_nil
+        end
+      end
+    end
+
+    context 'with errors disabled' do
+      subject do
+        InfluxReporter::Client.inst
+      end
+
+      before do
+        config.disable_errors = true
+        InfluxReporter.start! config
+      end
+      after { InfluxReporter.stop! }
+
+      describe '#report' do
+        it "doesn't do anything" do
+          exception = Exception.new('BOOM')
+
+          Client.inst.report exception
+
+          expect(Client.inst.queue.length).to be 0
+        end
+      end
+    end
+  end
+end

data/spec/influx_reporter/configuration_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Configuration do
+    it 'has defaults' do
+      conf = Configuration.new
+      expect(conf.timeout).to be 100
+      expect(conf.filter_parameters).to eq [/(authorization|password|passwd|secret)/i]
+    end
+
+    it 'overwrites defaults when config given' do
+      conf = Configuration.new(filter_parameters: [:secret])
+      expect(conf.timeout).to be 100
+      expect(conf.filter_parameters).to eq [:secret]
+    end
+
+    it 'can initialize with a hash' do
+      conf = Configuration.new timeout: 1000
+      expect(conf.timeout).to be 1000
+    end
+
+    it 'yields itself to a given block' do
+      conf = Configuration.new do |c|
+        c.timeout = 1000
+      end
+      expect(conf.timeout).to be 1000
+    end
+
+    describe '#validate' do
+      let(:auth_opts) { { database: 'endpoints' } }
+      it 'is true when all auth options are set' do
+        expect(Configuration.new(auth_opts).validate!).to be true
+      end
+
+      it 'is true' do
+        expect(Configuration.new(auth_opts).validate!).to be true
+      end
+    end
+  end
+end

data/spec/influx_reporter/data_builders/error_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  module DataBuilders
+    RSpec.describe Error do
+      let(:config) { Configuration.new }
+
+      subject do
+        Error.new config
+      end
+
+      def real_exception
+        1 / 0
+      rescue ZeroDivisionError => e
+        e
+      end
+
+      describe '#build' do
+        it 'builds an error dict from an exception' do
+          error_message = ErrorMessage.from_exception config, real_exception
+          example = {
+              series: 'errors',
+              values: {
+                  message: 'ZeroDivisionError: divided by 0',
+                  culprit: "influx_reporter/data_builders/error_spec.rb:15:in `/'"
+              },
+              tags: {
+                  level: :error,
+                  excpetion: 'ZeroDivisionError'
+              },
+              timestamp: an_instance_of(Integer)
+          }
+          expect(subject.build(error_message)).to match(example)
+        end
+      end
+    end
+  end
+end

data/spec/influx_reporter/data_builders/transactions_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  module DataBuilders
+    RSpec.describe Transactions, mock_time: true, start_without_worker: true do
+      describe '#build' do
+        subject do
+          transaction1 = Transaction.new(nil, 'endpoint', 'special.kind')
+          transaction2 = Transaction.new(nil, 'endpoint', 'special.kind')
+          transaction3 = Transaction.new(nil, 'endpoint', 'special.kind')
+          travel 100
+          transaction1.done 200
+          transaction2.done 200
+          transaction3.done 500
+
+          transaction4 = InfluxReporter.transaction('endpoint', 'special.kind.foo') do
+            travel 100
+            InfluxReporter.trace 'things' do
+              travel 100
+            end
+            InfluxReporter.trace 'things', 'db.custom.sql' do
+              travel 100
+            end
+          end.done(500)
+
+          transactions = [transaction1, transaction2, transaction3, transaction4]
+
+          DataBuilders::Transactions.new(Configuration.new).build transactions
+        end
+
+        it 'should create proper series names' do
+          data = subject
+          expect(data.length).to be 6
+          expect(data.map { |t| t[:series] }.uniq).to eq %w[special.kind trace.code trace.db]
+        end
+
+        it 'combines transactions by result' do
+          data = subject
+          expect(data.length).to be 6
+          expect(data.map { |t| t[:tags][:result] }.compact).to eq [200, 200, 500, 500]
+          expect(data.map { |t| t[:values][:duration] }.flatten).to eq [100.0, 100.0, 100.0, 300.0, 100.0, 100.0]
+        end
+      end
+    end
+  end
+end

data/spec/influx_reporter/error_message/exception_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe ErrorMessage::Exception do
+    class ::Thing
+      class Error < StandardError
+      end
+    end
+
+    describe '.from' do
+      it 'initializes an object from an actual exception' do
+        exception = Thing::Error.new 'BOOM'
+        obj = ErrorMessage::Exception.from(exception)
+        expect(obj.type).to eq 'Thing::Error'
+        expect(obj.value).to eq 'BOOM'
+        expect(obj.module).to eq 'Thing'
+      end
+    end
+  end
+end

data/spec/influx_reporter/error_message/http_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe ErrorMessage::HTTP do
+    describe '.from_rack_env' do
+      let(:config) { Configuration.new }
+
+      it 'initializes with a rack env' do
+        filter = Filter.new config
+
+        env = Rack::MockRequest.env_for '/nested/path?a=1&password=SECRET', 'HTTP_COOKIE' => 'user_id=1',
+                                                                            'REMOTE_ADDR' => '1.2.3.4',
+                                                                            'HTTP_USER_AGENT' => 'test-agent 1.2/3',
+                                                                            'HTTP_FOO' => 'bar'
+
+        http = ErrorMessage::HTTP.from_rack_env env, filter: filter
+
+        expect(http.url).to eq 'http://example.org/nested/path'
+        expect(http.method).to eq 'GET'
+        expect(http.query_string).to eq 'a=1&password=[FILTERED]'
+        expect(http.cookies).to eq('user_id=1')
+        expect(http.remote_host).to eq '1.2.3.4'
+        expect(http.http_host).to eq 'example.org:80'
+        expect(http.user_agent).to eq 'test-agent 1.2/3'
+
+        expect(http.headers).to eq('Cookie' => 'user_id=1',
+                                   'User-Agent' => 'test-agent 1.2/3',
+                                   'Foo' => 'bar')
+        expect(http.env).to eq(env.reject do |k, _v|
+          k.match(/(^HTTP_|[a-z])/) # starting with HTTP_ or lower case
+        end)
+      end
+
+      it 'adds form data' do
+        env = Rack::MockRequest.env_for '/', 'REQUEST_METHOD' => 'POST',
+                                             input: 'thing=hotdog&accept=1'
+        http = ErrorMessage::HTTP.from_rack_env env
+
+        expect(http.data).to eq('thing' => 'hotdog',
+                                'accept' => '1')
+      end
+
+      it 'adds body' do
+        env = Rack::MockRequest.env_for '/', 'REQUEST_METHOD' => 'POST',
+                                             'CONTENT_TYPE' => 'application/json',
+                                             input: { thing: 'hotdog' }.to_json
+        http = ErrorMessage::HTTP.from_rack_env env
+
+        expect(http.data).to eq('{"thing":"hotdog"}')
+      end
+    end
+  end
+end