appsignal 0.6.7 → 0.7.0.alpha.1

data/spec/{appsignal → lib/appsignal}/integrations/passenger_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 describe "Passenger integration" do
   let(:file) { File.expand_path('lib/appsignal/integrations/passenger.rb') }
   before(:all) { module PhusionPassenger ; end }

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+if rails_present?
+  describe Appsignal::Integrations::Railtie do
+    context "after initializing the app" do
+      before :all do
+        MyApp::Application.config.root = project_fixture_path
+        MyApp::Application.initialize!
+      end
+
+      context "logger" do
+        subject { Appsignal.logger }
+
+        it { should be_a Logger }
+      end
+
+      context "config" do
+        subject { Appsignal.config }
+
+        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
+        MyApp::Application.middleware.to_a.should include Appsignal::Rack::Listener
+      end
+
+      it "should not have added the instrumentation middleware" do
+        MyApp::Application.middleware.to_a.should_not include Appsignal::Rack::Instrumentation
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+begin
+  require 'sinatra'
+rescue LoadError
+end
+
+if defined?(::Sinatra)
+  ENV['APPSIGNAL_PUSH_API_KEY'] = 'key'
+  require 'appsignal/integrations/sinatra'
+
+  describe "Sinatra integration" do
+    context "logger" do
+      subject { Appsignal.logger }
+
+      it { should be_a Logger }
+    end
+
+    context "config" do
+      subject { Appsignal.config }
+
+      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]
+      )
+    end
+
+    it "should have added the instrumentation middleware" do
+      Sinatra::Application.middleware.to_a.should include(
+        [Appsignal::Rack::Instrumentation, [], nil]
+      )
+    end
+  end
+end

data/spec/{appsignal → lib/appsignal}/marker_spec.rb

@@ -1,15 +1,17 @@
 require 'spec_helper'
+require 'capistrano'
 
 describe Appsignal::Marker do
