appsignal 2.11.10-java → 3.0.0.beta.1-java

data/lib/appsignal/minutely.rb

@@ -3,8 +3,6 @@
 module Appsignal
   class Minutely
     class ProbeCollection
-      include Appsignal::Utils::DeprecationMessage
-
       def initialize
         @probes = {}
       end
@@ -27,16 +25,6 @@ module Appsignal
         probes[key]
       end
 
-      # @param probe [Object] Any object that listens to the `call` method will
-      #   be used as a probe.
-      # @deprecated Use {#register} instead.
-      # @return [void]
-      def <<(probe)
-        deprecation_message "Deprecated `Appsignal::Minute.probes <<` " \
-          "call. Please use `Appsignal::Minutely.probes.register` instead."
-        register probe.object_id, probe
-      end
-
       # Register a new minutely probe.
       #
       # Supported probe types are:
@@ -135,12 +123,6 @@ module Appsignal
       def start
         stop
         @thread = Thread.new do
-          # Advise multi-threaded app servers to ignore this thread
-          # for the purposes of fork safety warnings
-          if Thread.current.respond_to?(:thread_variable_set)
-            Thread.current.thread_variable_set(:fork_safe, true)
-          end
-
           sleep initial_wait_time
           initialize_probes
           loop do

data/lib/appsignal/transaction.rb

@@ -90,7 +90,7 @@ module Appsignal
         @transaction_id,
         @namespace,
         self.class.garbage_collection_profiler.total_time
-      ) || Appsignal::Extension::MockTransaction.new
+      )
     end
 
     def nil_transaction?

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.10".freeze
+  VERSION = "3.0.0.beta.1".freeze
 end

data/lib/appsignal.rb

@@ -129,7 +129,6 @@ module Appsignal
           config.write_to_environment
           Appsignal::Extension.start
           Appsignal::Hooks.load_hooks
-          Appsignal::EventFormatter.initialize_deprecated_formatters
           initialize_extensions
 
           if config[:enable_allocation_tracking] && !Appsignal::System.jruby?
@@ -222,15 +221,9 @@ module Appsignal
     # Sets the log level and sets the logger. Uses a file-based logger or the
     # STDOUT-based logger. See the `:log` configuration option.
     #
-    # @param path_arg [nil] Deprecated param. Use the `:log_path`
-    #   configuration option instead.
     # @return [void]
     # @since 0.7.0
-    def start_logger(path_arg = nil)
-      if path_arg
-        logger.info("Setting the path in start_logger has no effect anymore, set it in the config instead")
-      end
-
+    def start_logger
       if config && config[:log] == "file" && config.log_file_path
         start_file_logger(config.log_file_path)
       else
@@ -285,21 +278,6 @@ module Appsignal
       config && config.active? && extension_loaded?
     end
 
-    # @deprecated No replacement
-    def is_ignored_error?(error) # rubocop:disable Naming/PredicateName
-      deprecation_message "Appsignal.is_ignored_error? is deprecated " \
-        "with no replacement and will be removed in version 3.0."
-      Appsignal.config[:ignore_errors].include?(error.class.name)
-    end
-    alias :is_ignored_exception? :is_ignored_error?
-
-    # @deprecated No replacement
-    def is_ignored_action?(action) # rubocop:disable Naming/PredicateName
-      deprecation_message "Appsignal.is_ignored_action? is deprecated " \
-        "with no replacement and will be removed in version 3.0."
-      Appsignal.config[:ignore_actions].include?(action)
-    end
-
     private
 
     def start_stdout_logger
@@ -344,11 +322,7 @@ require "appsignal/marker"
 require "appsignal/minutely"
 require "appsignal/garbage_collection_profiler"
 require "appsignal/integrations/railtie" if defined?(::Rails)
-require "appsignal/integrations/resque"
-require "appsignal/integrations/resque_active_job"
 require "appsignal/transaction"
 require "appsignal/version"
 require "appsignal/rack/generic_instrumentation"
-require "appsignal/rack/js_exception_catcher"
-require "appsignal/js_exception_transaction"
 require "appsignal/transmitter"

data/spec/lib/appsignal/auth_check_spec.rb

@@ -28,29 +28,6 @@ describe Appsignal::AuthCheck do
     end.join("&")
   end
 
