appsignal 3.9.3 → 3.11.0

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

@@ -3,8 +3,11 @@ describe Appsignal::Rack::EventHandler do
   let(:env) do
     {
       "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}", # in milliseconds
-      "REQUEST_METHOD" => "GET",
-      "PATH_INFO" => "/path"
+      "REQUEST_METHOD" => "POST",
+      "PATH_INFO" => "/path",
+      "QUERY_STRING" => "query_param1=value1&query_param2=value2",
+      "rack.session" => { "session1" => "value1", "session2" => "value2" },
+      "rack.input" => StringIO.new("post_param1=value1&post_param2=value2")
     }
   end
   let(:request) { Rack::Request.new(env) }
@@ -172,20 +175,93 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction).to_not be_completed
     end
 
-    it "completes the transaction" do
+    it "sets params on the transaction" do
+      on_start
+      on_finish
+
+      expect(last_transaction).to include_params(
+        "query_param1" => "value1",
+        "query_param2" => "value2",
+        "post_param1" => "value1",
+        "post_param2" => "value2"
+      )
+    end
+
+    it "sets headers on the transaction" do
       on_start
       on_finish
 
-      expect(last_transaction).to_not have_action
       expect(last_transaction).to include_environment(
-        "REQUEST_METHOD" => "GET",
+        "REQUEST_METHOD" => "POST",
         "PATH_INFO" => "/path"
       )
+    end
+
+    it "sets session data on the transaction" do
+      on_start
+      on_finish
+
+      expect(last_transaction).to include_session_data(
+        "session1" => "value1",
+        "session2" => "value2"
+      )
+    end
+
+    it "sets the queue start time on the transaction" do
+      on_start
+      on_finish
+
       expect(last_transaction).to have_queue_start(queue_start_time)
+    end
+
+    it "completes the transaction" do
+      on_start
+      on_finish
+
+      expect(last_transaction).to_not have_action
       expect(last_transaction).to be_completed
     end
 
     context "without a response" do
+      it "sets params on the transaction" do
+        on_start
+        on_finish
+
+        expect(last_transaction).to include_params(
+          "query_param1" => "value1",
+          "query_param2" => "value2",
+          "post_param1" => "value1",
+          "post_param2" => "value2"
+        )
+      end
+
+      it "sets headers on the transaction" do
+        on_start
+        on_finish
+
+        expect(last_transaction).to include_environment(
+          "REQUEST_METHOD" => "POST",
+          "PATH_INFO" => "/path"
+        )
+      end
+
+      it "sets session data on the transaction" do
+        on_start
+        on_finish
+
+        expect(last_transaction).to include_session_data(
+          "session1" => "value1",
+          "session2" => "value2"
+        )
+      end
+
+      it "sets the queue start time on the transaction" do
+        on_start
+        on_finish
+
+        expect(last_transaction).to have_queue_start(queue_start_time)
+      end
+
       it "completes the transaction" do
         on_start
         on_finish(request, nil)
@@ -193,11 +269,6 @@ describe Appsignal::Rack::EventHandler do
         # The action is not set on purpose, as we can't set a normalized route
         # It requires the app to set an action name
         expect(last_transaction).to_not have_action
-        expect(last_transaction).to include_environment(
-          "REQUEST_METHOD" => "GET",
-          "PATH_INFO" => "/path"
-        )
-        expect(last_transaction).to have_queue_start(queue_start_time)
         expect(last_transaction).to be_completed
       end
 

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

@@ -1,28 +1,81 @@
-describe Appsignal::Rack::GenericInstrumentation do
-  let(:app) { double(:call => true) }
-  let(:env) { Rack::MockRequest.env_for("/some/path") }
-  let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, {}) }
+describe "Appsignal::Rack::GenericInstrumentation" do
+  describe "Appsignal::Rack::GenericInstrumentation constant" do
+    let(:err_stream) { std_stream }
+    let(:stderr) { err_stream.read }
+    before do
+      if Appsignal::Rack.const_defined?(:GenericInstrumentation)
+        hide_const "Appsignal::Rack::GenericInstrumentation"
+      end
+    end
+
+    it "returns the Rack::GenericInstrumentation constant" do
+      silence do
+        expect(Appsignal::Rack::GenericInstrumentation)
+          .to be(Appsignal::Rack::GenericInstrumentationAlias)
+      end
+    end
 
