appsignal 0.4.0

data/spec/appsignal/transaction/transaction_formatter_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Appsignal::TransactionFormatter do
+  let(:klass) { Appsignal::TransactionFormatter }
+  let(:formatter) { klass.new(transaction) }
+  let(:transaction) do
+    Appsignal::Transaction.create('1', {
+      'HTTP_USER_AGENT' => 'IE6',
+      'SERVER_NAME' => 'localhost',
+      'action_dispatch.routes' => 'not_available'
+    })
+  end
+  subject { formatter }
+
+  describe ".regular" do
+    subject { klass.regular(transaction) }
+    it { should be_a klass::RegularRequestFormatter }
+  end
+
+  describe ".slow" do
+    subject { klass.slow(transaction) }
+    it { klass.slow(transaction).should be_a klass::SlowRequestFormatter }
+  end
+
+  describe ".faulty" do
+    subject { klass.faulty(transaction) }
+    it { should be_a klass::FaultyRequestFormatter }
+  end
+
+  context "a new formatter" do
+    describe "#to_hash" do
+      subject { formatter.to_hash }
+      before { formatter.stub(:action => :foo, :formatted_process_action_event => :bar) }
+
+      it 'returns a formatted hash of the transaction data' do
+        should == {
+          :request_id => '1',
+          :action => :foo,
+          :log_entry => :bar,
+          :failed => false
+        }
+      end
+    end
+  end
+
+  # protected
+
+  it { should delegate(:id).to(:transaction) }
+  it { should delegate(:events).to(:transaction) }
+  it { should delegate(:exception).to(:transaction) }
+  it { should delegate(:exception?).to(:transaction) }
+  it { should delegate(:env).to(:transaction) }
+  it { should delegate(:request).to(:transaction) }
+  it { should delegate(:process_action_event).to(:transaction) }
+  it { should delegate(:action).to(:transaction) }
+
+  it { should delegate(:payload).to(:process_action_event) }
+
+  context "a new formatter" do
+    describe "#formatted_process_action_event" do
+      subject { formatter.send(:formatted_process_action_event) }
+
+      it "calls basic_process_action_event" do
+        formatter.should_receive(:basic_process_action_event)
+        subject
+      end
+
+      context "with actual process action event data" do
+        before { transaction.set_process_action_event(create_process_action_event) }
+
+        it { should be_a Hash }
+
+        it "merges formatted_payload on the basic_process_action_event" do
+          subject[:duration].should == 1000.0
+          subject[:action].should == 'BlogPostsController#show'
+        end
+      end
+
+      context "without any process action event data" do
+        it { should be_a Hash }
+
+        it "does not merge formatted_payload onto the basic_process_action_event" do
+          subject.keys.should_not include :duration
+          subject.keys.should_not include :action
+        end
+      end
+    end
+
+    describe "#basic_process_action_event" do
+      subject { formatter.send(:basic_process_action_event) }
+      before do
+        transaction.stub(:request => mock(
+          :fullpath => '/blog',
+          :session => {:current_user => 1})
+        )
+      end
+
+      it { should == {
+        :path => '/blog',
+        :kind => 'http_request'
+      } }
+
+      it "has no environment key" do
+        subject[:environment].should be_nil
+      end
+
+      it "has no session_data key" do
+        subject[:session_data].should be_nil
+      end
+    end
+
+    describe "#formatted_payload" do
+      let(:start_time) { Time.at(2.71828182) }
+      let(:end_time) { Time.at(3.141592654) }
+      subject { formatter.send(:formatted_payload) }
+      before do
+        transaction.stub(:sanitized_event_payload => {})
+        transaction.set_process_action_event(mock(
+          :name => 'name',
+          :duration => 2,
+          :time => start_time,
+          :end => end_time,
+          :payload => {
+            :controller => 'controller',
+            :action => 'action'
+          }
+        ))
+      end
+
+      it { should == {
+        :action => 'controller#action',
+        :controller => 'controller', # DEBUG this should no longer be here now
+        :duration => 2,
+        :time => start_time.to_f,
+        :end => end_time.to_f
+      } }
+    end
+
+    describe "#sanitized_event_payload" do
+      subject do
+        formatter.send(:sanitized_event_payload, double(:payload => {:key => :sensitive}))
+      end
+
+      it "calls Appsignal event payload sanitizer" do
+        Appsignal.should_receive(:event_payload_sanitizer).and_return(
+          proc do |event|
+            event.payload[:key] = 'censored'
+            event.payload
+          end
+        )
+        subject.should == {:key => 'censored'}
+      end
+
+      it "calls params sanitizer" do
+        Appsignal::ParamsSanitizer.should_receive(:sanitize).and_return(
+          :key => 'sensitive'
+        )
+        subject.should == {:key => 'sensitive'}
+      end
+    end
+
+    describe "#filtered_environment" do
+      subject { formatter.send(:filtered_environment) }
+
+      it "should have a SERVER_NAME" do
+        subject['SERVER_NAME'].should == 'localhost'
+      end
+
+      it "should have a HTTP_USER_AGENT" do
+        subject['HTTP_USER_AGENT'].should == 'IE6'
+      end
+
+      it "should not have a action_dispatch.routes" do
+        subject.should_not have_key 'action_dispatch.routes'
+      end
+    end
+  end
+end

