appsignal 0.4.0

data/spec/appsignal/config_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Appsignal::Config do
+  subject { Appsignal::Config.new(Dir.pwd, 'test').load }
+
+  it {
+    should == {
+      :ignore_exceptions => [],
+      :endpoint => 'http://localhost:3000/1',
+      :slow_request_threshold => 200,
+      :api_key => 'abc',
+      :active => true
+    }
+  }
+
+  context 'when there is no config file' do
+    before { Dir.stub(:pwd => '/not/existing') }
+
+    it "should log error" do
+      Appsignal.logger.should_receive(:error).with(
+        "config not found at:"\
+        " /not/existing/config/appsignal.yml"
+      )
+    end
+
+    after { subject }
+  end
+
+  context "the env is not in the config" do
+    subject { Appsignal::Config.new(Dir.pwd, 'staging').load }
+
+    it "should generate error" do
+      Appsignal.logger.should_receive(:error).with(
+        "config for 'staging' not found"
+      )
+    end
+
+    after { subject }
+  end
+end

data/spec/appsignal/exception_notification_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Appsignal::ExceptionNotification do
+  let(:error) { StandardError.new('moo') }
+  let(:notification) { Appsignal::ExceptionNotification.new({}, error) }
+  subject { notification }
+  before { Rails.stub(:respond_to? => false) }
+
+  its(:exception) { should == error }
+  its(:name) { should == 'StandardError' }
+  its(:message) { should == 'moo' }
+end

data/spec/appsignal/inactive_railtie_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Inactive Appsignal::Railtie" do
+  it "should not insert itself into the middleware stack" do
+    # This uses a hack because Rails really dislikes you trying to
+    # start multiple applications in one process. This works decently
+    # on every platform except JRuby, so we're disabling this test on
+    # JRuby for now.
+    if RUBY_PLATFORM == "java"
+      pending "This spec cannot run on JRuby currently"
+    else
+      pid = fork do
+        Appsignal.stub(:active? => false)
+        Rails.application = nil
+        instance_eval do
+          module MyTempApp
+            class Application < Rails::Application
+              config.active_support.deprecation = proc { |message, stack| }
+            end
+          end
+        end
+        MyTempApp::Application.initialize!
+
+        MyTempApp::Application.middleware.to_a.should_not include Appsignal::Middleware
+      end
+      Process.wait(pid)
+      raise 'Example failed' unless $?.exitstatus == 0
+    end
+  end
+end

data/spec/appsignal/marker_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Appsignal::Marker do
+  let(:marker) {
+    Appsignal::Marker.new({
+        :revision => '503ce0923ed177a3ce000005',
+        :repository => 'master',
+        :user => 'batman',
+        :rails_env => 'development'
+      },
+      Dir.pwd,
+      'development',
+      logger
+    )
+  }
+  let(:log) { StringIO.new }
+  let(:logger) { Logger.new(log) }
+
+  context "transmit" do
+    before do
+      @transmitter = mock()
+      Appsignal::Transmitter.should_receive(:new).
+        with('http://localhost:3000/1', 'markers', 'abc').
+        and_return(@transmitter)
+    end
+
+    it "should transmit data" do
+      @transmitter.should_receive(:transmit).
+        with(
+          {
+            :revision => "503ce0923ed177a3ce000005",
+            :repository => "master",
+            :user => "batman",
+            :rails_env => "development"
+          }
+        )
+
+      marker.transmit
+    end
+
+    context "logs" do
+      shared_examples_for "logging info and errors" do
+        it "should log status 200" do
+          @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!'
+          )
+        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')
+
+          marker.transmit
+
+          log.string.should include('Notifying Appsignal of deploy...')
+          log.string.should include(
+            'Something went wrong while trying to notify Appsignal: 500 at http://localhost:3000/1/markers'
+          )
+          log.string.should_not include(
+            'Appsignal has been notified of this deploy!'
+          )
+        end
+      end
+
+      it_should_behave_like "logging info and errors"
+
+      context "with a Capistrano logger" do
+        let(:logger) {
+          Capistrano::Logger.new(:output => log).tap do |logger|
+            logger.level = Capistrano::Logger::MAX_LEVEL
+          end
+        }
+
+        it_should_behave_like "logging info and errors"
+      end
+    end
+  end
+end

data/spec/appsignal/middleware_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Appsignal
+  IgnoreMeError = Class.new(StandardError)
+end
+
+class AppWithError
+  def self.call(env)
+    raise Appsignal::IgnoreMeError, 'the roof'
+  end
+end
+
+describe Appsignal::Middleware do
+  describe '#call' do
+    let(:app) { stub(:call => true) }
+    let(:env) { {'action_dispatch.request_id' => '1'} }
+    let(:middleware) { Appsignal::Middleware.new(app, {})}
+    let(:current) { stub(:complete! => true, :add_exception => true) }
+    before { Appsignal::Transaction.stub(:current => current) }
+
+    describe 'around call' do
+      it 'should call appsignal transaction' do
+        Appsignal::Transaction.should_receive(:create).with('1', env)
+      end
+
+      it 'should call complete! after the call' do
+        current.should_receive(:complete!)
+      end
+
+      after { middleware.call(env) }
+    end
+
+    describe 'with exception' do
+      let(:app) { AppWithError }
+
+      it 'should re-raise the exception' do
+        expect {
+          middleware.call(env)
+        }.to raise_error
+      end
+
+      it 'should catch the exception and notify the transaction of it' do
+        Appsignal::ExceptionNotification.should_receive(:new)
+        current.should_receive(:add_exception)
+        middleware.call(env) rescue nil
+      end
+
+      context 'when ignoring exception' do
+        before { Appsignal.stub(:config => {:ignore_exceptions => 'Appsignal::IgnoreMeError'})}
+
+        it 'should re-raise the exception' do
+          expect {
+            middleware.call(env)
+          }.to raise_error
+        end
+
+        it 'should ignore the error' do
+          Appsignal::ExceptionNotification.should_not_receive(:new)
+          current.should_not_receive(:add_exception)
+          middleware.call(env) rescue nil
+        end
+      end
+
+      describe 'after an error' do
+        it 'should call complete! after the call' do
+          current.should_receive(:complete!)
+        end
+
+        after { middleware.call(env) rescue nil }
+      end
+    end
+  end
+end

data/spec/appsignal/railtie_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'action_controller/railtie'
+require 'appsignal/railtie'
+
+describe Appsignal::Railtie do
+
+  before(:all) { MyApp::Application.initialize! }
+
+  it "should have set the appsignal subscriber" do
+    Appsignal.subscriber.
+      should be_a ActiveSupport::Notifications::Fanout::Subscriber
+  end
+
+  it "should have added the middleware for exceptions" do
+    MyApp::Application.middleware.to_a.should include Appsignal::Middleware
+  end
+
+  context "non action_controller event" do
+    it "should call add_event for non action_controller event" do
+      current = stub
+      current.should_receive(:add_event)
+      Appsignal::Transaction.should_receive(:current).twice.
+        and_return(current)
+    end
+
+    after { ActiveSupport::Notifications.instrument 'query.mongoid' }
+  end
+
+  context "action_controller event" do
+    it "should call set_process_action_event for action_controller event" do
+      current = stub
+      current.should_receive(:set_process_action_event)
+      current.should_receive(:add_event)
+      Appsignal::Transaction.should_receive(:current).exactly(3).times.
+        and_return(current)
+    end
+
+    after do
+      ActiveSupport::Notifications.
+        instrument 'process_action.action_controller'
+    end
+  end
+
+  context "event that starts with a bang" do
+    it "should not be processed" do
+      Appsignal::Transaction.should_not_receive(:current)
+    end
+
+    after do
+      ActiveSupport::Notifications.
+        instrument '!render_template'
+    end
+  end
+end

data/spec/appsignal/transaction/faulty_request_formatter_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Appsignal::TransactionFormatter::FaultyRequestFormatter do
+  let(:parent) { Appsignal::TransactionFormatter }
+  let(:transaction) { transaction_with_exception }
+  let(:faulty) { parent::FaultyRequestFormatter.new(transaction) }
+  subject { faulty }
+
+  describe "#to_hash" do
+    it "can call #to_hash on its superclass" do
+      parent.new(transaction).respond_to?(:to_hash).should be_true
+    end
+
+    context "return value" do
+      subject { faulty.to_hash }
+      before { faulty.stub(:formatted_exception => :faulty_request) }
+
+      it "includes the exception" do
+        subject[:exception].should == :faulty_request
+      end
+    end
+  end
+
+  # protected
+
+  it { should delegate(:backtrace).to(:exception) }
+  it { should delegate(:name).to(:exception) }
+  it { should delegate(:message).to(:exception) }
+
+  describe "#formatted_exception" do
+    subject { faulty.send(:formatted_exception) }
+
+    its(:keys) { should include :backtrace }
+    its(:keys) { should include :exception }
+    its(:keys) { should include :message }
+  end
+
+  describe "#basic_process_action_event" do
+    subject { faulty.send(:basic_process_action_event) }
+
+    it "should return a hash with extra keys" do
+      subject[:environment].should == {
+        "HTTP_USER_AGENT" => "IE6",
+        "SERVER_NAME" => "localhost"
+      }
+      subject[:session_data].should == {}
+    end
+  end
+end

data/spec/appsignal/transaction/params_sanitizer_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Appsignal::ParamsSanitizer do
+  describe ".sanitize" do
+    let(:file) { ActionDispatch::Http::UploadedFile.new(:tempfile => '/tmp') }
+    let(:params) do
+      {
+        :text => 'string',
+        :file => file,
+        :hash => {
+          :nested_text => 'string',
+          :nested_array => [
+            'something',
+            'else',
+            file,
+            {
+              :key => 'value',
+              :nested_array_hash_file => file,
+            }
+          ]
+        }
+      }
+    end
+    let(:sanitized_params) { Appsignal::ParamsSanitizer.sanitize(params) }
+
+    subject { sanitized_params }
+
+    it { should be_instance_of Hash }
+    it('should have a text') { subject[:text].should == 'string' }
+    it('should have a file') do
+      subject[:file].should be_instance_of String
+      subject[:file].should include '#<ActionDispatch::Http::UploadedFile:'
+    end
+
+    context "hash" do
+      subject { sanitized_params[:hash] }
+
+      it { should be_instance_of Hash }
+      it('should have a nested text') { subject[:nested_text].should == 'string' }
+
+      context "nested_array" do
+        subject { sanitized_params[:hash][:nested_array] }
+
+        it { should be_instance_of Array }
+
+        it("should have two string items") do
+          subject.first.should == 'something'
+          subject.second.should == 'else'
+        end
+        it "should have a file" do
+          subject.third.should be_instance_of String
+          subject.third.should include '#<ActionDispatch::Http::UploadedFile:'
+        end
+
+        context "nested hash" do
+          subject { sanitized_params[:hash][:nested_array].fourth }
+
+          it { should be_instance_of Hash }
+          it('should have a text') { subject[:key].should == 'value' }
+          it('should have a file') do
+            subject[:nested_array_hash_file].should be_instance_of String
+            subject[:nested_array_hash_file].should include '#<ActionDispatch::Http::UploadedFile:'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/appsignal/transaction/regular_request_formatter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Appsignal::TransactionFormatter::RegularRequestFormatter do
+  let(:parent) { Appsignal::TransactionFormatter }
+  let(:transaction) { appsignal_transaction }
+  let(:klass) { parent::RegularRequestFormatter }
+  let(:regular) { klass.new(transaction) }
+
+  describe "#sanitized_event_payload" do
+    subject { regular.sanitized_event_payload(:whatever, :arguments) }
+
+    it { should == {} }
+  end
+end

data/spec/appsignal/transaction/slow_request_formatter_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+
+describe Appsignal::TransactionFormatter::SlowRequestFormatter do
+  let(:parent) { Appsignal::TransactionFormatter }
+  let(:transaction) { slow_transaction }
+  let(:klass) { parent::SlowRequestFormatter }
+  let(:slow) { klass.new(transaction) }
+
+  describe "#to_hash" do
+    subject { slow.to_hash }
+    before { slow.stub(:detailed_events => :startled) }
+
+    it "includes events" do
+      subject[:events].should == :startled
+    end
+  end
+
+  # protected
+
+  context "with an event" do
+    let(:start_time) { Time.at(2.71828182) }
+    let(:end_time) { Time.at(3.141592654) }
+    let(:event) do
+      mock(
+        :event,
+        :name => 'Startled',
+        :duration => 2,
+        :time => start_time,
+        :end => end_time,
+        :payload => {
+          :controller => 'controller',
+          :action => 'action',
+          :sensitive => 'data'
+        }
+      )
+    end
+
+    describe "#detailed_events" do
+      subject { slow.send(:detailed_events) }
+      before do
+        slow.stub(
+          :events => [event],
+          :format => :foo
+        )
+      end
+
+      it { should == [:foo] }
+    end
+
+    describe "#format" do
+      subject { slow.send(:format, event) }
+      before { slow.stub(:sanitized_event_payload => :sanitized) }
+
+      it { should == {
+        :name => 'Startled',
+        :duration => 2,
+        :time => start_time.to_f,
+        :end => end_time.to_f,
+        :payload => :sanitized
+      } }
+    end
+  end
+
+  describe "#basic_process_action_event" do
+    subject { slow.send(:basic_process_action_event) }
+
+    it "should return a hash with extra keys" do
+      subject[:environment].should == {
+        "HTTP_USER_AGENT" => "IE6",
+        "SERVER_NAME" => "localhost"
+      }
+      subject[:session_data].should == {}
+    end
+  end
+end