appsignal 2.11.3-java → 2.11.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7f987568de0465681e378f999401d10053106029050f2e27c66e03634654534
-  data.tar.gz: 9d3bda2c23f46391752218d6a08290e19ffe59a9cdabd3d89841f208a5a4499c
+  metadata.gz: 2437240f8298f3750115f38e730027652c282e9f259c651bd8111c3ca155bbd7
+  data.tar.gz: 0b0e58c57c07ea20524c4f40a57ad3390834707e6f5319a20559b8285ff7d550
 SHA512:
-  metadata.gz: 626bba54cb4d1e1c5990f7e6636f07fef4b3f211e2bc5943a5bbf8ffa6e0d4eaa78abf5a203b491e32ee4d75fb3a5a6d339aaafa9a0bc12973fce90e0eaa5861
-  data.tar.gz: 62052287406db0bb8e95c6e9130886f9db8f7e9822b9d835a9faec3090facd4990addf13b99f107a26e777a37354bbe8ea795c392917cfe2c0884772000b0b3c
+  metadata.gz: 3e803aadead924e985168c693f8aaa7bd160febbd3bf371d5e4ea507449ce5e4ad2ce19be526ce56b118d39959b11cbdbadeb535e576f9a075b249be946999fa
+  data.tar.gz: fa3192e852d1e6e77ab137c18d3c75ca2b67cd751d0de97cc1bacc8512e49eb76a2c01100a232c0dc6de1fd67a91b05f56d0a236104edab7321d44a110b47f4f

data/.rubocop.yml

@@ -13,6 +13,8 @@ AllCops:
     - "gemfiles/vendor/**/*"
     - "vendor/**/*"
     - "benchmark.rake"
+    - "lib/appsignal/integrations/object_ruby_modern.rb"
+    - "spec/lib/appsignal/integrations/object_spec.rb"
   DisplayCopNames: true
   UseCache: true
   CacheRootDirectory: ./tmp

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+# 2.11.4
+- Support Ruby 3.0 for Object method instrumentation with keyword arguments
+  (https://docs.appsignal.com/ruby/instrumentation/method-instrumentation.html)
+  PR #693
+
 # 2.11.3
 - Support Shoryuken batch workers. PR #687
 

data/Rakefile

@@ -275,7 +275,8 @@ namespace :publish do
     Dir.chdir("#{File.dirname(__FILE__)}/pkg") do
       Dir["*.gem"].each do |gem_package|
         puts "## Publishing gem package: #{gem_package}"
-        system "gem push #{gem_package}"
+        result = system "gem push #{gem_package}"
+        raise "Failed to Push gem" unless result
       end
     end
   end
@@ -374,19 +375,21 @@ end
 begin
   require "rspec/core/rake_task"
   is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-  unless is_jruby
-    jruby_opts = "--exclude-pattern=spec/lib/appsignal/extension/jruby_spec.rb"
-  end
+  excludes = []
+  excludes << "spec/lib/appsignal/extension/jruby_spec.rb" unless is_jruby
+  is_ruby19 = RUBY_VERSION < "2.0"
+  excludes << "spec/lib/appsignal/integrations/object_spec.rb" if is_ruby19
+  exclude_pattern = "--exclude-pattern=#{excludes.join(",")}" if excludes.any?
 
   desc "Run the AppSignal gem test suite."
   RSpec::Core::RakeTask.new :test do |t|
-    t.rspec_opts = jruby_opts
+    t.rspec_opts = exclude_pattern
   end
 
   namespace :test do
     desc "Run the Appsignal gem test in an extension failure scenario"
     RSpec::Core::RakeTask.new :failure do |t|
-      t.rspec_opts = "#{jruby_opts} --tag extension_installation_failure"
+      t.rspec_opts = "#{exclude_pattern} --tag extension_installation_failure"
     end
   end
 rescue LoadError # rubocop:disable Lint/HandleExceptions

data/lib/appsignal/integrations/object.rb

@@ -4,38 +4,8 @@ if defined?(Appsignal)
   Appsignal::Environment.report_enabled("object_instrumentation")
 end
 
-class Object
-  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
-  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
-  end
-
-  def self.appsignal_reverse_class_name
-    return "AnonymousClass" unless name
-    name.split("::").reverse.join(".")
-  end
-
-  def appsignal_reverse_class_name
-    self.class.appsignal_reverse_class_name
-  end
+if RUBY_VERSION < "2.0"
+  require "appsignal/integrations/object_ruby_19"
+else
+  require "appsignal/integrations/object_ruby_modern"
 end

data/lib/appsignal/integrations/object_ruby_19.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Object
+  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
+  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
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
+end

data/lib/appsignal/integrations/object_ruby_modern.rb

@@ -0,0 +1,64 @@
+# 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
+      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
+      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
+    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
+    end
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
+end

data/lib/appsignal/system.rb

@@ -79,5 +79,9 @@ module Appsignal
     def self.jruby?
       RUBY_PLATFORM == "java"
     end
+
+    def self.ruby_2_7_or_newer?
+      RUBY_VERSION > "2.7"
+    end
   end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.3".freeze
+  VERSION = "2.11.4".freeze
 end

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

@@ -0,0 +1,266 @@
+require "appsignal/integrations/object"
+
+def is_ruby_19
+  RUBY_VERSION < "2.0"
+end
+
+describe Object do
+  describe "#instrument_method" do
+    context "with instance method" do
+      let(:klass) do
+        Class.new do
+          def foo(param1, options = {})
+            [param1, options]
+          end
+          appsignal_instrument_method :foo
+        end
+      end
+      let(:instance) { klass.new }
+
+      def call_with_arguments
+        instance.foo(
+          "abc",
+          :foo => "bar"
+        )
+      end
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+        end
+        after { Appsignal.config = nil }
+
+        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
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          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
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with nested named class" do
+          before do
+            module MyModule
+              module NestedModule
+                class NamedClass
+                  def bar
+                    2
+                  end
+                  appsignal_instrument_method :bar
+                end
+              end
+            end
+          end
+          after { Object.send(:remove_const, :MyModule) }
+          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,
+              Appsignal::EventFormatter::DEFAULT
+            expect(instance.bar).to eq(2)
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo, :name => "my_method.group"
+            end
+          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
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def foo
+                yield
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+
+          it "should yield the block" do
+            expect(instance.foo { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "does not instrument, but still calls the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+        end
+      end
+    end
+
+    context "with class method" do
+      let(:klass) do
+        Class.new do
+          def self.bar(param1, options = {})
+            [param1, options]
+          end
+          appsignal_instrument_class_method :bar
+        end
+      end
+      def call_with_arguments
+        klass.bar(
+          "abc",
+          :foo => "bar"
+        )
+      end
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once)
+            .and_return(transaction)
+        end
+        after { Appsignal.config = nil }
+
+        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 \
+              "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          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 \
+              "bar.class_method.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(klass.bar).to eq(2)
+          end
+
+          context "with nested named class" do
+            before do
+              module MyModule
+                module NestedModule
+                  class NamedClass
+                    def self.bar
+                      2
+                    end
+                    appsignal_instrument_class_method :bar
+                  end
+                end
+              end
+            end
+            after { Object.send(:remove_const, :MyModule) }
+            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.class_method.NamedClass.NestedModule.MyModule.other", nil, nil,
+                Appsignal::EventFormatter::DEFAULT
+              expect(klass.bar).to eq(2)
+            end
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar, :name => "my_method.group"
+            end
+          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
+            expect(klass.bar).to eq(2)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                yield
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+
+          it "should yield the block" do
+            expect(klass.bar { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "does not instrument, but still call the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+        end
+      end
+    end
+  end
+end

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

@@ -1,18 +1,30 @@
 require "appsignal/integrations/object"
 
+def is_ruby_19
+  RUBY_VERSION < "2.0"
+end
+
 describe Object do
   describe "#instrument_method" do
     context "with instance method" do
       let(:klass) do
         Class.new do
-          def foo
-            1
+          def foo(param1, options = {}, keyword_param: 1)
+            [param1, options, keyword_param]
           end
           appsignal_instrument_method :foo
         end
       end
       let(:instance) { klass.new }
 
+      def call_with_arguments
+        instance.foo(
+          "abc",
+          { :foo => "bar" },
+          :keyword_param => 2
+        )
+      end
+
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
@@ -27,7 +39,7 @@ describe Object do
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(instance.foo).to eq(1)
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
           end
         end
 
@@ -116,10 +128,10 @@ describe Object do
       context "when not active" do
         let(:transaction) { Appsignal::Transaction.current }
 
-        it "should not instrument, but still call the method" do
+        it "does not instrument, but still calls the method" do
           expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
-          expect(instance.foo).to eq(1)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
         end
       end
     end
@@ -127,12 +139,19 @@ describe Object do
     context "with class method" do
       let(:klass) do
         Class.new do
-          def self.bar
-            2
+          def self.bar(param1, options = {}, keyword_param: 1)
+            [param1, options, keyword_param]
           end
           appsignal_instrument_class_method :bar
         end
       end
+      def call_with_arguments
+        klass.bar(
+          "abc",
+          { :foo => "bar" },
+          :keyword_param => 2
+        )
+      end
 
       context "when active" do
         let(:transaction) { http_request_transaction }
@@ -149,7 +168,7 @@ describe Object do
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(klass.bar).to eq(2)
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
           end
         end
 
@@ -238,10 +257,10 @@ describe Object do
       context "when not active" do
         let(:transaction) { Appsignal::Transaction.current }
 
-        it "should not instrument, but still call the method" do
+        it "does not instrument, but still call the method" do
           expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
-          expect(klass.bar).to eq(2)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 2.11.3
+  version: 2.11.4
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-19 00:00:00.000000000 Z
+date: 2021-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -247,6 +247,8 @@ files:
 - lib/appsignal/integrations/grape.rb
 - lib/appsignal/integrations/mongo_ruby_driver.rb
 - lib/appsignal/integrations/object.rb
+- lib/appsignal/integrations/object_ruby_19.rb
+- lib/appsignal/integrations/object_ruby_modern.rb
 - lib/appsignal/integrations/padrino.rb
 - lib/appsignal/integrations/que.rb
 - lib/appsignal/integrations/railtie.rb
@@ -336,6 +338,7 @@ files:
 - spec/lib/appsignal/integrations/data_mapper_spec.rb
 - spec/lib/appsignal/integrations/grape_spec.rb
 - spec/lib/appsignal/integrations/mongo_ruby_driver_spec.rb
+- spec/lib/appsignal/integrations/object_19_spec.rb
 - spec/lib/appsignal/integrations/object_spec.rb
 - spec/lib/appsignal/integrations/padrino_spec.rb
 - spec/lib/appsignal/integrations/que_spec.rb
@@ -429,7 +432,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
+rubygems_version: 3.2.6
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com
@@ -488,6 +491,7 @@ test_files:
 - spec/lib/appsignal/integrations/data_mapper_spec.rb
 - spec/lib/appsignal/integrations/grape_spec.rb
 - spec/lib/appsignal/integrations/mongo_ruby_driver_spec.rb
+- spec/lib/appsignal/integrations/object_19_spec.rb
 - spec/lib/appsignal/integrations/object_spec.rb
 - spec/lib/appsignal/integrations/padrino_spec.rb
 - spec/lib/appsignal/integrations/que_spec.rb