appsignal 3.9.3-java → 3.10.0-java

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/transaction_spec.rb

@@ -326,6 +326,16 @@ describe Appsignal::Transaction do
         it "returns custom parameters" do
           expect(subject).to eq(:foo => "bar")
         end
+
+        context "when params is a callable object" do
+          it "calls the params object and sets the return value as parametesr" do
+            transaction.set_params { { "param1" => "value1" } }
+
+            expect(transaction.params).to eq(
+              "param1" => "value1"
+            )
+          end
+        end
       end
 
       context "without custom params set on transaction" do
@@ -374,6 +384,25 @@ describe Appsignal::Transaction do
           expect(transaction.params).to eq(params)
           expect(transaction).to include_params(params)
         end
+
+        it "updates the params on the transaction with a block" do
+          params = { "key" => "value" }
+          transaction.set_params { params }
+
+          transaction._sample
+          expect(transaction.params).to eq(params)
+          expect(transaction).to include_params(params)
+        end
+
+        it "updates with the params argument when both an argument and block are given" do
+          arg_params = { "argument" => "value" }
+          block_params = { "block" => "value" }
+          transaction.set_params(arg_params) { block_params }
+
+          transaction._sample
+          expect(transaction.params).to eq(arg_params)
+          expect(transaction).to include_params(arg_params)
+        end
       end
 
       context "when the given params is nil" do
@@ -402,6 +431,25 @@ describe Appsignal::Transaction do
           expect(transaction).to include_params(params)
         end
 
+        it "updates the params on the transaction with a block" do
+          params = { "key" => "value" }
+          transaction.set_params_if_nil { params }
+
+          transaction._sample
+          expect(transaction.params).to eq(params)
+          expect(transaction).to include_params(params)
+        end
+
+        it "updates with the params argument when both an argument and block are given" do
+          arg_params = { "argument" => "value" }
+          block_params = { "block" => "value" }
+          transaction.set_params_if_nil(arg_params) { block_params }
+
+          transaction._sample
+          expect(transaction.params).to eq(arg_params)
+          expect(transaction).to include_params(arg_params)
+        end
+
         context "when the given params is nil" do
           it "does not update the params on the transaction" do
             params = { "key" => "value" }
@@ -426,12 +474,24 @@ describe Appsignal::Transaction do
           expect(transaction.params).to eq(preset_params)
           expect(transaction).to include_params(preset_params)
         end
+
+        it "does not update the params with a block on the transaction" do
+          preset_params = { "other" => "params" }
+          params = { "key" => "value" }
+          transaction.set_params(preset_params)
+          transaction.set_params_if_nil { params }
+
+          transaction._sample
+          expect(transaction.params).to eq(preset_params)
+          expect(transaction).to include_params(preset_params)
+        end
       end
     end
 
     describe "#set_tags" do
       let(:long_string) { "a" * 10_001 }
-      before do
+
+      it "stores tags on the transaction" do
         transaction.set_tags(
           :valid_key => "valid_value",
           "valid_string_key" => "valid_value",
@@ -443,10 +503,8 @@ describe Appsignal::Transaction do
           :too_long_value => long_string,
           long_string => "too_long_key"
         )
-        transaction.sample_data
-      end
+        transaction._sample
 
-      it "stores tags on the transaction" do
         expect(transaction).to include_tags(
           "valid_key" => "valid_value",
           "valid_string_key" => "valid_value",
@@ -456,6 +514,96 @@ describe Appsignal::Transaction do
           long_string => "too_long_key"
         )
       end
