appsignal 3.9.2-java → 3.10.0-java

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

@@ -15,72 +15,109 @@ if DependencyHelper.webmachine_present?
 
   describe Appsignal::Integrations::WebmachineIntegration do
     let(:request) do
-      Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
+      Webmachine::Request.new(
+        "GET",
+        "http://google.com:80/foo?param1=value1&param2=value2",
+        {},
+        nil
+      )
     end
-    let(:resource)    { double(:trace? => false, :handle_exception => true, :"code=" => nil) }
-    let(:response)    { Response.new }
-    let(:transaction) { double(:set_action_if_nil => true) }
-    let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
-    before(:context) { start_agent }
-
-    # Make sure the request responds to the method we need to get query params.
-    describe "request" do
-      it "should respond to `query`" do
-        expect(request).to respond_to(:query)
+    let(:app) do
+      proc do
+        def to_html
+          "Some HTML"
+        end
+      end
+    end
+    let(:resource) do
+      app_block = app
+      Class.new(Webmachine::Resource) do
+        class_eval(&app_block) if app_block
+
+        def self.name
+          "MyResource"
+        end
       end
     end
+    let(:resource_instance) { resource.new(request, response) }
+    let(:response) { Webmachine::Response.new }
+    let(:fsm) { Webmachine::Decision::FSM.new(resource_instance, request, response) }
+    before { start_agent }
+    around { |example| keep_transactions { example.run } }
 
     describe "#run" do
-      before do
-        allow(SecureRandom).to receive(:uuid).and_return("uuid")
-        allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
+      it "creates a transaction" do
+        expect { fsm.run }.to(change { created_transactions.count }.by(1))
       end
 
-      it "should create a transaction" do
-        expect(Appsignal::Transaction).to receive(:create).with(
-          "uuid",
-          Appsignal::Transaction::HTTP_REQUEST,
-          request,
-          :params_method => :query
-        ).and_return(transaction)
+      it "sets the action" do
+        fsm.run
+        expect(last_transaction).to have_action("MyResource#GET")
       end
 
-      it "should set the action" do
-        expect(transaction).to receive(:set_action_if_nil).with("RSpec::Mocks::Double#GET")
+      context "with action already set" do
+        let(:app) do
+          proc do
+            def to_html
+              Appsignal.set_action("Custom Action")
+              "Some HTML"
+            end
+          end
+        end
+
+        it "doesn't overwrite the action" do
+          fsm.run
+          expect(last_transaction).to have_action("Custom Action")
+        end
       end
 
-      it "should call the original method" do
-        expect(fsm).to receive(:run)
+      it "records an instrumentation event" do
+        fsm.run
+        expect(last_transaction).to include_event("name" => "process_action.webmachine")
       end
 
-      it "should instrument the original method" do
-        expect(Appsignal).to receive(:instrument).with("process_action.webmachine")
+      it "sets the params" do
+        fsm.run
+        expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
       end
 
-      it "should close the transaction" do
-        expect(Appsignal::Transaction).to receive(:complete_current!)
+      it "closes the transaction" do
+        fsm.run
+        expect(last_transaction).to be_completed
+        expect(current_transaction?).to be_falsy
       end
 
-      after { fsm.run }
+      context "with parent transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets the action" do
+          fsm.run
+          expect(last_transaction).to have_action("MyResource#GET")
+        end
 
-      describe "concerning the response" do
-        it "sets a response code" do
-          expect(fsm.response.code).to be_nil
+        it "sets the params" do
           fsm.run
-          expect(fsm.response.code).not_to be_nil
+          last_transaction._sample
+          expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
+        end
+
+        it "does not close the transaction" do
+          expect(last_transaction).to_not be_completed
         end
       end
     end
 
     describe "#handle_exceptions" do
-      let(:error) { ExampleException }
+      let(:error) { ExampleException.new("error message") }
+      let(:transaction) { http_request_transaction }
 
-      it "should catch the error and send it to AppSignal" do
-        expect(Appsignal).to receive(:set_error).with(error)
-      end
+      it "tracks the error" do
+        with_current_transaction(transaction) do
+          fsm.send(:handle_exceptions) { raise error }
+        end
 
-      after do
-        fsm.send(:handle_exceptions) { raise error }
+        expect(last_transaction).to have_error("ExampleException", "error message")
       end
     end
   end

data/spec/lib/appsignal/probes/gvl_spec.rb

@@ -4,6 +4,13 @@ describe Appsignal::Probes::GvlProbe do
 
   let(:hostname) { "some-host" }
 
+  around do |example|
+    real_program_name = $PROGRAM_NAME
+    example.run
+  ensure
+    $PROGRAM_NAME = real_program_name
+  end
+
   def gauges_for(metric)
     gauges = appsignal_mock.gauges.select do |gauge|
       gauge[0] == metric
