appsignal 2.10.4-java → 2.10.8-java

data/spec/lib/appsignal/config_spec.rb

@@ -323,11 +323,11 @@ describe Appsignal::Config do
     end
 
     describe "support for old config keys" do
-      let(:out_stream) { std_stream }
-      let(:output) { out_stream.read }
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
       let(:config) { project_fixture_config(env, {}, test_logger(log)) }
       let(:log) { StringIO.new }
-      before { capture_stdout(out_stream) { config } }
+      before { capture_std_streams(std_stream, err_stream) { config } }
 
       describe ":api_key" do
         context "without :push_api_key" do
@@ -338,7 +338,7 @@ describe Appsignal::Config do
             expect(config.config_hash).to_not have_key :api_key
 
             message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(output).to include "appsignal WARNING: #{message}"
+            expect(stderr).to include "appsignal WARNING: #{message}"
             expect(log_contents(log)).to contains_log :warn, message
           end
         end
@@ -351,7 +351,7 @@ describe Appsignal::Config do
             expect(config.config_hash).to_not have_key :api_key
 
             message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(output).to include "appsignal WARNING: #{message}"
+            expect(stderr).to include "appsignal WARNING: #{message}"
             expect(log_contents(log)).to contains_log :warn, message
           end
         end
@@ -366,7 +366,7 @@ describe Appsignal::Config do
             expect(config.config_hash).to_not have_key :ignore_exceptions
 
             message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(output).to include "appsignal WARNING: #{message}"
+            expect(stderr).to include "appsignal WARNING: #{message}"
             expect(log_contents(log)).to contains_log :warn, message
           end
         end
@@ -379,7 +379,7 @@ describe Appsignal::Config do
             expect(config.config_hash).to_not have_key :ignore_exceptions
 
             message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(output).to include "appsignal WARNING: #{message}"
+            expect(stderr).to include "appsignal WARNING: #{message}"
             expect(log_contents(log)).to contains_log :warn, message
           end
         end

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -116,7 +116,8 @@ describe Appsignal::EventFormatter do
     end
 
     context "when registering deprecated formatters" do
-      let(:stdout_stream) { std_stream }
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
       let(:deprecated_formatter) do
         Class.new(Appsignal::EventFormatter) do
           register "mock.deprecated"
@@ -133,16 +134,16 @@ describe Appsignal::EventFormatter do
           "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
 
         logs = capture_logs do
-          capture_stdout(stdout_stream) { deprecated_formatter }
+          capture_std_streams(std_stream, err_stream) { deprecated_formatter }
         end
         expect(logs).to contains_log :warn, message
-        expect(stdout_stream.read).to include "appsignal WARNING: #{message}"
+        expect(stderr).to include "appsignal WARNING: #{message}"
 
         expect(klass.deprecated_formatter_classes.keys).to include("mock.deprecated")
       end
 
       it "initializes deprecated formatters" do
-        capture_stdout(stdout_stream) { deprecated_formatter }
+        capture_std_streams(std_stream, err_stream) { deprecated_formatter }
         klass.initialize_deprecated_formatters
 
         expect(klass.registered?("mock.deprecated")).to be_truthy

data/spec/lib/appsignal/hooks/delayed_job_spec.rb

@@ -36,6 +36,7 @@ describe Appsignal::Hooks::DelayedJobHook do
       let(:time) { Time.parse("01-01-2001 10:01:00UTC") }
       let(:created_at) { time - 3600 }
       let(:run_at) { time - 3600 }
+      let(:payload_object) { double(:args => args) }
       let(:job_data) do
         {
           :id             => 123,
@@ -45,38 +46,40 @@ describe Appsignal::Hooks::DelayedJobHook do
           :queue          => "default",
           :created_at     => created_at,
           :run_at         => run_at,
-          :payload_object => double(:args => args)
+          :payload_object => payload_object
         }
       end
       let(:args) { ["argument"] }
       let(:job) { double(job_data) }
       let(:invoked_block) { proc {} }
 
-      context "with a normal call" do
-        let(:default_params) do
-          {
-            :class    => "TestClass",
-            :method   => "perform",
-            :metadata => {
-              :priority => 1,
-              :attempts => 1,
-              :queue    => "default",
-              :id       => "123"
-            },
-            :params      => args,
-            :queue_start => run_at
-          }
-        end
-        after do
-          Timecop.freeze(time) do
+      def perform
+        Timecop.freeze(time) do
+          keep_transactions do
             plugin.invoke_with_instrumentation(job, invoked_block)
           end
         end
