appsignal 0.11.18 → 0.12.beta.0

data/spec/lib/appsignal/aggregator/middleware/action_view_sanitizer_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-if rails_present?
-  require 'action_view'
-  require 'appsignal/aggregator/middleware/action_view_sanitizer'
-
-  describe Appsignal::Aggregator::Middleware::ActionViewSanitizer do
-    let(:klass) { Appsignal::Aggregator::Middleware::ActionViewSanitizer }
-    let(:sanitizer) { klass.new }
-
-    describe "#call" do
-      before { Rails.root.stub(:to_s => '/var/www/app/20130101') }
-      let(:event) do
-        notification_event(
-          :name => 'render_partial.action_view',
-          :payload => create_payload(payload)
-        )
-      end
-      let(:payload) do
-        {
-          :identifier => '/var/www/app/20130101/app/views/home/index/html.erb'
-        }
-      end
-      subject { event.payload }
-      before { sanitizer.call(event) { } }
-
-      it "should strip Rails root from the path" do
-        subject[:identifier].should == 'app/views/home/index/html.erb'
-      end
-
-      context "with a frozen identifier" do
-        let(:payload) do
-          {
-            :identifier => '/var/www/app/20130101/app/views/home/index/html.erb'.freeze
-          }
-        end
-
-        it "should strip Rails root from the path" do
-          subject[:identifier].should == 'app/views/home/index/html.erb'
-        end
-      end
-    end
-  end
-end

data/spec/lib/appsignal/aggregator/middleware/chain_spec.rb

@@ -1,168 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal::Aggregator::Middleware do
-  let(:chain_klass) { Appsignal::Aggregator::Middleware::Chain }
-  let(:entry_klass) { Appsignal::Aggregator::Middleware::Entry }
-  let(:chain) { chain_klass.new }
-  let(:entry) { entry_klass.new(object, {:foo => :bar}) }
-
-  describe Appsignal::Aggregator::Middleware::Chain do
-    let(:object) { double(:object) }
-    let(:other_object) { double(:other_object) }
-
-    describe "#initialize" do
-      it "yields itself when passing a block" do
-        chain_klass.new { |o| o.should be_instance_of chain_klass }
-      end
-    end
-
-    describe "#remove" do
-      subject { chain.remove(object) }
-      before { chain.add(other_object) }
-
-      context "when it doesn't find the object" do
-        specify { expect { subject }.to_not raise_error }
-      end
-
-      context "when it finds the object" do
-        before { chain.add(object) }
-
-        specify { expect { subject }.to change(chain.entries, :count).by(-1) }
-      end
-    end
-
-    describe "#add" do
-      subject { chain.add(object) }
-
-      context "adding a new object" do
-        specify { expect { subject }.to change(chain.entries, :count).by(1) }
-      end
-
-      context "trying to add a duplicate (even with different arguments)" do
-        before { chain.add(object, :some_arguments) }
-
-        specify { expect { subject }.to_not change(chain.entries, :count).by(1) }
-      end
-    end
-
-    context "with a chain holding three items" do
-      subject { chain.entries.map(&:klass) }
-      before { [:first, :second, :third].each { |o| chain.add(o) } }
-
-      describe "#insert_before" do
-
-        context "before the second" do
-          before { chain.insert_before(:second, :object) }
-
-          it { should == [:first, :object, :second, :third] }
-        end
-
-        context "before the first" do
-          before { chain.insert_before(:first, :object) }
-
-          it { should == [:object, :first, :second, :third] }
-        end
-      end
-
-      describe "#insert_after" do
-
-        context "after the second" do
-          before { chain.insert_after(:second, :object) }
-
-          it { should == [:first, :second, :object, :third] }
-        end
-
-        context "after the third" do
-          before { chain.insert_after(:third, :object) }
-
-          it { should == [:first, :second, :third, :object] }
-        end
-      end
-
-      describe "#exists?" do
-        subject { chain.exists?(object) }
-
-        context "when it is in the chain" do
-          let(:object) { :first }
-
-          it { should be_true }
-        end
-
-        context "when it is not" do
-          let(:object) { :unknown }
-
-          it { should be_false }
-        end
-      end
-
-      describe "#retrieve" do
-        specify { chain.entries.each { |o| o.should_receive(:make_new) } }
-
-        after { chain.retrieve }
-      end
-
-      describe "#clear" do
-        before { chain.clear }
-        subject { chain.entries }
-
-        it { should be_empty }
-      end
-    end
-
-    describe "#invoke" do
-      let(:recorder) { [] }
-      subject { chain.invoke(:unsused) }
-      before(:all) do
-        TestInvoker1 = Struct.new(:id, :recorder) do
-          def call(event)
-            recorder << "Before#{id}"
-            yield
-            recorder << "After#{id}"
-          end
-        end
-        TestInvoker3 = Class.new(TestInvoker1)
-      end
-
-      context "all yielding entries" do
-        before do
-          TestInvoker2 = Class.new(TestInvoker1)
-
-          chain.add(TestInvoker1, 1, recorder)
-          chain.add(TestInvoker2, 2, recorder)
-          chain.add(TestInvoker3, 3, recorder)
-        end
-
-        it { should == %w(Before1 Before2 Before3 After3 After2 After1) }
-      end
-
-      context "a non yielding entry" do
-        before do
-          TestBlocker = Struct.new(:recorder) do
-            def call(event)
-              recorder << 'End-of-the-line!'
-            end
-          end
-
-          chain.add(TestInvoker1, 1, recorder)
-          chain.add(TestBlocker, recorder)
-          chain.add(TestInvoker3, 3, recorder)
-        end
-
-        it { should == %w(Before1 End-of-the-line! After1) }
-      end
-    end
-  end
-
-  describe Appsignal::Aggregator::Middleware::Entry do
-
-    describe "#make_new" do
-      let(:object) { double }
-      subject { entry.make_new }
-
-      it "initializes the passed object" do
-        object.should_receive(:new)
-        subject
-      end
-    end
-  end
-end