@@ -14,7 +21,7 @@ describe Appsignal::Probes::GvlProbe do
     end
   end
 
-  after(:each) { FakeGVLTools.reset }
+  after { FakeGVLTools.reset }
 
   it "gauges the global timer delta" do
     FakeGVLTools::GlobalTimer.monotonic_time = 100_000_000
@@ -26,6 +33,11 @@ describe Appsignal::Probes::GvlProbe do
     probe.call
 
     expect(gauges_for("gvl_global_timer")).to eq [
+      [200, {
+        :hostname => hostname,
+        :process_name => "rspec",
+        :process_id => Process.pid
+      }],
       [200, { :hostname => hostname }]
     ]
   end
@@ -58,7 +70,7 @@ describe Appsignal::Probes::GvlProbe do
   end
 
   context "when the waiting threads count is enabled" do
-    before(:each) do
+    before do
       FakeGVLTools::WaitingThreads.enabled = true
     end
 
@@ -67,13 +79,18 @@ describe Appsignal::Probes::GvlProbe do
       probe.call
 
       expect(gauges_for("gvl_waiting_threads")).to eq [
+        [3, {
+          :hostname => hostname,
+          :process_name => "rspec",
+          :process_id => Process.pid
+        }],
         [3, { :hostname => hostname }]
       ]
     end
   end
 
   context "when the waiting threads count is disabled" do
-    before(:each) do
+    before do
       FakeGVLTools::WaitingThreads.enabled = false
     end
 
@@ -84,4 +101,64 @@ describe Appsignal::Probes::GvlProbe do
       expect(gauges_for("gvl_waiting_threads")).to be_empty
     end
   end
+
+  context "when the process name is a custom value" do
+    before do
+      FakeGVLTools::WaitingThreads.enabled = true
+    end
+
+    it "uses only the first word as the process name" do
+      $PROGRAM_NAME = "sidekiq 7.1.6 app [0 of 5 busy]"
+      probe.call
+
+      expect(gauges_for("gvl_waiting_threads")).to eq [
+        [0, {
+          :hostname => hostname,
+          :process_name => "sidekiq",
+          :process_id => Process.pid
+        }],
+        [0, { :hostname => hostname }]
+      ]
+    end
+  end
+
+  context "when the process name is a path" do
+    before do
+      FakeGVLTools::WaitingThreads.enabled = true
+    end
+
+    it "uses only the binary name as the process name" do
+      $PROGRAM_NAME = "/foo/folder with spaces/bin/rails"
+      probe.call
+
+      expect(gauges_for("gvl_waiting_threads")).to eq [
+        [0, {
+          :hostname => hostname,
+          :process_name => "rails",
+          :process_id => Process.pid
+        }],
+        [0, { :hostname => hostname }]
+      ]
+    end
+  end
+
+  context "when the process name is an empty string" do
+    before do
+      FakeGVLTools::WaitingThreads.enabled = true
+    end
+
+    it "uses [unknown process] as the process name" do
+      $PROGRAM_NAME = ""
+      probe.call
+
+      expect(gauges_for("gvl_waiting_threads")).to eq [
+        [0, {
+          :hostname => hostname,
+          :process_name => "[unknown process]",
+          :process_id => Process.pid
+        }],
+        [0, { :hostname => hostname }]
+      ]
+    end
+  end
 end

data/spec/lib/appsignal/probes_spec.rb

@@ -20,7 +20,7 @@ describe Appsignal::Probes do
         .to include("appsignal WARNING: The constant Appsignal::Minutely has been deprecated.")
     end
 
-    it "logs a warning to STDERR" do
+    it "logs a warning" do
       logs =
         capture_logs do
           silence do
@@ -28,7 +28,10 @@ describe Appsignal::Probes do
           end
         end
 
-      expect(logs).to include("The constant Appsignal::Minutely has been deprecated.")
+      expect(logs).to contains_log(
+        :warn,
+        "The constant Appsignal::Minutely has been deprecated."
+      )
     end
   end
 
@@ -78,7 +81,7 @@ describe Appsignal::Probes do
     describe ".started?" do
       it "returns true when the probes thread has been started" do
         expect(Appsignal::Probes.started?).to be_falsy
-        Appsignal::Probes.register :my_probe, (lambda {})
+        Appsignal::Probes.register :my_probe, lambda {}
         Appsignal::Probes.start
         expect(Appsignal::Probes.started?).to be_truthy
       end
@@ -475,7 +478,7 @@ describe Appsignal::Probes do
         probe = lambda {}
         collection.internal_register :my_probe, probe
         list = []
-        collection.each do |name, p|
+        collection.each do |name, p| # rubocop:disable Style/MapIntoArray
           list << [name, p]
         end
         expect(list).to eql([[:my_probe, probe]])