appsignal 4.0.5 → 4.0.7

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

@@ -1,38 +0,0 @@
-describe Appsignal::Rack::InstrumentationMiddleware do
-  let(:app) { DummyApp.new }
-  let(:env) { Rack::MockRequest.env_for("/some/path") }
-  let(:middleware) { described_class.new(app, {}) }
-
-  before { start_agent }
-  around { |example| keep_transactions { example.run } }
-
-  def make_request(env)
-    middleware.call(env)
-  end
-
-  context "without an exception" do
-    it "reports a process_request_middleware.rack event" do
-      make_request(env)
-
-      expect(last_transaction).to include_event("name" => "process_request_middleware.rack")
-    end
-  end
-
-  context "with custom action name" do
-    let(:app) { DummyApp.new { |_env| Appsignal.set_action("MyAction") } }
-
-    it "reports the custom action name" do
-      make_request(env)
-
-      expect(last_transaction).to have_action("MyAction")
-    end
-  end
-
-  context "without action name metadata" do
-    it "reports no action name" do
-      make_request(env)
-
-      expect(last_transaction).to_not have_action
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-if DependencyHelper.rails_present?
-  describe Appsignal::Rack::RailsInstrumentation do
-    class MockController; end
-
-    let(:transaction) { new_transaction }
-    let(:app) { DummyApp.new }
-    let(:params) do
-      {
-        "controller" => "blog_posts",
-        "action" => "show",
-        "id" => "1",
-        "my_custom_param" => "my custom secret",
-        "password" => "super secret"
-      }
-    end
-    let(:env) do
-      http_request_env_with_data(
-        :params => params,
-        :with_queue_start => true,
-        "action_dispatch.request_id" => "request_id123",
-        "action_dispatch.parameter_filter" => [:my_custom_param, :password],
-        "action_controller.instance" => double(
-          :class => MockController,
-          :action_name => "index"
-        )
-      )
-    end
-    let(:middleware) { Appsignal::Rack::RailsInstrumentation.new(app, {}) }
-    around { |example| keep_transactions { example.run } }
-    before do
-      start_agent
-      env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
-    end
-
-    def make_request
-      middleware.call(env)
-      last_transaction&._sample
-    end
-
-    def make_request_with_error(error_class, error_message)
-      expect { make_request }.to raise_error(error_class, error_message)
-    end
-
-    context "with a request that doesn't raise an error" do
-      before { make_request }
-
-      it "calls the next middleware in the stack" do
-        expect(app).to be_called
-      end
-
-      it "does not instrument an event" do
-        expect(last_transaction).to_not include_events
-      end
-    end
-
-    context "with a request that raises an error" do
-      let(:app) do
-        DummyApp.new { |_env| raise ExampleException, "error message" }
-      end
-      before do
-        make_request_with_error(ExampleException, "error message")
-      end
-
-      it "calls the next middleware in the stack" do
-        expect(app).to be_called
-      end
-
-      it "reports the error on the transaction" do
-        expect(last_transaction).to have_error("ExampleException", "error message")
-      end
-    end
-
-    it "sets the controller action as the action name" do
-      make_request
-
-      expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-      expect(last_transaction).to have_action("MockController#index")
-    end
-
-    it "sets request metadata on the transaction" do
-      make_request
-
-      expect(last_transaction).to include_metadata(
-        "method" => "GET",
-        "path" => "/blog"
-      )
-      expect(last_transaction).to include_tags("request_id" => "request_id123")
-    end
-
-    it "reports Rails filter parameters" do
-      make_request
-
-      expect(last_transaction).to include_params(
-        "controller" => "blog_posts",
-        "action" => "show",
-        "id" => "1",
-        "my_custom_param" => "[FILTERED]",
-        "password" => "[FILTERED]"
-      )
-    end
-
-    context "with an invalid HTTP request method" do
-      it "does not store the invalid HTTP request method" do
-        env[:request_method] = "FOO"
-        env["REQUEST_METHOD"] = "FOO"
-        logs = capture_logs { make_request }
-
-        expect(last_transaction).to_not include_metadata("method" => anything)
-        expect(logs).to contains_log(
-          :error,
-          "Exception while fetching the HTTP request method: "
-        )
-      end
-    end
-
-    context "with a request path that's not a route" do
-      it "doesn't set an action name" do
-        env[:path] = "/unknown-route"
-        env["action_controller.instance"] = nil
-        make_request
-
-        expect(last_transaction).to_not have_action
-      end
-    end
-  end
-end

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