+      end
 
-        it "wraps it in a transaction with the correct params" do
-          expect(Appsignal).to receive(:monitor_transaction).with(
-            "perform_job.delayed_job",
-            default_params.merge(:params => ["argument"])
+      context "with a normal call" do
+        it "wraps it in a transaction" do
+          perform
+          transaction_data = last_transaction.to_h
+          expect(transaction_data).to include(
+            "action" => "TestClass#perform",
+            "namespace" => "background_job",
+            "error" => nil
+          )
+          expect(transaction_data["events"].map { |e| e["name"] })
+            .to eql(["perform_job.delayed_job"])
+          expect(transaction_data["sample_data"]).to include(
+            "metadata" => {
+              "priority" => 1,
+              "attempts" => 1,
+              "queue"    => "default",
+              "id"       => "123"
+            },
+            "params" => ["argument"]
           )
         end
 
@@ -89,14 +92,13 @@ describe Appsignal::Hooks::DelayedJobHook do
           end
 
           it "adds the more complex arguments" do
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.delayed_job",
-              default_params.merge(
-                :params => {
-                  :foo => "Foo",
-                  :bar => "Bar"
-                }
-              )
+            perform
+            transaction_data = last_transaction.to_h
+            expect(transaction_data["sample_data"]).to include(
+              "params" => {
+                "foo" => "Foo",
+                "bar" => "Bar"
+              }
             )
           end
 
@@ -107,14 +109,13 @@ describe Appsignal::Hooks::DelayedJobHook do
             end
 
             it "filters selected arguments" do
-              expect(Appsignal).to receive(:monitor_transaction).with(
-                "perform_job.delayed_job",
-                default_params.merge(
-                  :params => {
-                    :foo => "[FILTERED]",
-                    :bar => "Bar"
-                  }
-                )
+              perform
+              transaction_data = last_transaction.to_h
+              expect(transaction_data["sample_data"]).to include(
+                "params" => {
+                  "foo" => "[FILTERED]",
+                  "bar" => "Bar"
+                }
               )
             end
           end
@@ -124,98 +125,135 @@ describe Appsignal::Hooks::DelayedJobHook do
           let(:run_at) { Time.parse("2017-01-01 10:01:00UTC") }
 
           it "reports queue_start with run_at time" do
+            # TODO: Not available in transaction.to_h yet.
+            # https://github.com/appsignal/appsignal-agent/issues/293
             expect(Appsignal).to receive(:monitor_transaction).with(
               "perform_job.delayed_job",
-              default_params.merge(:queue_start => run_at)
-            )
+              a_hash_including(:queue_start => run_at)
+            ).and_call_original
+            perform
           end
         end
 
-        context "with custom name call" do
+        context "with class method job" do
           let(:job_data) do
-            {
-              :payload_object => double(
-                :appsignal_name => "CustomClass#perform",
-                :args           => args
-              ),
-              :id         => "123",
-              :name       => "TestClass#perform",
-              :priority   => 1,
-              :attempts   => 1,
-              :queue      => "default",
-              :created_at => created_at,
-              :run_at     => run_at
-            }
-          end
-          let(:default_params) do
-            {
-              :class => "CustomClass",
-              :method => "perform",
-              :metadata => {
-                :priority => 1,
-                :attempts => 1,
-                :queue    => "default",
-                :id       => "123"
-              },
-              :queue_start => run_at
-            }
+            { :name => "CustomClassMethod.perform", :payload_object => payload_object }
           end
 
-          it "wraps it in a transaction with the correct params" do
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.delayed_job",
-              default_params.merge(
-                :params => ["argument"]
-              )
-            )
+          it "wraps it in a transaction using the class method job name" do
+            perform
+            expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
           end
+        end
 
-          context "with more complex params" do
-            let(:args) do
-              {
-                :foo => "Foo",
-                :bar => "Bar"
-              }
-            end
+        context "with custom name call" do
+          before { perform }
 
