appsignal 3.12.5-java → 3.13.0-java

data/spec/lib/appsignal/check_in_spec.rb

@@ -0,0 +1,342 @@
+describe Appsignal::Heartbeat do
+  let(:err_stream) { std_stream }
+
+  after do
+    Appsignal.instance_variable_set(:@heartbeat_constant_deprecation_warning_emitted, false)
+  end
+
+  it "returns the Cron constant calling the Heartbeat constant" do
+    silence { expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron) }
+  end
+
+  it "prints a deprecation warning to STDERR" do
+    capture_std_streams(std_stream, err_stream) do
+      expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The constant Appsignal::Heartbeat has been deprecated.")
+  end
+
+  it "does not print a deprecation warning to STDERR more than once" do
+    capture_std_streams(std_stream, err_stream) do
+      expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The constant Appsignal::Heartbeat has been deprecated.")
+
+    err_stream.truncate(0)
+
+    capture_std_streams(std_stream, err_stream) do
+      expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+    end
+
+    expect(err_stream.read)
+      .not_to include("appsignal WARNING: The constant Appsignal::Heartbeat has been deprecated.")
+  end
+
+  it "logs a warning" do
+    logs =
+      capture_logs do
+        silence do
+          expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The constant Appsignal::Heartbeat has been deprecated."
+    )
+  end
+
+  it "does not log a warning more than once" do
+    logs =
+      capture_logs do
+        silence do
+          expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The constant Appsignal::Heartbeat has been deprecated."
+    )
+
+    logs =
+      capture_logs do
+        silence do
+          expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+        end
+      end
+
+    expect(logs).not_to contains_log(
+      :warn,
+      "The constant Appsignal::Heartbeat has been deprecated."
+    )
+  end
+end
+
+describe "Appsignal.heartbeat" do
+  let(:err_stream) { std_stream }
+
+  before do
+    Appsignal.instance_variable_set(:@heartbeat_helper_deprecation_warning_emitted, false)
+  end
+
+  it "should forward the call to Appsignal::CheckIn.cron" do
+    expect(Appsignal::CheckIn).to receive(:cron).with("heartbeat-name")
+    expect do
+      Appsignal.heartbeat("heartbeat-name")
+    end.not_to raise_error
+
+    block = proc { 42 }
+    expect(Appsignal::CheckIn).to receive(:cron).with("heartbeat-name") do |&given_block|
+      expect(given_block).to be(block)
+    end.and_return("output")
+    expect(Appsignal.heartbeat("heartbeat-name", &block)).to eq("output")
+  end
+
+  it "prints a deprecation warning to STDERR" do
+    capture_std_streams(std_stream, err_stream) do
+      Appsignal.heartbeat("heartbeat-name")
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The helper Appsignal.heartbeat has been deprecated.")
+  end
+
+  it "does not print a deprecation warning to STDERR more than once" do
+    capture_std_streams(std_stream, err_stream) do
+      Appsignal.heartbeat("heartbeat-name")
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The helper Appsignal.heartbeat has been deprecated.")
+
+    err_stream.truncate(0)
+
+    capture_std_streams(std_stream, err_stream) do
+      Appsignal.heartbeat("heartbeat-name")
+    end
+
+    expect(err_stream.read)
+      .not_to include("appsignal WARNING: The helper Appsignal.heartbeat has been deprecated.")
+  end
+
+  it "logs a warning" do
+    logs =
+      capture_logs do
+        silence do
+          Appsignal.heartbeat("heartbeat-name")
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The helper Appsignal.heartbeat has been deprecated."
+    )
+  end
+
+  it "does not log a warning more than once" do
+    logs =
+      capture_logs do
+        silence do
+          Appsignal.heartbeat("heartbeat-name")
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The helper Appsignal.heartbeat has been deprecated."
+    )
+
+    logs =
+      capture_logs do
+        silence do
+          Appsignal.heartbeat("heartbeat-name")
+        end
+      end
+
+    expect(logs).not_to contains_log(
+      :warn,
+      "The helper Appsignal.heartbeat has been deprecated."
+    )
+  end
+end
+
+describe Appsignal::CheckIn::Cron do
+  let(:config) { project_fixture_config }
+  let(:cron_checkin) { described_class.new(:name => "cron-checkin-name") }
+  let(:transmitter) { Appsignal::Transmitter.new("http://cron_checkins/", config) }
+
+  before(:each) do
+    allow(Appsignal).to receive(:active?).and_return(true)
+    config.logger = Logger.new(StringIO.new)
+    allow(Appsignal::CheckIn::Cron).to receive(:transmitter).and_return(transmitter)
+  end
+
+  describe "when Appsignal is not active" do
+    it "should not transmit any events" do
+      allow(Appsignal).to receive(:active?).and_return(false)
+      expect(transmitter).not_to receive(:transmit)
+
+      cron_checkin.start
+      cron_checkin.finish
+    end
+  end
+
+  describe "#start" do
+    it "should send a cron check-in start" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "start",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
+
+      expect(Appsignal.internal_logger).to receive(:debug).with(
+        "Transmitted cron check-in `cron-checkin-name` (#{cron_checkin.digest}) start event"
+      )
+      expect(Appsignal.internal_logger).not_to receive(:error)
+
+      cron_checkin.start
+    end
+
+    it "should log an error if it fails" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "start",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
+
+      expect(Appsignal.internal_logger).not_to receive(:debug)
+      expect(Appsignal.internal_logger).to receive(:error).with(
+        "Failed to transmit cron check-in start event: status code was 499"
+      )
+
+      cron_checkin.start
+    end
+  end
+
+  describe "#finish" do
+    it "should send a cron check-in finish" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "finish",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
+
+      expect(Appsignal.internal_logger).to receive(:debug).with(
+        "Transmitted cron check-in `cron-checkin-name` (#{cron_checkin.digest}) finish event"
+      )
+      expect(Appsignal.internal_logger).not_to receive(:error)
+
+      cron_checkin.finish
+    end
+
+    it "should log an error if it fails" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "finish",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
+
+      expect(Appsignal.internal_logger).not_to receive(:debug)
+      expect(Appsignal.internal_logger).to receive(:error).with(
+        "Failed to transmit cron check-in finish event: status code was 499"
+      )
+
+      cron_checkin.finish
+    end
+  end
+
+  describe ".cron" do
+    describe "when a block is given" do
+      it "should send a cron check-in start and finish and return the block output" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "start",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        output = Appsignal::CheckIn.cron("cron-checkin-with-block") { "output" }
+        expect(output).to eq("output")
+      end
+
+      it "should not send a cron check-in finish event when an error is raised" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "start",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        expect(transmitter).not_to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        ))
+
+        expect do
+          Appsignal::CheckIn.cron("cron-checkin-with-block") { raise "error" }
+        end.to raise_error(RuntimeError, "error")
+      end
+    end
+
+    describe "when no block is given" do
+      it "should only send a cron check-in finish event" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :identifier => "cron-checkin-without-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        Appsignal::CheckIn.cron("cron-checkin-without-block")
+      end
+    end
+  end
+
+  describe "#initialize" do
+    describe "when initialised with deprecated heartbeat keyword names" do
+      let(:err_stream) { std_stream }
+
+      after do
+        described_class.instance_variable_set(:@initializer_deprecation_warning_emitted, false)
+      end
+
+      it "can be initialised" do
+        cron_checkin = described_class.new(:name => "cron-checkin-name")
+        expect(cron_checkin.identifier).to eq("cron-checkin-name")
+      end
+
+      it "logs a deprecation warning" do
+        capture_std_streams(std_stream, err_stream) do
+          expect(described_class.new(:name => "cron-checkin-name"))
+            .to be_a(Appsignal::CheckIn::Cron)
+        end
+
+        expect(err_stream.read)
+          .to include(
+            "appsignal WARNING: Passing a `name` keyword argument to " \
+              "`Appsignal::CheckIn::Cron.new` is deprecated."
+          )
+      end
+    end
+
+    it "can be initialised with cron check-in keyword names" do
+      cron_checkin = described_class.new(:identifier => "cron-checkin-name")
+      expect(cron_checkin.identifier).to eq("cron-checkin-name")
+    end
+
+    it "raises an error when no identifier is given" do
+      expect do
+        described_class.new
+      end.to raise_error(ArgumentError, "missing keyword: :identifier")
+    end
+  end
+end

data/spec/lib/appsignal/cli/install_spec.rb

@@ -30,7 +30,7 @@ describe Appsignal::CLI::Install do
 
   define :include_complete_install do
     match do |actual|
-      actual.include?("AppSignal installation complete")
+      actual.include?("Please return to your browser and follow the instructions.")
     end
   end
 
@@ -105,7 +105,7 @@ describe Appsignal::CLI::Install do
         run
 
         expect(output).to include "Problem encountered:",
-          "No push API key entered"
+          "No Push API key entered"
       end
     end
 
@@ -120,7 +120,7 @@ describe Appsignal::CLI::Install do
           choose_environment_config
           run
 
-          expect(output).to include("Validating API key...", "API key valid")
+          expect(output).to include("Validating Push API key...", "Push API key valid")
         end
       end
 
@@ -129,7 +129,7 @@ describe Appsignal::CLI::Install do
 
         it "prints an error" do
           run
-          expect(output).to include "API key 'my_key' is not valid"
+          expect(output).to include "Push API key 'my_key' is not valid"
         end
       end
 
@@ -140,7 +140,7 @@ describe Appsignal::CLI::Install do
 
         it "prints an error" do
           run
-          expect(output).to include "There was an error validating your API key"
+          expect(output).to include "There was an error validating your Push API key"
         end
       end
     end
