appsignal 2.11.8 → 2.11.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cb57893fb10d1d54593fcf13b4d2b13ac728e9d0c5c16f046580b1befb6048d
-  data.tar.gz: ef465afb88df2f8f53015e84192159d464c4827e66a1ee19bed38b73712e810c
+  metadata.gz: 60535b76df01cdf84e0a7a0e018cb3822e56de610cbfd7694bdb10c06ba32b64
+  data.tar.gz: '092acba4f404fafd21333649bdd65c190da7b31507172f7da91c9a56debe2c5a'
 SHA512:
-  metadata.gz: 663ba5e66fd1bad997a27c164d7e9845effb7d419b6b23a3b33a1f0f71f50d18071194f75216e347956f11e3ad2730f82e7c24fb4029b2c9daf4bd597c289450
-  data.tar.gz: e7a8ba54779115a77703090837a9814e017884607d3b059b620a875cba9c52bc449fa56006ad443ecc076d1bf8bfc7b8c109bd7d61c811c8f5748e683b94f3d4
+  metadata.gz: 1e6a54ec292287cd2944032aa00af8d15505cb52c33e8b697d1659fa4ceaa8e89ffca68d6050ca2cad05a3b537838e5f6439cbfe4fd3301f220279fe266c4759
+  data.tar.gz: 843ccd65902958efcd641d09d8c65e9ec55ac0a908ac16651a4016fb99329bfa6b1c903472a59182e21f56f83ac738e7dd0eb03d957bbaed4bba550b8a8ce76b

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+# 2.11.9
+- Fix and simplify Ruby method delegation for object method instrumentation in
+  the different Ruby versions. PR #706
+
 # 2.11.8
 - Mark minutely probe thread as fork-safe by @pixeltrix. PR #704
 

data/lib/appsignal/integrations/object_ruby_modern.rb

@@ -1,56 +1,33 @@
 # frozen_string_literal: true
 
 class Object
-  if Appsignal::System.ruby_2_7_or_newer?
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+  def self.appsignal_instrument_class_method(method_name, options = {})
+    singleton_class.send \
+      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+    singleton_class.send(:define_method, method_name) do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
       end
-    end
-
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
-  else
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
-      end
+    if singleton_class.respond_to?(:ruby2_keywords, true)
+      singleton_class.send(:ruby2_keywords, method_name)
     end
+  end
 
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
+  def self.appsignal_instrument_method(method_name, options = {})
+    alias_method "appsignal_uninstrumented_#{method_name}", method_name
+    define_method method_name do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
+    ruby2_keywords method_name if respond_to?(:ruby2_keywords, true)
   end
 
   def self.appsignal_reverse_class_name

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.8".freeze
+  VERSION = "2.11.9".freeze
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 2.11.8
+  version: 2.11.9
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-18 00:00:00.000000000 Z
+date: 2021-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack