appsignal 2.11.0.beta.3-java → 2.11.1-java

data/spec/lib/appsignal/extension/jruby_spec.rb

@@ -1,42 +1,45 @@
-if Appsignal::System.jruby?
-  describe Appsignal::Extension::Jruby do
-    let(:extension) { Appsignal::Extension }
+describe "JRuby extension", :jruby do
+  let(:extension) { Appsignal::Extension }
+  let(:jruby_module) { Appsignal::Extension::Jruby }
 
-    describe "string conversions" do
-      it "keeps the same value during string type conversions" do
-        # UTF-8 string with NULL
-        # Tests if the conversions between the conversions without breaking on
-        # NULL terminated strings in C.
-        string = "Merry Christmas! \u0000 🎄"
+  it "creates a JRuby extension module" do
+    expect(Appsignal::Extension::Jruby).to be_kind_of(Module)
+  end
 
-        appsignal_string = extension.make_appsignal_string(string)
-        ruby_string = extension.make_ruby_string(appsignal_string)
+  describe "string conversions" do
+    it "keeps the same value during string type conversions" do
+      # UTF-8 string with NULL
+      # Tests if the conversions between the conversions without breaking on
+      # NULL terminated strings in C.
+      string = "Merry Christmas! \u0000 🎄"
 
-        expect(ruby_string).to eq("Merry Christmas! \u0000 🎄")
-      end
-    end
+      appsignal_string = extension.make_appsignal_string(string)
+      ruby_string = extension.make_ruby_string(appsignal_string)
 
-    it "loads libappsignal with FFI" do
-      expect(described_class.ffi_libraries.map(&:name).first).to include "libappsignal"
+      expect(ruby_string).to eq("Merry Christmas! \u0000 🎄")
     end
+  end
 
-    describe ".lib_extension" do
-      subject { described_class.lib_extension }
+  it "loads libappsignal with FFI" do
+    expect(jruby_module.ffi_libraries.map(&:name).first).to include "libappsignal"
+  end
+
+  describe ".lib_extension" do
+    subject { jruby_module.lib_extension }
 
-      context "when on a darwin system" do
-        before { expect(Appsignal::System).to receive(:agent_platform).and_return("darwin") }
+    context "when on a darwin system" do
+      before { expect(Appsignal::System).to receive(:agent_platform).and_return("darwin") }
 
-        it "returns the extension for darwin" do
-          is_expected.to eq "dylib"
-        end
+      it "returns the extension for darwin" do
+        is_expected.to eq "dylib"
       end
+    end
 
-      context "when on a linux system" do
-        before { expect(Appsignal::System).to receive(:agent_platform).and_return("linux") }
+    context "when on a linux system" do
+      before { expect(Appsignal::System).to receive(:agent_platform).and_return("linux") }
 
-        it "returns the lib extension for linux" do
-          is_expected.to eq "so"
-        end
+      it "returns the lib extension for linux" do
+        is_expected.to eq "so"
       end
     end
   end

data/spec/lib/appsignal/extension_install_failure_spec.rb

@@ -0,0 +1,23 @@
+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")
+      error_message =
+        if DependencyHelper.running_jruby?
+          "cannot open shared object file"
+        else
+          "LoadError: cannot load such file"
+        end
+      expect(stderr).to include(error_message)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+describe Appsignal::Hooks::ActionMailerHook do
+  if DependencyHelper.action_mailer_present? &&
+      DependencyHelper.rails_version >= Gem::Version.new("4.0.0")
+    context "with ActionMailer" do
+      require "action_mailer"
+
+      class UserMailer < ActionMailer::Base
+        default :from => "test@example.com"
+
+        def welcome
+          mail(:to => "test@example.com", :subject => "ActionMailer test", :content_type => "text/html") do |format|
+            format.html { render :html => "This is a test" }
+          end
+        end
+      end
+      UserMailer.delivery_method = :test
+
+      describe ".dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it "returns true" do
+          is_expected.to be_truthy
+        end
+      end
+
+      describe ".install" do
+        before do
+          start_agent
+          expect(Appsignal.active?).to be_truthy
+        end
+
+        it "is subscribed to 'process.action_mailer' and processes instrumentation" do
+          expect(Appsignal).to receive(:increment_counter).with(
+            :action_mailer_process,
+            1,
+            :mailer => "UserMailer", :action => :welcome
+          )
+
+          UserMailer.welcome.deliver_now
+        end
+      end
+    end
+  else
+    context "without ActionMailer" do
+      describe ".dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it "returns false" do
+          is_expected.to be_falsy
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/hooks/active_support_notifications/finish_with_state_shared_examples.rb