@@ -419,14 +419,16 @@ describe Appsignal::CLI::Install do
           expect(File.exist?(File.join(config_dir, "application.rb"))).to eql(false)
         end
 
-        it "fails the installation" do
+        it "falls back on the unknown framework installation" do
+          enter_app_name app_name
+          choose_environment_config
           run
 
-          expect(output).to include("We could not detect which framework you are using.")
+          expect(output)
+            .to include("\e[31mWarning: We could not detect which framework you are using\e[0m")
           expect(output).to_not include("Installing for Ruby on Rails")
+          expect(output).to include_env_push_api_key(push_api_key)
           expect(output).to include_complete_install
-
-          expect(File.exist?(config_file_path)).to be(false)
         end
       end
 
@@ -465,8 +467,10 @@ describe Appsignal::CLI::Install do
         let(:installation_instructions) do
           [
             "Installing for Sinatra",
-            "Sinatra requires some manual configuration.",
-            "require 'appsignal/integrations/sinatra'",
+            "Sinatra apps requires some manual setup.",
+            %(require "appsignal"),
+            "Appsignal.load(:sinatra)",
+            "Appsignal.start",
             "https://docs.appsignal.com/ruby/integrations/sinatra.html"
           ]
         end
@@ -533,7 +537,10 @@ describe Appsignal::CLI::Install do
         let(:installation_instructions) do
           [
             "Installing for Padrino",
-            "Padrino requires some manual configuration.",
+            "Padrino apps requires some manual setup.",
+            %(require "appsignal"),
+            "Appsignal.load(:padrino)",
+            "Appsignal.start",
             "https://docs.appsignal.com/ruby/integrations/padrino.html"
           ]
         end
@@ -600,7 +607,7 @@ describe Appsignal::CLI::Install do
         let(:installation_instructions) do
           [
             "Installing for Grape",
-            "Manual Grape configuration needed",
+            "Grape apps require some manual setup.",
             "https://docs.appsignal.com/ruby/integrations/grape.html"
           ]
         end
@@ -624,6 +631,7 @@ describe Appsignal::CLI::Install do
           it "completes the installation" do
             run
 
+            puts output
             expect(output).to include(*installation_instructions)
             expect(output).to include_complete_install
           end
@@ -667,7 +675,10 @@ describe Appsignal::CLI::Install do
         let(:installation_instructions) do
           [
             "Installing for Hanami",
-            "Hanami requires some manual configuration.",
+            "Hanami apps requires some manual setup.",
+            %(require "appsignal"),
+            "Appsignal.load(:hanami)",
+            "Appsignal.start",
             "https://docs.appsignal.com/ruby/integrations/hanami.html"
           ]
         end
@@ -728,47 +739,109 @@ describe Appsignal::CLI::Install do
       !hanami2_present?
     context "with unknown framework" do
       let(:push_api_key) { "my_key" }
+      let(:app_name) { "Test app" }
 
-      it_behaves_like "windows installation"
       it_behaves_like "push_api_key validation"
-      it_behaves_like "demo data"
+      it_behaves_like "requires an application name"
+
+      describe "unknown framework specific tests" do
+        let(:installation_instructions) do
+          [
+            "Installing",
+            "\e[31mWarning: We could not detect which framework you are using\e[0m",
+            "Some manual installation is most likely required.",
+            "https://docs.appsignal.com/ruby/integrations.html"
+          ]
+        end
+        before { enter_app_name app_name }
 
-      context "without color options" do
-        let(:options) { {} }
+        describe "configuration with environment variables" do
+          before { choose_environment_config }
 
