appsignal 3.8.1 → 3.9.0

data/spec/lib/appsignal/rack/generic_instrumentation_spec.rb

@@ -1,91 +1,38 @@
 describe Appsignal::Rack::GenericInstrumentation do
-  before :context do
-    start_agent
-  end
-
   let(:app) { double(:call => true) }
-  let(:env) { { :path => "/", :method => "GET" } }
-  let(:options) { {} }
-  let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, options) }
-
-  describe "#call" do
-    before do
-      allow(middleware).to receive(:raw_payload).and_return({})
-    end
-
-    context "when appsignal is active" do
-      before { allow(Appsignal).to receive(:active?).and_return(true) }
-
-      it "should call with monitoring" do
-        expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
-      end
-    end
-
-    context "when appsignal is not active" do
-      before { allow(Appsignal).to receive(:active?).and_return(false) }
-
-      it "should not call with monitoring" do
-        expect(middleware).to_not receive(:call_with_appsignal_monitoring)
-      end
+  let(:env) { Rack::MockRequest.env_for("/some/path") }
+  let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, {}) }
 
-      it "should call the stack" do
-        expect(app).to receive(:call).with(env)
-      end
-    end
+  before(:context) { start_agent }
+  around { |example| keep_transactions { example.run } }
 
-    after { middleware.call(env) }
+  def make_request(env)
+    middleware.call(env)
   end
 
-  describe "#call_with_appsignal_monitoring", :error => false do
-    it "should create a transaction" do
-      expect(Appsignal::Transaction).to receive(:create).with(
-        kind_of(String),
-        Appsignal::Transaction::HTTP_REQUEST,
-        kind_of(Rack::Request)
-      ).and_return(double(:set_action_if_nil => nil, :set_http_or_background_queue_start => nil,
-        :set_metadata => nil))
-    end
-
-    it "should call the app" do
-      expect(app).to receive(:call).with(env)
+  context "without an exception" do
+    it "reports a process_action.generic event" do
+      make_request(env)
+
+      expect(last_transaction.to_h).to include(
+        "events" => [
+          hash_including(
+            "body" => "",
+            "body_format" => Appsignal::EventFormatter::DEFAULT,
+            "count" => 1,
+            "name" => "process_action.generic",
+            "title" => ""
+          )
+        ]
+      )
     end
+  end
 
-    context "with an exception", :error => true do
-      let(:error) { ExampleException }
-      let(:app) do
-        double.tap do |d|
-          allow(d).to receive(:call).and_raise(error)
-        end
-      end
-
-      it "records the exception" do
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
-      end
-    end
-
-    it "should set the action to unknown" do
-      expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("unknown")
-    end
-
-    context "with a route specified in the env" do
-      before do
-        env["appsignal.route"] = "GET /"
-      end
-
-      it "should set the action" do
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("GET /")
-      end
-    end
+  context "without action name metadata" do
+    it "reports 'unknown' as the action name" do
+      make_request(env)
 
-    it "should set metadata" do
-      expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
+      expect(last_transaction.to_h).to include("action" => "unknown")
     end
-
-    it "should set the queue start" do
-      expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
-    end
-
-    after(:error => false) { middleware.call(env) }
-    after(:error => true) { expect { middleware.call(env) }.to raise_error(error) }
   end
 end

data/spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb

@@ -16,7 +16,9 @@ if DependencyHelper.sinatra_present?
 
     let(:settings) { double(:raise_errors => false) }
     let(:app) { double(:call => true, :settings => settings) }
-    let(:env) { { "sinatra.route" => "GET /", :path => "/", :method => "GET" } }
+    let(:env) do
+      Rack::MockRequest.env_for("/path", "sinatra.route" => "GET /path", "REQUEST_METHOD" => "GET")
+    end
     let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app) }
 
     before(:context) { start_agent }
@@ -28,8 +30,7 @@ if DependencyHelper.sinatra_present?
       before { allow(middleware).to receive(:raw_payload).and_return({}) }
 
       it "doesn't instrument requests" do
-        make_request(env)
-        expect(created_transactions.count).to eq(0)
+        expect { make_request(env) }.to_not(change { created_transactions.count })
       end
     end
 
@@ -47,7 +48,9 @@ if DependencyHelper.sinatra_present?
 
     let(:settings) { double(:raise_errors => false) }
     let(:app) { double(:call => true, :settings => settings) }
-    let(:env) { { "sinatra.route" => "GET /", :path => "/", :method => "GET" } }
+    let(:env) do
+      Rack::MockRequest.env_for("/path", "sinatra.route" => "GET /path", "REQUEST_METHOD" => "GET")
+    end
     let(:options) { {} }
     let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
 
@@ -93,216 +96,129 @@ if DependencyHelper.sinatra_present?
     describe "#call" do
       before { allow(middleware).to receive(:raw_payload).and_return({}) }
 
