appsignal 4.0.5 → 4.0.7

data/spec/lib/appsignal/capistrano2_spec.rb

@@ -1,227 +0,0 @@
-if DependencyHelper.capistrano2_present?
-  require "capistrano"
-  require "capistrano/configuration"
-  require "appsignal/capistrano"
-
-  describe "Capistrano 2 integration" do
-    let(:out_stream) { std_stream }
-    let(:output) { out_stream.read }
-    let(:config) { build_config }
-    let(:capistrano_config) do
-      Capistrano::Configuration.new.tap do |c|
-        c.set(:rails_env, "production")
-        c.set(:repository, "main")
-        c.set(:deploy_to, "/home/username/app")
-        c.set(:current_release, "")
-        c.set(:current_revision, "503ce0923ed177a3ce000005")
-        c.dry_run = false
-      end
-    end
-    before { Appsignal::Integrations::Capistrano.tasks(capistrano_config) }
-
-    def run
-      capture_stdout(out_stream) do
-        capistrano_config.find_and_execute_task("appsignal:deploy")
-      end
-    end
-
-    it "has a deploy task" do
-      expect(capistrano_config.find_task("appsignal:deploy")).to_not be_nil
-    end
-
-    describe "appsignal:deploy task" do
-      before do
-        ENV["USER"] = "batman"
-        ENV["PWD"] = project_fixture_path
-      end
-
-      context "config" do
-        before do
-          capistrano_config.dry_run = true
-        end
-
-        context "when appsignal_config is available" do
-          before do
-            capistrano_config.set(
-              :appsignal_config,
-              :name => "AppName",
-              :active => true,
-              :push_api_key => "abc"
-            )
-          end
-
-          it "overrides the default config with the custom appsignal_config" do
-            original_new = Appsignal::Marker.method(:new)
-
-            expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-              expect(given_config[:name]).to eq("AppName")
-              original_new.call(data, given_config)
-            end
-
-            run
-          end
-
-          context "when rack_env is used instead of rails_env" do
-            before do
-              capistrano_config.unset(:rails_env)
-              capistrano_config.set(:rack_env, "rack_production")
-            end
-
-            it "uses the rack_env as the env" do
-              original_new = Appsignal::Marker.method(:new)
-
-              expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-                expect(given_config.env).to eq("rack_production")
-                original_new.call(data, given_config)
-              end
-
-              run
-            end
-          end
-
-          context "when stage is used instead of rack_env / rails_env" do
-            before do
-              capistrano_config.unset(:rails_env)
-              capistrano_config.set(:stage, "stage_production")
-            end
-
-            it "uses the stage as the env" do
-              original_new = Appsignal::Marker.method(:new)
-
-              expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-                expect(given_config.env).to eq("stage_production")
-                original_new.call(data, given_config)
-              end
-
-              run
-            end
-          end
-
-          context "when appsignal_env is set" do
-            before do
-              capistrano_config.set(:rack_env, "rack_production")
-              capistrano_config.set(:stage, "stage_production")
-              capistrano_config.set(:appsignal_env, "appsignal_production")
-            end
-
-            it "uses the appsignal_env as the env" do
-              original_new = Appsignal::Marker.method(:new)
-
-              expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-                expect(given_config.env).to eq("appsignal_production")
-                original_new.call(data, given_config)
-              end
-
-              run
-            end
-          end
-
-          context "with invalid config" do
-            before do
-              capistrano_config.set(:appsignal_config, :push_api_key => nil)
-            end
-
-            it "does not continue with invalid config" do
-              run
-              expect(output).to include \
-                "Not notifying of deploy, config is not active for environment: production"
-            end
-          end
-        end
-      end
-
-      describe "markers" do
-        def stub_marker_request(data = {})
-          stub_api_request config, "markers", marker_data.merge(data)
-        end
-
-        let(:marker_data) do
-          {
-            :revision => "503ce0923ed177a3ce000005",
-            :user => "batman"
-          }
-        end
-
-        context "when active for this environment" do
-          it "transmits marker" do
-            stub_marker_request.to_return(:status => 200)
-            run
-
-            expect(output).to include \
-              "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005," \
-                " user: batman",
-              "AppSignal has been notified of this deploy!"
-          end
-
-          context "with overridden revision" do
-            before do
-              capistrano_config.set(:appsignal_revision, "abc123")
-              stub_marker_request(:revision => "abc123").to_return(:status => 200)
-              run
-            end
-
-            it "transmits the overridden revision" do
-              expect(output).to include \
-                "Notifying AppSignal of deploy with: revision: abc123, user: batman",
-                "AppSignal has been notified of this deploy!"
-            end
-          end
-
-          context "with overridden deploy user" do
-            before do
-              capistrano_config.set(:appsignal_user, "robin")
-              stub_marker_request(:user => "robin").to_return(:status => 200)
-              run
-            end
-
-            it "transmits the overridden deploy user" do
-              expect(output).to include \
-                "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005," \
-                  " user: robin",
-                "AppSignal has been notified of this deploy!"
-            end
-          end
-
-          context "with failed request" do
-            before do
-              stub_marker_request.to_return(:status => 500)
-              run
-            end
-
-            it "does not transmit marker" do
-              expect(output).to include \
-                "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005," \
-                  " user: batman",
-                "Something went wrong while trying to notify AppSignal:"
-              expect(output).to_not include "AppSignal has been notified of this deploy!"
-            end
-          end
-
-          context "when dry run" do
-            before do
-              capistrano_config.dry_run = true
-              run
-            end
-
-            it "does not transmit marker" do
-              expect(output).to include \
-                "Dry run: AppSignal deploy marker not actually sent."
-            end
-          end
-        end
-
-        context "when not active for this environment" do
-          before do
-            capistrano_config.set(:rails_env, "nonsense")
-            run
-          end
-
-          it "does not transmit marker" do
-            expect(output).to include \
-              "Not notifying of deploy, config is not active for environment: nonsense"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/appsignal/capistrano3_spec.rb

