appsignal 4.0.6 → 4.0.8

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

@@ -1,557 +0,0 @@
-describe Appsignal::CheckIn::Scheduler do
-  include WaitForHelper
-  include TakeAtMostHelper
-
-  let(:log_stream) { std_stream }
-  let(:logs) { log_contents(log_stream) }
-  let(:appsignal_options) { {} }
-  let(:scheduler) { Appsignal::CheckIn.scheduler }
-
-  before do
-    start_agent(:options => appsignal_options, :internal_logger => test_logger(log_stream))
-    # Shorten debounce intervals to make the tests run faster.
-    stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 0.1)
-    stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 0.1)
-  end
-
-  after do
-    scheduler.stop
-  end
-
-  describe "when no event is sent" do
-    it "does not start a thread" do
-      expect(scheduler.thread).to be_nil
-    end
-
-    it "does not schedule a debounce" do
-      expect(scheduler.waker).to be_nil
-    end
-
-    it "can be stopped" do
-      # Set all debounce intervals to 10 seconds, to make the assertion
-      # fail if it waits for the debounce -- this ensures that what is being
-      # tested is that no debounces are awaited when stopping the scheduler.
-      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
-      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
-
-      take_at_most(0.1) do
-        expect { scheduler.stop }.not_to raise_error
-      end
-    end
-
-    it "can be stopped more than once" do
-      # Set all debounce intervals to 10 seconds, to make the assertion
-      # fail if it waits for the debounce -- this ensures that what is being
-      # tested is that no debounces are awaited when stopping the scheduler.
-      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
-      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
-
-      take_at_most(0.1) do
-        expect { scheduler.stop }.not_to raise_error
-        expect { scheduler.stop }.not_to raise_error
-      end
-    end
-
-    it "closes the queue when stopped" do
-      scheduler.stop
-      expect(scheduler.queue.closed?).to be(true)
-    end
-  end
-
-  describe "when an event is sent" do
-    it "starts a thread" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-      Appsignal::CheckIn.cron("test")
-      expect(scheduler.thread).to be_a(Thread)
-    end
-
-    it "schedules a debounce" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-      Appsignal::CheckIn.cron("test")
-      expect(scheduler.waker).to be_a(Thread)
-    end
-
-    it "schedules the event to be transmitted" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-
-      expect(scheduler.events).to be_empty
-
-      Appsignal::CheckIn.cron("test")
-
-      expect(scheduler.events).not_to be_empty
-
-      wait_for("the event to be transmitted") { scheduler.transmitted == 1 }
-
-      expect(scheduler.events).to be_empty
-
-      expect(logs).to contains_log(:debug, "Scheduling cron check-in `test` finish event")
-      expect(logs).to contains_log(:debug, "Transmitted cron check-in `test` finish event")
-    end
-
-    it "waits for the event to be transmitted when stopped" do
-      # Set all debounce intervals to 10 seconds, to make the test
-      # fail if it waits for the debounce -- this ensures that what is being
-      # tested is that the events are transmitted immediately when the
-      # scheduler is stopped, without waiting for any debounce.
-      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
-      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
-
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-
-      Appsignal::CheckIn.cron("test")
-
-      expect(scheduler.events).not_to be_empty
-
-      take_at_most(0.1) do
-        expect { scheduler.stop }.not_to raise_error
-      end
-
-      # Check that the thread wasn't killed before the transmission was
-      # completed.
-      expect(scheduler.transmitted).to eq(1)
-
-      expect(scheduler.events).to be_empty
-
-      expect(logs).to contains_log(:debug, "Scheduling cron check-in `test` finish event")
-      expect(logs).to contains_log(:debug, "Transmitted cron check-in `test` finish event")
-    end
-
-    it "can be stopped more than once" do
-      # Set all debounce intervals to 10 seconds, to make the test
-      # fail if it waits for the debounce -- this ensures that what is being
-      # tested is that the events are transmitted immediately when the
-      # scheduler is stopped, without waiting for the debounce interval.
-      stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
-      stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
-
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-      Appsignal::CheckIn.cron("test")
-      take_at_most(0.1) do
-        expect { scheduler.stop }.not_to raise_error
-      end
-
-      # Check that the thread wasn't killed before the transmission was
-      # completed.
-      expect(scheduler.transmitted).to eq(1)
-
-      take_at_most(0.1) do
-        expect { scheduler.stop }.not_to raise_error
-      end
-    end
-
-    it "closes the queue when stopped" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-      Appsignal::CheckIn.cron("test")
-      scheduler.stop
-      expect(scheduler.queue.closed?).to be(true)
-    end
-
-    it "kills the thread when stopped" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-      Appsignal::CheckIn.cron("test")
-      scheduler.stop
-      expect(scheduler.thread.alive?).to be(false)
-    end
-
-    it "unschedules the debounce when stopped" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-      Appsignal::CheckIn.cron("test")
-      waker = scheduler.waker
-      scheduler.stop
-      expect(waker.alive?).to be(false)
-      expect(scheduler.waker).to be_nil
-    end
-  end
-
-  describe "when many events are sent" do
-    describe "within the short debounce interval" do
-      it "transmits all events at once" do
-        ["first", "second", "third"].map do |identifier|
-          stub_check_in_request(
-            :events => [
-              "identifier" => identifier,
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            ]
-          )
-        end
-
-        Appsignal::CheckIn.cron("first")
-        Appsignal::CheckIn.cron("second")
-        Appsignal::CheckIn.cron("third")
-
-        wait_for("the events to be transmitted") { scheduler.transmitted == 1 }
-      end
-
-      it "transmits all events at once when stopped" do
-        # Set a short debounce interval of 10 seconds, to make the final wait
-        # fail if it waits for the debounce -- this ensures that what is being
-        # tested is that the events are transmitted when the scheduler is
-        # stopped.
-        stub_const("Appsignal::CheckIn::Scheduler::INITIAL_DEBOUNCE_SECONDS", 10)
-
-        ["first", "second", "third"].map do |identifier|
-          stub_check_in_request(
-            :events => [
-              "identifier" => identifier,
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            ]
-          )
-        end
-
-        Appsignal::CheckIn.cron("first")
-        Appsignal::CheckIn.cron("second")
-        Appsignal::CheckIn.cron("third")
-
-        scheduler.stop
-
-        wait_for("the events to be transmitted") { scheduler.transmitted == 1 }
-      end
-    end
-
-    describe "further apart than the short debounce interval" do
-      it "transmits the first event and enqueues future events" do
-        stub_check_in_request(
-          :events => [
-            "identifier" => "first",
-            "kind" => "finish",
-            "check_in_type" => "cron"
-          ]
-        )
-
-        Appsignal::CheckIn.cron("first")
-
-        wait_for("the first event to be transmitted") { scheduler.transmitted == 1 }
-
-        stub_check_in_request(
-          :events => [
-            {
-              "identifier" => "second",
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            },
-            {
-              "identifier" => "third",
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            }
-          ]
-        )
-        Appsignal::CheckIn.cron("second")
-        Appsignal::CheckIn.cron("third")
-
-        expect(scheduler.events).to match(["second", "third"].map do |identifier|
-          hash_including({
-            :identifier => identifier,
-            :check_in_type => "cron",
-            :kind => "finish"
-          })
-        end)
-      end
-
-      it "transmits the other events after the debounce interval" do
-        stub_check_in_request(
-          :events => [
-            "identifier" => "first",
-            "kind" => "finish",
-            "check_in_type" => "cron"
-          ]
-        )
-        Appsignal::CheckIn.cron("first")
-
-        wait_for("the first event to be transmitted") { scheduler.transmitted == 1 }
-
-        stub_check_in_request(
-          :events => [
-            {
-              "identifier" => "second",
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            },
-            {
-              "identifier" => "third",
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            }
-          ]
-        )
-
-        Appsignal::CheckIn.cron("second")
-        Appsignal::CheckIn.cron("third")
-
-        expect(scheduler.events).to_not be_empty
-
-        wait_for("the other events to be transmitted") { scheduler.transmitted == 2 }
-
-        expect(scheduler.events).to be_empty
-
-        expect(logs).to contains_log(:debug, "Scheduling cron check-in `first` finish event")
-        expect(logs).to contains_log(:debug, "Transmitted cron check-in `first` finish event")
-        expect(logs).to contains_log(:debug, "Scheduling cron check-in `second` finish event")
-        expect(logs).to contains_log(:debug, "Scheduling cron check-in `third` finish event")
-        expect(logs).to contains_log(:debug, "Transmitted 2 check-in events")
-      end
-
-      it "transmits the other events when stopped" do
-        # Restore the original long debounce interval of 10 seconds, to make
-        # the final wait fail if it waits for the debounce -- this ensures
-        # that what is being tested is that the events are transmitted
-        # immediately when the scheduler is stopped.
-        stub_const("Appsignal::CheckIn::Scheduler::BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS", 10)
-
-        stub_check_in_request(
-          :events => [
-            "identifier" => "first",
-            "kind" => "finish",
-            "check_in_type" => "cron"
-          ]
-        )
-        Appsignal::CheckIn.cron("first")
-
-        wait_for("the event to be transmitted") { scheduler.transmitted == 1 }
-
-        stub_check_in_request(
-          :events => [
-            {
-              "identifier" => "second",
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            },
-            {
-              "identifier" => "third",
-              "kind" => "finish",
-              "check_in_type" => "cron"
-            }
-          ]
-        )
-
-        Appsignal::CheckIn.cron("second")
-        Appsignal::CheckIn.cron("third")
-
-        expect(scheduler.events).to_not be_empty
-
-        scheduler.stop
-
-        wait_for("the other events to be transmitted") { scheduler.transmitted == 2 }
-
-        expect(scheduler.events).to be_empty
-
-        expect(logs).to contains_log(:debug, "Scheduling cron check-in `first` finish event")
-        expect(logs).to contains_log(:debug, "Transmitted cron check-in `first` finish event")
-        expect(logs).to contains_log(:debug, "Scheduling cron check-in `second` finish event")
-        expect(logs).to contains_log(:debug, "Scheduling cron check-in `third` finish event")
-        expect(logs).to contains_log(:debug, "Transmitted 2 check-in events")
-      end
-    end
-  end
-
-  describe "when a similar event is sent more than once" do
-    it "only transmits one of the similar events" do
-      # We must instantiate `Appsignal::CheckIn::Cron` directly, as the
-      # `.cron` helper would use a different digest for each invocation.
-      cron = Appsignal::CheckIn::Cron.new(:identifier => "test")
-
-      stub_check_in_request(
-        :events => [
-          "identifier" => "test",
-          "kind" => "start",
-          "check_in_type" => "cron"
-        ]
-      )
-
-      cron.start
-      cron.start
-
-      wait_for("the event to be transmitted") { scheduler.transmitted == 1 }
-
-      expect(logs).to contains_log(
-        :debug,
-        "Scheduling cron check-in `test` start event (digest #{cron.digest}) to be transmitted"
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Scheduling cron check-in `test` start event (digest #{cron.digest}) to be transmitted"
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Replacing previously scheduled cron check-in `test` start event (digest #{cron.digest})"
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Transmitted cron check-in `test` start event (digest #{cron.digest})"
-      )
-    end
-  end
-
-  describe "when the scheduler is stopped" do
-    it "does not schedule any events to be transmitted" do
-      scheduler.stop
-
-      Appsignal::CheckIn.cron("test")
-
-      expect(scheduler.events).to be_empty
-
-      expect(logs).to contains_log(
-        :debug,
-        /Cannot transmit cron check-in `test` finish event .+: AppSignal is stopped/
-      )
-    end
-  end
-
-  describe "when AppSignal is not active" do
-    let(:appsignal_options) { { :active => false } }
-
-    it "does not schedule any events to be transmitted" do
-      scheduler.stop
-
-      Appsignal::CheckIn.cron("test")
-
-      expect(scheduler.events).to be_empty
-
-      expect(logs).to contains_log(
-        :debug,
-        /Cannot transmit cron check-in `test` finish event .+: AppSignal is not active/
-      )
-    end
-  end
-
-  describe "when transmitting returns a non-success response code" do
-    it "logs the error and continues" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "first",
-          "kind" => "start",
-          "check_in_type" => "cron"
-        ],
-        :response => { :status => 404 }
-      )
-      stub_check_in_request(
-        :events => [
-          "identifier" => "first",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ],
-        :response => { :status => 404 }
-      )
-
-      Appsignal::CheckIn.cron("first")
-
-      wait_for("the first event to be transmitted") { scheduler.transmitted == 1 }
-
-      stub_check_in_request(
-        :events => [
-          "identifier" => "second",
-          "kind" => "start",
-          "check_in_type" => "cron"
-        ]
-      )
-      stub_check_in_request(
-        :events => [
-          "identifier" => "second",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-
-      Appsignal::CheckIn.cron("second")
-
-      wait_for("the second event to be transmitted") { scheduler.transmitted == 2 }
-
-      expect(logs).to contains_log(
-        :error,
-        /Failed to transmit cron check-in `first` finish event .+: 404 status code/
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Transmitted cron check-in `second` finish event"
-      )
-    end
-  end
-
-  describe "when transmitting throws an error" do
-    it "logs the error and continues" do
-      stub_check_in_request(
-        :events => [
-          "identifier" => "first",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ],
-        :response => ExampleStandardError.new("Something went wrong")
-      )
-
-      Appsignal::CheckIn.cron("first")
-
-      wait_for("the first event to be transmitted") { scheduler.transmitted == 1 }
-
-      stub_check_in_request(
-        :events => [
-          "identifier" => "second",
-          "kind" => "finish",
-          "check_in_type" => "cron"
-        ]
-      )
-
-      Appsignal::CheckIn.cron("second")
-
-      wait_for("the second event to be transmitted") { scheduler.transmitted == 2 }
-
-      expect(logs).to contains_log(
-        :error,
-        /Failed to transmit cron check-in `first` finish event .+: ExampleStandardError: Something went wrong/ # rubocop:disable Layout/LineLength
-      )
-      expect(logs).to contains_log(
-        :debug,
-        "Transmitted cron check-in `second` finish event"
-      )
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require "appsignal/cli"
-
-describe Appsignal::CLI::Demo do
-  include CLIHelpers
-
-  let(:options) { {} }
-  let(:out_stream) { std_stream }
-  let(:output) { out_stream.read }
-  before(:context) { Appsignal.stop }
-
-  def run
-    run_within_dir project_fixture_path
-  end
-
-  def run_within_dir(chdir)
-    Dir.chdir chdir do
-      capture_stdout(out_stream) { run_cli("demo", options) }
-    end
-  end
-
-  context "without configuration" do
-    it "returns an error" do
-      expect { run_within_dir tmp_dir }.to raise_error(SystemExit)
-
-      expect(output).to include("Error: Unable to start the AppSignal agent")
-    end
-  end
-
-  context "with configuration" do
-    before do
-      # Ignore sleeps to speed up the test
-      allow(Appsignal::Demo).to receive(:sleep)
-    end
-    let(:options) { { :environment => "development" } }
-
-    it "calls Appsignal::Demo transmitter" do
-      expect(Appsignal::Demo).to receive(:transmit).and_return(true)
-      run
-    end
-
-    it "outputs message" do
-      run
-      expect(output).to include("Demonstration sample data sent!")
-    end
-  end
-end

data/spec/lib/appsignal/cli/diagnose/paths_spec.rb

@@ -1,16 +0,0 @@
-require "bundler/cli"
-require "bundler/cli/common"
-require "appsignal/cli/diagnose/paths"
-
-describe Appsignal::CLI::Diagnose::Paths do
-  describe "#paths" do
-    before { start_agent }
-
-    it "returns gem installation path as package_install_path" do
-      expect(described_class.new.paths[:package_install_path]).to eq(
-        :label => "AppSignal gem path",
-        :path => Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip
-      )
-    end
-  end
-end

data/spec/lib/appsignal/cli/diagnose/utils_spec.rb

@@ -1,86 +0,0 @@
-require "appsignal/cli/diagnose/utils"
-
-describe Appsignal::CLI::Diagnose::Utils do
-  describe ".username_for_uid" do
-    subject { described_class.username_for_uid(uid) }
-
-    context "when user with id exists" do
-      let(:uid) { 0 }
-
-      it "returns username" do
-        is_expected.to be_kind_of(String)
-      end
-    end
-
-    context "when user with id does not exist" do
-      let(:uid) { -1 }
-
-      it "returns nil" do
-        is_expected.to be_nil
-      end
-    end
-  end
-
-  describe ".group_for_gid" do
-    subject { described_class.group_for_gid(uid) }
-
-    context "when group with id exists" do
-      let(:uid) { 0 }
-
-      it "returns group name" do
-        is_expected.to be_kind_of(String)
-      end
-    end
-
-    context "when group with id does not exist" do
-      let(:uid) { -3 }
-
-      it "returns nil" do
-        is_expected.to be_nil
-      end
-    end
-  end
-
-  describe ".read_file_content" do
-    let(:path) { File.join(spec_system_tmp_dir, "test_file.txt") }
-    let(:bytes_to_read) { 100 }
-    subject { described_class.read_file_content(path, bytes_to_read) }
-    before do
-      File.write(path, file_contents)
-    end
-
-    context "when file is bigger than read size" do
-      let(:file_contents) do
-        "".tap do |s|
-          100.times do |i|
-            s << "line #{i}\n"
-          end
-        end
-      end
-
-      it "returns the last X bytes" do
-        is_expected
-          .to eq(file_contents[(file_contents.length - bytes_to_read)..file_contents.length])
-      end
-    end
-
-    context "when file is smaller than read size" do
-      let(:file_contents) { "line 1\n" }
-
-      it "returns the whole file content" do
-        is_expected.to eq(file_contents)
-      end
-    end
-
-    context "when reading the file raises an illegal seek error" do
-      let(:file_contents) { "line 1\n" }
-      before do
-        expect(File).to receive(:binread).and_raise(Errno::ESPIPE)
-      end
-
-      it "returns the error as the content" do
-        expect { subject }.to raise_error(Errno::ESPIPE)
-      end
-    end
-  end
-end