+  let(:config) { project_fixture_config }
   let(:marker) {
-    Appsignal::Marker.new({
+    Appsignal::Marker.new(
+      {
         :revision => '503ce0923ed177a3ce000005',
         :repository => 'master',
         :user => 'batman',
-        :rails_env => 'development'
+        :rails_env => 'production'
       },
-      Dir.pwd,
-      'development',
+      config,
       logger
     )
   }
@@ -17,23 +19,20 @@ describe Appsignal::Marker do
   let(:logger) { Logger.new(log) }
 
   context "transmit" do
+    let(:transmitter) { double }
     before do
-      @transmitter = double
-      Appsignal::Transmitter.should_receive(:new).
-        with('http://localhost:3000/1', 'markers', 'abc').
-        and_return(@transmitter)
+      Appsignal::Transmitter.should_receive(:new).with(
+        'markers', config
+      ).and_return(transmitter)
     end
 
     it "should transmit data" do
-      @transmitter.should_receive(:transmit).
-        with(
-          {
-            :revision => "503ce0923ed177a3ce000005",
-            :repository => "master",
-            :user => "batman",
-            :rails_env => "development"
-          }
-        )
+      transmitter.should_receive(:transmit).with(
+        :revision => '503ce0923ed177a3ce000005',
+        :repository => 'master',
+        :user => 'batman',
+        :rails_env => 'production'
+      )
 
       marker.transmit
     end
@@ -41,19 +40,17 @@ describe Appsignal::Marker do
     context "logs" do
       shared_examples_for "logging info and errors" do
         it "should log status 200" do
-          @transmitter.should_receive(:transmit).and_return('200')
+          transmitter.should_receive(:transmit).and_return('200')
 
           marker.transmit
 
           log.string.should include('Notifying Appsignal of deploy...')
-          log.string.should include(
-            'Appsignal has been notified of this deploy!'
-          )
+          log.string.should include('Appsignal has been notified of this deploy!')
         end
 
         it "should log other status" do
-          @transmitter.should_receive(:transmit).and_return('500')
-          @transmitter.should_receive(:uri).and_return('http://localhost:3000/1/markers')
+          transmitter.should_receive(:transmit).and_return('500')
+          transmitter.should_receive(:uri).and_return('http://localhost:3000/1/markers')
 
           marker.transmit
 

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Appsignal::Rack::Instrumentation do
+  before :all do
+    start_agent
+    @events = []
+    @subscriber = ActiveSupport::Notifications.subscribe do |*args|
+      @events << ActiveSupport::Notifications::Event.new(*args)
+    end
+  end
+  after :all do
+    ActiveSupport::Notifications.unsubscribe(@subscriber)
+  end
+
+  let(:app) { double(:call => true) }
+  let(:env) { {} }
+  let(:middleware) { Appsignal::Rack::Instrumentation.new(app, {}) }
+
+  describe "#call" do
+    it "should instrument the call" do
+      app.should_receive(:call).with(env)
+      middleware.stub(:raw_payload => {})
+
+      middleware.call(env)
+
+      @events.last.name.should == 'process_action.rack'
+    end
+  end
+
+  describe "raw_payload" do
+    let(:env) do
+      {
+        'rack.input' => StringIO.new,
+        'REQUEST_METHOD' => 'GET',
+        'PATH_INFO' => '/homepage',
+        'REQUEST_METHOD' => 'GET',
+        'QUERY_STRING' => 'param=something'
+      }
+    end
+    subject { middleware.raw_payload(env) }
+
+    it { should == {
+      :action => 'GET:/homepage',
+      :params => {'param' => 'something'},
+      :method => 'GET',
+      :path => '/homepage'
+    } }
+  end
+end

data/spec/{appsignal → lib/appsignal/rack}/listener_spec.rb

@@ -10,16 +10,23 @@ class AppWithError
   end
 end
 
-describe Appsignal::Listener do
+describe Appsignal::Rack::Listener do
+  before :all do
+    start_agent
+  end
+  let(:app) { double(:call => true) }
+  let(:middleware) { Appsignal::Rack::Listener.new(app, {})}
+  let(:env) { {} }
+
   describe '#call' do
-    let(:app) { double(:call => true) }
-    let(:env) { {'action_dispatch.request_id' => '1'} }
-    let(:middleware) { Appsignal::Listener.new(app, {})}
     let(:current) { double(:complete! => true, :add_exception => true) }
-    before { Appsignal::Transaction.stub(:current => current) }
+    before do
+      middleware.stub(:request_id => '1')
+      Appsignal::Transaction.stub(:current => current)
+    end
 
     describe 'around call' do
-      it 'should call appsignal transaction' do
+      it 'should create an appsignal transaction' do
         Appsignal::Transaction.should_receive(:create).with('1', env)
       end
 
@@ -27,6 +34,14 @@ describe Appsignal::Listener do
         current.should_receive(:complete!)
       end
 
+      context "when not active" do
+        before { Appsignal.stub(:active? => false) }
+
+        it 'should not create an appsignal transaction' do
+          Appsignal::Transaction.should_not_receive(:create)
+        end
+      end
+
       after { middleware.call(env) }
     end
 
@@ -68,4 +83,22 @@ describe Appsignal::Listener do
       end
     end
   end
+
+  describe "#request_id" do
+    subject { middleware.request_id(env) }
+
+    context "when Rails provides a request_id" do
+      let(:env) { {'action_dispatch.request_id' => '1'} }
+
+      it { should == '1' }
+    end
+
+    context "when Rails does not provide a request_id" do
+      before do
+        SecureRandom.stub(:uuid => '2')
+      end
+
+      it { should == '2' }
+    end
+  end
 end

data/spec/{appsignal/transaction/transaction_formatter_spec.rb → lib/appsignal/transaction/formatter_spec.rb}

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
-describe Appsignal::TransactionFormatter do
-  let(:klass) { Appsignal::TransactionFormatter }
+describe Appsignal::Transaction::Formatter do
+  before :all do
+    start_agent
+  end
+
+  let(:klass) { Appsignal::Transaction::Formatter }
   let(:formatter) { klass.new(transaction) }
   subject { formatter }
   before { transaction.stub(:fullpath => '/foo') }
@@ -34,6 +38,17 @@ describe Appsignal::TransactionFormatter do
       its([:failed]) { should be_false }
     end
 
+    context "with a regular request when queue time is present" do
+      let(:transaction) { regular_transaction_with_x_request_start }
+      before { transaction.truncate! }
+
+      context "log_entry content" do
+        subject { formatter.hash[:log_entry] }
+
+        its([:queue_duration]) { should be_within(0.01).of(40.0) }
+      end
+    end
+
     context "with an exception request" do
       let(:transaction) { transaction_with_exception }
 
@@ -53,10 +68,18 @@ describe Appsignal::TransactionFormatter do
         its(:keys) { should =~ [:exception, :message, :backtrace] }
         its([:exception]) { should == 'ArgumentError' }
         its([:message]) { should == 'oh no' }
-        its([:backtrace]) { should == [
-          'app/controllers/somethings_controller.rb:10',
-          '/user/local/ruby/path.rb:8'
-        ] }
+
+        if rails_present?
+          its([:backtrace]) { should == [
+            'app/controllers/somethings_controller.rb:10',
+            '/user/local/ruby/path.rb:8'
+          ] }
+        else
+          its([:backtrace]) { should == [
+            File.join(project_fixture_path, 'app/controllers/somethings_controller.rb:10'),
+            '/user/local/ruby/path.rb:8'
+          ] }
+        end
       end
     end
 

data/spec/{appsignal → lib/appsignal}/transaction/params_sanitizer_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
-describe Appsignal::ParamsSanitizer do
-  let(:file) { ActionDispatch::Http::UploadedFile.new(:tempfile => '/tmp') }
+describe Appsignal::Transaction::ParamsSanitizer do
+  let(:klass) { Appsignal::Transaction::ParamsSanitizer }
+  let(:file) { uploaded_file }
   let(:params) do
     {
       :text => 'string',
@@ -20,17 +21,17 @@ describe Appsignal::ParamsSanitizer do
       }
     }
   end
-  let(:sanitized_params) { Appsignal::ParamsSanitizer.sanitize(params) }
-  let(:scrubbed_params) { Appsignal::ParamsSanitizer.scrub(params) }
+  let(:sanitized_params) { klass.sanitize(params) }
+  let(:scrubbed_params) { klass.scrub(params) }
 
   describe ".sanitize!" do
     subject { params }
-    before { Appsignal::ParamsSanitizer.sanitize!(subject) }
+    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 '#<ActionDispatch::Http::UploadedFile:' }
+    its([:file]) { should include '::UploadedFile' }
 
     context "hash" do
       subject { params[:hash] }