-  describe ".new" do
-    describe "with logger argument" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:log_stream) { std_stream }
-      let(:log) { log_contents(log_stream) }
-
-      it "logs and prints a deprecation message" do
-        Appsignal.logger = test_logger(log_stream)
-
-        capture_std_streams(std_stream, err_stream) do
-          Appsignal::AuthCheck.new(config, Appsignal.logger)
-        end
-
-        deprecation_message =
-          "`Appsignal::AuthCheck.new`'s `logger` argument " \
-          "will be removed in the next major version."
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-  end
-
   describe "#perform" do
     subject { auth_check.perform }
 
@@ -62,7 +39,7 @@ describe Appsignal::AuthCheck do
       end
     end
 
-    context "when encountering an exception", :not_ruby19 do
+    context "when encountering an exception" do
       before { stubbed_request.to_timeout }
 
       it "raises an error" do

data/spec/lib/appsignal/cli_spec.rb

@@ -16,7 +16,7 @@ describe Appsignal::CLI do
 
       expect(output).to include "appsignal <command> [options]"
       expect(output).to include \
-        "Available commands: demo, diagnose, install, notify_of_deploy"
+        "Available commands: demo, diagnose, install"
     end
   end
 

data/spec/lib/appsignal/config_spec.rb

@@ -168,8 +168,6 @@ describe Appsignal::Config do
         :push_api_key                   => "abc",
         :name                           => "TestApp",
         :active                         => true,
-        :enable_frontend_error_catching => false,
-        :frontend_error_catching_path   => "/appsignal_error_catcher",
         :enable_allocation_tracking     => true,
         :enable_gc_instrumentation      => false,
         :enable_host_metrics            => true,
@@ -357,70 +355,6 @@ describe Appsignal::Config do
         config
       end
     end