-  before(:context) { start_agent }
-  around { |example| keep_transactions { example.run } }
+    it "prints a deprecation warning to STDERR" do
+      capture_std_streams(std_stream, err_stream) do
+        Appsignal::Rack::GenericInstrumentation
+      end
 
-  def make_request(env)
-    middleware.call(env)
-  end
+      expect(stderr).to include(
+        "appsignal WARNING: The constant Appsignal::Rack::GenericInstrumentation " \
+          "has been deprecated."
+      )
+    end
 
-  context "without an exception" do
-    it "reports a process_action.generic event" do
-      make_request(env)
+    it "logs a warning" do
+      logs =
+        capture_logs do
+          silence do
+            Appsignal::Rack::GenericInstrumentation
+          end
+        end
 
-      expect(last_transaction).to include_event("name" => "process_action.generic")
+      expect(logs).to contains_log(
+        :warn,
+        "The constant Appsignal::Rack::GenericInstrumentation has been deprecated."
+      )
     end
   end
 
-  context "without action name metadata" do
-    it "reports 'unknown' as the action name" do
-      make_request(env)
+  describe "middleware" do
+    let(:app) { double(:call => true) }
+    let(:env) { Rack::MockRequest.env_for("/some/path") }
+    let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, {}) }
+
+    before(:context) { 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_action.generic event" do
+        make_request(env)
+
+        expect(last_transaction).to include_event("name" => "process_action.generic")
+      end
+    end
+
+    context "with action name env" do
+      it "reports the appsignal.action env as the action name" do
+        env["appsignal.action"] = "MyAction"
+        make_request(env)
+
+        expect(last_transaction).to have_action("MyAction")
+      end
+    end
+
+    context "without action name metadata" do
+      it "reports 'unknown' as the action name" do
+        make_request(env)
 
-      expect(last_transaction).to have_action("unknown")
+        expect(last_transaction).to have_action("unknown")
+      end
     end
   end
 end

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

@@ -5,7 +5,7 @@ if DependencyHelper.grape_present?
     let(:err_stream) { std_stream }
     let(:stderr) { err_stream.read }
 
-    it "returns the Probes constant calling the Minutely constant" do
+    it "returns the Rack::GrapeMiddleware constant calling the Grape::Middleware constant" do
       silence { expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware) }
     end
 

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

@@ -0,0 +1,38 @@
+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

@@ -114,8 +114,10 @@ if DependencyHelper.rails_present?
         make_request
 
         expect(last_transaction).to_not include_metadata("method" => anything)
-        expect(log_contents(log))
-          .to contains_log(:error, "Unable to report HTTP request method: '")
+        expect(log_contents(log)).to contains_log(
+          :error,
+          "Exception while fetching the HTTP request method: "
+        )
       end
     end
 

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

@@ -1,146 +1,69 @@
-require "appsignal/rack/streaming_listener"
-
-describe Appsignal::Rack::StreamingListener do
-  let(:env) do
-    {
-      "rack.input" => StringIO.new,
-      "REQUEST_METHOD" => "GET",
-      "PATH_INFO" => "/homepage",
-      "QUERY_STRING" => "param=something"
-    }
+describe "Appsignal::Rack::StreamingListener" do
+  def load_middleware
+    load "lib/appsignal/rack/streaming_listener.rb"
   end
-  let(:app) { DummyApp.new }
-  let(:listener) { Appsignal::Rack::StreamingListener.new(app, {}) }
-  before(:context) { start_agent }
-  around { |example| keep_transactions { example.run } }
 
-  describe "#call" do
-    context "when Appsignal is not active" do
-      before { allow(Appsignal).to receive(:active?).and_return(false) }
+  describe "loading the streaming_listener integrations file" do
+    let(:err_stream) { std_stream }
+    let(:stderr) { err_stream.read }
+    after { Appsignal::Rack.send(:remove_const, :StreamingListener) }
 
-      it "does not create a transaction" do
-        expect do
-          listener.call(env)
-        end.to_not(change { created_transactions.count })
+    it "prints a deprecation warning to STDERR" do
+      capture_std_streams(std_stream, err_stream) do
+        load_middleware
       end
 
-      it "calls the app" do
-        listener.call(env)
-
-        expect(app).to be_called
-      end
+      expect(stderr).to include(
+        "appsignal WARNING: The constant Appsignal::Rack::StreamingListener " \
+          "has been deprecated."
+      )
     end
 