@@ -1,217 +0,0 @@
-if DependencyHelper.sinatra_present?
-  require "appsignal/rack/sinatra_instrumentation"
-
-  module SinatraRequestHelpers
-    def make_request
-      middleware.call(env)
-    end
-
-    def make_request_with_error(error)
-      expect { middleware.call(env) }.to raise_error(error)
-    end
-  end
-
-  describe Appsignal::Rack::SinatraInstrumentation do
-    include SinatraRequestHelpers
-
-    let(:settings) { double(:raise_errors => false) }
-    let(:app) { double(:call => true, :settings => settings) }
-    let(:env) do
-      Rack::MockRequest.env_for("/path", "sinatra.route" => "GET /path", "REQUEST_METHOD" => "GET")
-    end
-    let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app) }
-
-    before { start_agent }
-    around do |example|
-      keep_transactions { example.run }
-    end
-
-    describe "#call" do
-      before { allow(middleware).to receive(:raw_payload).and_return({}) }
-
-      it "doesn't instrument requests" do
-        expect { make_request }.to_not(change { created_transactions.count })
-      end
-    end
-
-    describe ".settings" do
-      subject { middleware.settings }
-
-      it "returns the app's settings" do
-        expect(subject).to eq(app.settings)
-      end
-    end
-  end
-
-  describe Appsignal::Rack::SinatraBaseInstrumentation do
-    include SinatraRequestHelpers
-
-    let(:settings) { double(:raise_errors => false) }
-    let(:app) { double(:call => true, :settings => settings) }
-    let(:env) do
-      Rack::MockRequest.env_for("/path", "sinatra.route" => "GET /path", "REQUEST_METHOD" => "GET")
-    end
-    let(:appsignal_env) { :default }
-    let(:options) { {} }
-    let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
-
-    before { start_agent(:env => appsignal_env) }
-    around { |example| keep_transactions { example.run } }
-
-    describe "#initialize" do
-      context "with no settings method in the Sinatra app" do
-        let(:app) { double(:call => true) }
-
-        it "does not raise errors" do
-          expect(middleware.raise_errors_on).to be(false)
-        end
-      end
-
-      context "with no raise_errors setting in the Sinatra app" do
-        let(:app) { double(:call => true, :settings => double) }
-
-        it "does not raise errors" do
-          expect(middleware.raise_errors_on).to be(false)
-        end
-      end
-
-      context "with raise_errors turned off in the Sinatra app" do
-        let(:app) { double(:call => true, :settings => double(:raise_errors => false)) }
-
-        it "raises errors" do
-          expect(middleware.raise_errors_on).to be(false)
-        end
-      end
-
-      context "with raise_errors turned on in the Sinatra app" do
-        let(:app) { double(:call => true, :settings => double(:raise_errors => true)) }
-
-        it "raises errors" do
-          expect(middleware.raise_errors_on).to be(true)
-        end
-      end
-    end
-
-    describe "#call" do
-      before { allow(middleware).to receive(:raw_payload).and_return({}) }
-
-      context "when appsignal is not active" do
-        let(:appsignal_env) { :inactive_env }
-
-        it "does not instrument requests" do
-          expect { make_request }.to_not(change { created_transactions.count })
-        end
-
-        it "calls the next middleware in the stack" do
-          make_request
-
-          expect(app).to have_received(:call).with(env)
-        end
-      end
-
-      context "when appsignal is active" do
-        context "without an error" do
-          it "creates a transaction for the request" do
-            expect { make_request }.to(change { created_transactions.count }.by(1))
-
-            expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-          end
-
-          it "reports a process_action.sinatra event" do
-            make_request
-
-            expect(last_transaction).to include_event("name" => "process_action.sinatra")
-          end
-        end
-
-        context "with an error in sinatra.error" do
-          let(:error) { ExampleException.new("error message") }
-          before { env["sinatra.error"] = error }
-
-          it "creates a transaction for the request" do
-            expect { make_request }.to(change { created_transactions.count }.by(1))
-
-            expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-          end
-
-          context "when raise_errors is off" do
-            let(:settings) { double(:raise_errors => false) }
-
-            it "records the error" do
-              make_request
-
-              expect(last_transaction).to have_error("ExampleException", "error message")
-            end
-          end
-
-          context "when raise_errors is on" do
-            let(:settings) { double(:raise_errors => true) }
-
-            it "does not record the error" do
-              make_request
-
-              expect(last_transaction).to_not have_error
-            end
-          end
-
-          context "if sinatra.skip_appsignal_error is set" do
-            before do
-              env.merge!(
-                "sinatra.error" => error,
-                "sinatra.skip_appsignal_error" => true
-              )
-            end
-
-            it "does not record the error" do
-              make_request
-
-              expect(last_transaction).to_not have_error
-            end
-          end
-        end
-
-        describe "action name" do
-          it "sets the action to the request method and path" do
-            make_request
-
-            expect(last_transaction).to have_action("GET /path")
-          end
-
-          context "without 'sinatra.route' env" do
-            let(:env) do
-              Rack::MockRequest.env_for("/path", "REQUEST_METHOD" => "GET")
-            end
-
-            it "doesn't set an action name" do
-              make_request
-
-              expect(last_transaction).to_not have_action
-            end
-          end
-
-          context "with mounted modular application" do
-            before { env["SCRIPT_NAME"] = "/api" }
-
-            it "sets the action name with an application prefix path" do
-              make_request
-
-              expect(last_transaction).to have_action("GET /api/path")
-            end
-
-            context "without 'sinatra.route' env" do
-              let(:env) do
-                Rack::MockRequest.env_for("/path", "REQUEST_METHOD" => "GET")
-              end
-
-              it "doesn't set an action name" do
-                make_request
-
-                expect(last_transaction).to_not have_action
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/appsignal/rack_spec.rb

