influx_reporter 1.0.0

data/spec/influx_reporter/normalizers_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Normalizers do
+    let(:config) { Configuration.new }
+
+    describe Normalizers::Default do
+      it 'skips' do
+        normalizer = Normalizers::Default.new config
+        expect(normalizer.normalize(1, 2, 3)).to eq :skip
+      end
+    end
+  end
+end

data/spec/influx_reporter/sql_summarizer_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe SqlSummarizer do
+    let(:config) { Configuration.new }
+
+    subject { SqlSummarizer.new(config) }
+
+    it 'summarizes selects' do
+      expect(subject.signature_for("SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)")).to eq('SQL')
+    end
+
+    it 'summarizes selects from table' do
+      expect(subject.signature_for('SELECT * FROM table')).to eq('SELECT FROM table')
+    end
+
+    it 'summarizes selects from table with columns' do
+      expect(subject.signature_for('SELECT a, b FROM table')).to eq('SELECT FROM table')
+    end
+
+    it 'summarizes inserts' do
+      expect(subject.signature_for("INSERT INTO table (a, b) VALUES ('A','B')")).to eq('INSERT INTO table')
+    end
+
+    it 'summarizes updates' do
+      expect(subject.signature_for("UPDATE table SET a = 'B' WHERE b = 'B'")).to eq('UPDATE table')
+    end
+
+    it 'summarizes deletes' do
+      expect(subject.signature_for("DELETE FROM table WHERE b = 'B'")).to eq('DELETE FROM table')
+    end
+  end
+end

data/spec/influx_reporter/subscriber_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Subscriber do
+    let(:config) { Configuration.new }
+    let(:client) { Client.new config }
+
+    subject do
+      Subscriber.new config, client
+    end
+
+    describe '#register!' do
+      it 'subscribes to ActiveSupport::Notifications' do
+        expect(ActiveSupport::Notifications).to receive(:subscribe)
+        subject.register!
+      end
+      it 'unregisters first if already registered' do
+        subject.register!
+        expect(subject).to receive(:unregister!)
+        expect(ActiveSupport::Notifications).to receive(:subscribe)
+        subject.register!
+      end
+    end
+
+    describe '#unregister' do
+      it 'unsubscribes to AS::Notifications' do
+        expect(ActiveSupport::Notifications).to receive(:unsubscribe)
+        subject.register!
+        subject.unregister!
+      end
+    end
+
+    describe 'ActiveSupport::Notifications API', start_without_worker: true do
+      let(:message_args) do
+        [
+          'process_action.action_controller',
+          nil,
+          { controller: 'Controller', action: 'index' }
+        ]
+      end
+      describe '#start' do
+        it 'adds a new notification to current transaction' do
+          transaction = InfluxReporter.transaction 'Test'
+
+          expect do
+            subject.start(*message_args)
+          end.to change(transaction.notifications, :length).by 1
+
+          transaction.release
+        end
+      end
+
+      describe '#finish' do
+        it 'adds a trace to current transaction' do
+          transaction = InfluxReporter.transaction 'Test'
+
+          expect do
+            subject.start(*message_args)
+            subject.finish(*message_args)
+          end.to change(transaction.traces, :length).by 1
+
+          transaction.release
+        end
+        it 'adds a stack of parents', mock_time: true do
+          transaction = InfluxReporter.transaction 'Rack' do
+            subject.start(*message_args)
+            travel 100
+            InfluxReporter.trace('thing-1') do
+              travel 100
+            end
+            travel 100
+            subject.finish(*message_args)
+          end.done(200)
+
+          expect(transaction.traces.length).to eq 3
+          expect(transaction.traces.last.parents.map(&:signature)).to eq ['transaction', 'Controller#index']
+        end
+      end
+    end
+  end
+end

