appsignal 2.11.5-java → 2.11.10-java

data/spec/lib/appsignal/extension_install_failure_spec.rb

@@ -1,13 +1,6 @@
 describe Appsignal::Extension, :extension_installation_failure do
   context "when the extension library cannot be loaded" do
-    # This test breaks the installation on purpose and is not run by default.
-    # See `rake test:failure`. If this test was run, run `rake
-    # extension:install` again to fix the extension installation.
     it "prints and logs an error" do
-      # ENV var to make sure installation fails on purpurse
-      ENV["_TEST_APPSIGNAL_EXTENSION_FAILURE"] = "true"
-      `rake extension:install` # Run installation
-
       require "open3"
       _stdout, stderr, _status = Open3.capture3("bin/appsignal --version")
       expect(stderr).to include("ERROR: AppSignal failed to load extension")

data/spec/lib/appsignal/extension_spec.rb

@@ -119,22 +119,56 @@ describe Appsignal::Extension do
     end
   end
 
-  context "when the extension library cannot be loaded" do
-    subject { Appsignal::Extension }
+  context "when the extension library cannot be loaded", :extension_installation_failure do
+    let(:ext) { Appsignal::Extension }
 
-    before do
-      allow(Appsignal).to receive(:extension_loaded).and_return(false)
-      allow(Appsignal).to receive(:testing?).and_return(false)
+    around do |example|
+      Appsignal::Testing.without_testing { example.run }
     end
 
     it "should indicate that the extension is not loaded" do
       expect(Appsignal.extension_loaded?).to be_falsy
     end
 
-    it "should not raise errors when methods are called" do
-      expect do
-        subject.something
-      end.not_to raise_error
+    it "does not raise errors when methods are called" do
+      ext.appsignal_start
+      ext.something
+    end
+
+    describe Appsignal::Extension::MockData do
+      it "does not error on missing data_map_new extension method calls" do
+        map = ext.data_map_new
+        expect(map).to be_kind_of(Appsignal::Extension::MockData)
+        # Does not raise errors any arbitrary method call that does not exist
+        map.set_string("key", "value")
+        map.set_int("key", 123)
+        map.something
+      end
+
+      it "does not error on missing data_array_new extension method calls" do
+        array = ext.data_array_new
+        expect(array).to be_kind_of(Appsignal::Extension::MockData)
+        # Does not raise errors any arbitrary method call that does not exist
+        array.append_string("value")
+        array.append_int(123)
+        array.something
+      end
+    end
+
+    describe Appsignal::Extension::MockTransaction do
+      it "does not error on missing transaction extension method calls" do
+        transaction = described_class.new
+
+        transaction.start_event(0)
+        transaction.finish_event(
+          "name",
+          "title",
+          "body",
+          Appsignal::EventFormatter::DEFAULT,
+          0
+        )
+        transaction.something
+      end
     end
   end
 end

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

@@ -2,6 +2,8 @@ describe Appsignal::Hooks::ActionCableHook do
   if DependencyHelper.action_cable_present?
     context "with ActionCable" do
       require "action_cable/engine"
+      # Require test helper to test with ConnectionStub
+      require "action_cable/channel/test_case" if DependencyHelper.rails6_present?
 
       describe ".dependencies_present?" do
         subject { described_class.new.dependencies_present? }
@@ -262,6 +264,49 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
+
+          if DependencyHelper.rails6_present?
+            context "with ConnectionStub" do
+              let(:connection) { ActionCable::Channel::ConnectionStub.new }
+              let(:transaction_id) { "Stubbed transaction id" }
+              before do
+                # Stub future (private AppSignal) transaction id generated by the hook.
+                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              end
+
+              it "does not fail on missing `#env` method on `ConnectionStub`" do
+                instance.subscribe_to_channel
+
+                expect(subject).to include(
+                  "action" => "MyChannel#subscribed",
+                  "error" => nil,
+                  "id" => transaction_id,
+                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                  "metadata" => {
+                    "method" => "websocket",
+                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
+                  }
+                )
+                expect(subject["events"].first).to include(
+                  "allocation_count" => kind_of(Integer),
+                  "body" => "",
+                  "body_format" => Appsignal::EventFormatter::DEFAULT,
+                  "child_allocation_count" => kind_of(Integer),
+                  "child_duration" => kind_of(Float),
+                  "child_gc_duration" => kind_of(Float),
+                  "count" => 1,
+                  "gc_duration" => kind_of(Float),
+                  "start" => kind_of(Float),
+                  "duration" => kind_of(Float),
+                  "name" => "subscribed.action_cable",
+                  "title" => ""
+                )
+                expect(subject["sample_data"]).to include(
+                  "params" => { "internal" => "true" }
+                )
+              end
+            end
+          end
         end
 
         describe "unsubscribe callback" do