@@ -1,243 +0,0 @@
-describe Appsignal::Rack::Utils do
-  describe ".queue_start_from" do
-    let(:header_time) { fixed_time - 0.4 }
-    let(:header_time_value) { (header_time * factor).to_i }
-    subject { described_class.queue_start_from(env) }
-
-    shared_examples "HTTP queue start" do
-      context "when env is nil" do
-        let(:env) { nil }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "with no relevant header set" do
-        let(:env) { {} }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "with the HTTP_X_REQUEST_START header set" do
-        let(:env) { { "HTTP_X_REQUEST_START" => "t=#{header_time_value}" } }
-
-        it { is_expected.to eq 1_389_783_599_600 }
-
-        context "with unparsable content" do
-          let(:env) { { "HTTP_X_REQUEST_START" => "something" } }
-
-          it { is_expected.to be_nil }
-        end
-
-        context "with unparsable content at the end" do
-          let(:env) { { "HTTP_X_REQUEST_START" => "t=#{header_time_value}aaaa" } }
-
-          it { is_expected.to eq 1_389_783_599_600 }
-        end
-
-        context "with a really low number" do
-          let(:env) { { "HTTP_X_REQUEST_START" => "t=100" } }
-
-          it { is_expected.to be_nil }
-        end
-
-        context "with the alternate HTTP_X_QUEUE_START header set" do
-          let(:env) { { "HTTP_X_QUEUE_START" => "t=#{header_time_value}" } }
-
-          it { is_expected.to eq 1_389_783_599_600 }
-        end
-      end
-    end
-
-    context "time in milliseconds" do
-      let(:factor) { 1_000 }
-
-      it_should_behave_like "HTTP queue start"
-    end
-
-    context "time in microseconds" do
-      let(:factor) { 1_000_000 }
-
-      it_should_behave_like "HTTP queue start"
-    end
-  end
-end
-
-describe Appsignal::Rack::ApplyRackRequest do
-  describe "#apply_to" do
-    let(:merged_env) do
-      Rack::MockRequest.env_for(
-        "/some/path",
-        {
-          "REQUEST_METHOD" => "GET",
-          :params => { "page" => 2, "query" => "lorem" },
-          "rack.session" => { "session" => "data", "user_id" => 123 }
-        }.merge(env)
-      )
-    end
-    let(:env) { {} }
-    let(:request) { ::Rack::Request.new(merged_env) }
-    let(:options) { {} }
-    let(:helper) { described_class.new(request, options) }
-    let(:transaction) { http_request_transaction }
-    before { start_agent }
-
-    def apply_to(transaction)
-      helper.apply_to(transaction)
-      transaction._sample
-    end
-
-    it "sets request metadata" do
-      apply_to(transaction)
-
-      expect(transaction).to include_metadata(
-        "method" => "GET",
-        "path" => "/some/path"
-      )
-      expect(transaction).to include_environment(
-        "REQUEST_METHOD" => "GET",
-        "PATH_INFO" => "/some/path"
-        # and more, but we don't need to test Rack mock defaults
-      )
-    end
-
-    context "with an invalid HTTP request method" do
-      let(:env) { { "REQUEST_METHOD" => "FOO" } }
-
-      it "stores the invalid HTTP request method" do
-        apply_to(transaction)
-
-        expect(transaction).to include_metadata("method" => "FOO")
-      end
-    end
-
-    context "when fetching the request method raises an error" do
-      class BrokenRequestMethodRequest < Rack::Request
-        def request_method
-          raise "uh oh!"
-        end
-      end
-
-      let(:env) { { "REQUEST_METHOD" => "FOO" } }
-      let(:request) { BrokenRequestMethodRequest.new(merged_env) }
-
-      it "does not store the invalid HTTP request method" do
-        logs = capture_logs { apply_to(transaction) }
-
-        expect(transaction).to_not include_metadata("method" => anything)
-        expect(logs).to contains_log(
-          :error,
-          "Exception while fetching the HTTP request method: RuntimeError: uh oh"
-        )
-      end
-    end
-
-    it "sets request parameters" do
-      apply_to(transaction)
-
-      expect(transaction).to include_params(
-        "page" => "2",
-        "query" => "lorem"
-      )
-    end
-
-    context "when params_method isn't set" do
-      let(:options) { { :params_method => nil } }
-
-      it "reports no params" do
-        apply_to(transaction)
-
-        expect(transaction).to_not include_params
-      end
-    end
-
-    context "when fetching the request method raises an error" do
-      class BrokenRequestParamsRequest < Rack::Request
-        def params
-          raise "uh oh!"
-        end
-      end
-
-      let(:request) { BrokenRequestParamsRequest.new(merged_env) }
-      let(:options) { { :params_method => :params } }
-
-      it "does not store the invalid HTTP request method" do
-        logs = capture_logs { apply_to(transaction) }
-
-        expect(transaction).to_not include_params
-        expect(logs).to contains_log(
-          :error,
-          "Exception while fetching params " \
-            "from 'BrokenRequestParamsRequest#params': RuntimeError uh oh!"
-        )
-      end
-    end
-
-    it "sets session data" do
-      apply_to(transaction)
-
-      expect(transaction).to include_session_data("session" => "data", "user_id" => 123)
-    end
-
-    context "with Hash-like session data" do
-      let(:env) { { "rack.session" => HashLike.new("hash-like" => "value", "user_id" => 123) } }
-
-      it "sets session data" do
-        apply_to(transaction)
-
-        expect(transaction).to include_session_data("hash-like" => "value", "user_id" => 123)
-      end
-    end
-
-    context "with queue start header" do
-      let(:queue_start_time) { fixed_time * 1_000 }
-      let(:env) { { "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}" } } # in milliseconds
-
-      it "sets the queue start" do
-        apply_to(transaction)
-
-        expect(transaction).to have_queue_start(queue_start_time)
-      end
-    end
-
-    class RackFilteredRequest
-      attr_reader :env
-
-      def initialize(env)
-        @env = env
-      end
-
-      def path
-        "/static/path"
-      end
-
-      def request_method
-        "GET"
-      end
-
-      def filtered_params
-        { "abc" => "123" }
-      end
-
-      def session
-        { "data" => "value" }
-      end
-    end
-
-    context "with overridden request class and params method" do
-      let(:request) { RackFilteredRequest.new(env) }
-      let(:options) { { :params_method => :filtered_params } }
-
-      it "uses the overridden request class and params method to fetch params" do
-        apply_to(transaction)
-
-        expect(transaction).to include_params("abc" => "123")
-      end
-
-      it "uses the overridden request class to fetch session data" do
-        apply_to(transaction)
-
-        expect(transaction).to include_session_data("data" => "value")
-      end
-    end
-  end
-end