appsignal 4.0.6-java → 4.0.8-java

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -1,193 +0,0 @@
-class MockFormatter < Appsignal::EventFormatter
-  attr_reader :body
-
-  def initialize
-    super
-    @body = "some value"
-  end
-
-  def format(_payload)
-    ["title", body]
-  end
-end
-
-class MockFormatterDouble < MockFormatter
-end
-
-class MissingFormatMockFormatter
-end
-
-class IncorrectFormatMockFormatter < Appsignal::EventFormatter
-  def format
-  end
-end
-
-class IncorrectFormatMock2Formatter < Appsignal::EventFormatter
-  def format(_payload, _foo = nil)
-  end
-end
-
-class MockDependentFormatter < Appsignal::EventFormatter
-  def initialize
-    super
-    raise "There is an error"
-  end
-
-  def format(_payload)
-  end
-end
-
-describe Appsignal::EventFormatter do
-  let(:klass) { described_class }
-  around do |example|
-    original_formatters = described_class.formatters
-    example.run
-    described_class.class_variable_set(:@@formatters, original_formatters)
-  end
-
-  describe ".register" do
-    it "registers a formatter" do
-      expect(klass.registered?("mock")).to be_falsy
-
-      klass.register "mock", MockFormatter
-
-      expect(klass.formatters["mock"]).to be_instance_of(MockFormatter)
-      expect(klass.formatter_classes["mock"]).to eq MockFormatter
-    end
-
-    context "when a formatter with the name already exists" do
-      it "does not register the formatter again" do
-        logs = capture_logs do
-          klass.register("mock.twice", MockFormatter)
-          klass.register("mock.twice", MockFormatter)
-        end
-        expect(klass.registered?("mock.twice")).to be_truthy
-        expect(logs).to contains_log :warn,
-          "Formatter for 'mock.twice' already registered, not registering 'MockFormatter'"
-      end
-    end
-
-    context "when there is an error initializing the formatter" do
-      it "does not register the formatter and logs an error" do
-        logs = capture_logs do
-          described_class.register "mock.dependent", MockDependentFormatter
-        end
-        expect(klass.registered?("mock.dependent")).to be_falsy
-        expect(logs).to contains_log :error,
-          "'There is an error' " \
-            "when initializing mock.dependent event formatter"
-      end
-    end
-
-    context "when formatter has no format/1 method" do
-      context "when the formatter has no format method" do
-        it "does not register the formatter and logs an error" do
-          logs = capture_logs do
-            described_class.register "mock.missing", MissingFormatMockFormatter
-          end
-          expect(klass.registered?("mock.missing")).to be_falsy
-          expect(logs).to contains_log :error,
-            "'MissingFormatMockFormatter does not have a format(payload) " \
-              "method' when initializing mock.missing event formatter"
-        end
-      end
-
-      context "when the formatter has an format/0 method" do
-        it "does not register the formatter and logs an error" do
-          logs = capture_logs do
-            described_class.register "mock.incorrect", IncorrectFormatMockFormatter
-          end
-          expect(klass.registered?("mock.incorrect")).to be_falsy
-          expect(logs).to contains_log :error,
-            "'IncorrectFormatMockFormatter does not have a format(payload) " \
-              "method' when initializing mock.incorrect event formatter"
-        end
-      end
-
-      context "when formatter has an format/2 method" do
-        it "does not register the formatter and logs an error" do
-          logs = capture_logs do
-            described_class.register "mock.incorrect", IncorrectFormatMock2Formatter
-          end
-          expect(klass.registered?("mock.incorrect")).to be_falsy
-          expect(logs).to contains_log :error,
-            "'IncorrectFormatMock2Formatter does not have a format(payload) " \
-              "method' when initializing mock.incorrect event formatter"
-        end
-      end
-    end
-  end
-
-  describe ".registered?" do
-    context "when checking by name" do
-      context "when there is a formatter with that name" do
-        it "returns true" do
-          klass.register "mock", MockFormatter
-          expect(klass.registered?("mock")).to be_truthy
-        end
-      end
-
-      context "when there is no formatter with that name" do
-        it "returns false" do
-          expect(klass.registered?("nonsense")).to be_falsy
-        end
-      end
-    end
-
-    context "when checking by name and class" do
-      context "when there is a formatter with that name and class" do
-        it "returns true" do
-          klass.register "mock", MockFormatter
-          expect(klass.registered?("mock", MockFormatter)).to be_truthy
-        end
-      end
-
-      context "when there is no formatter with that name and class" do
-        it "returns false" do
-          klass.register "mock", MockFormatterDouble
-          expect(klass.registered?("mock", MockFormatter)).to be_falsy
-        end
-      end
-    end
-  end
-
-  describe ".unregister" do
-    context "when a formatter with the name is registered" do
-      it "unregisters the formatter has the same class" do
-        klass.register("mock.unregister", MockFormatter)
-        expect(klass.registered?("mock.unregister")).to be_truthy
-
-        klass.unregister("mock.unregister", Hash)
-        expect(klass.registered?("mock.unregister")).to be_truthy
-
-        klass.unregister("mock.unregister", MockFormatter)
-        expect(klass.registered?("mock.unregister")).to be_falsy
-      end
-    end
-
-    context "when a formatter with the same name and class is not registered" do
-      it "unregisters nothing" do
-        expect do
-          expect do
-            klass.unregister("nonse.unregister", MockFormatter)
-          end.to_not(change { klass.formatters })
-        end.to_not(change { klass.formatter_classes })
-      end
-    end
-  end
-
-  describe ".format" do
-    context "when no formatter with the name is registered" do
-      it "returns nil" do
-        expect(klass.format("nonsense", {})).to be_nil
-      end
-    end
-
-    context "when a formatter with the name is registered" do
-      it "calls the formatter and use a value set in the initializer" do
-        klass.register "mock", MockFormatter
-        expect(klass.format("mock", {})).to eq ["title", "some value"]
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-describe "JRuby extension", :jruby do
-  let(:extension) { Appsignal::Extension }
-  let(:jruby_module) { Appsignal::Extension::Jruby }
-
-  it "creates a JRuby extension module" do
-    expect(Appsignal::Extension::Jruby).to be_kind_of(Module)
-  end
-
-  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 🎄"
-
-      appsignal_string = extension.make_appsignal_string(string)
-      ruby_string = extension.make_ruby_string(appsignal_string)
-
-      expect(ruby_string).to eq("Merry Christmas! \u0000 🎄")
-    end
-  end
-
-  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") }
-
-      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") }
-
-      it "returns the lib extension for linux" do
-        is_expected.to eq "so"
-      end
-    end
-  end
-end

data/spec/lib/appsignal/extension_install_failure_spec.rb

@@ -1,20 +0,0 @@
-describe Appsignal::Extension, :extension_installation_failure do
-  context "when the extension library cannot be loaded" do
-    it "prints and logs an error" do
-      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?
-          if DependencyHelper.macos?
-            "Could not open library"
-          else
-            "cannot open shared object file"
-          end
-        else
-          "LoadError: cannot load such file"
-        end
-      expect(stderr).to include(error_message)
-    end
-  end
-end

data/spec/lib/appsignal/extension_spec.rb

@@ -1,178 +0,0 @@
-describe Appsignal::Extension do
-  describe ".agent_config" do
-    subject { Appsignal::Extension.agent_config }
-
-    it { is_expected.to have_key("version") }
-    it { is_expected.to have_key("triples") }
-  end
-
-  describe ".agent_version" do
-    subject { Appsignal::Extension.agent_version }
-
-    it { is_expected.to be_kind_of(String) }
-  end
-
-  context "when the extension library can be loaded" do
-    subject { Appsignal::Extension }
-
-    it "should indicate that the extension is loaded" do
-      expect(Appsignal.extension_loaded?).to be_truthy
-    end
-
-    context "without valid config" do
-      let(:out_stream) { std_stream }
-      let(:output) { out_stream.read }
-
-      describe ".start" do
-        it "outputs a warning about not starting the extension" do
-          capture_std_streams(out_stream, out_stream) do
-            subject.start
-          end
-
-          expect(output).to match \
-            %r{
-              WARNING:\sError\swhen\sreading\sappsignal\sconfig,\s
-              appsignal\s\(as\s(\d{2,4})/(\d{2,4})\)\snot\sstarting
-            }x
-        end
-      end
-
-      describe ".stop" do
-        it "does nothing" do
-          capture_std_streams(out_stream, out_stream) do
-            subject.stop
-          end
-          expect(output).to be_empty
-        end
-      end
-    end
-
-    context "with a valid config" do
-      before do
-        build_config.write_to_environment
-      end
-
-      it "should have a start and stop method" do
-        subject.start
-        subject.stop
-      end
-
-      context "with a transaction" do
-        subject { Appsignal::Extension.start_transaction("request_id", "http_request", 0) }
-
-        it "should have a start_event method" do
-          subject.start_event(0)
-        end
-
-        it "should have a finish_event method" do
-          subject.finish_event("name", "title", "body", 0, 0)
-        end
-
-        it "should have a record_event method" do
-          subject.record_event("name", "title", "body", 0, 1000, 1000)
-        end
-
-        it "should have a set_error method" do
-          subject.set_error("name", "message", Appsignal::Extension.data_map_new)
-        end
-
-        it "should have a set_sample_data method" do
-          subject.set_sample_data("params", Appsignal::Extension.data_map_new)
-        end
-
-        it "should have a set_action method" do
-          subject.set_action("value")
-        end
-
-        it "should have a set_namespace method" do
-          subject.set_namespace("value")
-        end
-
-        it "should have a set_queue_start method" do
-          subject.set_queue_start(10)
-        end
-
-        it "should have a set_metadata method" do
-          subject.set_metadata("key", "value")
-        end
-
-        it "should have a finish method" do
-          subject.finish(0)
-        end
-
-        it "should have a duplicate method" do
-          subject.duplicate("request_id")
-        end
-
-        it "should have a complete method" do
-          subject.complete
-        end
-      end
-
-      it "should have a set_gauge method" do
-        subject.set_gauge("key", 1.0, Appsignal::Extension.data_map_new)
-      end
-
-      it "should have a increment_counter method" do
-        subject.increment_counter("key", 1.0, Appsignal::Extension.data_map_new)
-      end
-
-      it "should have a add_distribution_value method" do
-        subject.add_distribution_value("key", 1.0, Appsignal::Extension.data_map_new)
-      end
-    end
-  end
-
-  context "when the extension library cannot be loaded", :extension_installation_failure do
-    let(:ext) { Appsignal::Extension }
-
-    around do |example|
-      Appsignal::Testing.without_testing { example.run }
-    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
-    end
-  end
-end