+
+      it "merges the tags when called multiple times" do
+        transaction.set_tags(:key1 => "value1")
+        transaction.set_tags(:key2 => "value2")
+        transaction._sample
+
+        expect(transaction).to include_tags(
+          "key1" => "value1",
+          "key2" => "value2"
+        )
+      end
+    end
+
+    describe "#set_custom_data" do
+      let(:log_stream) { std_stream }
+      let(:logs) { log_contents(log_stream) }
+      around { |example| use_logger_with(log_stream) { example.run } }
+
+      it "stores custom Hash data on the transaction" do
+        transaction.set_custom_data(
+          :user => {
+            :id => 123,
+            :locale => "abc"
+          },
+          :organization => {
+            :slug => "appsignal",
+            :plan => "enterprise"
+          }
+        )
+
+        transaction._sample
+        expect(transaction).to include_custom_data(
+          "user" => {
+            "id" => 123,
+            "locale" => "abc"
+          },
+          "organization" => {
+            "slug" => "appsignal",
+            "plan" => "enterprise"
+          }
+        )
+      end
+
+      it "stores custom Array data on the transaction" do
+        transaction.set_custom_data([
+          [123, "abc"],
+          ["appsignal", "enterprise"]
+        ])
+
+        transaction._sample
+        expect(transaction).to include_custom_data([
+          [123, "abc"],
+          ["appsignal", "enterprise"]
+        ])
+      end
+
+      it "does not store non Hash or Array custom data" do
+        transaction.set_custom_data("abc")
+        transaction._sample
+        expect(transaction).to_not include_custom_data
+
+        transaction.set_custom_data(123)
+        transaction._sample
+        expect(transaction).to_not include_custom_data
+
+        transaction.set_custom_data(Object.new)
+        transaction._sample
+        expect(transaction).to_not include_custom_data
+
+        expect(logs).to contains_log(
+          :error,
+          "set_custom_data: Unsupported data type String received."
+        )
+        expect(logs).to contains_log(
+          :error,
+          "set_custom_data: Unsupported data type Integer received."
+        )
+        expect(logs).to contains_log(
+          :error,
+          "set_custom_data: Unsupported data type String received."
+        )
+      end
+
+      it "overwrites the custom data if called multiple times" do
+        transaction.set_custom_data("user" => { "id" => 123 })
+        transaction.set_custom_data("user" => { "id" => 456 })
+
+        transaction._sample
+        expect(transaction).to include_custom_data("user" => { "id" => 456 })
+      end
     end
 
     describe "#add_breadcrumb" do
@@ -811,6 +959,17 @@ describe Appsignal::Transaction do
           kind_of(Integer)
         )
       end
+
+      context "when params is a callable object" do
+        it "calls the params object and sets the return value as parametesr" do
+          transaction.set_params { { "param1" => "value1" } }
+
+          transaction.sample_data
+          expect(transaction).to include_params(
+            "param1" => "value1"
+          )
+        end
+      end
     end
 
     describe "#set_error" do

data/spec/lib/appsignal_spec.rb

@@ -321,6 +321,20 @@ describe Appsignal do
       end
     end
 
+    describe ".report_error" do
+      let(:error) { ExampleException.new("specific error") }
+
+      it "does not raise an error" do
+        Appsignal.report_error(error)
+      end
+
+      it "does not create a transaction" do
+        expect do
+          Appsignal.report_error(error)
+        end.to_not(change { created_transactions.count })
+      end
+    end
+
     describe ".set_namespace" do
       it "does not raise an error" do
         Appsignal.set_namespace("custom")
@@ -332,6 +346,12 @@ describe Appsignal do
         Appsignal.tag_request(:tag => "tag")
       end
     end
+
+    describe ".set_custom_data" do
+      it "does not raise an error" do
+        Appsignal.set_custom_data(:data => "value")
+      end
+    end
   end
 
   context "with config and started" do
@@ -466,15 +486,13 @@ describe Appsignal do
     end
 
     describe ".tag_request" do
-      around do |example|
-        start_agent
-        with_current_transaction(transaction) { example.run }
-      end
+      before { start_agent }
 
       context "with transaction" do
         let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
 
-        it "calls set_tags on the current transaction" do
+        it "sets tags on the current transaction" do
           Appsignal.tag_request("a" => "b")
 
           transaction._sample
@@ -494,7 +512,85 @@ describe Appsignal do
       end
 
       it "also listens to tag_job" do