-    context "when Appsignal is active" do
-      before { allow(Appsignal).to receive(:active?).and_return(true) }
-
-      let(:wrapper) { Appsignal::StreamWrapper.new("body", transaction) }
-      let(:raw_payload) { { :foo => :bar } }
-      before { allow(listener).to receive(:raw_payload).and_return(raw_payload) }
-
-      it "creates a transaction" do
-        expect do
-          listener.call(env)
-        end.to(change { created_transactions.count }.by(1))
-      end
-
-      it "instruments the call" do
-        listener.call(env)
-
-        expect(last_transaction).to include_event("name" => "process_action.rack")
-      end
-
-      it "set `appsignal.action` to the action name" do
-        env["appsignal.action"] = "Action"
-
-        listener.call(env)
-
-        expect(last_transaction).to have_action("Action")
-      end
-
-      it "adds the path, method and queue start to the transaction" do
-        listener.call(env)
-
-        expect(last_transaction).to include_metadata(
-          "path" => "/homepage",
-          "method" => "GET"
-        )
-        expect(last_transaction).to have_queue_start
-      end
-
-      context "with an exception in the instrumentation call" do
-        let(:error) { ExampleException.new("error message") }
-        let(:app) { DummyApp.new { raise error } }
-
-        it "adds the exception to the transaction" do
-          expect do
-            listener.call(env)
-          end.to raise_error(error)
-
-          expect(last_transaction).to have_error("ExampleException", "error message")
+    it "logs a warning" do
+      logs =
+        capture_logs do
+          silence do
+            load_middleware
+          end
         end
-      end
 
-      it "wraps the body in a wrapper" do
-        _, _, body = listener.call(env)
-
-        expect(body).to be_a(Appsignal::StreamWrapper)
-      end
+      expect(logs).to contains_log(
+        :warn,
+        "The constant Appsignal::Rack::StreamingListener has been deprecated."
+      )
     end
   end
-end
-
-describe Appsignal::StreamWrapper do
-  let(:stream) { double }
-  let(:transaction) { http_request_transaction }
-  let(:wrapper) { Appsignal::StreamWrapper.new(stream, transaction) }
-  before do
-    start_agent
-    set_current_transaction(transaction)
-  end
-  around { |example| keep_transactions { example.run } }
 
-  describe "#each" do
-    it "calls the original stream" do
-      expect(stream).to receive(:each)
+  describe "middleware" do
+    let(:env) { {} }
+    let(:app) { DummyApp.new }
+    let(:middleware) { Appsignal::Rack::StreamingListener.new(app, {}) }
+    around { |example| keep_transactions { example.run } }
+    before(:context) { load_middleware }
+    before { start_agent }
 
-      wrapper.each
+    def make_request
+      middleware.call(env)
     end
 
-    context "when #each raises an error" do
-      let(:error) { ExampleException.new("error message") }
-
-      it "records the exception" do
-        allow(stream).to receive(:each).and_raise(error)
+    it "instruments the call" do
+      make_request
 
-        expect { wrapper.send(:each) }.to raise_error(error)
-
-        expect(transaction).to have_error("ExampleException", "error message")
-      end
+      expect(last_transaction).to include_event("name" => "process_streaming_request.rack")
     end
-  end
-
-  describe "#close" do
-    it "closes the original stream and completes the transaction" do
-      expect(stream).to receive(:close)
 
-      wrapper.close
+    it "set no action by default" do
+      make_request
 
-      expect(current_transaction?).to be_falsy
-      expect(transaction).to be_completed
+      expect(last_transaction).to_not have_action
     end
 
-    context "when #close raises an error" do
-      let(:error) { ExampleException.new("error message") }
+    it "set `appsignal.action` to the action name" do
+      env["appsignal.action"] = "Action"
 
-      it "records the exception and completes the transaction" do
-        allow(stream).to receive(:close).and_raise(error)
+      make_request
 
-        expect { wrapper.send(:close) }.to raise_error(error)
-
-        expect(transaction).to have_error("ExampleException", "error message")
-        expect(transaction).to be_completed
-      end
+      expect(last_transaction).to have_action("Action")
     end
   end
 end

data/spec/lib/appsignal/rack_spec.rb

@@ -0,0 +1,63 @@
+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