data/spec/appsignal/transaction_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe Appsignal::Transaction do
+  describe '.create' do
+    before { Appsignal::Transaction.create('1', {}) }
+
+    it 'should add the id to the thread' do
+      Thread.current[:appsignal_transaction_id].should == '1'
+    end
+
+    it 'should add the transaction to the list' do
+      Appsignal.transactions['1'].should be_a Appsignal::Transaction
+    end
+  end
+
+  describe '.current' do
+    let(:transaction) { Appsignal::Transaction.create('1', {}) }
+    before { transaction }
+    subject { Appsignal::Transaction.current }
+
+    it 'should return the correct transaction' do
+      should eq transaction
+    end
+  end
+
+  describe 'transaction instance' do
+    let(:transaction) do
+      Appsignal::Transaction.create('1', {
+        'HTTP_USER_AGENT' => 'IE6',
+        'SERVER_NAME' => 'localhost',
+        'action_dispatch.routes' => 'not_available'
+      })
+    end
+
+    describe '#request' do
+      subject { transaction.request }
+
+      it { should be_a ActionDispatch::Request }
+    end
+
+    describe '#set_process_action_event' do
+      let(:process_action_event) { create_process_action_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') }
+
+      it 'should add an event' do
+        expect {
+          transaction.add_event(event)
+        }.to change(transaction, :events).to([event])
+      end
+    end
+
+    describe '#add_exception' do
+      let(:exception) {stub(:name => 'test') }
+
+      it 'should add an exception' do
+        expect {
+          transaction.add_exception(exception)
+        }.to change(transaction, :exception).to(exception)
+      end
+    end
+
+    describe '#slow_request?' do
+      let(:duration) { 199 }
+      subject { transaction.slow_request? }
+      before { transaction.set_process_action_event(
+        stub(:duration => duration, :payload => {})
+      ) }
+
+      it { should be_false }
+
+      context "when the request took too long" do
+        let(:duration) { 200 }
+
+        it { should be_true }
+      end
+
+      context "when process action event is empty" do
+        before { transaction.set_process_action_event(nil) }
+
+        it { should be_false }
+      end
+
+      context "when process action event does not have a payload" do
+        before { transaction.set_process_action_event(stub(:payload => nil)) }
+
+        it { should be_false }
+      end
+    end
+
+    describe "#clear_payload_and_events!" do
+      subject { slow_transaction }
+
+      it "should clear the process action payload and events" do
+        subject.clear_payload_and_events!
+
+        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) }
+
+      context "with an exception request" do
+        before { transaction.stub(:exception? => true) }
+
+        it "calls TransactionFormatter.faulty with self" do
+          Appsignal::TransactionFormatter.should_receive(:faulty).
+            with(transaction).and_return({})
+        end
+      end
+
+      context "with a slow request" do
+        before { transaction.stub(:slow_request? => true) }
+
+        it "calls TransactionFormatter.slow with self" do
+          Appsignal::TransactionFormatter.should_receive(:slow).
+            with(transaction).and_return({})
+        end
+      end
+
+      context "with a regular request" do
+        before { transaction.stub(:slow_request? => false) }
+
+        it "calls TransactionFormatter.slow with self" do
+          Appsignal::TransactionFormatter.should_receive(:regular).
+            with(transaction).and_return({})
+        end
+      end
+
+      after { subject }
+    end
+
+    describe '#complete!' do
+      before { transaction.set_process_action_event(
+        stub(:duration => 199, :time => Time.now, :payload => nil)
+      ) }
+
+      it 'should remove transaction from the list' do
+        expect {
+          transaction.complete!
+        }.to change(Appsignal.transactions, :length).by(-1)
+      end
+
+      context 'calling the appsignal agent' do
+        context 'without events and exception' do
+          it 'should add transaction to the agent' do
+            Appsignal.agent.should_receive(:add_to_queue).with(transaction)
+          end
+        end
+
+        context 'with events' do
+          before { transaction.add_event(stub) }
+
+          it 'should add transaction to the agent' do
+            Appsignal.agent.should_receive(:add_to_queue).with(transaction)
+          end
+        end
+
+        context 'with exception' do
+          before { transaction.add_exception(stub) }
+
+          it 'should add transaction to the agent' do
+            Appsignal.agent.should_receive(:add_to_queue).with(transaction)
+          end
+        end
+
+        after { transaction.complete! }
+      end
+
+      context 'thread' do
+        before { transaction.complete! }
+
+        it 'should reset the thread transaction id' do
+          Thread.current[:appsignal_transaction_id].should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/appsignal/transmitter_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Appsignal::Transmitter do
+  let(:_80beans_) { 'http://www.80beans.com' }
+  let(:action) { 'action' }
+  let(:klass) { Appsignal::Transmitter }
+  let(:instance) { klass.new(_80beans_, action, :the_api_key) }
+  subject { instance }
+
+  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}")
+    end
+  end
+
+  describe "#transmit" do
+    let(:http_client) { stub(:request => stub(:code => '200')) }
+    before { instance.stub(:http_client => http_client) }
+
+    subject { instance.transmit(:shipit => :payload) }
+
+    it { should == '200' }
+  end
+
+  describe "#http_post" do
+    it "calls Net::HTTP.post_form with the correct params" do
+      post = stub
+      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}"
+      ).and_return(post)
+      instance.send(:http_post, :the => :payload)
+    end
+  end
+
+  describe "ca_file_path" do
+    subject { instance.send(:ca_file_path) }
+
+    it { should include('resources/cacert.pem') }
+    it("should exist") { File.exists?(subject).should be_true }
+  end
+
+  describe "#http_client" do
+    subject { instance.send(:http_client) }
+
+    context "with a http uri" do
+      it { should be_instance_of(Net::HTTP) }
+
+      its(:use_ssl?) { should be_false }
+    end
+
+    context "with a https uri" do
+      let(:instance) { klass.new('https://www.80beans.com', action, :the_api_key) }
+
+      its(:use_ssl?) { should be_true }
+      its(:verify_mode) { should == OpenSSL::SSL::VERIFY_PEER }
+      its(:ca_file) { include('resources/cacert.pem') }
+    end
+  end
+end

