appsignal 3.9.3-java → 3.11.0-java

data/spec/lib/appsignal/utils/integration_logger_spec.rb

@@ -1,25 +1,21 @@
 describe Appsignal::Utils::IntegrationLogger do
-  let(:log) { std_stream }
+  let(:log_stream) { std_stream }
+  let(:logs) { log_contents(log_stream) }
   let(:logger) do
-    Appsignal::Utils::IntegrationLogger.new(log).tap do |l|
+    Appsignal::Utils::IntegrationLogger.new(log_stream).tap do |l|
       l.formatter = logger_formatter
     end
   end
 
-  describe "#seen_keys" do
-    it "returns a Set" do
-      expect(logger.seen_keys).to be_a(Set)
-    end
-  end
+  it "logs messages" do
+    logger.debug("debug message")
+    logger.info("info message")
+    logger.warn("warning message")
+    logger.error("error message")
 
-  describe "#warn_once_then_debug" do
-    it "only warns once, then uses debug" do
-      message = "This is a log line"
-      3.times { logger.warn_once_then_debug(:key, message) }
-
-      logs = log_contents(log)
-      expect(logs.scan(/#{Regexp.escape(log_line(:WARN, message))}/).count).to eql(1)
-      expect(logs.scan(/#{Regexp.escape(log_line(:DEBUG, message))}/).count).to eql(2)
-    end
+    expect(logs).to contains_log(:debug, "debug message")
+    expect(logs).to contains_log(:info, "info message")
+    expect(logs).to contains_log(:warn, "warning message")
+    expect(logs).to contains_log(:error, "error message")
   end
 end

data/spec/lib/appsignal/utils/integration_memory_logger_spec.rb

@@ -68,16 +68,6 @@ describe Appsignal::Utils::IntegrationLogger do
     end
   end
 
-  describe "#warn_once_then_debug" do
-    it "only warns once, then uses debug" do
-      message = "This is a log line"
-      3.times { logger.warn_once_then_debug(:key, message) }
-
-      expect(logger.messages[:WARN]).to eq([message])
-      expect(logger.messages[:DEBUG]).to eq([message, message])
-    end
-  end
-
   describe "#error" do
     it "adds a log message with the error severity" do
       logger.error("error message")

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,13 +346,190 @@ 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
     before { start_agent }
     around { |example| keep_transactions { example.run } }
 
+    describe ".monitor" do
+      it "creates a transaction" do
+        expect do
+          Appsignal.monitor(:action => "MyAction")
+        end.to(change { created_transactions.count }.by(1))
+
+        transaction = last_transaction
+        expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        expect(transaction).to have_action("MyAction")
+        expect(transaction).to_not have_error
+        expect(transaction).to_not include_events
+        expect(transaction).to_not have_queue_start
+        expect(transaction).to be_completed
+      end
+
+      it "returns the block's return value" do
+        expect(Appsignal.monitor(:action => nil) { :return_value }).to eq(:return_value)
+      end
+
+      it "sets a custom namespace via the namespace argument" do
+        Appsignal.monitor(:namespace => "custom", :action => nil)
+
+        expect(last_transaction).to have_namespace("custom")
+      end
+
+      it "doesn't overwrite custom namespace set in the block" do
+        Appsignal.monitor(:namespace => "custom", :action => nil) do
+          Appsignal.set_namespace("more custom")
+        end
+
+        expect(last_transaction).to have_namespace("more custom")
+      end
+
+      it "sets the action via the action argument using a string" do
+        Appsignal.monitor(:action => "custom")
+
+        expect(last_transaction).to have_action("custom")
+      end
+
+      it "sets the action via the action argument using a symbol" do
+        Appsignal.monitor(:action => :custom)
+
+        expect(last_transaction).to have_action("custom")
+      end
+
+      it "doesn't overwrite custom action set in the block" do
+        Appsignal.monitor(:action => "custom") do
+          Appsignal.set_action("more custom")
+        end
+
+        expect(last_transaction).to have_action("more custom")
+      end
+
+      it "doesn't set the action when value is nil" do
+        Appsignal.monitor(:action => nil)
+
+        expect(last_transaction).to_not have_action
+      end
+
+      it "doesn't set the action when value is :set_later" do
+        Appsignal.monitor(:action => :set_later)
+
+        expect(last_transaction).to_not have_action
+      end
+
+      it "reports exceptions that occur in the block" do
+        expect do
+          Appsignal.monitor :action => nil do
+            raise ExampleException, "error message"
+          end
+        end.to raise_error(ExampleException, "error message")
+
+        expect(last_transaction).to have_error("ExampleException", "error message")
+      end
+
+      context "with already active transction" do
+        let(:err_stream) { std_stream }
+        let(:stderr) { err_stream.read }
+        let(:transaction) { http_request_transaction }
+        before do
+          set_current_transaction(transaction)
+          transaction.set_action("My action")
+        end
+
+        it "doesn't create a new transaction" do
+          logs = nil
+          expect do
+            logs =
+              capture_logs do
+                capture_std_streams(std_stream, err_stream) do
+                  Appsignal.monitor(:action => nil)
+                end
+              end
+          end.to_not(change { created_transactions.count })
+
+          warning = "An active transaction around this 'Appsignal.monitor' call."
+          expect(logs).to contains_log(:warn, warning)
+          expect(stderr).to include("appsignal WARNING: #{warning}")
+        end
+
+        it "does not overwrite the parent transaction's namespace" do
+          silence { Appsignal.monitor(:namespace => "custom", :action => nil) }
+
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        end
+
+        it "does not overwrite the parent transaction's action" do
+          silence { Appsignal.monitor(:action => "custom") }
+
+          expect(transaction).to have_action("My action")
+        end
+
+        it "doesn't complete the parent transaction" do
+          silence { Appsignal.monitor(:action => nil) }
+
+          expect(transaction).to_not be_completed
+        end
+      end
+    end
+
+    describe ".monitor_and_stop" do
+      it "calls Appsignal.stop after the block" do
+        allow(Appsignal).to receive(:stop)
+        Appsignal.monitor_and_stop(:namespace => "custom", :action => "My Action")
+
+        transaction = last_transaction
+        expect(transaction).to have_namespace("custom")
+        expect(transaction).to have_action("My Action")
+        expect(transaction).to be_completed
+
+        expect(Appsignal).to have_received(:stop).with("monitor_and_stop")
+      end
+    end
+
     describe ".monitor_transaction" do
+      it "prints a deprecation warning" do
+        err_stream = std_stream
+        capture_std_streams(std_stream, err_stream) do
+          Appsignal.monitor_transaction(
+            "perform_job.something",
+            :class => "BackgroundJob",
+            :method => "perform"
+          ) do
+            :return_value
+          end
+        end
+
+        expect(err_stream.read).to include(
+          "appsignal WARNING: The `Appsignal.monitor_transaction` helper is deprecated."
+        )
+      end
+
+      it "logs a deprecation warning" do
+        logs =
+          capture_logs do
+            silence do
+              Appsignal.monitor_transaction(
+                "perform_job.something",
+                :class => "BackgroundJob",
+                :method => "perform"
+              ) do
+                :return_value
+              end
+            end
+          end
+
+        expect(logs).to contains_log(
+          :warn,
+          "The `Appsignal.monitor_transaction` helper is deprecated."
+        )
+      end
+
       context "with a successful call" do
         it "instruments and completes for a background job" do
           return_value = nil
@@ -348,7 +539,8 @@ describe Appsignal do
                 "perform_job.something",
                 {
                   :class => "BackgroundJob",
-                  :method => "perform"
+                  :method => "perform",
+                  :queue_start => fixed_time.to_i
                 }
               ) do
                 :return_value
@@ -360,6 +552,7 @@ describe Appsignal do
           expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
           expect(transaction).to have_action("BackgroundJob#perform")
           expect(transaction).to include_event("name" => "perform_job.something")
+          expect(transaction).to have_queue_start(1_389_783_600_000)
           expect(transaction).to be_completed
         end
 
@@ -371,7 +564,8 @@ describe Appsignal do
                 "process_action.something",
                 {
                   :controller => "BlogPostsController",
-                  :action => "show"
+                  :action => "show",
+                  "HTTP_X_REQUEST_START" => "t=#{fixed_time.to_i * 1000}"
                 }
               ) do
                 :return_value
@@ -383,6 +577,7 @@ describe Appsignal do
           expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
           expect(transaction).to have_action("BlogPostsController#show")
           expect(transaction).to include_event("name" => "process_action.something")
+          expect(transaction).to have_queue_start(1_389_783_600_000)
           expect(transaction).to be_completed
         end
       end
@@ -424,6 +619,43 @@ describe Appsignal do
     end
 
     describe ".monitor_single_transaction" do
+      it "prints a deprecation warning" do
+        err_stream = std_stream
+        capture_std_streams(std_stream, err_stream) do
+          Appsignal.monitor_single_transaction(
+            "perform_job.something",
+            :class => "BackgroundJob",
+            :method => "perform"
+          ) do
+            :return_value
+          end
+        end
+
+        expect(err_stream.read).to include(
+          "appsignal WARNING: The `Appsignal.monitor_single_transaction` helper is deprecated."
+        )
+      end
+
+      it "logs a deprecation warning" do
+        logs =
+          capture_logs do
+            silence do
+              Appsignal.monitor_single_transaction(
+                "perform_job.something",
+                :class => "BackgroundJob",
+                :method => "perform"
+              ) do
+                :return_value
+              end
+            end
+          end
+
+        expect(logs).to contains_log(
+          :warn,
+          "The `Appsignal.monitor_single_transaction` helper is deprecated."
+        )
+      end
+
       context "with a successful call" do
         it "calls monitor_transaction and Appsignal.stop" do
           expect(Appsignal).to receive(:stop)
@@ -466,15 +698,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 +724,161 @@ 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 { start_agent }
+
+      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_session_data" do
+      before { start_agent }
+
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets session data on the transaction" do
+          Appsignal.set_session_data("data" => "value1")
+
+          transaction._sample
+          expect(transaction).to include_session_data("data" => "value1")
+        end
+
+        it "overwrites the session data if called multiple times" do
+          Appsignal.set_session_data("data" => "value1")
+          Appsignal.set_session_data("data" => "value2")
+
+          transaction._sample
+          expect(transaction).to include_session_data("data" => "value2")
+        end
+
+        it "sets session data with a block on the transaction" do
+          Appsignal.set_session_data { { "data" => "value1" } }
+
+          transaction._sample
+          expect(transaction).to include_session_data("data" => "value1")
+        end
+      end
+
+      context "without transaction" do
+        it "does not set session data on the transaction" do
+          Appsignal.set_session_data("a" => "b")
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_session_data)
+        end
+      end
+    end
+
+    describe ".set_headers" do
+      before { start_agent }
+
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets request headers on the transaction" do
+          Appsignal.set_headers("PATH_INFO" => "/some-path")
+
+          transaction._sample
+          expect(transaction).to include_environment("PATH_INFO" => "/some-path")
+        end
+
+        it "overwrites the request headers if called multiple times" do
+          Appsignal.set_headers("PATH_INFO" => "/some-path1")
+          Appsignal.set_headers("PATH_INFO" => "/some-path2")
+
+          transaction._sample
+          expect(transaction).to include_environment("PATH_INFO" => "/some-path2")
+        end
+
+        it "sets request headers with a block on the transaction" do
+          Appsignal.set_headers { { "PATH_INFO" => "/some-path" } }
+
+          transaction._sample
+          expect(transaction).to include_environment("PATH_INFO" => "/some-path")
+        end
+      end
+
+      context "without transaction" do
+        it "does not set request headers on the transaction" do
+          Appsignal.set_headers("PATH_INFO" => "/some-path")
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_headers)
+        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 +1377,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 } }
 
