appsignal 2.5.0.alpha.1-java

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -0,0 +1,100 @@
+class MockFormatter < Appsignal::EventFormatter
+  register "mock"
+
+  attr_reader :body
+
+  def initialize
+    @body = "some value"
+  end
+
+  def format(_payload)
+    ["title", body]
+  end
+end
+
+class MissingFormatMockFormatter < Appsignal::EventFormatter
+  def transform(_payload)
+  end
+end
+
+class IncorrectFormatMockFormatter < Appsignal::EventFormatter
+  def format
+  end
+end
+
+class MockDependentFormatter < Appsignal::EventFormatter
+  register "mock.dependent"
+
+  def initialize
+    NonsenseDependency.something
+  end
+end
+
+describe Appsignal::EventFormatter do
+  before do
+    Appsignal::EventFormatter.initialize_formatters
+  end
+
+  let(:klass) { Appsignal::EventFormatter }
+
+  context "registering and unregistering formatters" do
+    it "should register a formatter" do
+      expect(klass.formatters["mock"]).to be_instance_of(MockFormatter)
+    end
+
+    it "should know wether a formatter is registered" do
+      expect(klass.registered?("mock")).to be_truthy
+      expect(klass.registered?("mock", MockFormatter)).to be_truthy
+      expect(klass.registered?("mock", Hash)).to be_falsy
+      expect(klass.registered?("nonsense")).to be_falsy
+    end
+
+    it "doesn't register formatters that raise a name error in the initializer" do
+      expect(klass.registered?("mock.dependent")).to be_falsy
+    end
+
+    it "doesn't register formatters that don't have a format(payload) method" do
+      klass.register("mock.missing_format", MissingFormatMockFormatter)
+      klass.register("mock.incorrect_format", IncorrectFormatMockFormatter)
+
+      Appsignal::EventFormatter.initialize_formatters
+
+      expect(klass.registered?("mock.missing_format")).to be_falsy
+      expect(klass.registered?("mock.incorrect_format")).to be_falsy
+    end
+
+    it "should register a custom formatter" do
+      klass.register("mock.specific", MockFormatter)
+      Appsignal::EventFormatter.initialize_formatters
+
+      expect(klass.formatter_classes["mock.specific"]).to eq MockFormatter
+      expect(klass.registered?("mock.specific")).to be_truthy
+      expect(klass.formatters["mock.specific"]).to be_instance_of(MockFormatter)
+      expect(klass.formatters["mock.specific"].body).to eq "some value"
+    end
+
+    it "should not have a formatter that's not registered" do
+      expect(klass.formatters["nonsense"]).to be_nil
+    end
+
+    it "should unregister a formatter if the registered one has the same class" do
+      klass.register("mock.unregister", MockFormatter)
+
+      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 "calling formatters" do
+    it "should return nil if there is no formatter registered" do
+      expect(klass.format("nonsense", {})).to be_nil
+    end
+
+    it "should call the formatter if it is registered and use a value set in the initializer" do
+      expect(klass.format("mock", {})).to eq ["title", "some value"]
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+if Appsignal::System.jruby?
+  describe Appsignal::Extension::Jruby do
+    let(:extension) { Appsignal::Extension }
+
+    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(described_class.ffi_libraries.map(&:name).first).to include "libappsignal"
+    end
+
+    describe ".lib_extension" do
+      subject { described_class.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
+end

data/spec/lib/appsignal/extension_spec.rb

@@ -0,0 +1,137 @@
+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 include \
+            "WARNING: Error when reading appsignal config, appsignal not starting"
+        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
+        project_fixture_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 complete method" do
+          subject.complete
+        end
+      end
+
+      it "should have a set_gauge method" do
+        subject.set_gauge("key", 1.0)
+      end
+
+      it "should have a increment_counter method" do
+        subject.increment_counter("key", 1)
+      end
+
+      it "should have a add_distribution_value method" do
+        subject.add_distribution_value("key", 1.0)
+      end
+    end
+  end
+
+  context "when the extension library cannot be loaded" do
+    subject { Appsignal::Extension }
+
+    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 "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/garbage_collection_profiler_spec.rb

@@ -0,0 +1,66 @@
+describe Appsignal::GarbageCollectionProfiler do
+  let(:internal_profiler) { FakeGCProfiler.new }
+  let(:profiler) { described_class.new }
+
+  before do
+    allow_any_instance_of(described_class)
+      .to receive(:internal_profiler)
+      .and_return(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::GarbageCollectionProfiler.new
+          results << profiler.total_time
+        end
+      end
+
+      threads.each(&:join)
+      expect(results).to eq([123, 0])
+    end
+  end
+end

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

@@ -0,0 +1,370 @@
+describe Appsignal::Hooks::ActionCableHook do
+  if DependencyHelper.action_cable_present?
+    context "with ActionCable" do
+      require "action_cable/engine"
+
+      describe ".dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it "returns true" do
+          is_expected.to be_truthy
+        end
+      end
+
+      describe ActionCable::Channel::Base do
+        let(:transaction) do
+          Appsignal::Transaction.new(
+            transaction_id,
+            Appsignal::Transaction::ACTION_CABLE,
+            ActionDispatch::Request.new(env)
+          )
+        end
+        let(:channel) do
+          Class.new(ActionCable::Channel::Base) do
+            def speak(_data)
+            end
+
+            def self.to_s
+              "MyChannel"
+            end
+          end
+        end
+        let(:log) { StringIO.new }
+        let(:server) do
+          ActionCable::Server::Base.new.tap do |s|
+            s.config.logger = ActiveSupport::Logger.new(log)
+          end
+        end
+        let(:connection) { ActionCable::Connection::Base.new(server, env) }
+        let(:identifier) { { :channel => "MyChannel" }.to_json }
+        let(:params) { {} }
+        let(:request_id) { SecureRandom.uuid }
+        let(:transaction_id) { request_id }
+        let(:env) do
+          http_request_env_with_data("action_dispatch.request_id" => request_id, :params => params)
+        end
+        let(:instance) { channel.new(connection, identifier, params) }
+        subject { transaction.to_h }
+        before do
+          start_agent
+          expect(Appsignal.active?).to be_truthy
+          transaction
+
+          expect(Appsignal::Transaction).to receive(:create)
+            .with(transaction_id, Appsignal::Transaction::ACTION_CABLE, kind_of(ActionDispatch::Request))
+            .and_return(transaction)
+          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
+          # Make sure sample data is added
+          expect(transaction.ext).to receive(:finish).and_return(true)
+          # Stub complete call, stops it from being cleared in the extension
+          # And allows us to call `#to_h` on it after it's been completed.
+          expect(transaction.ext).to receive(:complete)
+
+          # Stub transmit call for subscribe/unsubscribe tests
+          allow(connection).to receive(:websocket)
+            .and_return(instance_double("ActionCable::Connection::WebSocket", :transmit => nil))
+        end
+
+        describe "#perform_action" do
+          it "creates a transaction for an action" do
+            instance.perform_action("message" => "foo", "action" => "speak")
+
+            expect(subject).to include(
+              "action" => "MyChannel#speak",
+              "error" => nil,
+              "id" => transaction_id,
+              "namespace" => Appsignal::Transaction::ACTION_CABLE,
+              "metadata" => {
+                "method" => "websocket",
+                "path" => "/blog"
+              }
+            )
+            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" => "perform_action.action_cable",
+              "title" => ""
+            )
+            expect(subject["sample_data"]).to include(
+              "params" => {
+                "action" => "speak",
+                "message" => "foo"
+              }
+            )
+          end
+
+          context "without request_id (standalone server)" do
+            let(:request_id) { nil }
+            let(:transaction_id) { SecureRandom.uuid }
+            let(:action_transaction) do
+              Appsignal::Transaction.new(
+                transaction_id,
+                Appsignal::Transaction::ACTION_CABLE,
+                ActionDispatch::Request.new(env)
+              )
+            end
+            before do
+              # Stub future (private AppSignal) transaction id generated by the hook.
+              expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+            end
+
+            it "uses its own internal request_id set by the subscribed callback" do
+              # Subscribe action, sets the request_id
+              instance.subscribe_to_channel
+              expect(transaction.to_h["id"]).to eq(transaction_id)
+
+              # Expect another transaction for the action.
+              # This transaction will use the same request_id as the
+              # transaction id used to subscribe to the channel.
+              expect(Appsignal::Transaction).to receive(:create).with(
+                transaction_id,
+                Appsignal::Transaction::ACTION_CABLE,
+                kind_of(ActionDispatch::Request)
+              ).and_return(action_transaction)
+              allow(Appsignal::Transaction).to receive(:current).and_return(action_transaction)
+              # Stub complete call, stops it from being cleared in the extension
+              # And allows us to call `#to_h` on it after it's been completed.
+              expect(action_transaction.ext).to receive(:complete)
+
+              instance.perform_action("message" => "foo", "action" => "speak")
+              expect(action_transaction.to_h["id"]).to eq(transaction_id)
+            end
+          end
+
+          context "with an error in the action" do
+            let(:channel) do
+              Class.new(ActionCable::Channel::Base) do
+                def speak(_data)
+                  raise ExampleException, "oh no!"
+                end
+
+                def self.to_s
+                  "MyChannel"
+                end
+              end
+            end
+
+            it "registers an error on the transaction" do
+              expect do
+                instance.perform_action("message" => "foo", "action" => "speak")
+              end.to raise_error(ExampleException)
+
+              expect(subject).to include(
+                "action" => "MyChannel#speak",
+                "id" => transaction_id,
+                "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                "metadata" => {
+                  "method" => "websocket",
+                  "path" => "/blog"
+                }
+              )
+              expect(subject["error"]).to include(
+                "backtrace" => kind_of(String),
+                "name" => "ExampleException",
+                "message" => "oh no!"
+              )
+              expect(subject["sample_data"]).to include(
+                "params" => {
+                  "action" => "speak",
+                  "message" => "foo"
+                }
+              )
+            end
+          end
+        end
+
+        describe "subscribe callback" do
+          let(:params) { { "internal" => true } }
+
+          it "creates a transaction for a subscription" 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" => "/blog"
+              }
+            )
+            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
+
+          context "without request_id (standalone server)" do
+            let(:request_id) { nil }
+            let(:transaction_id) { SecureRandom.uuid }
+            before do
+              allow(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              instance.subscribe_to_channel
+            end
+
+            it "uses its own internal request_id" do
+              expect(subject["id"]).to eq(transaction_id)
+            end
+          end
+
+          context "with an error in the callback" do
+            let(:channel) do
+              Class.new(ActionCable::Channel::Base) do
+                def subscribed
+                  raise ExampleException, "oh no!"
+                end
+
+                def self.to_s
+                  "MyChannel"
+                end
+              end
+            end
+
+            it "registers an error on the transaction" do
+              expect do
+                instance.subscribe_to_channel
+              end.to raise_error(ExampleException)
+
+              expect(subject).to include(
+                "action" => "MyChannel#subscribed",
+                "id" => transaction_id,
+                "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                "metadata" => {
+                  "method" => "websocket",
+                  "path" => "/blog"
+                }
+              )
+              expect(subject["error"]).to include(
+                "backtrace" => kind_of(String),
+                "name" => "ExampleException",
+                "message" => "oh no!"
+              )
+              expect(subject["sample_data"]).to include(
+                "params" => { "internal" => "true" }
+              )
+            end
+          end
+        end
+
+        describe "unsubscribe callback" do
+          let(:params) { { "internal" => true } }
+
+          it "creates a transaction for a subscription" 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" => "/blog"
+              }
+            )
+            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
+
+          context "without request_id (standalone server)" do
+            let(:request_id) { nil }
+            let(:transaction_id) { SecureRandom.uuid }
+            before do
+              allow(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              instance.unsubscribe_from_channel
+            end
+
+            it "uses its own internal request_id" do
+              expect(subject["id"]).to eq(transaction_id)
+            end
+          end
+
+          context "with an error in the callback" do
+            let(:channel) do
+              Class.new(ActionCable::Channel::Base) do
+                def unsubscribed
+                  raise ExampleException, "oh no!"
+                end
+
+                def self.to_s
+                  "MyChannel"
+                end
+              end
+            end
+
+            it "registers an error on the transaction" do
+              expect do
+                instance.unsubscribe_from_channel
+              end.to raise_error(ExampleException)
+
+              expect(subject).to include(
+                "action" => "MyChannel#unsubscribed",
+                "id" => transaction_id,
+                "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                "metadata" => {
+                  "method" => "websocket",
+                  "path" => "/blog"
+                }
+              )
+              expect(subject["error"]).to include(
+                "backtrace" => kind_of(String),
+                "name" => "ExampleException",
+                "message" => "oh no!"
+              )
+              expect(subject["sample_data"]).to include(
+                "params" => { "internal" => "true" }
+              )
+            end
+          end
+        end
+      end
+    end
+  else
+    context "without ActionCable" do
+      describe ".dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it "returns false" do
+          is_expected.to be_falsy
+        end
+      end
+    end
+  end
+end