@@ -1,284 +0,0 @@
-if DependencyHelper.capistrano3_present?
-  require "capistrano/all"
-  require "capistrano/deploy"
-  require "appsignal/capistrano"
-
-  describe "Capistrano 3 integration" do
-    let(:capistrano) { Class.new.extend(Capistrano::DSL) }
-    let(:env) { :production }
-    let(:options) { {} }
-    let(:config) { build_config(:env => env, :options => options) }
-    let(:out_stream) { std_stream }
-    let(:output) { out_stream.read }
-    let(:logger) { Logger.new(out_stream) }
-    let!(:capistrano_config) do
-      Capistrano::Configuration.reset!
-      Capistrano::Configuration.env.tap do |c|
-        c.set(:log_level, :error)
-        c.set(:logger, logger)
-        c.set(:rails_env, "production")
-        c.set(:repository, "main")
-        c.set(:deploy_to, "/home/username/app")
-        c.set(:current_release, "")
-        c.set(:current_revision, "503ce0923ed177a3ce000005")
-      end
-    end
-    let(:marker_data) do
-      {
-        :revision => "503ce0923ed177a3ce000005",
-        :user => "batman"
-      }
-    end
-    before { Rake::Task["appsignal:deploy"].reenable }
-
-    def run
-      capture_std_streams(out_stream, out_stream) do
-        capistrano.invoke("appsignal:deploy")
-      end
-    end
-
-    it "should have a deploy task" do
-      expect(Rake::Task.task_defined?("appsignal:deploy")).to be_truthy
-    end
-
-    describe "appsignal:deploy task" do
-      before do
-        ENV["USER"] = "batman"
-      end
-      around do |example|
-        Dir.chdir project_fixture_path do
-          example.run
-        end
-      end
-
-      context "config" do
-        let(:options) { { :name => "AppName" } }
-        before do
-          capistrano_config.set(
-            :appsignal_config,
-            :name => "AppName",
-            :active => true,
-            :push_api_key => "abc"
-          )
-        end
-
-        context "when rack_env is the only env set" do
-          let(:env) { "rack_production" }
-          before do
-            capistrano_config.delete(:rails_env)
-            capistrano_config.set(:rack_env, env)
-          end
-
-          it "uses the rack_env as the env" do
-            stub_marker_request(
-              :environment => env.to_s,
-              :name => "AppName",
-              :push_api_key => "abc"
-            ).to_return(:status => 200)
-            original_new = Appsignal::Marker.method(:new)
-
-            expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-              expect(given_config.env).to eq("rack_production")
-              original_new.call(data, given_config)
-            end
-
-            run
-          end
-        end
-
-        context "when stage is set" do
-          let(:env) { "stage_production" }
-          before do
-            capistrano_config.set(:rack_env, "rack_production")
-            capistrano_config.set(:stage, env)
-          end
-
-          it "prefers the Capistrano stage rather than rails_env and rack_env" do
-            stub_marker_request(
-              :environment => env.to_s,
-              :name => "AppName",
-              :push_api_key => "abc"
-            ).to_return(:status => 200)
-            original_new = Appsignal::Marker.method(:new)
-
-            expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-              expect(given_config.env).to eq("stage_production")
-              original_new.call(data, given_config)
-            end
-
-            run
-          end
-        end
-
-        context "when `appsignal_config` is set" do
-          before do
-            ENV["APPSIGNAL_APP_NAME"] = "EnvName"
-            capistrano_config.set(:appsignal_config, :name => "CapName")
-          end
-
-          it "overrides the default config with the custom appsignal_config" do
-            stub_marker_request(
-              :environment => env.to_s,
-              :name => "CapName",
-              :push_api_key => "abc"
-            ).to_return(:status => 200)
-            original_new = Appsignal::Marker.method(:new)
-
-            expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-              expect(given_config[:name]).to eq("CapName")
-              original_new.call(data, given_config)
-            end
-
-            run
-          end
-
-          context "with invalid config" do
-            before do
-              capistrano_config.set(:appsignal_config, :push_api_key => nil)
-            end
-
-            it "does not continue with invalid config" do
-              run
-              expect(output).to include \
-                "Not notifying of deploy, config is not active for environment: production"
-            end
-          end
-        end
-
-        context "when `appsignal_env` is set" do
-          let(:env) { "appsignal_production" }
-          before do
-            capistrano_config.set(:rack_env, "rack_production")
-            capistrano_config.set(:stage, "stage_production")
-            capistrano_config.set(:appsignal_env, env)
-          end
-
-          it "prefers the appsignal_env rather than stage, rails_env and rack_env" do
-            stub_marker_request(
-              :environment => env.to_s,
-              :name => "AppName",
-              :push_api_key => "abc"
-            ).to_return(:status => 200)
-            original_new = Appsignal::Marker.method(:new)
-
-            expect(Appsignal::Marker).to receive(:new) do |data, given_config|
-              expect(given_config.env).to eq("appsignal_production")
-              original_new.call(data, given_config)
-            end
-
-            run
-          end
-        end
-      end
-
-      describe "markers" do
-        context "when active for this environment" do
-          it "transmits marker" do
-            stub_marker_request(
-              :environment => env.to_s,
-              :name => "TestApp",
-              :push_api_key => "abc"
-            ).to_return(:status => 200)
-            run
-
-            expect(output).to include \
-              "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, " \
-                "user: batman",
-              "AppSignal has been notified of this deploy!"
-          end
-
-          context "with overridden revision" do
-            before do
-              capistrano_config.set(:appsignal_revision, "abc123")
-              stub_marker_request(
-                {
-                  :environment => env.to_s,
-                  :name => "TestApp",
-                  :push_api_key => "abc"
-                },
-                :revision => "abc123"
-              ).to_return(:status => 200)
-              run
-            end
-
-            it "transmits the overridden revision" do
-              expect(output).to include \
-                "Notifying AppSignal of deploy with: revision: abc123, user: batman",
-                "AppSignal has been notified of this deploy!"
-            end
-          end
-
-          context "with overridden deploy user" do
-            before do
-              capistrano_config.set(:appsignal_user, "robin")
-              stub_marker_request(
-                {
-                  :environment => env.to_s,
-                  :name => "TestApp",
-                  :push_api_key => "abc"
-                },
-                :user => "robin"
-              ).to_return(:status => 200)
-              run
-            end
-
-            it "transmits the overridden deploy user" do
-              expect(output).to include \
-                "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, " \
-                  "user: robin",
-                "AppSignal has been notified of this deploy!"
-            end
-          end
-
-          if Gem::Version.new(Capistrano::VERSION) >= Gem::Version.new("3.5.0")
-            context "when dry run" do
-              before do
-                expect(capistrano_config).to receive(:dry_run?).and_return(true)
-                run
-              end
-
-              it "does not transmit the marker" do
-                expect(output).to include "Dry run: AppSignal deploy marker not actually sent."
-              end
-            end
-          end
-
-          context "with failed request" do
-            before do
-              stub_marker_request(
-                :environment => env.to_s,
-                :name => "TestApp",
-                :push_api_key => "abc"
-              ).to_return(:status => 500)
-              run
-            end
-
-            it "does not transmit marker" do
-              expect(output).to include \
-                "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, " \
-                  "user: batman",
-                "Something went wrong while trying to notify AppSignal:"
-              expect(output).to_not include "AppSignal has been notified of this deploy!"
-            end
-          end
-        end
-
-        context "when not active for this environment" do
-          before do
-            capistrano_config.set(:rails_env, "nonsense")
-            run
-          end
-
-          it "should not send deploy marker" do
-            expect(output).to include \
-              "Not notifying of deploy, config is not active for environment: nonsense"
-          end
-        end
-      end
-    end
-  end
-
-  def stub_marker_request(config = {}, data = {})
-    stub_api_request config, "markers", marker_data.merge(data)
-  end
-end

