appsignal 0.12.beta.31 → 0.12.beta.32

data/lib/appsignal/rack/instrumentation.rb

@@ -1,32 +0,0 @@
-require 'rack'
-
-module Appsignal
-  module Rack
-    class Instrumentation
-      def initialize(app, options = {})
-        Appsignal.logger.debug 'Initializing Appsignal::Rack::Instrumentation'
-        @app, @options = app, options
-      end
-
-      def call(env)
-        ActiveSupport::Notifications.instrument(
-          'process_action.rack',
-          raw_payload(env)
-        ) do |payload|
-          @app.call(env)
-        end
-      end
-
-      def raw_payload(env)
-        request = @options.fetch(:request_class, ::Rack::Request).new(env)
-        params = request.public_send(@options.fetch(:params_method, :params))
-        {
-          :action => "#{request.request_method}:#{request.path}",
-          :params => params,
-          :method => request.request_method,
-          :path   => request.path
-        }
-      end
-    end
-  end
-end

data/lib/appsignal/rack/listener.rb

@@ -1,32 +0,0 @@
-module Appsignal
-  module Rack
-    class Listener
-      def initialize(app, options = {})
-        Appsignal.logger.debug 'Initializing Appsignal::Rack::Listener'
-        @app, @options = app, options
-      end
-
-      def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          @app.call(env)
-        end
-      end
-
-      def call_with_appsignal_monitoring(env)
-        Appsignal::Transaction.create(request_id(env), env)
-        @app.call(env)
-      rescue Exception => exception
-        Appsignal.set_exception(exception)
-        raise exception
-      ensure
-        Appsignal::Transaction.complete_current!
-      end
-
-      def request_id(env)
-        env['action_dispatch.request_id'] || SecureRandom.uuid
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-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',
-        'QUERY_STRING' => 'param=something'
-      }
-    end
-    subject { middleware.raw_payload(env) }
-
-    it { should == {
-      :action => 'GET:/homepage',
-      :params => {'param' => 'something'},
-      :method => 'GET',
-      :path => '/homepage'
-    } }
-  end
-
-  describe "use a custom request class and parameters method" do
-    let(:request_class) do
-      double(
-        new: double(
-          request_method: 'POST',
-          path: '/somewhere',
-          filtered_params: {'param' => 'changed_something'}
-        )
-      )
-    end
-    let(:options) do
-      { request_class: request_class, params_method: :filtered_params }
-    end
-    let(:middleware) { Appsignal::Rack::Instrumentation.new(app, options) }
-    subject { middleware.raw_payload(env) }
-
-    it { should == {
-      :action => 'POST:/somewhere',
-      :params => {'param' => 'changed_something'},
-      :method => 'POST',
-      :path => '/somewhere'
-    } }
-  end
-end

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

@@ -1,104 +0,0 @@
-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::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(:current) { double(:request_id => '1', :set_error => true, :transaction_index => 1) }
-    before do
-      middleware.stub(:request_id => '1')
-      Appsignal::Transaction.stub(:current => current)
-    end
-
-    describe 'around call' do
-      it 'should create an appsignal transaction' do
-        Appsignal::Transaction.should_receive(:create).with('1', env)
-      end
-
-      it 'should call complete! after the call' do
-        Appsignal::Transaction.should_receive(:complete_current!)
-      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
-
-    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
-        current.should_receive(:set_error)
-        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
-          current.should_not_receive(:set_error)
-          middleware.call(env) rescue nil
-        end
-      end
-
-      describe 'after an error' do
-        it 'should call complete_current! after the call' do
-          Appsignal::Transaction.should_receive(:complete_current!)
-        end
-
-        after { middleware.call(env) rescue nil }
-      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