-      context "when appsignal is active" do
-        it "instruments requests" do
-          expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
-        end
-      end
-
       context "when appsignal is not active" do
         before { allow(Appsignal).to receive(:active?).and_return(false) }
 
         it "does not instrument requests" do
-          expect(created_transactions.count).to eq(0)
+          expect { make_request(env) }.to_not(change { created_transactions.count })
         end
 
         it "calls the next middleware in the stack" do
-          expect(app).to receive(:call).with(env)
-        end
-      end
-
-      after { make_request(env) }
-    end
-
-    describe "#call_with_appsignal_monitoring" do
-      context "without an error" do
-        it "creates a transaction" do
-          expect(app).to receive(:call).with(env)
-
           make_request(env)
 
-          expect(created_transactions.count).to eq(1)
-          expect(last_transaction.to_h).to include(
-            "namespace" => Appsignal::Transaction::HTTP_REQUEST,
-            "action" => "GET /",
-            "error" => nil,
-            "metadata" => { "path" => "" }
-          )
-        end
-      end
-
-      context "with an error" do
-        let(:error) { ExampleException }
-        let(:app) do
-          double.tap do |d|
-            allow(d).to receive(:call).and_raise(error)
-            allow(d).to receive(:settings).and_return(settings)
-          end
-        end
-
-        it "records the exception" do
-          make_request_with_error(env, error)
-
-          expect(created_transactions.count).to eq(1)
-          expect(last_transaction.to_h).to include(
-            "namespace" => Appsignal::Transaction::HTTP_REQUEST,
-            "action" => "GET /",
-            "error" => hash_including(
-              "name" => "ExampleException",
-              "message" => "ExampleException"
-            )
-          )
+          expect(app).to have_received(:call).with(env)
         end
       end
 
-      context "with an error in sinatra.error" do
-        let(:error) { ExampleException.new }
-        let(:env) { { "sinatra.error" => error } }
-
-        context "when raise_errors is off" do
-          let(:settings) { double(:raise_errors => false) }
-
-          it "record the error" do
+      context "when appsignal is active" do
+        context "without an exception" do
+          it "reports a process_action.sinatra event" do
             make_request(env)
 
-            expect(created_transactions.count).to eq(1)
             expect(last_transaction.to_h).to include(
-              "error" => hash_including(
-                "name" => "ExampleException",
-                "message" => "ExampleException"
-              )
+              "events" => [
+                hash_including(
+                  "body" => "",
+                  "body_format" => Appsignal::EventFormatter::DEFAULT,
+                  "count" => 1,
+                  "name" => "process_action.sinatra",
+                  "title" => ""
+                )
+              ]
             )
           end
         end
 
-        context "when raise_errors is on" do
-          let(:settings) { double(:raise_errors => true) }
-
-          it "does not record the error" do
-            make_request(env)
-
-            expect(created_transactions.count).to eq(1)
-            expect(last_transaction.to_h).to include("error" => nil)
+        context "with an error in sinatra.error" do
+          let(:error) { ExampleException.new("error message") }
+          before do
+            env["sinatra.error"] = error
           end
-        end
 
-        context "if sinatra.skip_appsignal_error is set" do
-          let(:env) { { "sinatra.error" => error, "sinatra.skip_appsignal_error" => true } }
+          context "when raise_errors is off" do
+            let(:settings) { double(:raise_errors => false) }
 
-          it "does not record the error" do
-            make_request(env)
+            it "record the error" do
+              expect { make_request(env) }
+                .to(change { created_transactions.count }.by(1))
 
-            expect(created_transactions.count).to eq(1)
-            expect(last_transaction.to_h).to include("error" => nil)
+              expect(last_transaction.to_h).to include(
+                "error" => hash_including(
+                  "name" => "ExampleException",
+                  "message" => "error message"
+                )
+              )
+            end
           end
-        end
-      end
 
-      describe "action name" do
-        it "sets the action" do
-          make_request(env)
+          context "when raise_errors is on" do
+            let(:settings) { double(:raise_errors => true) }
 
-          expect(created_transactions.count).to eq(1)
-          expect(last_transaction.to_h).to include("action" => "GET /")
-        end
+            it "does not record the error" do
+              expect { make_request(env) }
+                .to(change { created_transactions.count }.by(1))
+
+              expect(last_transaction.to_h).to include("error" => nil)
+            end
+          end
 
-        context "without 'sinatra.route' env" do
-          let(:env) { { :path => "/", :method => "GET" } }
+          context "if sinatra.skip_appsignal_error is set" do
+            before do
+              env.merge!(
+                "sinatra.error" => error,
+                "sinatra.skip_appsignal_error" => true
+              )
+            end
 
-          it "doesn't set an action name" do
-            make_request(env)
+            it "does not record the error" do
+              expect { make_request(env) }
+                .to(change { created_transactions.count }.by(1))
 