@@ -1078,7 +1557,7 @@ describe Appsignal do
       end
     end
 
-    describe ".without_instrumentation" do
+    describe ".ignore_instrumentation_events" do
       around { |example| keep_transactions { example.run } }
       let(:transaction) { http_request_transaction }
 
@@ -1090,20 +1569,44 @@ describe Appsignal do
           expect(transaction).to receive(:resume!).and_call_original
 
           Appsignal.instrument("register.this.event") { :do_nothing }
-          Appsignal.without_instrumentation do
+          Appsignal.ignore_instrumentation_events do
             Appsignal.instrument("dont.register.this.event") { :do_nothing }
           end
 
           expect(transaction).to include_event("name" => "register.this.event")
           expect(transaction).to_not include_event("name" => "dont.register.this.event")
         end
+
+        it "has a without_instrumentation alias that prints a deprecation warning" do
+          Appsignal.instrument("register.this.event") { :do_nothing }
+          err_stream = std_stream
+          logs =
+            capture_logs do
+              capture_std_streams(std_stream, err_stream) do
+                Appsignal.without_instrumentation do
+                  Appsignal.instrument("dont.register.this.event") { :do_nothing }
+                end
+              end
+            end
+
+          expect(transaction).to include_event("name" => "register.this.event")
+          expect(transaction).to_not include_event("name" => "dont.register.this.event")
+
+          expect(logs).to contains_log(
+            :warn,
+            "The `Appsignal.without_instrumentation` helper is deprecated."
+          )
+          expect(err_stream.read).to include(
+            "appsignal WARNING: The `Appsignal.without_instrumentation` helper is deprecated."
+          )
+        end
       end
 
       context "without current transaction" do
         let(:transaction) { nil }
 
         it "does not crash" do
-          Appsignal.without_instrumentation { :do_nothing }
+          Appsignal.ignore_instrumentation_events { :do_nothing }
         end
       end
     end
@@ -1121,8 +1624,9 @@ describe Appsignal do
           Appsignal.start_logger
         end
       end
-      expect(stderr).to include("appsignal WARNING: Callng 'Appsignal.start_logger' is deprecated.")
-      expect(log).to contains_log(:warn, "Callng 'Appsignal.start_logger' is deprecated.")
+      expect(stderr)
+        .to include("appsignal WARNING: Calling 'Appsignal.start_logger' is deprecated.")
+      expect(log).to contains_log(:warn, "Calling 'Appsignal.start_logger' is deprecated.")
     end
   end