@@ -45,7 +46,7 @@ describe Appsignal::ParamsSanitizer do
         its([0]) { should == 'something' }
         its([1]) { should == 'else' }
         its([2]) { should be_instance_of String }
-        its([2]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+        its([2]) { should include '::UploadedFile' }
 
         context "nested hash" do
           subject { params[:hash][:nested_array][3] }
@@ -53,7 +54,7 @@ describe Appsignal::ParamsSanitizer do
           it { should be_instance_of Hash }
           its([:key]) { should == 'value' }
           its([:file]) { should be_instance_of String }
-          its([:file]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+          its([:file]) { should include '::UploadedFile' }
         end
       end
     end
@@ -65,7 +66,7 @@ describe Appsignal::ParamsSanitizer do
     it { should be_instance_of Hash }
     its([:text]) { should == 'string' }
     its([:file]) { should be_instance_of String }
-    its([:file]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+    its([:file]) { should include '::UploadedFile' }
 
     it "does not change the original params" do
       subject
@@ -86,7 +87,7 @@ describe Appsignal::ParamsSanitizer do
         its([0]) { should == 'something' }
         its([1]) { should == 'else' }
         its([2]) { should be_instance_of String }
-        its([2]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+        its([2]) { should include '::UploadedFile' }
 
         context "nested hash" do
           subject { sanitized_params[:hash][:nested_array][3] }
@@ -94,7 +95,7 @@ describe Appsignal::ParamsSanitizer do
           it { should be_instance_of Hash }
           its([:key]) { should == 'value' }
           its([:file]) { should be_instance_of String }
-          its([:file]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+          its([:file]) { should include '::UploadedFile' }
         end
       end
     end
@@ -102,7 +103,7 @@ describe Appsignal::ParamsSanitizer do
 
   describe ".scrub!" do
     subject { params }
-    before { Appsignal::ParamsSanitizer.scrub!(subject) }
+    before { klass.scrub!(subject) }
 
     it { should be_instance_of Hash }
     its([:text]) { should == '?' }

data/spec/{appsignal → lib/appsignal}/transaction_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe Appsignal::Transaction do
+  before :all do
+    start_agent
+  end
+
   describe '.create' do
     before { Appsignal::Transaction.create('1', {}) }
 
@@ -23,19 +27,20 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe 'transaction instance' do
-    let(:transaction) do
-      Appsignal::Transaction.create('1', {
+  context "with transaction instance" do
+    let(:env) do
+      {
         'HTTP_USER_AGENT' => 'IE6',
         'SERVER_NAME' => 'localhost',
         'action_dispatch.routes' => 'not_available'
-      })
+      }
     end
+    let(:transaction) { Appsignal::Transaction.create('1', env) }
 
     describe '#request' do
       subject { transaction.request }
 
-      it { should be_a ActionDispatch::Request }
+      it { should be_a ::Rack::Request }
     end
 
     describe '#set_process_action_event' do
@@ -284,6 +289,46 @@ describe Appsignal::Transaction do
 
     # protected
 
+    describe "#http_queue_start" do
+      let(:slightly_earlier_time) { fixed_time - 10.0 }
+      let(:slightly_earlier_time_in_msec) { (slightly_earlier_time.to_f * 1_000_000).to_i }
+      subject { transaction.send(:http_queue_start) }
+
+      context "without the env" do
+        let(:env) { nil }
+
+        it { should be_nil }
+      end
+
+      context "with no relevant header set" do
+        it { should be_nil }
+      end
+
+      context "with the HTTP_X_REQUEST_START header set" do
+        let(:env) { {'HTTP_X_REQUEST_START' => "t=#{slightly_earlier_time_in_msec}"} }
+
+        it { should == 978364850.0 }
+
+        context "with unparsable content" do
+          let(:env) { {'HTTP_X_REQUEST_START' => 'something'} }
+
+          it { should be_nil }
+        end
+
+        context "with some cruft" do
+          let(:env) { {'HTTP_X_REQUEST_START' => "t=#{slightly_earlier_time_in_msec}aaaa"} }
+
+          it { should == 978364850.0 }
+        end
+
+        context "with the alternate HTTP_X_QUEUE_START header set" do
+          let(:env) { {'HTTP_X_QUEUE_START' => "t=#{slightly_earlier_time_in_msec}"} }
+
+          it { should == 978364850.0 }
+        end
+      end
+    end
+
     describe '#add_sanitized_context!' do
       subject { transaction.send(:add_sanitized_context!) }
 
@@ -351,7 +396,7 @@ describe Appsignal::Transaction do
       end
 
       it "passes the session data into the params sanitizer" do
-        Appsignal::ParamsSanitizer.should_receive(:sanitize).with({:foo => :bar}).
+        Appsignal::Transaction::ParamsSanitizer.should_receive(:sanitize).with({:foo => :bar}).
           and_return(:sanitized_foo)
         subject
         transaction.sanitized_session_data.should == :sanitized_foo
@@ -370,7 +415,7 @@ describe Appsignal::Transaction do
           end
 
           it "should return an session hash" do
-            Appsignal::ParamsSanitizer.should_receive(:sanitize).with({'foo' => :bar}).
+            Appsignal::Transaction::ParamsSanitizer.should_receive(:sanitize).with({'foo' => :bar}).
               and_return(:sanitized_foo)
             subject
           end