@@ -349,6 +394,49 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
+
+          if DependencyHelper.rails6_present?
+            context "with ConnectionStub" do
+              let(:connection) { ActionCable::Channel::ConnectionStub.new }
+              let(:transaction_id) { "Stubbed transaction id" }
+              before do
+                # Stub future (private AppSignal) transaction id generated by the hook.
+                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              end
+
+              it "does not fail on missing `#env` method on `ConnectionStub`" do
+                instance.unsubscribe_from_channel
+
+                expect(subject).to include(
+                  "action" => "MyChannel#unsubscribed",
+                  "error" => nil,
+                  "id" => transaction_id,
+                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                  "metadata" => {
+                    "method" => "websocket",
+                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
+                  }
+                )
+                expect(subject["events"].first).to include(
+                  "allocation_count" => kind_of(Integer),
+                  "body" => "",
+                  "body_format" => Appsignal::EventFormatter::DEFAULT,
+                  "child_allocation_count" => kind_of(Integer),
+                  "child_duration" => kind_of(Float),
+                  "child_gc_duration" => kind_of(Float),
+                  "count" => 1,
+                  "gc_duration" => kind_of(Float),
+                  "start" => kind_of(Float),
+                  "duration" => kind_of(Float),
+                  "name" => "unsubscribed.action_cable",
+                  "title" => ""
+                )
+                expect(subject["sample_data"]).to include(
+                  "params" => { "internal" => "true" }
+                )
+              end
+            end
+          end
         end
       end
     end

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

@@ -16,14 +16,31 @@ describe Appsignal::Hooks::SidekiqHook do
   end
 
   describe "#install" do
-    class SidekiqMiddlewareMock < Set
-      def exists?(middleware)
-        include?(middleware)
+    class SidekiqMiddlewareMockWithPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      unless method_defined? :prepend
+        def prepend(middleware) # For Ruby < 2.5
+          insert(0, middleware)
+        end
       end
     end
+
+    class SidekiqMiddlewareMockWithoutPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      undef_method :prepend if method_defined? :prepend # For Ruby >= 2.5
+    end
+
     module SidekiqMock
+      def self.middleware_mock=(mock)
+        @middlewares = mock.new
+      end
+
       def self.middlewares
-        @middlewares ||= SidekiqMiddlewareMock.new
+        @middlewares
       end
 
       def self.configure_server
@@ -36,15 +53,52 @@ describe Appsignal::Hooks::SidekiqHook do
       end
     end
 
+    def add_middleware(middleware)
+      Sidekiq.configure_server do |sidekiq_config|
+        sidekiq_config.middlewares.add(middleware)
+      end
+    end
+
     before do
       Appsignal.config = project_fixture_config
       stub_const "Sidekiq", SidekiqMock
     end
 
-    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
-      described_class.new.install
+    context "when Sidekiq middleware responds to prepend method" do # Sidekiq 3.3.0 and newer
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithPrepend }
+
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain in the first position" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
 
-      expect(Sidekiq.server_middleware.exists?(Appsignal::Hooks::SidekiqPlugin)).to be(true)
+        expect(Sidekiq.server_middleware).to eql([
+          Appsignal::Hooks::SidekiqPlugin, # Prepend makes it the first entry
+          user_middleware1,
+          user_middleware2
+        ])
+      end
+    end
+
+    context "when Sidekiq middleware does not respond to prepend method" do
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithoutPrepend }
+
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
+
+        # Add middlewares in whatever order they were added
+        expect(Sidekiq.server_middleware).to eql([
+          user_middleware1,
+          Appsignal::Hooks::SidekiqPlugin,
+          user_middleware2
+        ])
+      end
     end
   end
 end