data/spec/lib/appsignal/aggregator/middleware/delete_blanks_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal::Aggregator::Middleware::DeleteBlanks do
-  let(:klass) { Appsignal::Aggregator::Middleware::DeleteBlanks }
-  let(:delete_blanks) { klass.new }
-
-  describe "#call" do
-    let(:event) do
-      notification_event(
-        :name => 'something',
-        :payload => create_payload(payload)
-      )
-    end
-    let(:payload) do
-      {
-        :string => 'not empty',
-        :array => ['something'],
-        :hash => {'something' => 'something'},
-        :empty_string => '',
-        :empty_array => [],
-        :empty_hash => {},
-        :nil => nil
-      }
-    end
-    subject { event.payload }
-    before { delete_blanks.call(event) { } }
-
-    it { should have_key(:string) }
-    it { should have_key(:array) }
-    it { should have_key(:hash) }
-
-    it { should_not have_key(:empty_string) }
-    it { should_not have_key(:empty_array) }
-    it { should_not have_key(:empty_hash) }
-    it { should_not have_key(:nil) }
-  end
-end

data/spec/lib/appsignal/aggregator/post_processor_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal::Aggregator::PostProcessor do
-  before :all do
-    start_agent
-  end
-
-  let(:klass) { Appsignal::Aggregator::PostProcessor }
-  let(:post_processor) { klass.new(transactions) }
-
-  describe "#initialize" do
-    subject { klass.new(:foo) }
-
-    its(:transactions) { should == :foo }
-  end
-
-  describe "#post_processed_queue!" do
-    let(:first_transaction) { regular_transaction }
-    let(:second_transaction) do
-      slow_transaction(
-        :events => [
-          notification_event(
-            :payload => {
-              :set_value => 'set value',
-              :nil_value => nil
-            }
-          )
-        ]
-      )
-    end
-    let(:transactions) { [first_transaction, second_transaction] }
-    let(:processed_queue) { post_processor.post_processed_queue! }
-    subject { processed_queue }
-
-    it { should have(2).items }
-
-    context "the first transaction" do
-      subject { processed_queue[0] }
-
-      it { should_not have_key(:events) }
-
-      context "log entry" do
-        subject { processed_queue[0][:log_entry] }
-
-        it { should have_key(:duration) }
-        it { should have_key(:end) }
-        it { should_not have_key(:events) }
-      end
-    end
-
-    context "the second transaction" do
-      context "log entry" do
-        subject { processed_queue[1][:log_entry] }
-
-        it { should have_key(:duration) }
-        it { should have_key(:end) }
-      end
-
-      context "first event" do
-        subject { processed_queue[1][:events][0] }
-
-        it { should_not be_nil }
-        it { should have_key(:name) }
-
-        it "should have the set value in the payload" do
-          subject[:payload][:set_value].should == 'set value'
-        end
-
-        it "should not have the nil value in the payload"\
-           "since delete blanks is in the middle ware stack" do
-          subject[:payload].should_not have_key(:nil_value)
-        end
-      end
-    end
-  end
-
-  describe ".default_middleware" do
-    subject { klass.default_middleware }
-
-    it { should be_instance_of Appsignal::Aggregator::Middleware::Chain }
-
-    it "should include the default middleware stack" do
-      subject.exists?(Appsignal::Aggregator::Middleware::DeleteBlanks).should be_true
-      if rails_present?
-        subject.exists?(Appsignal::Aggregator::Middleware::ActionViewSanitizer).should be_true
-
-        if active_record_present?
-          subject.exists?(Appsignal::Aggregator::Middleware::ActiveRecordSanitizer).should be_true
-        end
-      else
-        subject.exists?(Appsignal::Aggregator::Middleware::ActionViewSanitizer).should be_false
-
-        if active_record_present?
-          subject.exists?(Appsignal::Aggregator::Middleware::ActiveRecordSanitizer).should be_false
-        end
-      end
-    end
-  end
-end

data/spec/lib/appsignal/aggregator_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal::Aggregator do
-  before :all do
-    start_agent
-  end
-
-  let(:aggregator) { Appsignal::Aggregator.new }
-
-  describe "#add" do
-    subject { aggregator.add(transaction) }
-
-    context "adding a regular transaction" do
-      let(:transaction) { regular_transaction }
-
-      specify { transaction.should_receive(:truncate!) }
-    end
-
-    context "adding a slow transaction" do
-      let(:transaction) { slow_transaction }
-
-      specify {
-        aggregator.should_receive(:pre_process_slowness!).with(transaction)
-      }
-    end
-
-    context "adding a transaction with an exception" do
-      let(:transaction) { transaction_with_exception }
-
-      specify { transaction.should_receive(:clear_events!) }
-      specify { transaction.should_receive(:convert_values_to_primitives!) }
-    end
-
-    after { subject }
-  end
-
-  describe "#has_transactions?" do
-    subject { aggregator.has_transactions? }
-
-    context "with an empty queue" do
-      it { should be_false }
-    end
-
-    context "with an non empty queue" do
-      before { aggregator.add(regular_transaction) }
-
-      it { should be_true }
-    end
-  end
-
-  describe "#post_processed_queue!" do
-    let(:transaction) { slow_transaction }
-    let(:other_transaction) { regular_transaction }
-    subject { aggregator.post_processed_queue! }
-    before do
-      aggregator.add(transaction)
-      aggregator.add(other_transaction)
-    end
-
-    it { should be_a Array }
-
-    it "calls to_hash on each transaction in the queue" do
-      transaction.should_receive(:to_hash)
-      other_transaction.should_receive(:to_hash)
-      subject
-    end
-  end
-
-  # protected
-
-  describe "#similar_slowest" do
-    subject { aggregator.send(:similar_slowest, transaction) }
-    before { aggregator.add(other_transaction) }
-
-    context "passing a transaction concerning a different action" do
-      let(:transaction) { slow_transaction }
-      let(:other_transaction) do
-        time = Time.parse('01-01-2001 10:01:00')
-        appsignal_transaction(
-          :process_action_event => notification_event(
-            :payload => create_payload(
-              :action => 'show',
-              :controller => 'SomeOtherController'
-            )
-          )
-        )
-      end
-
-      it { should be_nil }
-    end
-
-    context "passing concerning the same action" do
-      let(:transaction) { slow_transaction }
-      let(:other_transaction) { slower_transaction }
-
-      it { should == other_transaction }
-    end
-  end
-
-  describe "#pre_process_slowness!" do
-    subject { aggregator.send(:pre_process_slowness!, transaction) }
-
-    context "without a similar slow transaction" do
-      let(:transaction) { slow_transaction }
-
-      it "calls convert_values_to_primitives on transaction" do
-        transaction.should_receive(:convert_values_to_primitives!)
-        subject
-      end
-
-      it "indexes the slow transaction" do
-        expect { subject }.to change(aggregator, :slowness_index).
-          to({transaction.action => transaction})
-      end
-    end
-
-    context "with a non similar slow transaction" do
-      let(:transaction) { slow_transaction }
-      let(:other_transaction) do
-        time = Time.parse('01-01-2001 10:01:00')
-        appsignal_transaction(
-          :process_action_event => notification_event(
-            :action => 'foooo',
-            :start => time,
-            :ending => time + Appsignal.config[:slow_request_threshold] / 500.0
-          )
-        )
-      end
-
-      it "calls convert_values_to_primitives on transaction" do
-        transaction.should_receive(:convert_values_to_primitives!)
-        subject
-      end
-
-      it "indexes the slow transaction" do
-        expect { subject }.to change(aggregator, :slowness_index).to({
-          other_transaction.action => other_transaction,
-          transaction.action => transaction
-        })
-      end
-    end
-
-    context "with a similar but slower transaction" do
-      let(:transaction) { slow_transaction }
-      let(:slower) { slower_transaction }
-      before { aggregator.add(slower) }
-
-      it "calls truncate on the transaction" do
-        transaction.should_receive(:truncate!)
-        transaction.should_not_receive(:convert_values_to_primitives!)
-        subject
-      end
-
-      it "does not index the slow transaction" do
-        expect { subject }.to_not change(aggregator, :slowness_index)
-      end
-
-      it "does not modify the slow transaction" do
-        slower.should_not_receive(:truncate!)
-        slower.should_not_receive(:convert_values_to_primitives!)
-        subject
-      end
-    end
-
-    context "with a similar but faster transaction" do
-      let(:transaction) { slower_transaction }
-      let(:faster_transaction) { slow_transaction }
-      before { aggregator.add(faster_transaction) }
-
-      it "calls truncate on the faster transaction" do
-        faster_transaction.should_receive(:truncate!)
-        subject
-      end
-
-      it "calls convert_values_to_primitives on the (slower) transaction" do
-        transaction.should_receive(:convert_values_to_primitives!)
-        subject
-      end
-
-      it "indexes the slow transaction" do
-        expect { subject }.to change(aggregator, :slowness_index).
-          to({faster_transaction.action => transaction})
-      end
-    end
-  end
-end