appsignal 0.11.18 → 0.12.beta.0

data/spec/lib/appsignal/event_formatter/net_http/request_formatter_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Appsignal::EventFormatter::NetHttp::RequestFormatter do
+  let(:klass)     { Appsignal::EventFormatter::NetHttp::RequestFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register request.net_http" do
+    Appsignal::EventFormatter.registered?('request.net_http', klass).should be_true
+  end
+
+  describe "#format" do
+    let(:payload) do
+      {
+        :protocol => 'http',
+        :url      => 'appsignal.com',
+        :domain   => 'appsignal.com',
+        :path     => '/about',
+        :method   => 'GET'
+      }
+    end
+
+    subject { formatter.format(payload) }
+
+    it { should == ['GET http://appsignal.com', nil] }
+  end
+end

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+class MockFormatter < Appsignal::EventFormatter
+  register 'mock'
+
+  attr_reader :body
+
+  def initialize
+    @body = 'some value'
+  end
+
+  def format(payload)
+    ['title', @body]
+  end
+end
+
+class MissingFormatMockFormatter < Appsignal::EventFormatter
+  def transform(payload)
+  end
+end
+
+class IncorrectFormatMockFormatter < Appsignal::EventFormatter
+  def format
+  end
+end
+
+class MockDependentFormatter < Appsignal::EventFormatter
+  register 'mock.dependent'
+
+  def initialize
+    NonsenseDependency.something
+  end
+end
+
+describe Appsignal::EventFormatter do
+  before do
+    Appsignal::EventFormatter.initialize_formatters
+  end
+
+  let(:klass) { Appsignal::EventFormatter }
+
+  context "registering and unregistering formatters" do
+    it "should register a formatter" do
+      klass.formatters['mock'].should be_instance_of(MockFormatter)
+    end
+
+    it "should know wether a formatter is registered" do
+      klass.registered?('mock').should be_true
+      klass.registered?('mock', MockFormatter).should be_true
+      klass.registered?('mock', Hash).should be_false
+      klass.registered?('nonsense').should be_false
+    end
+
+    it "doesn't register formatters that raise a name error in the initializer" do
+      klass.registered?('mock.dependent').should be_false
+    end
+
+    it "doesn't register formatters that don't have a format(payload) method" do
+      klass.register('mock.missing_format', MissingFormatMockFormatter)
+      klass.register('mock.incorrect_format', IncorrectFormatMockFormatter)
+
+      Appsignal::EventFormatter.initialize_formatters
+
+      klass.registered?('mock.missing_format').should be_false
+      klass.registered?('mock.incorrect_format').should be_false
+    end
+
+    it "should register a custom formatter" do
+      klass.register('mock.specific', MockFormatter)
+      Appsignal::EventFormatter.initialize_formatters
+
+      klass.formatter_classes['mock.specific'].should == MockFormatter
+      klass.registered?('mock.specific').should be_true
+      klass.formatters['mock.specific'].should be_instance_of(MockFormatter)
+      klass.formatters['mock.specific'].body.should == 'some value'
+    end
+
+    it "should not have a formatter that's not registered" do
+      klass.formatters['nonsense'].should be_nil
+    end
+
+    it "should unregister a formatter if the registered one has the same class" do
+      klass.register('mock.unregister', MockFormatter)
+
+      klass.unregister('mock.unregister', Hash)
+      klass.registered?('mock.unregister').should be_true
+
+      klass.unregister('mock.unregister', MockFormatter)
+      klass.registered?('mock.unregister').should be_false
+    end
+  end
+
+  context "calling formatters" do
+    it "should return nil if there is no formatter registered" do
+      klass.format('nonsense', {}).should == nil
+    end
+
+    it "should call the formatter if it is registered and use a value set in the initializer" do
+      klass.format('mock', {}).should == ['title', 'some value']
+    end
+  end
+end

data/spec/lib/appsignal/extension_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Appsignal::Extension do
+  context "call native methods without errors" do
+    subject { Appsignal::Extension }
+
+    it "should have a start method" do
+      subject.start
+    end
+
+    context "with a valid config" do
+      before do
+        project_fixture_config.write_to_environment
+      end
+
+      it "should have a start method" do
+        subject.start
+      end
+
+      it "should have a start_transaction method" do
+        subject.start_transaction('request_id')
+      end
+
+      it "should have a start_event method" do
+        subject.start_event('request_id')
+      end
+
+      it "should have a finish_event method" do
+        subject.finish_event(
+          'request_id',
+          'name',
+          'title',
+          'body'
+        )
+      end
+
+      it "should have a set_transaction_error method" do
+        subject.set_transaction_error(
+          'request_id',
+          'name',
+          'message'
+        )
+      end
+
+      it "should have a set_transaction_error_data method" do
+        subject.set_transaction_error_data(
+          'request_id',
+          'params',
+          '{}'
+        )
+      end
+
+      it "should have a set_transaction_basedata method" do
+        subject.set_transaction_basedata(
+          'request_id',
+          'kind',
+          'action',
+          100
+        )
+      end
+
+      it "should have a set_transaction_metadata method" do
+        subject.set_transaction_metadata(
+          'request_id',
+          'key',
+          'value'
+        )
+      end
+
+      it "should have a finish_transaction method" do
+        subject.finish_transaction('request_id')
+      end
+    end
+  end
+end

data/spec/lib/appsignal/instrumentations/net_http_spec.rb

@@ -9,15 +9,31 @@ describe "Net::HTTP instrumentation" do
     end
   end
 
-  it "should instrument request" do
-    stub_request(:any, 'www.google.com')
+  it "should generate an event for a http request" do
+    stub_request(:any, 'http://www.google.com/')
 
     Net::HTTP.get_response(URI.parse('http://www.google.com'))
 
     event = events.last
     event.name.should == 'request.net_http'
-    event.payload[:host].should == 'www.google.com'
-    event.payload[:scheme].should == 'http'
+    event.payload[:protocol].should == 'http'
+    event.payload[:domain].should == 'www.google.com'
+    event.payload[:path].should == '/'
+    event.payload[:method].should == 'GET'
+  end
+
+  it "should generate an event for a https request" do
+    stub_request(:any, 'https://www.google.com/')
+
+    uri = URI.parse('https://www.google.com')
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.get(uri.request_uri)
+
+    event = events.last
+    event.name.should == 'request.net_http'
+    event.payload[:protocol].should == 'https'
+    event.payload[:domain].should == 'www.google.com'
     event.payload[:path].should == '/'
     event.payload[:method].should == 'GET'
   end

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

@@ -99,9 +99,10 @@ describe "Delayed Job integration" do
 
       context "with an erroring call" do
         it "should add the error to the transaction" do
-          Appsignal::Transaction.any_instance.should_receive(:add_exception).with(error)
+          Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+          Appsignal::Transaction.should_receive(:complete_current!)
+
           invoked_block.stub(:call).and_raise(error)
-          Appsignal::Transaction.any_instance.should_receive(:complete!)
 
           lambda {
             plugin.invoke_with_instrumentation(job, invoked_block)

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

@@ -51,13 +51,6 @@ if rails_present?
         end
       end
 
-      context "agent" do
-        before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
-        subject { Appsignal.agent }
-
-        it { should be_a(Appsignal::Agent) }
-      end
-
       context "listener middleware" do
         it "should have added the listener middleware" do
           expect( app.middleware ).to receive(:insert_before).with(

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

@@ -1,82 +1,78 @@
 require 'spec_helper'
 
-if resque_present?
-  describe "Resque integration" do
-    let(:file) { File.expand_path('lib/appsignal/integrations/resque.rb') }
+describe "Resque integration" do
+  let(:file) { File.expand_path('lib/appsignal/integrations/resque.rb') }
 
-    context "with resque" do
-      before do
-        load file
-        start_agent
-
-        class TestJob
-          extend Appsignal::Integrations::ResquePlugin
+  context "with resque" do
+    before do
+      module Resque
 
-          def self.perform
-          end
+        def self.before_first_fork
         end
 
-        class BrokenTestJob
-          extend Appsignal::Integrations::ResquePlugin
+        def self.after_fork
+        end
 
-          def self.perform
-            raise VerySpecificError.new('broken')
-          end
+        class Job
         end
 
+        class TestError < StandardError
+        end
       end
 
-      describe :around_perform_resque_plugin do
-        let(:transaction) { Appsignal::Transaction.new(1, {}) }
-        let(:job) { Resque::Job.new('default', {'class' => 'TestJob'}) }
-        before do
-          transaction.stub(:complete! => true)
-          Appsignal::Transaction.stub(:current => transaction)
-        end
+      load file
+      start_agent
+    end
 
-        context "without exception" do
-          it "should create a new transaction" do
-            Appsignal::Transaction.should_receive(:create).and_return(transaction)
-          end
+    describe :around_perform_resque_plugin do
+      let(:transaction) { Appsignal::Transaction.new('1', {}) }
+      let(:job) { Resque::Job }
+      let(:invoked_job) { nil }
+      before do
+        transaction.stub(:complete! => true)
+        Appsignal::Transaction.stub(:current => transaction)
+      end
 
-          it "should wrap in a transaction with the correct params" do
-            Appsignal.should_receive(:monitor_transaction).with(
-              'perform_job.resque',
-              :class => 'TestJob',
-              :method => 'perform'
-            )
-          end
+      context "without exception" do
+        it "should create a new transaction" do
+          Appsignal::Transaction.should_receive(:create).and_return(transaction)
+        end
 
-          it "should close the transaction" do
-            transaction.should_receive(:complete!)
-          end
+        it "should wrap in a transaction with the correct params" do
+          Appsignal.should_receive(:monitor_transaction).with(
+            'perform_job.resque',
+            :class => 'Resque::Job',
+            :method => 'perform'
+          )
+        end
 
-          after { job.perform  }
+        it "should close the transaction" do
+          Appsignal::Transaction.should_receive(:complete_current!)
         end
 
-        context "with exception" do
-          let(:job) { Resque::Job.new('default', {'class' => 'BrokenTestJob'}) }
+        after { job.around_perform_resque_plugin { invoked_job }  }
+      end
 
-          it "should set the exception" do
-            transaction.should_receive(:add_exception)
-          end
+      context "with exception" do
+        it "should set the exception" do
+          transaction.should_receive(:set_error)
+        end
 
-          after do
-            begin
-              job.perform
-            rescue VerySpecificError
-              # Do nothing
-            end
+        after do
+          begin
+            job.around_perform_resque_plugin { raise(Resque::TestError.new('the roof')) }
+          rescue Resque::TestError
+            # Do nothing
           end
         end
       end
     end
+  end
 
-    context "without resque" do
-      before(:all) { Object.send(:remove_const, :Resque) }
+  context "without resque" do
+    before(:all) { Object.send(:remove_const, :Resque) }
 
-      specify { expect { ::Resque }.to raise_error(NameError) }
-      specify { expect { load file }.to_not raise_error }
-    end
+    specify { expect { ::Resque }.to raise_error(NameError) }
+    specify { expect { load file }.to_not raise_error }
   end
 end

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

@@ -13,9 +13,14 @@ describe "Sequel integration", if: sequel_present? do
     before { Appsignal::Transaction.create('uuid', 'test') }
 
     it "should instrument queries" do
-      expect { db['SELECT 1'].all }
-        .to change { Appsignal::Transaction.current.events.empty? }
-        .from(true).to(false)
+      expect( Appsignal::Extension ).to receive(:start_event)
+        .at_least(:once)
+        .with('uuid')
+      expect( Appsignal::Extension ).to receive(:finish_event)
+        .at_least(:once)
+        .with('uuid', "sql.sequel", "", "")
+
+      db['SELECT 1'].all
     end
   end
 end

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

@@ -47,23 +47,6 @@ describe "Sidekiq integration" do
       )
     end
 
-    it "reports the correct job class for a ActiveJob wrapped job" do
-      item['wrapped'] = 'ActiveJobClass'
-      Appsignal.should_receive(:monitor_transaction).with(
-        'perform_job.sidekiq',
-        :class    => 'ActiveJobClass',
-        :method   => 'perform',
-        :metadata => {
-          'retry_count' => "0",
-          'queue'       => 'default',
-          'extra'       => 'data',
-          'wrapped'     => 'ActiveJobClass'
-        },
-        :params      => ['Model', "1"],
-        :queue_start => Time.parse('01-01-2001 10:00:00UTC')
-      )
-    end
-
     after do
       Timecop.freeze(Time.parse('01-01-2001 10:01:00UTC')) do
         Appsignal::Integrations::SidekiqPlugin.new.call(worker, item, queue) do
@@ -76,7 +59,7 @@ describe "Sidekiq integration" do
   context "with an erroring call" do
     let(:error) { VerySpecificError.new('the roof') }
     it "should add the exception to appsignal" do
-      current_transaction.should_receive(:add_exception).with(error)
+      current_transaction.should_receive(:set_error).with(error)
     end
 
     after do
@@ -121,11 +104,11 @@ describe "Sidekiq integration" do
 
   describe "#truncate" do
     let(:very_long_text) do
-      "a" * 400
+      "a" * 200
     end
 
-    it "should truncate the text to 200 chars max" do
-      plugin.truncate(very_long_text).should == "#{'a' * 197}..."
+    it "should truncate the text to 100 chars max" do
+      plugin.truncate(very_long_text).should == "#{'a' * 97}..."
     end
   end