data/spec/lib/appsignal/integrations/object_spec.rb

@@ -30,12 +30,57 @@ describe Object do
         before do
           Appsignal.config = project_fixture_config
           expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+          expect(Appsignal.active?).to be_truthy
         end
         after { Appsignal.config = nil }
 
+        context "with different kind of arguments" do
+          let(:klass) do
+            Class.new do
+              def positional_arguments(param1, param2)
+                [param1, param2]
+              end
+              appsignal_instrument_method :positional_arguments
+
+              def positional_arguments_splat(*params)
+                params
+              end
+              appsignal_instrument_method :positional_arguments_splat
+
+              def keyword_arguments(a: nil, b: nil)
+                [a, b]
+              end
+              appsignal_instrument_method :keyword_arguments
+
+              def keyword_arguments_splat(**kwargs)
+                kwargs
+              end
+              appsignal_instrument_method :keyword_arguments_splat
+
+              def splat(*args, **kwargs)
+                [args, kwargs]
+              end
+              appsignal_instrument_method :splat
+            end
+          end
+
+          it "instruments the method and calls it" do
+            expect(instance.positional_arguments("abc", "def")).to eq(["abc", "def"])
+            expect(instance.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
+            expect(instance.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
+            expect(instance.keyword_arguments_splat(:a => "a", :b => "b"))
+              .to eq(:a => "a", :b => "b")
+
+            expect(instance.splat).to eq([[], {}])
+            expect(instance.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
+            expect(instance.splat("abc", "def")).to eq([["abc", "def"], {}])
+            expect(instance.splat("abc", "def", :a => "a", :b => "b"))
+              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
+          end
+        end
+
         context "with anonymous class" do
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -56,7 +101,6 @@ describe Object do
           let(:klass) { NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -81,7 +125,6 @@ describe Object do
           let(:klass) { MyModule::NestedModule::NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
@@ -101,7 +144,6 @@ describe Object do
           end
 
           it "instruments with custom name" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -162,6 +204,51 @@ describe Object do
         end
         after { Appsignal.config = nil }
 
+        context "with different kind of arguments" do
+          let(:klass) do
+            Class.new do
+              def self.positional_arguments(param1, param2)
+                [param1, param2]
+              end
+              appsignal_instrument_class_method :positional_arguments
+
+              def self.positional_arguments_splat(*params)
+                params
+              end
+              appsignal_instrument_class_method :positional_arguments_splat
+
+              def self.keyword_arguments(a: nil, b: nil)
+                [a, b]
+              end
+              appsignal_instrument_class_method :keyword_arguments
+
+              def self.keyword_arguments_splat(**kwargs)
+                kwargs
+              end
+              appsignal_instrument_class_method :keyword_arguments_splat
+
+              def self.splat(*args, **kwargs)
+                [args, kwargs]
+              end
+              appsignal_instrument_class_method :splat
+            end
+          end
+
+          it "instruments the method and calls it" do
+            expect(klass.positional_arguments("abc", "def")).to eq(["abc", "def"])
+            expect(klass.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
+            expect(klass.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
+            expect(klass.keyword_arguments_splat(:a => "a", :b => "b"))
+              .to eq(:a => "a", :b => "b")
+
+            expect(klass.splat).to eq([[], {}])
+            expect(klass.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
+            expect(klass.splat("abc", "def")).to eq([["abc", "def"], {}])
+            expect(klass.splat("abc", "def", :a => "a", :b => "b"))
+              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
+          end
+        end
+
         context "with anonymous class" do
           it "instruments the method and calls it" do
             expect(Appsignal.active?).to be_truthy

data/spec/lib/appsignal/transaction_spec.rb

@@ -246,6 +246,23 @@ describe Appsignal::Transaction do
         expect(transaction.ext).to_not be_nil
       end
 
+      context "when extension is not loaded", :extension_installation_failure do
+        around do |example|
+          Appsignal::Testing.without_testing { example.run }
+        end
+
+        it "does not error on missing extension method calls" do
+          expect(transaction.ext).to be_kind_of(Appsignal::Extension::MockTransaction)
+          transaction.start_event
+          transaction.finish_event(
+            "name",
+            "title",
+            "body",
+            Appsignal::EventFormatter::DEFAULT
+          )
+        end
+      end
+
       it "sets the transaction id" do
         expect(transaction.transaction_id).to eq "1"
       end

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

@@ -4,110 +4,156 @@ describe Appsignal::Utils::Data do
   describe ".generate" do
     subject { Appsignal::Utils::Data.generate(body) }
 
-    context "with a valid hash body" do
-      let(:body) do
-        {
-          "the" => "payload",
-          "int" => 1, # Fixnum
-          "int61" => 1 << 61, # Fixnum
-          "int62" => 1 << 62, # Bignum, this one still works
-          "int63" => 1 << 63, # Bignum, turnover point for C, too big for long
-          "int64" => 1 << 64, # Bignum
-          "float" => 1.0,
-          1 => true,
-          nil => "test",
-          :foo => [1, 2, "three", { "foo" => "bar" }],
-          "bar" => nil,
-          "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
-        }
+    context "when extension is not loaded", :extension_installation_failure do
+      around do |example|
+        Appsignal::Testing.without_testing { example.run }
       end
 
-      it { is_expected.to eq Appsignal::Utils::Data.generate(body) }
-      it { is_expected.to_not eq Appsignal::Utils::Data.generate({}) }
-
-      describe "#to_s" do
-        it "returns a serialized hash" do
-          expect(subject.to_s).to eq %({"":"test",) +
-            %("1":true,) +
-            %("bar":null,) +
-            %("baz":{"arr":[1,2],"foo":"bʊr"},) +
-            %("float":1.0,) +
-            %("foo":[1,2,"three",{"foo":"bar"}],) +
-            %("int":1,) +
-            %("int61":#{1 << 61},) +
-            %("int62":#{1 << 62},) +
-            %("int63":"bigint:#{1 << 63}",) +
-            %("int64":"bigint:#{1 << 64}",) +
-            %("the":"payload"})
+      context "with valid hash body" do
+        let(:body) { hash_body }
+
+        it "does not error and returns MockData class" do
+          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
+          expect(subject.to_s).to eql("{}")
         end
       end
-    end
 
-    context "with a valid array body" do
-      let(:body) do
-        [
-          nil,
-          true,
-          false,
-          "string",
-          1, # Fixnum
-          1.0, # Float
-          1 << 61, # Fixnum
-          1 << 62, # Bignum, this one still works
-          1 << 63, # Bignum, turnover point for C, too big for long
-          1 << 64, # Bignum
-          { "arr" => [1, 2, "three"], "foo" => "bʊr" }
-        ]
+      context "with valid array body" do
+        let(:body) { array_body }
+
+        it "does not error and returns MockData class" do
+          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
+          expect(subject.to_s).to eql("{}")
+        end
       end
 
-      it { is_expected.to eq Appsignal::Utils::Data.generate(body) }
-      it { is_expected.to_not eq Appsignal::Utils::Data.generate({}) }
-
-      describe "#to_s" do
-        it "returns a serialized array" do
-          expect(subject.to_s).to eq %([null,) +
-            %(true,) +
-            %(false,) +
-            %(\"string\",) +
-            %(1,) +
-            %(1.0,) +
-            %(#{1 << 61},) +
-            %(#{1 << 62},) +
-            %("bigint:#{1 << 63}",) +
-            %("bigint:#{1 << 64}",) +
-            %({\"arr\":[1,2,\"three\"],\"foo\":\"bʊr\"}])
+      context "with an invalid body" do
+        let(:body) { "body" }
+
+        it "raise a type error" do
+          expect do
+            subject
+          end.to raise_error TypeError
         end
       end
     end
 
-    context "with a body that contains strings with invalid utf-8 content" do
-      let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
-      let(:body) do
-        {
-          "field_one" => [0x61, 0x61].pack("c*"),
-          :field_two => string_with_invalid_utf8,
-          "field_three" => [
-            "one", string_with_invalid_utf8
-          ],
-          "field_four" => {
-            "one" => string_with_invalid_utf8
-          }
-        }
+    context "when extension is loaded" do
+      context "with a valid hash body" do
+        let(:body) { hash_body }
+
+        it "returns a valid Data object" do
+          is_expected.to eq Appsignal::Utils::Data.generate(body)
+          is_expected.to_not eq Appsignal::Utils::Data.generate({})
+        end
+
+        describe "#to_s" do
+          it "returns a serialized hash" do
+            expect(subject.to_s).to eq %({"":"test",) +
+              %("1":true,) +
+              %("bar":null,) +
+              %("baz":{"arr":[1,2],"foo":"bʊr"},) +
+              %("float":1.0,) +
+              %("foo":[1,2,"three",{"foo":"bar"}],) +
+              %("int":1,) +
+              %("int61":#{1 << 61},) +
+              %("int62":#{1 << 62},) +
+              %("int63":"bigint:#{1 << 63}",) +
+              %("int64":"bigint:#{1 << 64}",) +
+              %("the":"payload"})
+          end
+        end
+      end
+
+      context "with a valid array body" do
+        let(:body) { array_body }
+
+        it "returns a valid Data object" do
+          is_expected.to eq Appsignal::Utils::Data.generate(body)
+          is_expected.to_not eq Appsignal::Utils::Data.generate({})
+        end
+
+        describe "#to_s" do
+          it "returns a serialized array" do
+            expect(subject.to_s).to eq %([null,) +
+              %(true,) +
+              %(false,) +
+              %(\"string\",) +
+              %(1,) +
+              %(1.0,) +
+              %(#{1 << 61},) +
+              %(#{1 << 62},) +
+              %("bigint:#{1 << 63}",) +
+              %("bigint:#{1 << 64}",) +
+              %({\"arr\":[1,2,\"three\"],\"foo\":\"bʊr\"}])
+          end
+        end
       end
 
-      describe "#to_s" do
-        it { expect(subject.to_s).to eq %({"field_four":{"one":"aa�"},"field_one":"aa","field_three":["one","aa�"],"field_two":"aa�"}) }
+      context "with a body that contains strings with invalid utf-8 content" do
+        let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
+        let(:body) do
+          {
+            "field_one" => [0x61, 0x61].pack("c*"),
+            :field_two => string_with_invalid_utf8,
+            "field_three" => [
+              "one", string_with_invalid_utf8
+            ],
+            "field_four" => {
+              "one" => string_with_invalid_utf8
+            }
+          }
+        end
+
+        describe "#to_s" do
+          it "returns a JSON representation in a String" do
+            expect(subject.to_s).to eq %({"field_four":{"one":"aa�"},"field_one":"aa","field_three":["one","aa�"],"field_two":"aa�"})
+          end
+        end
       end
-    end
 
-    context "with an invalid body" do
-      let(:body) { "body" }
+      context "with an invalid body" do
+        let(:body) { "body" }
 
-      it "should raise a type error" do
-        expect do
-          subject
-        end.to raise_error TypeError
+        it "raises a type error" do
+          expect do
+            subject
+          end.to raise_error TypeError
+        end
       end
     end
   end
+
+  def hash_body
+    {
+      "the" => "payload",
+      "int" => 1, # Fixnum
+      "int61" => 1 << 61, # Fixnum
+      "int62" => 1 << 62, # Bignum, this one still works
+      "int63" => 1 << 63, # Bignum, turnover point for C, too big for long
+      "int64" => 1 << 64, # Bignum
+      "float" => 1.0,
+      1 => true,
+      nil => "test",
+      :foo => [1, 2, "three", { "foo" => "bar" }],
+      "bar" => nil,
+      "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
+    }
+  end
+
+  def array_body
+    [
+      nil,
+      true,
+      false,
+      "string",
+      1, # Fixnum
+      1.0, # Float
+      1 << 61, # Fixnum
+      1 << 62, # Bignum, this one still works
+      1 << 63, # Bignum, turnover point for C, too big for long
+      1 << 64, # Bignum
+      { "arr" => [1, 2, "three"], "foo" => "bʊr" }
+    ]
+  end
 end