@@ -0,0 +1,35 @@
+shared_examples "activesupport finish_with_state override" do
+  let(:instrumenter) { as.instrumenter }
+
+  it "instruments an ActiveSupport::Notifications.start/finish event with payload on finish" do
+    listeners_state = instrumenter.start("sql.active_record", {})
+    instrumenter.finish_with_state(listeners_state, "sql.active_record", :sql => "SQL")
+
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "SQL",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "does not instrument events whose name starts with a bang" do
+    expect(Appsignal::Transaction.current).not_to receive(:start_event)
+    expect(Appsignal::Transaction.current).not_to receive(:finish_event)
+
+    listeners_state = instrumenter.start("!sql.active_record", {})
+    instrumenter.finish_with_state(listeners_state, "!sql.active_record", :sql => "SQL")
+
+    expect(transaction.to_h["events"]).to be_empty
+  end
+end

data/spec/lib/appsignal/hooks/active_support_notifications/instrument_shared_examples.rb

@@ -0,0 +1,145 @@
+shared_examples "activesupport instrument override" do
+  it "instruments an ActiveSupport::Notifications.instrument event" do
+    return_value = as.instrument("sql.active_record", :sql => "SQL") do
+      "value"
+    end
+
+    expect(return_value).to eq "value"
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "SQL",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
+    return_value = as.instrument("no-registered.formatter", :key => "something") do
+      "value"
+    end
+
+    expect(return_value).to eq "value"
+    expect(transaction.to_h["events"]).to match([
+      {
+        "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,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "no-registered.formatter",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "converts non-string names to strings" do
+    as.instrument(:not_a_string) {}
+    expect(transaction.to_h["events"]).to match([
+      {
+        "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,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "not_a_string",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "does not instrument events whose name starts with a bang" do
+    expect(Appsignal::Transaction.current).not_to receive(:start_event)
+    expect(Appsignal::Transaction.current).not_to receive(:finish_event)
+
+    return_value = as.instrument("!sql.active_record", :sql => "SQL") do
+      "value"
+    end
+
+    expect(return_value).to eq "value"
+  end
+
+  context "when an error is raised in an instrumented block" do
+    it "instruments an ActiveSupport::Notifications.instrument event" do
+      expect do
+        as.instrument("sql.active_record", :sql => "SQL") do
+          raise ExampleException, "foo"
+        end
+      end.to raise_error(ExampleException, "foo")
+
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "SQL",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "sql.active_record",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
+    end
+  end
+
+  context "when a message is thrown in an instrumented block" do
+    it "instruments an ActiveSupport::Notifications.instrument event" do
+      expect do
+        as.instrument("sql.active_record", :sql => "SQL") do
+          throw :foo
+        end
+      end.to throw_symbol(:foo)
+
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "SQL",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "sql.active_record",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
+    end
+  end
+
+  context "when a transaction is completed in an instrumented block" do
+    it "does not complete the ActiveSupport::Notifications.instrument event" do
+      expect(transaction).to receive(:complete)
+      as.instrument("sql.active_record", :sql => "SQL") do
+        Appsignal::Transaction.complete_current!
+      end
+
+      expect(transaction.to_h["events"]).to match([])
+    end
+  end
+end

data/spec/lib/appsignal/hooks/active_support_notifications/start_finish_shared_examples.rb

@@ -0,0 +1,69 @@
+shared_examples "activesupport start finish override" do
+  let(:instrumenter) { as.instrumenter }
+
+  it "instruments an ActiveSupport::Notifications.start/finish event with payload on start ignores payload" do
+    instrumenter.start("sql.active_record", :sql => "SQL")
+    instrumenter.finish("sql.active_record", {})
+
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "instruments an ActiveSupport::Notifications.start/finish event with payload on finish" do
+    instrumenter.start("sql.active_record", {})
+    instrumenter.finish("sql.active_record", :sql => "SQL")
+
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "SQL",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "does not instrument events whose name starts with a bang" do
+    expect(Appsignal::Transaction.current).not_to receive(:start_event)
+    expect(Appsignal::Transaction.current).not_to receive(:finish_event)
+
+    instrumenter.start("!sql.active_record", {})
+    instrumenter.finish("!sql.active_record", {})
+
+    expect(transaction.to_h["events"]).to be_empty
+  end
+
+  context "when a transaction is completed in an instrumented block" do
+    it "does not complete the ActiveSupport::Notifications.instrument event" do
+      expect(transaction).to receive(:complete)
+
+      instrumenter.start("sql.active_record", {})
+      Appsignal::Transaction.complete_current!
+      instrumenter.finish("sql.active_record", {})
+
+      expect(transaction.to_h["events"]).to match([])
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require_relative "./active_support_notifications/instrument_shared_examples"
+
 describe Appsignal::Hooks::ActiveSupportNotificationsHook do
   if active_support_present?
     let(:notifier) { ActiveSupport::Notifications::Fanout.new }
@@ -18,148 +20,18 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
       it { is_expected.to be_truthy }
     end
 
-    it "instruments an ActiveSupport::Notifications.instrument event" do
-      return_value = as.instrument("sql.active_record", :sql => "SQL") do
-        "value"
-      end
-
-      expect(return_value).to eq "value"
-      expect(transaction.to_h["events"]).to match([
-        {
-          "allocation_count" => kind_of(Integer),
-          "body" => "SQL",
-          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-          "child_allocation_count" => kind_of(Integer),
-          "child_duration" => kind_of(Float),
-          "child_gc_duration" => kind_of(Float),
-          "count" => 1,
-          "duration" => kind_of(Float),
-          "gc_duration" => kind_of(Float),
-          "name" => "sql.active_record",
-          "start" => kind_of(Float),
-          "title" => ""
-        }
-      ])
-    end
-
-    it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
-      return_value = as.instrument("no-registered.formatter", :key => "something") do
-        "value"
-      end
-
-      expect(return_value).to eq "value"
-      expect(transaction.to_h["events"]).to match([
-        {
-          "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,
-          "duration" => kind_of(Float),
-          "gc_duration" => kind_of(Float),
-          "name" => "no-registered.formatter",
-          "start" => kind_of(Float),
-          "title" => ""
-        }
-      ])
-    end
-
-    it "converts non-string names to strings" do
-      as.instrument(:not_a_string) {}
-      expect(transaction.to_h["events"]).to match([
-        {
-          "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,
-          "duration" => kind_of(Float),
-          "gc_duration" => kind_of(Float),
-          "name" => "not_a_string",
-          "start" => kind_of(Float),
-          "title" => ""
-        }
-      ])
-    end
-
-    it "does not instrument events whose name starts with a bang" do
-      expect(Appsignal::Transaction.current).not_to receive(:start_event)
-      expect(Appsignal::Transaction.current).not_to receive(:finish_event)
-
-      return_value = as.instrument("!sql.active_record", :sql => "SQL") do
-        "value"
-      end
-
-      expect(return_value).to eq "value"
-    end
-
-    context "when an error is raised in an instrumented block" do
-      it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect do
-          as.instrument("sql.active_record", :sql => "SQL") do
-            raise ExampleException, "foo"
-          end
-        end.to raise_error(ExampleException, "foo")
-
-        expect(transaction.to_h["events"]).to match([
-          {
-            "allocation_count" => kind_of(Integer),
-            "body" => "SQL",
-            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-            "child_allocation_count" => kind_of(Integer),
-            "child_duration" => kind_of(Float),
-            "child_gc_duration" => kind_of(Float),
-            "count" => 1,
-            "duration" => kind_of(Float),
-            "gc_duration" => kind_of(Float),
-            "name" => "sql.active_record",
-            "start" => kind_of(Float),
-            "title" => ""
-          }
-        ])
-      end
-    end
+    it_behaves_like "activesupport instrument override"
 
-    context "when a message is thrown in an instrumented block" do
-      it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect do
-          as.instrument("sql.active_record", :sql => "SQL") do
-            throw :foo
-          end
-        end.to throw_symbol(:foo)
+    if ::ActiveSupport::Notifications::Instrumenter.method_defined?(:start)
+      require_relative "./active_support_notifications/start_finish_shared_examples"
 
-        expect(transaction.to_h["events"]).to match([
-          {
-            "allocation_count" => kind_of(Integer),
-            "body" => "SQL",
-            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-            "child_allocation_count" => kind_of(Integer),
-            "child_duration" => kind_of(Float),
-            "child_gc_duration" => kind_of(Float),
-            "count" => 1,
-            "duration" => kind_of(Float),
-            "gc_duration" => kind_of(Float),
-            "name" => "sql.active_record",
-            "start" => kind_of(Float),
-            "title" => ""
-          }
-        ])
-      end
+      it_behaves_like "activesupport start finish override"
     end
 
-    context "when a transaction is completed in an instrumented block" do
-      it "does not complete the ActiveSupport::Notifications.instrument event" do
-        expect(transaction).to receive(:complete)
-        as.instrument("sql.active_record", :sql => "SQL") do
-          Appsignal::Transaction.complete_current!
-        end
+    if ::ActiveSupport::Notifications::Instrumenter.method_defined?(:finish_with_state)
+      require_relative "./active_support_notifications/finish_with_state_shared_examples"
 
-        expect(transaction.to_h["events"]).to match([])
-      end
+      it_behaves_like "activesupport finish_with_state override"
     end
   else
     describe "#dependencies_present?" do