-
-    describe "support for old config keys" do
-      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_std_streams(std_stream, err_stream) { config } }
-
-      describe ":api_key" do
-        context "without :push_api_key" do
-          let(:env) { "old_config" }
-
-          it "sets the :push_api_key with the old :api_key value" do
-            expect(config[:push_api_key]).to eq "def"
-            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(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :push_api_key" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :api_key config and deletes it" do
-            expect(config[:push_api_key]).to eq "ghi"
-            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(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-
-      describe ":ignore_exceptions" do
-        context "without :ignore_errors" do
-          let(:env) { "old_config" }
-
-          it "sets :ignore_errors with the old :ignore_exceptions value" do
-            expect(config[:ignore_errors]).to eq ["StandardError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :ignore_errors" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :ignore_exceptions config" do
-            expect(config[:ignore_errors]).to eq ["NoMethodError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-    end
   end
 
   context "with config in the environment" do

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -114,43 +114,6 @@ describe Appsignal::EventFormatter do
         end
       end
     end
-
-    context "when registering deprecated formatters" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:deprecated_formatter) do
-        Class.new(Appsignal::EventFormatter) do
-          register "mock.deprecated"
-
-          def format(_payload)
-          end
-        end
-      end
-
-      it "registers deprecated formatters and logs & prints a warning" do
-        message = "Formatter for 'mock.deprecated' is using a deprecated registration method. " \
-          "This event formatter will not be loaded. " \
-          "Please update the formatter according to the documentation at: " \
-          "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
-
-        logs = capture_logs do
-          capture_std_streams(std_stream, err_stream) { deprecated_formatter }
-        end
-        expect(logs).to contains_log :warn, 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_std_streams(std_stream, err_stream) { deprecated_formatter }
-        klass.initialize_deprecated_formatters
-
-        expect(klass.registered?("mock.deprecated")).to be_truthy
-        expect(klass.formatters["mock.deprecated"]).to be_instance_of(deprecated_formatter)
-        expect(klass.deprecated_formatter_classes["mock.deprecated"]).to eq(deprecated_formatter)
-      end
-    end
   end
 
   describe ".registered?" do

data/spec/lib/appsignal/extension_install_failure_spec.rb

@@ -1,6 +1,13 @@
 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,56 +119,22 @@ describe Appsignal::Extension do
     end
   end
 
-  context "when the extension library cannot be loaded", :extension_installation_failure do
-    let(:ext) { Appsignal::Extension }
+  context "when the extension library cannot be loaded" do
+    subject { Appsignal::Extension }
 
-    around do |example|
-      Appsignal::Testing.without_testing { example.run }
+    before do
+      allow(Appsignal).to receive(:extension_loaded).and_return(false)
+      allow(Appsignal).to receive(:testing?).and_return(false)
     end
 
     it "should indicate that the extension is not loaded" do
       expect(Appsignal.extension_loaded?).to be_falsy
     end
 
-    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
+    it "should not raise errors when methods are called" do
+      expect do
+        subject.something
+      end.not_to raise_error
     end
   end
 end

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

@@ -2,8 +2,6 @@ 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? }
@@ -264,49 +262,6 @@ 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
@@ -394,49 +349,6 @@ 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/celluloid_spec.rb

@@ -3,6 +3,11 @@ describe Appsignal::Hooks::CelluloidHook do
     before :context do
       module Celluloid
         def self.shutdown
+          @shut_down = true
+        end
+
+        def self.shut_down?
+          @shut_down == true
         end
       end
       Appsignal::Hooks::CelluloidHook.new.install
@@ -18,7 +23,7 @@ describe Appsignal::Hooks::CelluloidHook do
     end
 
     specify { expect(Appsignal).to receive(:stop) }
-    specify { expect(Celluloid).to receive(:shutdown_without_appsignal) }
+    specify { expect(Celluloid.shut_down?).to be true }
 
     after do
       Celluloid.shutdown

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

@@ -20,8 +20,7 @@ describe Appsignal::Hooks::RakeHook do
       end
 
       it "calls the original task" do
-        expect(task).to receive(:execute_without_appsignal).with(arguments)
-        perform
+        expect(perform).to eq([])
       end
     end
 

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

@@ -1,33 +1,68 @@
 describe Appsignal::Hooks::RedisHook do
   before do
     Appsignal.config = project_fixture_config
-    Appsignal::Hooks.load_hooks
   end
 
   if DependencyHelper.redis_present?
     context "with redis" do
       context "with instrumentation enabled" do
-        before do
-          Appsignal.config.config_hash[:instrument_redis] = true
-          allow_any_instance_of(Redis::Client).to receive(:process_without_appsignal).and_return(1)
-        end
-
         describe "#dependencies_present?" do
           subject { described_class.new.dependencies_present? }
 
           it { is_expected.to be_truthy }
         end
 
-        it "should instrument a redis call" do
-          Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
-          expect(Appsignal::Transaction.current).to receive(:start_event)
-            .at_least(:once)
-          expect(Appsignal::Transaction.current).to receive(:finish_event)
-            .at_least(:once)
-            .with("query.redis", "redis://127.0.0.1:6379/0", "get ?", 0)
+        describe "integration" do
+          before do
+            Appsignal.config.config_hash[:instrument_redis] = true
+          end
+
+          context "install" do
+            before do
+              Appsignal::Hooks.load_hooks
+            end
+
+            it "does something" do
+              # Test if the last included module (prepended module) was our
+              # integration. That's not certain with the assertions below
+              # because we have to overwrite the `process` method for the test.
+              expect(Redis::Client.included_modules.first)
+                .to eql(Appsignal::Integrations::RedisIntegration)
+            end
+          end
+
+          context "instrumentation" do
+            before do
+              # Stub Redis::Client class so that it doesn't perform an actual
+              # Redis query. This class will be included (prepended) with the
+              # AppSignal Redis integration.
+              stub_const("Redis::Client", Class.new do
+                def id
+                  :stub_id
+                end
+
+                def process(_commands)
+                  :stub_process
+                end
+              end)
+              # Load the integration again for the stubbed Redis::Client class.
+              # Call it directly because {Appsignal::Hooks.load_hooks} keeps
+              # track if it was installed already or not.
+              Appsignal::Hooks::RedisHook.new.install
+            end
+
+            it "instrument a redis call" do
+              Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+              expect(Appsignal::Transaction.current).to receive(:start_event)
+                .at_least(:once)
+              expect(Appsignal::Transaction.current).to receive(:finish_event)
+                .at_least(:once)
+                .with("query.redis", :stub_id, "get ?", 0)
 
-          client = Redis::Client.new
-          expect(client.process([[:get, "key"]])).to eq 1
+              client = Redis::Client.new
+              expect(client.process([[:get, "key"]])).to eql(:stub_process)
+            end
+          end
         end
       end