appsignal 0.4.7 → 0.5.0

data/spec/appsignal/transaction_spec.rb

@@ -39,18 +39,17 @@ describe Appsignal::Transaction do
     end
 
     describe '#set_process_action_event' do
-      let(:process_action_event) { create_process_action_event }
+      let(:process_action_event) { notification_event }
 
       it 'should add a process action event' do
         transaction.set_process_action_event(process_action_event)
 
         transaction.process_action_event.should == process_action_event
-        transaction.action.should == 'BlogPostsController#show'
       end
     end
 
     describe '#add_event' do
-      let(:event) {stub(:name => 'test') }
+      let(:event) { mock(:event, :name => 'test') }
 
       it 'should add an event' do
         expect {
@@ -59,29 +58,54 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe '#add_exception' do
-      let(:exception) {stub(:name => 'test') }
+    context "using exceptions" do
+      let(:exception) { mock(:exception, :name => 'test') }
 
-      it 'should add an exception' do
-        expect {
-          transaction.add_exception(exception)
-        }.to change(transaction, :exception).to(exception)
+      describe '#add_exception' do
+        it 'should add an exception' do
+          expect {
+            transaction.add_exception(exception)
+          }.to change(transaction, :exception).to(exception)
+        end
+      end
+
+      describe "#exception?" do
+        subject { transaction.exception? }
+
+        context "without an exception" do
+          it { should be_false }
+        end
+
+        context "without an exception" do
+          before { transaction.add_exception(exception) }
+
+          it { should be_true }
+        end
       end
     end
 
     describe '#slow_request?' do
-      let(:duration) { 199 }
+      let(:start) { Time.now }
       subject { transaction.slow_request? }
-      before { transaction.set_process_action_event(
-        stub(:duration => duration, :payload => {})
-      ) }
 
-      it { should be_false }
+      context "duration" do
+        before do
+          transaction.set_process_action_event(
+            notification_event(:start => start, :ending => start + duration)
+          )
+        end
 
-      context "when the request took too long" do
-        let(:duration) { 200 }
+        context "when it reasonably fast" do
+          let(:duration) { 0.199 } # in seconds
 
-        it { should be_true }
+          it { should be_false }
+        end
+
+        context "when the request took too long" do
+          let(:duration) { 0.200 } # in seconds
+
+          it { should be_true }
+        end
       end
 
       context "when process action event is empty" do
@@ -91,88 +115,148 @@ describe Appsignal::Transaction do
       end
 
       context "when process action event does not have a payload" do
-        before { transaction.set_process_action_event(stub(:payload => nil)) }
+        let(:event) { notification_event }
+        before do
+          event.instance_variable_set(:@payload, nil)
+          transaction.set_process_action_event(event)
+        end
 
         it { should be_false }
       end
     end
 
-    describe "#clear_payload_and_events!" do
+    describe "#slower?" do
+      context "comparing to a slower transaction" do
+        subject { regular_transaction.slower?(slow_transaction) }
+
+        it { should be_false }
+      end
+
+      context "comparing to a faster transaction" do
+        subject { slow_transaction.slower?(regular_transaction) }
+
+        it { should be_true }
+      end
+    end
+
+    describe "#truncate!" do
       subject { slow_transaction }
 
       it "should clear the process action payload and events" do
-        subject.clear_payload_and_events!
+        subject.truncate!
 
         subject.process_action_event.payload.should be_empty
         subject.events.should be_empty
       end
     end
 
-    describe '#to_hash' do
-      subject { transaction.to_hash }
-      before { transaction.stub(:exception? => false) }
+    describe "#convert_values_to_primitives!" do
+      let(:transaction) { slow_transaction }
+      let(:action_event_payload) { transaction.process_action_event.payload }
+      let(:event_payload) { transaction.events.first.payload }
+      let(:weird_class) { Class.new }
+
+      context "with values that need to be converted" do
+        context "process action event payload" do
+          subject { action_event_payload }
+          before do
+            action_event_payload.clear
+            action_event_payload.
+              merge!(:model => {:with => [:weird, weird_class]})
+            transaction.convert_values_to_primitives!
+          end
+
+          it { should == {:model => {:with => [:weird, weird_class.inspect]}} }
+        end
 
-      context "with an exception request" do
-        before { transaction.stub(:exception? => true) }
+        context "payload of events" do
+          subject { event_payload }
+          before do
+            event_payload.clear
+            event_payload.merge!(:weird => weird_class)
+            transaction.convert_values_to_primitives!
+          end
 
-        it "calls TransactionFormatter.faulty with self" do
-          Appsignal::TransactionFormatter.should_receive(:faulty).
-            with(transaction).and_return({})
+          it { should == {:weird => weird_class.inspect} }
         end
       end
 
-      context "with a slow request" do
-        before { transaction.stub(:slow_request? => true) }
+      context "without values that need to be converted" do
+        subject { transaction.convert_values_to_primitives! }
+
+        it "doesn't change the action event payload" do
+          before = action_event_payload.dup
+          subject
+          action_event_payload.should == before
+        end
 
-        it "calls TransactionFormatter.slow with self" do
-          Appsignal::TransactionFormatter.should_receive(:slow).
-            with(transaction).and_return({})
+        it " doesn't change the event payloads" do
+          before = event_payload.dup
+          subject
+          event_payload.should == before
         end
       end
+    end
 
-      context "with a regular request" do
-        before { transaction.stub(:slow_request? => false) }
+    describe "#type" do
+      context "with a regular transaction" do
+        subject { regular_transaction.type }
 
-        it "calls TransactionFormatter.slow with self" do
-          Appsignal::TransactionFormatter.should_receive(:regular).
-            with(transaction).and_return({})
-        end
+        it { should == :regular_request }
+      end
+
+      context "with a slow transaction" do
+        subject { slow_transaction.type }
+
+        it { should == :slow_request }
       end
 
-      after { subject }
+      context "with an exception transaction" do
+        subject { transaction_with_exception.type }
+
+        it { should == :exception }
+      end
+    end
+
+    describe '#to_hash' do
+      subject { transaction.to_hash }
+
+      it { should be_instance_of Hash }
     end
 
     describe '#complete!' do
-      before { transaction.set_process_action_event(
-        stub(:duration => 199, :time => Time.now, :payload => nil)
-      ) }
+      let(:event) { mock(:event) }
+      before { transaction.set_process_action_event(notification_event) }
 
       it 'should remove transaction from the list' do
-        expect {
-          transaction.complete!
-        }.to change(Appsignal.transactions, :length).by(-1)
+        expect { transaction.complete! }.
+          to change(Appsignal.transactions, :length).by(-1)
       end
 
-      context 'calling the appsignal agent' do
-        context 'without events and exception' do
+      context 'enqueueing' do
+        context 'sanity check' do
+          specify { Appsignal.should respond_to(:enqueue) }
+        end
+
+        context 'without events and without exception' do
           it 'should add transaction to the agent' do
-            Appsignal.agent.should_receive(:add_to_queue).with(transaction)
+            Appsignal.should_receive(:enqueue).with(transaction)
           end
         end
 
         context 'with events' do
-          before { transaction.add_event(stub) }
+          before { transaction.add_event(event) }
 
           it 'should add transaction to the agent' do
-            Appsignal.agent.should_receive(:add_to_queue).with(transaction)
+            Appsignal.should_receive(:enqueue).with(transaction)
           end
         end
 
         context 'with exception' do
-          before { transaction.add_exception(stub) }
+          before { transaction.add_exception(event) }
 
           it 'should add transaction to the agent' do
-            Appsignal.agent.should_receive(:add_to_queue).with(transaction)
+            Appsignal.should_receive(:enqueue).with(transaction)
           end
         end
 
@@ -187,5 +271,54 @@ describe Appsignal::Transaction do
         end
       end
     end
+
+    # protected
+
+    describe '#add_sanitized_context!' do
+      subject { transaction.send(:add_sanitized_context!) }
+
+      it "delegates to sanitize_environment! and sanitize_session_data!" do
+        transaction.should_receive(:sanitize_environment!)
+        transaction.should_receive(:sanitize_session_data!)
+        subject
+      end
+
+      specify { expect { subject }.to change(transaction, :env).to(nil) }
+    end
+
+    describe '#sanitize_environment!' do
+      let(:whitelisted_keys) { Appsignal::Transaction::ENV_METHODS }
+      let(:transaction) { Appsignal::Transaction.create('1', env) }
+      let(:env) do
+        Hash.new.tap do |hash|
+          whitelisted_keys.each { |o| hash[o] = 1 } # use all whitelisted keys
+          hash[:not_whitelisted] = 'I will be sanitized'
+        end
+      end
+      subject { transaction.sanitized_environment }
+      before { transaction.send(:sanitize_environment!) }
+
+      its(:keys) { should == whitelisted_keys }
+    end
+
+    describe '#sanitize_session_data!' do
+      subject { transaction.send(:sanitize_session_data!) }
+      before do
+        transaction.should respond_to(:request)
+        transaction.stub_chain(:request, :session => :foo)
+        transaction.stub_chain(:request, :fullpath => :bar)
+      end
+
+      it "passes the session data into the params sanitizer" do
+        Appsignal::ParamsSanitizer.should_receive(:sanitize).with(:foo).
+          and_return(:sanitized_foo)
+        subject
+        transaction.sanitized_session_data.should == :sanitized_foo
+      end
+
+      it "sets the fullpath of the request" do
+        expect { subject }.to change(transaction, :fullpath).to(:bar)
+      end
+    end
   end
 end

data/spec/appsignal/transmitter_spec.rb

@@ -10,13 +10,16 @@ describe Appsignal::Transmitter do
   describe "#uri" do
     it "returns the uri" do
       Socket.stub(:gethostname => 'app1.local')
-      subject.uri.should ==
-        URI("http://www.80beans.com/action?api_key=the_api_key&hostname=app1.local&gem_version=#{Appsignal::VERSION}")
+      subject.uri.should == URI(
+        "http://www.80beans.com/action?api_key=the_api_key&"\
+        "hostname=app1.local&gem_version=#{Appsignal::VERSION}"
+      )
     end
   end
 
   describe "#transmit" do
-    let(:http_client) { stub(:request => stub(:code => '200')) }
+    let(:response) { mock(:response, :code => '200') }
+    let(:http_client) { mock(:request, :request => response) }
     before { instance.stub(:http_client => http_client) }
 
     subject { instance.transmit(:shipit => :payload) }
@@ -26,13 +29,15 @@ describe Appsignal::Transmitter do
 
   describe "#http_post" do
     it "calls Net::HTTP.post_form with the correct params" do
-      post = stub
-      post.should_receive(:[]=).with('Content-Type', 'application/json; charset=UTF-8')
+      post = mock(:post)
+      post.should_receive(:[]=).
+        with('Content-Type', 'application/json; charset=UTF-8')
       post.should_receive(:body=).with("{\"the\":\"payload\"}")
       Socket.stub(:gethostname => 'app1.local')
 
       Net::HTTP::Post.should_receive(:new).with(
-        "/action?api_key=the_api_key&hostname=app1.local&gem_version=#{Appsignal::VERSION}"
+        "/action?api_key=the_api_key&hostname=app1.local&"\
+        "gem_version=#{Appsignal::VERSION}"
       ).and_return(post)
       instance.send(:http_post, :the => :payload)
     end

data/spec/appsignal_spec.rb

@@ -3,6 +3,17 @@ require 'spec_helper'
 describe Appsignal do
   it { should respond_to :subscriber }
 
+  describe ".enqueue" do
+    let(:transaction) { regular_transaction }
+    subject { Appsignal.enqueue(transaction) }
+
+    it "forwards the call to the agent" do
+      Appsignal.agent.should respond_to(:enqueue)
+      Appsignal.agent.should_receive(:enqueue).with(transaction)
+      subject
+    end
+  end
+
   describe ".transactions" do
     subject { Appsignal.transactions }
 
@@ -42,6 +53,28 @@ describe Appsignal do
     end
   end
 
+  describe ".post_processing_middleware" do
+    before { Appsignal.instance_variable_set(:@post_processing_chain, nil) }
+
+    it "returns the default middleware stack" do
+      Appsignal::PostProcessor.should_receive(:default_middleware)
+      Appsignal.post_processing_middleware
+    end
+
+    it "returns a chain when called without a block" do
+      instance = Appsignal.post_processing_middleware
+      instance.should be_an_instance_of Appsignal::Middleware::Chain
+    end
+
+    context "when passing a block" do
+      it "yields an appsignal middleware chain" do
+        Appsignal.post_processing_middleware do |o|
+          o.should be_an_instance_of Appsignal::Middleware::Chain
+        end
+      end
+    end
+  end
+
   describe '.active?' do
     subject { Appsignal.active? }
 

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require 'rspec'
+require 'pry'
 require 'rails'
 require 'action_controller/railtie'
 
@@ -15,71 +16,17 @@ module MyApp
   end
 end
 
-require 'appsignal'
-
-RSpec.configure do |config|
+def log_file
+  File.join(File.dirname(__FILE__), '../log/appsignal.log')
 end
 
-def transaction_with_exception
-  appsignal_transaction.tap do |o|
-    begin
-      raise ArgumentError, 'oh no'
-    rescue ArgumentError => exception
-      env = {}
-      o.add_exception(
-        Appsignal::ExceptionNotification.new(env, exception)
-      )
-    end
-  end
-end
-
-def regular_transaction
-  appsignal_transaction(:process_action_event => create_process_action_event)
-end
+require 'appsignal'
 
-def slow_transaction
-  appsignal_transaction(
-    :process_action_event => create_process_action_event(nil, nil, Time.parse('01-01-2001 10:01:00'))
-  )
-end
+RSpec.configure do |config|
+  config.include TransactionHelpers
+  config.include NotificationHelpers
 
-def appsignal_transaction(args = {})
-  process_action_event = args.delete(:process_action_event)
-  events = args.delete(:events) || [create_process_action_event(name='query.mongoid')]
-  exception = args.delete(:exception)
-  Appsignal::Transaction.create(
-    '1',
-    {
-      'HTTP_USER_AGENT' => 'IE6',
-      'SERVER_NAME' => 'localhost',
-      'action_dispatch.routes' => 'not_available'
-    }.merge(args)
-  ).tap do |o|
-    o.set_process_action_event(process_action_event)
-    o.add_exception(exception)
-    events.each { |event| o.add_event(event) }
+  config.before :all do
+    FileUtils.rm(log_file) if File.exists?(log_file)
   end
 end
-
-def create_process_action_event(name=nil, start=nil, ending=nil, tid=nil, payload=nil)
-  ActiveSupport::Notifications::Event.new(
-    name || 'process_action.action_controller',
-    start || Time.parse("01-01-2001 10:00:00"),
-    ending || Time.parse("01-01-2001 10:00:01"),
-    tid || '1',
-    payload || create_payload
-  )
-end
-
-def create_payload(args = {})
-  {
-    :path => '/blog',
-    :action => 'show',
-    :controller => 'BlogPostsController',
-    :request_format => 'html',
-    :request_method => "GET",
-    :status => '200',
-    :view_runtime => 500,
-    :db_runtime => 500
-  }.merge(args)
-end