data/spec/lib/appsignal/garbage_collection_spec.rb

@@ -1,98 +0,0 @@
-describe Appsignal::GarbageCollection do
-  describe ".profiler" do
-    before do
-      # Unset the internal memoized variable to avoid state leaking
-      described_class.clear_profiler!
-    end
-
-    context "when GC instrumentation is disabled" do
-      it "returns the NilProfiler" do
-        expect(described_class.profiler).to be_a(Appsignal::GarbageCollection::NilProfiler)
-      end
-    end
-
-    context "when GC profiling is enabled" do
-      before { GC::Profiler.enable }
-      after { GC::Profiler.disable }
-
-      it "returns the Profiler" do
-        expect(described_class.profiler).to be_a(Appsignal::GarbageCollection::Profiler)
-      end
-    end
-  end
-end
-
-describe Appsignal::GarbageCollection::Profiler do
-  let(:internal_profiler) { FakeGCProfiler.new }
-  let(:profiler) { described_class.new }
-
-  before do
-    stub_const("GC::Profiler", internal_profiler)
-  end
-
-  context "on initialization" do
-    it "has a total time of 0" do
-      expect(profiler.total_time).to eq(0)
-    end
-  end
-
-  context "when the GC has run" do
-    before { internal_profiler.total_time = 0.12345 }
-
-    it "fetches the total time from Ruby's GC::Profiler" do
-      expect(profiler.total_time).to eq(123)
-    end
-
-    it "clears Ruby's GC::Profiler afterward" do
-      expect(internal_profiler).to receive(:clear)
-      profiler.total_time
-    end
-  end
-
-  context "when the total GC time becomes too high" do
-    it "resets the total time" do
-      internal_profiler.total_time = 2_147_483_647
-      expect(profiler.total_time).to eq(0)
-    end
-  end
-
-  context "when the GC has run multiple times" do
-    it "adds all times from Ruby's GC::Profiler together" do
-      2.times do
-        internal_profiler.total_time = 0.12345
-        profiler.total_time
-      end
-
-      expect(profiler.total_time).to eq(246)
-    end
-  end
-
-  context "when in multiple threads and with a slow GC::Profiler" do
-    it "does not count garbage collection times twice" do
-      threads = []
-      results = []
-      internal_profiler.clear_delay = 0.001
-      internal_profiler.total_time = 0.12345
-
-      2.times do
-        threads << Thread.new do
-          profiler = Appsignal::GarbageCollection::Profiler.new
-          results << profiler.total_time
-        end
-      end
-
-      threads.each(&:join)
-      expect(results).to eq([123, 0])
-    end
-  end
-end
-
-describe Appsignal::GarbageCollection::NilProfiler do
-  let(:profiler) { described_class.new }
-
-  describe "#total_time" do
-    it "has a total time of 0" do
-      expect(profiler.total_time).to eq(0)
-    end
-  end
-end