-            it "adds the more complex arguments" do
-              expect(Appsignal).to receive(:monitor_transaction).with(
-                "perform_job.delayed_job",
-                default_params.merge(
-                  :params => {
-                    :foo => "Foo",
-                    :bar => "Bar"
-                  }
-                )
-              )
+          context "with appsignal_name defined" do
+            context "with payload_object being an object" do
+              context "with value" do
+                let(:payload_object) { double(:appsignal_name => "CustomClass#perform") }
+
+                it "wraps it in a transaction using the custom name" do
+                  expect(last_transaction.to_h["action"]).to eql("CustomClass#perform")
+                end
+              end
+
+              context "with non-String value" do
+                let(:payload_object) { double(:appsignal_name => Object.new) }
+
+                it "wraps it in a transaction using the original job name" do
+                  expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
+                end
+              end
+
+              context "with class method name as job" do
+                let(:payload_object) { double(:appsignal_name => "CustomClassMethod.perform") }
+
+                it "wraps it in a transaction using the custom name" do
+                  perform
+                  expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
+                end
+              end
             end
 
-            context "with parameter filtering" do
-              before do
-                Appsignal.config = project_fixture_config("production")
-                Appsignal.config[:filter_parameters] = ["foo"]
+            context "with payload_object being a Hash" do
+              context "with value" do
+                let(:payload_object) { double(:appsignal_name => "CustomClassHash#perform") }
+
+                it "wraps it in a transaction using the custom name" do
+                  expect(last_transaction.to_h["action"]).to eql("CustomClassHash#perform")
+                end
               end
 
-              it "filters selected arguments" do
-                expect(Appsignal).to receive(:monitor_transaction).with(
-                  "perform_job.delayed_job",
-                  default_params.merge(
-                    :params => {
-                      :foo => "[FILTERED]",
-                      :bar => "Bar"
-                    }
-                  )
-                )
+              context "with non-String value" do
+                let(:payload_object) { double(:appsignal_name => Object.new) }
+
+                it "wraps it in a transaction using the original job name" do
+                  expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
+                end
+              end
+
+              context "with class method name as job" do
+                let(:payload_object) { { :appsignal_name => "CustomClassMethod.perform" } }
+
+                it "wraps it in a transaction using the custom name" do
+                  perform
+                  expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
+                end
+              end
+            end
+
+            context "with payload_object being acting like a Hash and returning a non-String value" do
+              class ClassActingAsHash
+                def self.[](_key)
+                  Object.new
+                end
+
+                def self.appsignal_name
+                  "ClassActingAsHash#perform"
+                end
+              end
+              let(:payload_object) { ClassActingAsHash }
+
+              # We check for hash values before object values
+              # this means ClassActingAsHash returns `Object.new` instead
+              # of `self.appsignal_name`. Since this isn't a valid `String`
+              # we return the default job name as action name.
+              it "wraps it in a transaction using the original job name" do
+                expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
               end
             end
           end
         end
 
+        context "without job name" do
+          let(:job_data) do
+            { :name => "", :payload_object => payload_object }
+          end
+
+          it "wraps it in a transaction using the class method job name" do
+            perform
+            expect(last_transaction.to_h["action"]).to eql("unknown")
+          end
+        end
+
+        context "with invalid job name" do
+          let(:job_data) do
+            { :name => "Banana", :payload_object => payload_object }
+          end
+
+          it "wraps it in a transaction using the class method job name" do
+            perform
+            expect(last_transaction.to_h["action"]).to eql("unknown")
+          end
+        end
+
         if active_job_present?
           require "active_job"
 
           context "when wrapped by ActiveJob" do
-            let(:wrapped_job) do
+            let(:payload_object) do
               ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(
                 "arguments"  => args,
                 "job_class"  => "TestClass",
@@ -233,32 +271,30 @@ describe Appsignal::Hooks::DelayedJobHook do
                 :queue          => "default",
                 :created_at     => created_at,
                 :run_at         => run_at,
-                :payload_object => wrapped_job
+                :payload_object => payload_object
               )
             end
-            let(:default_params) do
-              {
-                :class    => "TestClass",
-                :method   => "perform",
-                :metadata => {
-                  :priority => 1,
-                  :attempts => 1,
-                  :queue    => "default",
-                  :id       => "123"
-                },
-                :queue_start => run_at,
-                :params      => args
-              }
-            end
             let(:args) { ["activejob_argument"] }
 