-            expect(created_transactions.count).to eq(1)
-            expect(last_transaction.to_h).to include("action" => nil)
+              expect(last_transaction.to_h).to include("error" => nil)
+            end
           end
         end
 
-        context "with mounted modular application" do
-          before { env["SCRIPT_NAME"] = "/api" }
-
-          it "should call set_action with an application prefix path" do
+        describe "action name" do
+          it "sets the action to the request method and path" do
             make_request(env)
 
-            expect(created_transactions.count).to eq(1)
-            expect(last_transaction.to_h).to include("action" => "GET /api/")
+            expect(last_transaction.to_h).to include("action" => "GET /path")
           end
 
           context "without 'sinatra.route' env" do
-            let(:env) { { :path => "/", :method => "GET" } }
+            let(:env) do
+              Rack::MockRequest.env_for("/path", "REQUEST_METHOD" => "GET")
+            end
 
             it "doesn't set an action name" do
               make_request(env)
 
-              expect(created_transactions.count).to eq(1)
               expect(last_transaction.to_h).to include("action" => nil)
             end
           end
-        end
-      end
-
-      context "metadata" do
-        let(:env) { { "PATH_INFO" => "/some/path", "REQUEST_METHOD" => "GET" } }
-
-        it "sets metadata from the environment" do
-          make_request(env)
-
-          expect(created_transactions.count).to eq(1)
-          expect(last_transaction.to_h).to include(
-            "metadata" => {
-              "method" => "GET",
-              "path" => "/some/path"
-            },
-            "sample_data" => hash_including(
-              "environment" => hash_including(
-                "REQUEST_METHOD" => "GET",
-                "PATH_INFO" => "/some/path"
-              )
-            )
-          )
-        end
-      end
 
-      context "with queue start" do
-        let(:queue_start_time) { fixed_time * 1_000 }
-        let(:env) do
-          { "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}" } # in milliseconds
-        end
-
-        it "sets the queue start" do
-          make_request(env)
-          expect(last_transaction.ext.queue_start).to eq(queue_start_time)
-        end
-      end
-
-      class FilteredRequest
-        def initialize(_args) # rubocop:disable Style/RedundantInitialize
-        end
-
-        def path
-          "/static/path"
-        end
+          context "with mounted modular application" do
+            before { env["SCRIPT_NAME"] = "/api" }
 
-        def request_method
-          "GET"
-        end
+            it "sets the action name with an application prefix path" do
+              make_request(env)
 
-        def filtered_params
-          { "abc" => "123" }
-        end
-      end
+              expect(last_transaction.to_h).to include("action" => "GET /api/path")
+            end
 
-      context "with overridden request class and params method" do
-        let(:options) { { :request_class => FilteredRequest, :params_method => :filtered_params } }
+            context "without 'sinatra.route' env" do
+              let(:env) do
+                Rack::MockRequest.env_for("/path", "REQUEST_METHOD" => "GET")
+              end
 
-        it "uses the overridden request class and params method to fetch params" do
-          make_request(env)
+              it "doesn't set an action name" do
+                make_request(env)
 
-          expect(created_transactions.count).to eq(1)
-          expect(last_transaction.to_h).to include(
-            "sample_data" => hash_including(
-              "params" => { "abc" => "123" }
-            )
-          )
+                expect(last_transaction.to_h).to include("action" => nil)
+              end
+            end
+          end
         end
       end
     end

data/support/install_deps

@@ -4,6 +4,12 @@ set -eu
 
 gem_args="--no-verbose --no-document"
 
+# Workaround for https://github.com/jruby/jruby/issues/7059
+if [[ "${RUBY_VERSION}" == *"jruby"* ]]; then
+  echo "Skipping rubygems and bundler update for JRuby"
+  exit 0
+fi
+
 case "${_RUBYGEMS_VERSION-"latest"}" in
   "latest")
     echo "Updating rubygems"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.8.1
+  version: 3.9.0
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-17 00:00:00.000000000 Z
+date: 2024-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -271,6 +271,7 @@ files:
 - lib/appsignal/probes/helpers.rb
 - lib/appsignal/probes/mri.rb
 - lib/appsignal/probes/sidekiq.rb
+- lib/appsignal/rack/abstract_middleware.rb
 - lib/appsignal/rack/event_handler.rb
 - lib/appsignal/rack/generic_instrumentation.rb
 - lib/appsignal/rack/rails_instrumentation.rb
@@ -372,6 +373,7 @@ files:
 - spec/lib/appsignal/probes/mri_spec.rb
 - spec/lib/appsignal/probes/sidekiq_spec.rb
 - spec/lib/appsignal/probes_spec.rb
+- spec/lib/appsignal/rack/abstract_middleware_spec.rb
 - spec/lib/appsignal/rack/event_handler_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb