appsignal 0.11.18 → 0.12.beta.0

data/spec/lib/appsignal/event_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal::Event do
-
-  describe "#sanitize!" do
-    let(:payload) { {:foo => 'bar'} }
-    let(:event) { Appsignal::Event.new('event.test', 1, 2, 3, payload) }
-
-    it "should call the sanitizer" do
-      expect( Appsignal::ParamsSanitizer ).to receive(:sanitize).with(payload)
-      event.sanitize!
-    end
-
-    it "should store the result on the payload" do
-      Appsignal::ParamsSanitizer.stub(:sanitize => {:foo => 'sanitized'})
-      expect {
-        event.sanitize!
-      }.to change(event, :payload).from(:foo => 'bar').to(:foo => 'sanitized')
-    end
-  end
-
-  describe "#truncate!" do
-    let(:payload) { {:foo => 'bar'} }
-    let(:event) { Appsignal::Event.new('event.test', 1, 2, 3, payload) }
-
-    it "should remove the payload" do
-      expect {
-        event.truncate!
-      }.to change(event, :payload).from(:foo => 'bar').to({})
-    end
-  end
-
-  describe ".event_for_instrumentation" do
-    context "with non-moped event" do
-      it "should instantiate a new Appsignal::Event" do
-        expect( Appsignal::Event ).to receive(:new)
-        Appsignal::Event.event_for_instrumentation('query.active_record')
-      end
-    end
-
-    context "with moped event" do
-      it "should instantiate a moped event" do
-        expect( Appsignal::Event::MopedEvent ).to receive(:new)
-        Appsignal::Event.event_for_instrumentation('query.moped')
-      end
-    end
-  end
-end

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

@@ -1,171 +0,0 @@
-require 'spec_helper'
-
-if padrino_present?
-  describe "Padrino integration"   do
-    require File.expand_path('lib/appsignal/integrations/padrino.rb')
-
-    class ClassWithRouter
-      include Padrino::Routing
-    end
-
-    before do
-      @events = []
-      @subscriber = ActiveSupport::Notifications.subscribe do |*args|
-        @events << ActiveSupport::Notifications::Event.new(*args)
-      end
-    end
-    after do
-      ActiveSupport::Notifications.unsubscribe(@subscriber)
-    end
-
-    describe "Appsignal::Integrations::PadrinoPlugin" do
-      before do
-        Appsignal.stub(
-          :active?      => true,
-          :start        => true,
-          :start_logger => true
-        )
-      end
-
-      it "should start the logger on init" do
-        expect( Appsignal ).to receive(:start_logger)
-      end
-
-      it "should start appsignal on init" do
-        expect( Appsignal ).to receive(:start)
-      end
-
-      it "should add the Listener middleware to the stack" do
-        expect( Padrino ).to receive(:use).with(Appsignal::Rack::Listener)
-      end
-
-      context "when not active" do
-        before { Appsignal.stub(:active? => false) }
-
-        it "should not add the Listener middleware to the stack" do
-          expect( Padrino ).to_not receive(:use)
-        end
-      end
-
-      after { Appsignal::Integrations::PadrinoPlugin.init }
-    end
-
-    describe "Padrino::Routing::InstanceMethods" do
-      let(:base)     { double }
-      let(:router)   { ClassWithRouter.new }
-      let(:env)      { {} }
-      let(:settings) { double(:name => 'TestApp') }
-
-      describe "#route!" do
-        let(:request) do
-          double(
-            :params          => {'id' => 1},
-            :session         => {'user_id' => 123},
-            :request_method  => 'GET',
-            :path            => '/users/1',
-            :controller      => 'users',
-            :action          => 'show'
-          )
-        end
-
-        before do
-          router.stub(
-            :route_without_appsignal => true,
-            :request                 => request,
-            :env                     => env,
-            :settings                => settings,
-            :get_payload_action      => 'controller#action'
-          )
-        end
-
-        context "when Sinatra tells us it's a static file" do
-          let(:env) { {'sinatra.static_file' => true} }
-
-          it "should call the original method" do
-            expect( router ).to receive(:route_without_appsignal)
-          end
-
-          it "should not instrument the request" do
-            expect( ActiveSupport::Notifications ).to_not receive(:instrument)
-          end
-
-          after { router.route!(base) }
-        end
-
-        context "with a dynamic request" do
-
-          it "should call the original method" do
-            expect( router ).to receive(:route_without_appsignal)
-          end
-
-          it "should instrument the action" do
-            expect( ActiveSupport::Notifications ).to receive(:instrument).with(
-              'process_action.padrino',
-              {
-                :params  => {'id' => 1},
-                :session => {'user_id' => 123},
-                :method  => 'GET',
-                :path    => '/users/1'
-              }
-            )
-          end
-
-          after { router.route!(base) }
-        end
-
-        it "should add the action to the payload" do
-          router.route!(base)
-
-          expect( @events.first.payload[:action] ).to eql('controller#action')
-        end
-
-        context "with an exception" do
-          before { router.stub(:route_without_appsignal).and_raise(VerySpecificError) }
-
-          it "should add the exception to the current transaction" do
-            expect( Appsignal ).to receive(:add_exception)
-
-            router.route!(base) rescue VerySpecificError
-          end
-        end
-      end
-
-      describe "#get_payload_action" do
-        before { router.stub(:settings  => settings) }
-
-        context "when request is nil" do
-          it "should return the site" do
-            expect( router.get_payload_action(nil) ).to eql('TestApp')
-          end
-        end
-
-        context "when there's no route object" do
-          let(:request) { double(:controller => 'Controller', :action => 'action') }
-
-          it "should return the site name, controller and action" do
-            expect( router.get_payload_action(request) ).to eql('TestApp:Controller#action')
-          end
-
-          context "when there's no action" do
-            let(:request) { double(:controller => 'Controller', :fullpath => '/action') }
-
-            it "should return the site name, controller and fullpath" do
-              expect( router.get_payload_action(request) ).to eql('TestApp:Controller#/action')
-            end
-          end
-        end
-
-        context "when request has a route object" do
-          let(:request)      { double }
-          let(:route_object) { double(:original_path => '/accounts/edit/:id') }
-          before             { request.stub(:route_obj => route_object) }
-
-          it "should return the original path" do
-            expect( router.get_payload_action(request) ).to eql('TestApp:/accounts/edit/:id')
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe "Passenger integration" do
-  let(:file) { File.expand_path('lib/appsignal/integrations/passenger.rb') }
-  before(:all) do
-    module PhusionPassenger
-    end
-  end
-
-  it "adds behavior to stopping_worker_process and starting_worker_process" do
-    PhusionPassenger.should_receive(:on_event).with(:starting_worker_process)
-    PhusionPassenger.should_receive(:on_event).with(:stopping_worker_process)
-    load file
-  end
-
-  context "without passenger" do
-    before(:all) { Object.send(:remove_const, :PhusionPassenger) }
-
-    specify { expect { PhusionPassenger }.to raise_error(NameError) }
-    specify { expect { load file }.to_not raise_error }
-  end
-end

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

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require 'rake'
-describe "Rack integration" do
-  let(:file) { File.expand_path('lib/appsignal/integrations/rake.rb') }
-  let(:app)  { double(:current_scope => nil) }
-  let(:task) { Rake::Task.new('task', app) }
-  before do
-    load file
-    task.stub(
-      :name                     => 'task:name',
-      :invoke_without_appsignal => true
-    )
-  end
-
-  describe "#invoke" do
-
-    it "should call with appsignal monitoring" do
-      expect( task ).to receive(:invoke_with_appsignal).with(['foo'])
-    end
-
-    it "should call the original task" do
-      expect( task ).to receive(:invoke_without_appsignal).with(['foo'])
-    end
-
-    after { task.invoke(['foo']) }
-  end
-
-  describe "#invoke_with_appsignal" do
-    context "with transaction" do
-      let!(:transaction) { Appsignal::Transaction.new('123', {}) }
-      let!(:agent)       { double('Agent', :send_queue => true) }
-      before do
-        SecureRandom.stub(:uuid => '123')
-        Appsignal::Transaction.stub(:create => transaction)
-        Appsignal.stub(:agent => agent, :active? => true)
-      end
-
-      it "should create a transaction" do
-        expect( Appsignal::Transaction ).to receive(:create).with(
-          '123',
-          ENV,
-          :kind => 'background_job',
-          :action => 'task:name',
-          :params => ['foo']
-        )
-      end
-
-      it "should call the original task" do
-        expect( task ).to receive(:invoke_without_appsignal).with('foo')
-      end
-
-      it "should complete the transaction" do
-        expect( transaction ).to receive(:complete!)
-      end
-
-      it "should send the queue" do
-        expect( Appsignal.agent ).to receive(:send_queue)
-      end
-
-      context "when Appsignal is not active" do
-        before { Appsignal.stub(:active? => false) }
-
-        it "should not send the queue" do
-          expect( Appsignal.agent ).to_not receive(:send_queue)
-        end
-      end
-
-      context "with an exception" do
-        let(:exception) { VerySpecificError.new }
-
-        before do
-          task.stub(:invoke_without_appsignal).and_raise(exception)
-          Appsignal.stub(:is_ignored_exception? => false )
-        end
-
-        it "should add the exception to the transaction" do
-          expect( transaction ).to receive(:add_exception).with(exception)
-        end
-
-        context "when ignored" do
-          before { Appsignal.stub(:is_ignored_exception? => true ) }
-
-          it "should NOT add the exception to the transaction" do
-            expect( transaction ).to_not receive(:add_exception)
-          end
-        end
-      end
-    end
-
-    after { task.invoke_with_appsignal('foo') rescue VerySpecificError }
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe "Unicorn integration" do
-  let(:file) { File.expand_path('lib/appsignal/integrations/unicorn.rb') }
-  before(:all) do
-    module Unicorn
-      class HttpServer
-        def worker_loop(worker)
-        end
-      end
-
-      class Worker
-        def close
-        end
-      end
-    end
-  end
-  before do
-    load file
-    start_agent
-  end
-
-  it "adds behavior to Unicorn::HttpServer#worker_loop" do
-    server = Unicorn::HttpServer.new
-    worker = double
-
-    Appsignal.agent.should_receive(:forked!)
-    server.should_receive(:original_worker_loop).with(worker)
-
-    server.worker_loop(worker)
-  end
-
-  it "should add behavior to Unicorn::Worker#close" do
-    worker = Unicorn::Worker.new
-
-    Appsignal.agent.should_receive(:shutdown).with(true, 'stopping Unicorn worker process')
-    worker.should_receive(:original_close)
-
-    worker.close
-  end
-
-  context "without unicorn" do
-    before(:all) { Object.send(:remove_const, :Unicorn) }
-
-    specify { expect { Unicorn }.to raise_error(NameError) }
-    specify { expect { load file }.to_not raise_error }
-  end
-end

data/spec/lib/appsignal/ipc_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-require 'fileutils'
-
-unless running_jruby?
-  describe Appsignal::IPC do
-    before :all do
-      start_agent
-    end
-    after :all do
-      Appsignal::IPC::Client.stop
-      Appsignal::IPC::Server.stop
-    end
-
-    subject { Appsignal::IPC }
-
-    describe ".forked!" do
-      it "should stop the server, start the client and stop the appsignal thread" do
-        Appsignal::IPC::Server.should_receive(:stop)
-        Appsignal::IPC::Client.should_receive(:start)
-        Appsignal.agent.should_receive(:stop_thread)
-
-        subject.forked!
-      end
-    end
-
-    describe Appsignal::IPC::Server do
-      subject { Appsignal::IPC::Server }
-
-      describe ".start" do
-        before do
-          FileUtils.rm_rf(File.join(project_fixture_path, 'tmp'))
-          Process.stub(:pid => 100)
-        end
-
-        it "should start a DRb server" do
-          DRb.should_receive(:start_service).with(
-            instance_of(String),
-            Appsignal::IPC::Server
-          )
-          subject.start
-          subject.uri.should == 'drbunix:/tmp/appsignal-100'
-        end
-
-        context "when a tmp path exists in the project path" do
-          before do
-            FileUtils.mkdir_p(File.join(project_fixture_path, 'tmp'))
-          end
-
-          it "should use a uri in the project path" do
-            subject.start
-            subject.uri.should == "drbunix:#{project_fixture_path}/tmp/appsignal-100"
-          end
-        end
-      end
-
-      describe ".stop" do
-        it "should stop the DRb server" do
-          DRb.should_receive(:stop_service)
-          subject.stop
-        end
-      end
-
-      describe ".enqueue" do
-        let(:transaction) { regular_transaction }
-
-        it "should enqueue" do
-          Appsignal.agent.aggregator.has_transactions?.should be_false
-          subject.enqueue(transaction)
-          Appsignal.agent.aggregator.has_transactions?.should be_true
-        end
-      end
-    end
-
-    describe Appsignal::IPC::Client do
-      before do
-        Appsignal::IPC::Client.stop
-      end
-
-      subject { Appsignal::IPC::Client }
-
-      describe ".start" do
-        it "should start the client" do
-          subject.active?.should be_false
-
-          subject.start
-
-          subject.server.should be_instance_of(DRbObject)
-          subject.active?.should be_true
-        end
-      end
-
-      describe ".stop" do
-        it "should stop the client" do
-          subject.start
-          subject.stop
-
-          subject.server.should be_nil
-          subject.active?.should be_false
-        end
-      end
-
-      describe ".enqueue" do
-        let(:transaction) { regular_transaction }
-
-        it "should send the transaction to the server" do
-          subject.start
-          subject.server.should_receive(:enqueue).with(transaction)
-          subject.enqueue(transaction)
-        end
-      end
-    end
-
-    describe "integration between client and server" do
-      it "should enqueue a transaction on the master" do
-        Appsignal::IPC::Server.start
-
-        fork do
-          Appsignal::IPC.forked!
-          Appsignal::IPC::Client.enqueue(regular_transaction)
-        end
-
-        Appsignal.agent.should_receive(:enqueue).with(instance_of(Appsignal::Transaction))
-
-        sleep 1 # Wait for the forked process to do it's work
-      end
-    end
-  end
-end