-            context "with simple params" do
-              it "wraps it in a transaction with the correct params" do
-                expect(Appsignal).to receive(:monitor_transaction).with(
-                  "perform_job.delayed_job",
-                  default_params.merge(:params => ["activejob_argument"])
-                )
-              end
+            it "wraps it in a transaction with the correct params" do
+              perform
+              transaction_data = last_transaction.to_h
+              expect(transaction_data).to include(
+                "action" => "TestClass#perform",
+                "namespace" => "background_job",
+                "error" => nil
+              )
+              expect(transaction_data["events"].map { |e| e["name"] })
+                .to eql(["perform_job.delayed_job"])
+              expect(transaction_data["sample_data"]).to include(
+                "metadata" => {
+                  "priority" => 1,
+                  "attempts" => 1,
+                  "queue"    => "default",
+                  "id"       => "123"
+                },
+                "params" => ["activejob_argument"]
+              )
             end
 
             context "with more complex params" do
@@ -270,14 +306,14 @@ describe Appsignal::Hooks::DelayedJobHook do
               end
 
               it "adds the more complex arguments" do
-                expect(Appsignal).to receive(:monitor_transaction).with(
-                  "perform_job.delayed_job",
-                  default_params.merge(
-                    :params => {
-                      :foo => "Foo",
-                      :bar => "Bar"
-                    }
-                  )
+                perform
+                transaction_data = last_transaction.to_h
+                expect(transaction_data).to include("action" => "TestClass#perform")
+                expect(transaction_data["sample_data"]).to include(
+                  "params" => {
+                    "foo" => "Foo",
+                    "bar" => "Bar"
+                  }
                 )
               end
 
@@ -288,14 +324,14 @@ describe Appsignal::Hooks::DelayedJobHook do
                 end
 
                 it "filters selected arguments" do
-                  expect(Appsignal).to receive(:monitor_transaction).with(
-                    "perform_job.delayed_job",
-                    default_params.merge(
-                      :params => {
-                        :foo => "[FILTERED]",
-                        :bar => "Bar"
-                      }
-                    )
+                  perform
+                  transaction_data = last_transaction.to_h
+                  expect(transaction_data).to include("action" => "TestClass#perform")
+                  expect(transaction_data["sample_data"]).to include(
+                    "params" => {
+                      "foo" => "[FILTERED]",
+                      "bar" => "Bar"
+                    }
                   )
                 end
               end
@@ -307,8 +343,9 @@ describe Appsignal::Hooks::DelayedJobHook do
               it "reports queue_start with run_at time" do
                 expect(Appsignal).to receive(:monitor_transaction).with(
                   "perform_job.delayed_job",
-                  default_params.merge(:queue_start => run_at)
-                )
+                  a_hash_including(:queue_start => run_at)
+                ).and_call_original
+                perform
               end
             end
           end
@@ -316,33 +353,28 @@ describe Appsignal::Hooks::DelayedJobHook do
       end
 
       context "with an erroring call" do
-        let(:error) { ExampleException }
-        let(:transaction) do
-          Appsignal::Transaction.new(
-            SecureRandom.uuid,
-            Appsignal::Transaction::BACKGROUND_JOB,
-            Appsignal::Transaction::GenericRequest.new({})
-          )
-        end
+        let(:error) { ExampleException.new("uh oh") }
         before do
           expect(invoked_block).to receive(:call).and_raise(error)
-
-          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-          expect(Appsignal::Transaction).to receive(:create)
-            .with(
-              kind_of(String),
-              Appsignal::Transaction::BACKGROUND_JOB,
-              kind_of(Appsignal::Transaction::GenericRequest)
-            ).and_return(transaction)
         end
 
         it "adds the error to the transaction" do
-          expect(transaction).to receive(:set_error).with(error)
-          expect(transaction).to receive(:complete)
-
           expect do
-            plugin.invoke_with_instrumentation(job, invoked_block)
+            perform
           end.to raise_error(error)
+
+          transaction_data = last_transaction.to_h
+          expect(transaction_data).to include(
+            "action" => "TestClass#perform",
+            "namespace" => "background_job",
+            "error" => {
+              "name" => "ExampleException",
+              "message" => "uh oh",
+              # TODO: backtrace should be an Array of Strings
+              # https://github.com/appsignal/appsignal-agent/issues/294
+              "backtrace" => kind_of(String)
+            }
+          )
         end
       end
     end