data/spec/appsignal_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Appsignal do
+  it { should respond_to :subscriber }
+
+  describe ".transactions" do
+    subject { Appsignal.transactions }
+
+    it { should be_a Hash }
+  end
+
+  describe '.agent' do
+    subject { Appsignal.agent }
+
+    it { should be_a Appsignal::Agent }
+  end
+
+  describe '.logger' do
+    subject { Appsignal.logger }
+
+    it { should be_a Logger }
+    its(:level) { should == Logger::INFO }
+  end
+
+  describe '.config' do
+    subject { Appsignal.config }
+
+    it 'should return the endpoint' do
+      subject[:endpoint].should eq 'http://localhost:3000/1'
+    end
+
+    it 'should return the api key' do
+      subject[:api_key].should eq 'abc'
+    end
+
+    it 'should return ignored exceptions' do
+      subject[:ignore_exceptions].should eq []
+    end
+
+    it 'should return the slow request threshold' do
+      subject[:slow_request_threshold].should eq 200
+    end
+  end
+
+  describe '.active?' do
+    subject { Appsignal.active? }
+
+    context "without config" do
+      before { Appsignal.stub(:config => nil) }
+
+      it { should be_false }
+    end
+
+    context "with config but inactive" do
+      before { Appsignal.stub(:config => {:active => false}) }
+
+      it { should be_false }
+    end
+
+    context "with active config" do
+      before { Appsignal.stub(:config => {:active => true}) }
+
+      it { should be_true }
+    end
+  end
+end