data/spec/influx_reporter/trace_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  describe Trace, mock_time: true do
+    describe '#initialize' do
+      it 'has a timestamp' do
+        trace = Trace.new nil, 'test'
+        expect(trace.timestamp).to eq (Time.now.utc.to_i * 1_000_000_000 + Time.now.utc.nsec)
+      end
+    end
+
+    describe '#start' do
+      it 'has a relative and absolute start time with a transaction' do
+        transaction = Transaction.new(nil, 'Test')
+        travel 400
+        trace = transaction.trace 'test-1' do
+          travel 100
+          transaction.trace 'test-2' do |t|
+            travel 100
+            t
+          end
+        end
+
+        expect(trace.signature).to eq 'test-2'
+        expect(trace.relative_start).to eq 100_000_000
+      end
+    end
+
+    describe '#done' do
+      it 'sets duration' do
+        transaction = Transaction.new nil, 'Test'
+        trace = Trace.new(transaction, 'test').start transaction.start_time
+        travel 100
+        trace.done
+
+        expect(trace.duration).to eq 100_000_000
+        expect(trace).to be_done
+      end
+    end
+  end
+end

data/spec/influx_reporter/transaction_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'influx_reporter'
+
+module InfluxReporter
+  describe Transaction, mock_time: true do
+    describe '#initialize' do
+      it 'has a root trace, timestamp and start time' do
+        transaction = Transaction.new nil, 'Test'
+        expect(transaction.traces.length).to be 1
+        expect(transaction.timestamp).to eq 694_224_000_000_000_000
+        expect(transaction.start_time).to eq 694_224_000_000_000_000
+      end
+    end
+
+    describe '#release' do
+      it 'sets clients current transaction to nil' do
+        client = Struct.new(:current_transaction).new(1)
+        transaction = Transaction.new client, 'Test'
+        transaction.release
+        expect(client.current_transaction).to be_nil
+      end
+    end
+
+    describe '#done' do
+      it 'it sets result, durations and ends root trace' do
+        transaction = Transaction.new nil, 'Test'
+
+        travel 100
+        transaction.done(200)
+
+        expect(transaction.result).to be 200
+        expect(transaction.traces.first).to be_done
+        expect(transaction.duration).to eq 100_000_000
+      end
+    end
+
+    describe '#submit' do
+      it 'ends transaction and submits it to the client' do
+        client = double('client', submit_transaction: true, :current_transaction= => true)
+        transaction = Transaction.new client, 'Test'
+
+        travel 100
+        transaction.submit 200
+
+        expect(transaction.result).to be 200
+        expect(transaction).to be_done
+        expect(client).to have_received(:current_transaction=)
+        expect(client).to have_received(:submit_transaction).with transaction
+      end
+    end
+
+    describe '#running_traces' do
+      it 'returns running traces' do
+        transaction = Transaction.new nil, 'Test'
+
+        transaction.trace 'test' do
+          travel 100
+        end
+
+        running_trace = transaction.trace 'test2'
+        travel 100
+
+        expect(transaction.running_traces).to eq [transaction.root_trace, running_trace]
+      end
+    end
+
+    describe '#trace' do
+      subject do
+        transaction = Transaction.new nil, 'Test'
+
+        travel 100
+
+        transaction.trace 'test' do
+          travel 100
+        end
+
+        transaction.done
+      end
+      it 'creates a new trace' do
+        expect(subject.traces.length).to be 2
+      end
+      it 'has root as a parent' do
+        expect(subject.traces.last.parents).to eq [subject.traces.first]
+      end
+      it 'has a duration' do
+        expect(subject.traces.last.duration).to eq 100_000_000
+      end
+      it 'has a relative start' do
+        expect(subject.traces.last.relative_start).to eq 100_000_000
+      end
+      it 'has a total duration' do
+        expect(subject.duration).to eq 200_000_000
+      end
+    end
+  end
+end

data/spec/influx_reporter/util/inspector_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Util::Inspector, start_without_worker: true, mock_time: true do
+    let(:transaction) do
+      InfluxReporter.transaction 'Test' do |transaction|
+        travel 10
+        InfluxReporter.trace('test 1', 'trace.test') do
+          travel 100
+          InfluxReporter.trace('test 2', 'trace.test') { travel 150 }
+          travel 50
+        end
+        travel 50
+        InfluxReporter.trace('test 3', 'trace.test') do
+          travel 100
+        end
+        travel 1
+
+        transaction
+      end
+    end
+    subject do
+      Util::Inspector.new.transaction(transaction, include_parents: true)
+    end
+
+    it "doesn't explode" do
+      expect { subject }.to_not raise_error
+    end
+
+    it "doesn't exceed it's length" do
+      expect(subject.split("\n").map(&:length).find { |l| l < 100 })
+    end
+
+    # preview
+    it 'is beautiful' do
+      puts subject
+    end
+  end
+end