data/spec/lib/appsignal/check_in/cron_spec.rb

@@ -1,202 +0,0 @@
-describe Appsignal::CheckIn::Cron do
-  let(:log_stream) { std_stream }
-  let(:logs) { log_contents(log_stream) }
-  let(:appsignal_options) { {} }
-  let(:config) { project_fixture_config }
-  let(:cron_checkin) { described_class.new(:identifier => "cron-checkin-name") }
-  let(:transmitter) { Appsignal::Transmitter.new("https://checkin-endpoint.invalid") }
-  let(:scheduler) { Appsignal::CheckIn::Scheduler.new }
-
-  before do
-    start_agent(
-      :options => appsignal_options,
-      :internal_logger => test_logger(log_stream)
-    )
-    allow(Appsignal::CheckIn).to receive(:scheduler).and_return(scheduler)
-    allow(Appsignal::CheckIn).to receive(:transmitter).and_return(transmitter)
-  end
-  after { stop_scheduler }
-
-  def stop_scheduler
-    scheduler.stop
-  end
-
-  describe "when Appsignal is not active" do
-    let(:appsignal_options) { { :active => false } }
-
-    it "does not transmit any events" do
-      expect(Appsignal).to_not be_started
-
-      cron_checkin.start
-      cron_checkin.finish
-      stop_scheduler
-
-      expect(logs).to contains_log(
-        :debug,
-        /Cannot transmit cron check-in `cron-checkin-name` start event .+: AppSignal is not active/
-      )
-      expect(logs).to contains_log(
-        :debug,
-        /Cannot transmit cron check-in `cron-checkin-name` finish event .+: AppSignal is not active/
-      )
-    end
-  end
-
-  describe "when AppSignal is stopped" do
-    it "does not transmit any events" do
-      Appsignal.stop
-
-      cron_checkin.start
-      cron_checkin.finish
-
-      expect(logs).to contains_log(
-        :debug,
-        "Cannot transmit cron check-in `cron-checkin-name` start event"
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Cannot transmit cron check-in `cron-checkin-name` finish event"
-      )
-    end
-  end
-
-  describe "#start" do
-    it "sends a cron check-in start" do
-      cron_checkin.start
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "start",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "200", nil))
-
-      scheduler.stop
-
-      expect(logs).to_not contains_log(:error)
-      expect(logs).to contains_log(
-        :debug,
-        "Scheduling cron check-in `cron-checkin-name` start event"
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Transmitted cron check-in `cron-checkin-name` start event"
-      )
-    end
-
-    it "logs an error if it fails" do
-      cron_checkin.start
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "start",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "499", nil))
-
-      scheduler.stop
-
-      expect(logs).to contains_log(
-        :debug,
-        "Scheduling cron check-in `cron-checkin-name` start event"
-      )
-      expect(logs).to contains_log(
-        :error,
-        /Failed to transmit cron check-in `cron-checkin-name` start event .+: 499 status code/
-      )
-    end
-  end
-
-  describe "#finish" do
-    it "sends a cron check-in finish" do
-      cron_checkin.finish
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "finish",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "200", nil))
-
-      scheduler.stop
-      expect(logs).to_not contains_log(:error)
-      expect(logs).to contains_log(
-        :debug,
-        "Scheduling cron check-in `cron-checkin-name` finish event"
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Transmitted cron check-in `cron-checkin-name` finish event"
-      )
-    end
-
-    it "logs an error if it fails" do
-      cron_checkin.finish
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "finish",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "499", nil))
-
-      scheduler.stop
-
-      expect(logs).to contains_log(
-        :debug,
-        "Scheduling cron check-in `cron-checkin-name` finish event"
-      )
-      expect(logs).to contains_log(
-        :error,
-        /Failed to transmit cron check-in `cron-checkin-name` finish event .+: 499 status code/
-      )
-    end
-  end
-
-  describe ".cron" do
-    describe "when a block is given" do
-      it "sends a cron check-in start and finish and return the block output" do
-        expect(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "start",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
-
-        expect(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
-
-        output = Appsignal::CheckIn.cron("cron-checkin-with-block") { "output" }
-        expect(output).to eq("output")
-      end
-
-      it "does not send a cron check-in finish event when an error is raised" do
-        expect(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "start",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
-
-        expect(scheduler).not_to receive(:schedule).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 "only sends a cron check-in finish event" do
-        expect(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-without-block",
-          :check_in_type => "cron"
-        ))
-
-        Appsignal::CheckIn.cron("cron-checkin-without-block")
-      end
-    end
-  end
-end