appsignal 0.11.18 → 0.12.beta.0

data/spec/lib/appsignal/integrations/sinatra_spec.rb

@@ -22,12 +22,6 @@ if defined?(::Sinatra)
       it { should be_a(Appsignal::Config) }
     end
 
-    context "agent" do
-      subject { Appsignal.agent }
-
-      it { should be_a(Appsignal::Agent) }
-    end
-
     it "should have added the listener middleware" do
       Sinatra::Application.middleware.to_a.should include(
         [Appsignal::Rack::Listener, [], nil]

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -1,15 +1,16 @@
 require 'spec_helper'
 
 describe Appsignal::JSExceptionTransaction do
-  let(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
+  before { SecureRandom.stub(:uuid => '123abc') }
+
+  let!(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
   let(:data) do
     {
       'name'        => 'TypeError',
       'message'     => 'foo is not a valid method',
       'action'      => 'ExceptionIncidentComponent',
       'path'        => 'foo.bar/moo',
-      'environment' => {"user_agent" => "Mozilla/5.0"},
-      'tags'        => {"intercom_user_id" => "abc123"},
+      'environment' => 'development',
       'backtrace'   => [
         'foo.bar/js:11:1',
         'foo.bar/js:22:2',
@@ -17,77 +18,73 @@ describe Appsignal::JSExceptionTransaction do
     }
   end
 
-  describe "#type" do
-    it "should return `:exception`" do
-      expect( transaction.type ).to eql :exception
-    end
-  end
+  describe "#initialize" do
+    it "should call all required methods" do
+      expect( Appsignal::Extension ).to receive(:start_transaction).with('123abc')
 
-  describe "#action" do
-    it "should return the action" do
-      expect( transaction.action ).to eql 'ExceptionIncidentComponent'
-    end
-  end
+      expect( transaction ).to receive(:set_base_data)
+      expect( transaction ).to receive(:set_metadata)
+      expect( transaction ).to receive(:set_error)
+      expect( transaction ).to receive(:set_error_data)
 
-  describe "#clear_events" do
-    it "should respond to `clear_events!`" do
-      expect( transaction ).to respond_to :clear_events!
+      transaction.send :initialize, data
     end
   end
 
-  describe "#convert_values_to_primitives!" do
-    it "should respond to `convert_values_to_primitives!`" do
-      expect( transaction ).to respond_to :convert_values_to_primitives!
+  describe "#set_base_data" do
+    it "should call `Appsignal::Extension.set_transaction_basedata`" do
+      expect( Appsignal::Extension ).to receive(:set_transaction_basedata).with(
+        '123abc',
+        'frontend',
+        'ExceptionIncidentComponent',
+        0
+      )
+
+      transaction.set_base_data
     end
   end
 
-  describe "#events" do
-    it "should respond to `events` with an empty array" do
-      expect( transaction.events ).to eql []
-    end
+  describe "#set_metadata" do
+   it "should call `Appsignal::Extension.set_transaction_metadata`" do
+     expect( Appsignal::Extension ).to receive(:set_transaction_metadata).with(
+      '123abc',
+       'path',
+       'foo.bar/moo'
+     )
+
+     transaction.set_metadata
+   end
   end
 
-  describe "#to_hash" do
-    around do |sample|
-      Timecop.freeze(Time.at(123)) { sample.run }
-    end
+  describe "#set_error" do
+   it "should call `Appsignal::Extension.set_transaction_error`" do
+     expect( Appsignal::Extension ).to receive(:set_transaction_error).with(
+      '123abc',
+       'TypeError',
+       'foo is not a valid method'
+     )
 
-    before do
-      SecureRandom.stub(:uuid => 'uuid')
-      Appsignal.stub(:agent => double(:revision => 'abcdef'))
-    end
+     transaction.set_error
+   end
+  end
 
-    it "should generate a hash based on the given data" do
-      expect( transaction.to_hash).to eql({
-        :request_id => 'uuid',
-        :log_entry => {
-          :action      => 'ExceptionIncidentComponent',
-          :path        => 'foo.bar/moo',
-          :kind        => 'frontend',
-          :time        => 123,
-          :environment => {"user_agent" => "Mozilla/5.0"},
-          :tags        => {"intercom_user_id" => "abc123"},
-          :revision    => 'abcdef'
-        },
-        :exception => {
-          :exception => 'TypeError',
-          :message   => 'foo is not a valid method',
-          :backtrace => [
-            'foo.bar/js:11:1',
-            'foo.bar/js:22:2',
-          ]
-        },
-        :failed => true
-      })
-    end
+  describe "#set_error_data" do
+   it "should call `Appsignal::Extension.set_transaction_error_data`" do
+     expect( Appsignal::Extension ).to receive(:set_transaction_error_data).with(
+      '123abc',
+      'backtrace',
+      '["foo.bar/js:11:1","foo.bar/js:22:2"]'
+     )
 
-    describe "#complete!" do
-      it "should enqueue itself" do
-        expect( Appsignal ).to receive(:enqueue).with(transaction)
+     transaction.set_error_data
+   end
+  end
 
-        transaction.complete!
-      end
+  describe "#complete!" do
+    it "should call all required methods" do
+      expect( Appsignal::Extension ).to receive(:finish_transaction).with('123abc')
+      transaction.complete!
     end
-
   end
+
 end

data/spec/lib/appsignal/params_sanitizer_spec.rb

@@ -6,54 +6,39 @@ class ErrorOnInspect
   end
 end
 
-class ClassWithInspect
-  def inspect
-    "#<ClassWithInspect foo=\"bar\"/>"
-  end
-end
-
 describe Appsignal::ParamsSanitizer do
   let(:klass) { Appsignal::ParamsSanitizer }
   let(:file) { uploaded_file }
   let(:params) do
     {
-      :text       => 'string',
-      :file       => file,
-      :float      => 0.0,
-      :bool_true  => true,
-      :bool_false => false,
-      :int        => 1,
-      :hash       => {
-        :nested_text  => 'string',
+      :text => 'string',
+      :file => file,
+      :hash => {
+        :nested_text => 'string',
         :nested_array => [
           'something',
           'else',
           file,
           {
-            :key  => 'value',
+            :key => 'value',
             :file => file,
           },
-          ErrorOnInspect.new,
-          ClassWithInspect.new
+          ErrorOnInspect.new
         ]
       }
     }
   end
   let(:sanitized_params) { klass.sanitize(params) }
-  let(:scrubbed_params)  { klass.scrub(params) }
+  let(:scrubbed_params) { klass.scrub(params) }
 
   describe ".sanitize!" do
     subject { params }
     before { klass.sanitize!(subject) }
 
     it { should be_instance_of Hash }
-    its([:text])        { should == 'string' }
-    its([:file])        { should be_instance_of String }
-    its([:file])        { should include '::UploadedFile' }
-    its([:float])       { should == 0.0 }
-    its([:int])         { should == 1 }
-    its([:bool_true])   { should == 'true' }
-    its([:bool_false])  { should == 'false' }
+    its([:text]) { should == 'string' }
+    its([:file]) { should be_instance_of String }
+    its([:file]) { should include '::UploadedFile' }
 
     context "hash" do
       subject { params[:hash] }
@@ -69,8 +54,7 @@ describe Appsignal::ParamsSanitizer do
         its([1]) { should == 'else' }
         its([2]) { should be_instance_of String }
         its([2]) { should include '::UploadedFile' }
-        its([4]) { should == '#<ErrorOnInspect>' }
-        its([5]) { should == '#<ClassWithInspect>' }
+        its([4]) { should == '#<ErrorOnInspect/>' }
 
         context "nested hash" do
           subject { params[:hash][:nested_array][3] }

data/spec/lib/appsignal/rack/listener_spec.rb

@@ -19,7 +19,7 @@ describe Appsignal::Rack::Listener do
   let(:env) { {} }
 
   describe '#call' do
-    let(:current) { double(:complete! => true, :add_exception => true) }
+    let(:current) { double(:request_id => '1', :set_error => true) }
     before do
       middleware.stub(:request_id => '1')
       Appsignal::Transaction.stub(:current => current)
@@ -31,7 +31,7 @@ describe Appsignal::Rack::Listener do
       end
 
       it 'should call complete! after the call' do
-        current.should_receive(:complete!)
+        Appsignal::Transaction.should_receive(:complete_current!)
       end
 
       context "when not active" do
@@ -55,7 +55,7 @@ describe Appsignal::Rack::Listener do
       end
 
       it 'should catch the exception and notify the transaction of it' do
-        current.should_receive(:add_exception)
+        current.should_receive(:set_error)
         middleware.call(env) rescue nil
       end
 
@@ -69,14 +69,14 @@ describe Appsignal::Rack::Listener do
         end
 
         it 'should ignore the error' do
-          current.should_not_receive(:add_exception)
+          current.should_not_receive(:set_error)
           middleware.call(env) rescue nil
         end
       end
 
       describe 'after an error' do
-        it 'should call complete! after the call' do
-          current.should_receive(:complete!)
+        it 'should call complete_current! after the call' do
+          Appsignal::Transaction.should_receive(:complete_current!)
         end
 
         after { middleware.call(env) rescue nil }

data/spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb

@@ -23,34 +23,6 @@ if defined?(::Sinatra)
     let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app, {}) }
 
     describe "#call" do
-     before do
-       middleware.stub(:raw_payload => {})
-     end
-
-      context "when appsignal is active" do
-        before { Appsignal.stub(:active? => true) }
-
-        it "should call with monitoring" do
-          expect( middleware ).to receive(:call_with_appsignal_monitoring).with(env)
-        end
-      end
-
-      context "when appsignal is not active" do
-        before { Appsignal.stub(:active? => false) }
-
-        it "should not call with monitoring" do
-          expect( middleware ).to_not receive(:call_with_appsignal_monitoring)
-        end
-
-        it "should call the stack" do
-          expect( app ).to receive(:call).with(env)
-        end
-      end
-
-      after { middleware.call(env) }
-    end
-
-    describe "#call_with_appsignal_monitoring" do
       before do
         middleware.stub(:raw_payload => {})
         env['sinatra.route'] = 'GET /'
@@ -59,7 +31,7 @@ if defined?(::Sinatra)
       it "should instrument the call" do
         app.should_receive(:call).with(env)
 
-        middleware.call_with_appsignal_monitoring(env)
+        middleware.call(env)
 
         process_action_event = @events.last
         process_action_event.name.should == 'process_action.sinatra'
@@ -70,26 +42,13 @@ if defined?(::Sinatra)
         app.should_receive(:call).with(env).and_raise('the roof')
 
         lambda {
-          middleware.call_with_appsignal_monitoring(env)
+          middleware.call(env)
         }.should raise_error
 
         process_action_event = @events.last
         process_action_event.name.should == 'process_action.sinatra'
         process_action_event.payload[:action].should == 'GET /'
       end
-
-      it "should add exceptions stored in env under sinatra.error" do
-        exception = RuntimeError.new('Raise the roof')
-        env['sinatra.error'] = exception
-
-        transaction = double
-        transaction.stub(:set_process_action_event)
-        transaction.stub(:add_event)
-        Appsignal.should_receive(:add_exception).with(exception)
-        Appsignal::Transaction.stub(:current => transaction)
-
-        middleware.call_with_appsignal_monitoring(env)
-      end
     end
 
     describe "raw_payload" do

data/spec/lib/appsignal/subscriber_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe Appsignal::Subscriber do
+  before :all do
+    start_agent
+  end
+
+  before do
+    Thread.current[:appsignal_transaction] = nil
+  end
+
+  let(:subscriber) { Appsignal.subscriber }
+  subject { subscriber }
+
+  context "initialization" do
+    it "should be in the subscriber list" do
+      ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers).select do |s|
+        s.instance_variable_get(:@delegate).is_a?(Appsignal::Subscriber)
+      end.count == 1
+    end
+  end
+
+  context "subscriptions" do
+    describe "subscribe" do
+      it "should subscribe" do
+        ActiveSupport::Notifications.should_receive(:subscribe).with(/^[^!]/, subject).at_least(:once)
+
+        subject.subscribe
+      end
+    end
+
+    describe "#unsubscribe" do
+      it "should unsubscribe" do
+        ActiveSupport::Notifications.should_receive(:unsubscribe).with(subject).at_least(:once)
+
+        subject.unsubscribe
+      end
+    end
+
+    describe "#resubscribe" do
+      it "should unsubscribe and subscribe" do
+        subject.should_receive(:unsubscribe).at_least(:once)
+        subject.should_receive(:subscribe)
+
+        subject.resubscribe
+      end
+    end
+  end
+
+  describe "#publish" do
+    it "should exist" do
+      lambda {
+        subject.publish('name', '')
+      }.should_not raise_error
+    end
+  end
+
+  context "handling events using #start and #finish" do
+    it "should should not listen to events that start with a bang" do
+      subject.should_not_receive(:start)
+      subject.should_not_receive(:finish)
+
+      ActiveSupport::Notifications.instrument '!render_template'
+    end
+
+    it "should not record events when there is no current transaction" do
+      Appsignal::Extension.should_not_receive(:start_event)
+      Appsignal::Extension.should_not_receive(:finish_event)
+
+      lambda {
+        ActiveSupport::Notifications.instrument 'something'
+      }.should_not raise_error
+    end
+
+    context "with a current transaction" do
+      let(:transaction) { Appsignal::Transaction.current }
+
+      before do
+        Appsignal::Transaction.create('request-id', {})
+      end
+
+      it "should call native start and finish event for every event" do
+        Appsignal::Extension.should_receive(:start_event).exactly(4).times
+        Appsignal::Extension.should_receive(:finish_event).with('request-id', 'one', '', '').once
+        Appsignal::Extension.should_receive(:finish_event).with('request-id', 'two', '', '').once
+        Appsignal::Extension.should_receive(:finish_event).with('request-id', 'two.three', '', '').once
+        Appsignal::Extension.should_receive(:finish_event).with('request-id', 'one.three', '', '').once
+
+        ActiveSupport::Notifications.instrument('one') do
+          ActiveSupport::Notifications.instrument('two') do
+            ActiveSupport::Notifications.instrument('one.three') do
+            end
+            ActiveSupport::Notifications.instrument('two.three') do
+            end
+          end
+        end
+      end
+
+      it "should call finish with title and body if there is a formatter" do
+          Appsignal::Extension.should_receive(:start_event).once
+          Appsignal::Extension.should_receive(:finish_event).with(
+            'request-id',
+            'request.net_http',
+            'GET http://www.google.com',
+            ''
+          ).once
+
+          ActiveSupport::Notifications.instrument(
+            'request.net_http',
+            :protocol => 'http',
+            :domain   => 'www.google.com',
+            :method   => 'GET'
+          )
+      end
+
+      context "root event" do
+        it "should not set the root event for normal events" do
+          transaction.should_not_receive(:set_root_event)
+
+          ActiveSupport::Notifications.instrument 'something'
+        end
+
+        it "should set the root event when the name starts with process_action" do
+          transaction.respond_to?(:set_root_event).should be_true
+          transaction.should_receive(:set_root_event).with(
+            'process_action.action_controller',
+            :params => {}
+          )
+
+          ActiveSupport::Notifications.instrument 'process_action.action_controller', {:params => {}}
+        end
+
+        it "should set the root event when the name starts with perform_job" do
+          transaction.respond_to?(:set_root_event).should be_true
+          transaction.should_receive(:set_root_event).with(
+            'perform_job.resque',
+            :params => {}
+          )
+
+          ActiveSupport::Notifications.instrument 'perform_job.resque', {:params => {}}
+        end
+      end
+
+      context "when paused" do
+        before { transaction.pause! }
+
+        it "should set a root event, but no other events" do
+          Appsignal::Extension.should_not_receive(:start_event)
+          Appsignal::Extension.should_not_receive(:finish_event)
+
+          transaction.respond_to?(:set_root_event).should be_true
+          transaction.should_receive(:set_root_event).with(
+            'perform_job.resque',
+            :params => {}
+          )
+
+          ActiveSupport::Notifications.instrument 'perform_job.resque', {:params => {}}
+        end
+      end
+    end
+  end
+end