data/spec/influx_reporter/util_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Util do
+    describe '#nearest_minute', mock_time: true do
+      it 'normalizes to nearest minute' do
+        travel 125_000 # two minutes five secs
+        expect(Util.nearest_minute).to eq Time.utc(1992, 1, 1, 0, 2, 0)
+      end
+    end
+
+    describe '#ms', mock_time: true do
+      it 'returns current ms since unix epoch' do
+        expect(Util.nanos).to eq 694_224_000_000_000_000
+      end
+    end
+  end
+end

data/spec/influx_reporter/worker_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module InfluxReporter
+  RSpec.describe Worker do
+    before do
+      @queue = Queue.new
+    end
+
+    let :worker do
+      config = build_config
+      Worker.new config, @queue, InfluxDBClient.new(config)
+    end
+
+    describe '#run' do
+      context 'during a loop' do
+        before { allow(worker).to receive(:loop).and_yield }
+
+        subject { Thread.new { worker.run }.join 0.05 }
+
+        it 'does nothing with an empty queue' do
+          subject
+          expect(WebMock).to_not have_requested(:any, /.*/)
+        end
+
+        it 'pops the queue' do
+          @queue << Worker::PostRequest.new('/errors/', { series: 'test', values: { id: 1 }, timestamp: 0})
+          @queue << Worker::PostRequest.new('/errors/', { series: 'test', values: { id: 1 }, timestamp: 1})
+
+          subject
+
+          expect(WebMock).to have_requested(:post, %r{/write}).with(body: 'test id=1i 0')
+          expect(WebMock).to have_requested(:post, %r{/write}).with(body: 'test id=1i 1')
+        end
+      end
+
+      context 'can be stopped by sending a message' do
+        it 'loops until stopped' do
+          thread = Thread.new do
+            worker.run
+          end
+
+          @queue << Worker::StopMessage.new
+
+          thread.join
+
+          expect(thread).to_not be_alive
+          expect(@queue).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/influx_reporter_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe InfluxReporter do
+  it { should_not be_started }
+
+  describe 'self.start!' do
+    it 'delegates to client' do
+      conf = InfluxReporter::Configuration.new database: 'test'
+      expect(InfluxReporter::Client).to receive(:start!).with(conf) { true }
+      InfluxReporter.start! conf
+    end
+  end
+
+  it { should delegate :stop!, to: InfluxReporter }
+
+  describe 'when InfluxReporter is started', start: true do
+    it { should be_started }
+
+    it { should delegate :transaction, to: InfluxReporter::Client.inst, args: ['Test', nil, nil] }
+    it { should delegate :trace, to: InfluxReporter::Client.inst, args: ['test', nil, {}] }
+    it { should delegate :report, to: InfluxReporter::Client.inst, args: [Exception.new, nil] }
+    it { should delegate :set_context, to: InfluxReporter::Client.inst, args: [{}] }
+    it { should delegate :with_context, to: InfluxReporter::Client.inst, args: [{}] }
+    it { should delegate :report_message, to: InfluxReporter::Client.inst, args: ['My message', nil] }
+    it { should delegate :capture, to: InfluxReporter::Client.inst }
+
+    describe 'a block example', mock_time: true do
+      it 'is done' do
+        transaction = InfluxReporter.transaction 'Test' do
+          travel 100
+          InfluxReporter.trace 'test1' do
+            travel 100
+            InfluxReporter.trace 'test1-1' do
+              travel 100
+            end
+            InfluxReporter.trace 'test1-2' do
+              travel 100
+            end
+            travel 100
+          end
+        end.done(true)
+
+        expect(transaction).to be_done
+        expect(transaction.duration).to eq 500_000_000
+      end
+    end
+  end
+end