-        expect(Appsignal).to respond_to(:tag_job)
+        expect(Appsignal.method(:tag_job)).to eq(Appsignal.method(:tag_request))
+      end
+
+      it "also listens to set_tags" do
+        expect(Appsignal.method(:set_tags)).to eq(Appsignal.method(:tag_request))
+      end
+    end
+
+    describe ".set_params" do
+      before do
+        start_agent
+      end
+
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets parameters on the transaction" do
+          Appsignal.set_params("param1" => "value1")
+
+          transaction._sample
+          expect(transaction).to include_params("param1" => "value1")
+        end
+
+        it "overwrites the params if called multiple times" do
+          Appsignal.set_params("param1" => "value1")
+          Appsignal.set_params("param2" => "value2")
+
+          transaction._sample
+          expect(transaction).to include_params("param2" => "value2")
+        end
+
+        it "sets parameters with a block on the transaction" do
+          Appsignal.set_params { { "param1" => "value1" } }
+
+          transaction._sample
+          expect(transaction).to include_params("param1" => "value1")
+        end
+      end
+
+      context "without transaction" do
+        it "does not set tags on the transaction" do
+          Appsignal.set_params("a" => "b")
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_params)
+        end
+      end
+    end
+
+    describe ".set_custom_data" do
+      before { start_agent }
+
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction transaction }
+
+        it "sets custom data on the current transaction" do
+          Appsignal.set_custom_data(
+            :user => { :id => 123 },
+            :organization => { :slug => "appsignal" }
+          )
+
+          transaction._sample
+          expect(transaction).to include_custom_data(
+            "user" => { "id" => 123 },
+            "organization" => { "slug" => "appsignal" }
+          )
+        end
+      end
+
+      context "without transaction" do
+        it "does not set tags on the transaction" do
+          Appsignal.set_custom_data(
+            :user => { :id => 123 },
+            :organization => { :slug => "appsignal" }
+          )
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_custom_data)
+        end
       end
     end
 
@@ -993,6 +1089,101 @@ describe Appsignal do
       end
     end
 
+    describe ".report_error" do
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
+      let(:error) { ExampleException.new("error message") }
+      before { start_agent }
+      around { |example| keep_transactions { example.run } }
+
+      context "when the error is not an Exception" do
+        let(:error) { Object.new }
+
+        it "does not set an error" do
+          silence { Appsignal.report_error(error) }
+
+          expect(last_transaction).to_not have_error
+        end
+
+        it "logs an error" do
+          logs = capture_logs { Appsignal.report_error(error) }
+          expect(logs).to contains_log(
+            :error,
+            "Appsignal.report_error: Cannot set error. " \
+              "The given value is not an exception: #{error.inspect}"
+          )
+        end
+      end
+
+      context "when there is no active transaction" do
+        it "creates a new transaction" do
+          expect do
+            Appsignal.report_error(error)
+          end.to(change { created_transactions.count }.by(1))
+        end
+
+        it "completes the transaction" do
+          Appsignal.report_error(error)
+
+          expect(last_transaction).to be_completed
+        end
+
+        context "when given a block" do
+          it "yields the transaction and allows additional metadata to be set" do
+            Appsignal.report_error(error) do |t|
+              t.set_action("my_action")
+              t.set_namespace("my_namespace")
+              t.set_tags(:tag1 => "value1")
+            end
+
+            transaction = last_transaction
+            expect(transaction).to have_namespace("my_namespace")
+            expect(transaction).to have_action("my_action")
+            expect(transaction).to have_error("ExampleException", "error message")
+            expect(transaction).to include_tags("tag1" => "value1")
+            expect(transaction).to be_completed
+          end
+        end
+      end
+
+      context "when there is an active transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "adds the error to the active transaction" do
+          Appsignal.report_error(error)
+
+          expect(last_transaction).to eq(transaction)
+          transaction._sample
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+          expect(transaction).to have_error("ExampleException", "error message")
+        end
+
+        it "does not complete the transaction" do
+          Appsignal.report_error(error)
+
+          expect(last_transaction).to_not be_completed
+        end
+
+        context "when given a block" do
+          it "yields the transaction and allows additional metadata to be set" do
+            Appsignal.report_error(error) do |t|
+              t.set_action("my_action")
+              t.set_namespace("my_namespace")
+              t.set_tags(:tag1 => "value1")
+            end
+
+            transaction._sample
+            expect(transaction).to have_namespace("my_namespace")
+            expect(transaction).to have_action("my_action")
+            expect(transaction).to have_error("ExampleException", "error message")
+            expect(transaction).to include_tags("tag1" => "value1")
+            expect(transaction).to_not be_completed
+          end
+        end
+      end
+    end
+
     describe ".set_action" do
       around { |example| keep_transactions { example.run } }
 

data/spec/support/mocks/dummy_app.rb

@@ -8,7 +8,7 @@ class DummyApp
     if @app
       @app&.call(env)
     else
-      [200, {}, "body"]
+      [200, {}, ["body"]]
     end
   ensure
     @called = true