-        it "prints the instructions in color" do
-          run
-          expect(output).to have_colorized_text(:green, "## Starting AppSignal Installer      ##")
+          it_behaves_like "windows installation"
+          it_behaves_like "capistrano install"
+          it_behaves_like "demo data"
+
+          it "prints environment variables" do
+            run
+
+            expect(output).to include_env_push_api_key(push_api_key)
+            expect(output).to include_env_app_name(app_name)
+          end
+
+          it "completes the installation" do
+            run
+
+            expect(output).to include(*installation_instructions)
+            expect(output).to include_complete_install
+          end
         end
-      end
 
-      context "with --color option" do
-        let(:options) { { "color" => nil } }
+        describe "configure with a configuration file" do
+          before { choose_config_file }
 
-        it "prints the instructions in color" do
-          run
-          expect(output).to have_colorized_text(:green, "## Starting AppSignal Installer      ##")
+          it_behaves_like "windows installation"
+          it_behaves_like "capistrano install"
+          it_behaves_like "demo data"
+
+          it "writes configuration to file" do
+            run
+            expect(output).to include_file_config
+            expect(config_file).to configure_app_name(app_name)
+            expect(config_file).to configure_push_api_key(push_api_key)
+            expect(config_file).to configure_environment("development")
+            expect(config_file).to configure_environment("staging")
+            expect(config_file).to configure_environment("production")
+          end
+
+          it "completes the installation" do
+            run
+
+            expect(output).to include(*installation_instructions)
+            expect(output).to include_complete_install
+          end
         end
       end
 
-      context "with --no-color option" do
-        let(:options) { { "no-color" => nil } }
+      describe "color flag" do
+        before do
+          enter_app_name "Test app"
+          choose_environment_config
+        end
 
-        it "prints the instructions without special colors" do
-          run
-          expect(output).to include("Starting AppSignal Installer")
-          expect(output).to_not have_color_markers
+        context "without color options" do
+          let(:options) { {} }
+
+          it "prints the instructions in color" do
+            run
+            expect(output).to have_colorized_text(
+              :green,
+              "## Starting AppSignal Installer           ##"
+            )
+          end
         end
-      end
 
-      it "prints a message about unknown framework" do
-        run
+        context "with --color option" do
+          let(:options) { { "color" => nil } }
 
-        expect(output).to include \
-          "\e[31mWarning:\e[0m We could not detect which framework you are using."
-        expect(output).to_not include_env_push_api_key
-        expect(output).to_not include_env_app_name
-        expect(File.exist?(config_file_path)).to be_falsy
+          it "prints the instructions in color" do
+            run
+            expect(output).to have_colorized_text(
+              :green,
+              "## Starting AppSignal Installer           ##"
+            )
+          end
+        end
+
+        context "with --no-color option" do
+          let(:options) { { "no-color" => nil } }
+
+          it "prints the instructions without special colors" do
+            run
+            expect(output).to include("## Starting AppSignal Installer           ##")
+            expect(output).to_not have_color_markers
+          end
+        end
       end
     end
   end

data/spec/lib/appsignal/config_spec.rb

@@ -1439,5 +1439,29 @@ describe Appsignal::Config do
 
       expect(dsl.cpu_count).to eq(1.0)
     end
+
+    describe "#app_path=" do
+      it "prints a deprecation warning" do
+        err_stream = std_stream
+        capture_std_streams(std_stream, err_stream) do
+          dsl.app_path = "foo"
+        end
+
+        expect(err_stream.read).to include(
+          "appsignal WARNING: The `Appsignal.configure`'s `app_path=` writer is deprecated"
+        )
+      end
+
+      it "logs a deprecation warning" do
+        logs = capture_logs do
+          silence { dsl.app_path = "foo" }
+        end
+
+        expect(logs).to contains_log(
+          :warn,
+          "The `Appsignal.configure`'s `app_path=` writer is deprecated"
+        )
+      end
+    end
   end
 end

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

@@ -67,27 +67,6 @@ if DependencyHelper.http_present?
       end
     end
 
-    context "with an HTTP exception" do
-      let(:error) { ExampleException.new("oh no!") }
-
-      it "reports the exception and re-raises it" do
-        stub_request(:get, "https://www.google.com").and_raise(error)
-
-        expect do
-          HTTP.get("https://www.google.com")
-        end.to raise_error(ExampleException)
-
-        expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-        expect(transaction).to include_event(
-          "body" => "",
-          "body_format" => Appsignal::EventFormatter::DEFAULT,
-          "name" => "request.http_rb",
-          "title" => "GET https://www.google.com"
-        )
-        expect(transaction).to have_error(error.class.name, error.message)
-      end
-    end
-
     context "with various URI objects" do
       it "parses an object responding to #to_s" do
         request_uri = Struct.new(:uri) do