appsignal 4.0.4 → 4.0.6

data/spec/lib/appsignal/rack_spec.rb

@@ -61,3 +61,183 @@ describe Appsignal::Rack::Utils do
     end
   end
 end
+
+describe Appsignal::Rack::ApplyRackRequest do
+  describe "#apply_to" do
+    let(:merged_env) do
+      Rack::MockRequest.env_for(
+        "/some/path",
+        {
+          "REQUEST_METHOD" => "GET",
+          :params => { "page" => 2, "query" => "lorem" },
+          "rack.session" => { "session" => "data", "user_id" => 123 }
+        }.merge(env)
+      )
+    end
+    let(:env) { {} }
+    let(:request) { ::Rack::Request.new(merged_env) }
+    let(:options) { {} }
+    let(:helper) { described_class.new(request, options) }
+    let(:transaction) { http_request_transaction }
+    before { start_agent }
+
+    def apply_to(transaction)
+      helper.apply_to(transaction)
+      transaction._sample
+    end
+
+    it "sets request metadata" do
+      apply_to(transaction)
+
+      expect(transaction).to include_metadata(
+        "method" => "GET",
+        "path" => "/some/path"
+      )
+      expect(transaction).to include_environment(
+        "REQUEST_METHOD" => "GET",
+        "PATH_INFO" => "/some/path"
+        # and more, but we don't need to test Rack mock defaults
+      )
+    end
+
+    context "with an invalid HTTP request method" do
+      let(:env) { { "REQUEST_METHOD" => "FOO" } }
+
+      it "stores the invalid HTTP request method" do
+        apply_to(transaction)
+
+        expect(transaction).to include_metadata("method" => "FOO")
+      end
+    end
+
+    context "when fetching the request method raises an error" do
+      class BrokenRequestMethodRequest < Rack::Request
+        def request_method
+          raise "uh oh!"
+        end
+      end
+
+      let(:env) { { "REQUEST_METHOD" => "FOO" } }
+      let(:request) { BrokenRequestMethodRequest.new(merged_env) }
+
+      it "does not store the invalid HTTP request method" do
+        logs = capture_logs { apply_to(transaction) }
+
+        expect(transaction).to_not include_metadata("method" => anything)
+        expect(logs).to contains_log(
+          :error,
+          "Exception while fetching the HTTP request method: RuntimeError: uh oh"
+        )
+      end
+    end
+
+    it "sets request parameters" do
+      apply_to(transaction)
+
+      expect(transaction).to include_params(
+        "page" => "2",
+        "query" => "lorem"
+      )
+    end
+
+    context "when params_method isn't set" do
+      let(:options) { { :params_method => nil } }
+
+      it "reports no params" do
+        apply_to(transaction)
+
+        expect(transaction).to_not include_params
+      end
+    end
+
+    context "when fetching the request method raises an error" do
+      class BrokenRequestParamsRequest < Rack::Request
+        def params
+          raise "uh oh!"
+        end
+      end
+
+      let(:request) { BrokenRequestParamsRequest.new(merged_env) }
+      let(:options) { { :params_method => :params } }
+
+      it "does not store the invalid HTTP request method" do
+        logs = capture_logs { apply_to(transaction) }
+
+        expect(transaction).to_not include_params
+        expect(logs).to contains_log(
+          :error,
+          "Exception while fetching params " \
+            "from 'BrokenRequestParamsRequest#params': RuntimeError uh oh!"
+        )
+      end
+    end
+
+    it "sets session data" do
+      apply_to(transaction)
+
+      expect(transaction).to include_session_data("session" => "data", "user_id" => 123)
+    end
+
+    context "with Hash-like session data" do
+      let(:env) { { "rack.session" => HashLike.new("hash-like" => "value", "user_id" => 123) } }
+
+      it "sets session data" do
+        apply_to(transaction)
+
+        expect(transaction).to include_session_data("hash-like" => "value", "user_id" => 123)
+      end
+    end
+
+    context "with queue start header" do
+      let(:queue_start_time) { fixed_time * 1_000 }
+      let(:env) { { "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}" } } # in milliseconds
+
+      it "sets the queue start" do
+        apply_to(transaction)
+
+        expect(transaction).to have_queue_start(queue_start_time)
+      end
+    end
+
+    class RackFilteredRequest
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def path
+        "/static/path"
+      end
+
+      def request_method
+        "GET"
+      end
+
+      def filtered_params
+        { "abc" => "123" }
+      end
+
+      def session
+        { "data" => "value" }
+      end
+    end
+
+    context "with overridden request class and params method" do
+      let(:request) { RackFilteredRequest.new(env) }
+      let(:options) { { :params_method => :filtered_params } }
+
+      it "uses the overridden request class and params method to fetch params" do
+        apply_to(transaction)
+
+        expect(transaction).to include_params("abc" => "123")
+      end
+
+      it "uses the overridden request class to fetch session data" do
+        apply_to(transaction)
+
+        expect(transaction).to include_session_data("data" => "value")
+      end
+    end
+  end
+end

data/spec/lib/appsignal/transaction_spec.rb

@@ -211,15 +211,15 @@ describe Appsignal::Transaction do
 
     context "when a transaction has errors" do
       let(:error) do
-        e = ExampleStandardError.new("test message")
-        allow(e).to receive(:backtrace).and_return(["line 1"])
-        e
+        ExampleStandardError.new("test message").tap do |e|
+          e.set_backtrace(["line 1"])
+        end
       end
 
       let(:other_error) do
-        e = ExampleStandardError.new("other test message")
-        allow(e).to receive(:backtrace).and_return(["line 2"])
-        e
+        ExampleStandardError.new("other test message").tap do |e|
+          e.set_backtrace(["line 2"])
+        end
       end
 
       context "when an error is already set on the transaction" do
@@ -1526,9 +1526,9 @@ describe Appsignal::Transaction do
     let(:transaction) { create_transaction }
 
     let(:error) do
-      e = ExampleStandardError.new("test message")
-      allow(e).to receive(:backtrace).and_return(["line 1"])
-      e
+      ExampleStandardError.new("test message").tap do |e|
+        e.set_backtrace(["line 1"])
+      end
     end
 
     context "when error argument is not an error" do
@@ -1588,9 +1588,9 @@ describe Appsignal::Transaction do
 
     context "when an error is already set in the transaction" do
       let(:other_error) do
-        e = ExampleStandardError.new("other test message")
-        allow(e).to receive(:backtrace).and_return(["line 2"])
-        e
+        ExampleStandardError.new("other test message").tap do |e|
+          e.set_backtrace(["line 2"])
+        end
       end
 
       before { transaction.set_error(other_error) }
@@ -1697,12 +1697,92 @@ describe Appsignal::Transaction do
         end
       end
     end
+
+    context "with a PG::UniqueViolation" do
+      let(:error) do
+        PG::UniqueViolation.new(
+          "ERROR: duplicate key value violates unique constraint " \
+            "\"index_users_on_email\" DETAIL: Key (email)=(test@test.com) already exists."
+        )
+      end
+      before do
+        stub_const("PG::UniqueViolation", Class.new(StandardError))
+        transaction.add_error(error)
+      end
+
+      it "returns a sanizited error message" do
+        expect(transaction).to have_error(
+          "PG::UniqueViolation",
+          "ERROR: duplicate key value violates unique constraint " \
+            "\"index_users_on_email\" DETAIL: Key (email)=(?) already exists."
+        )
+      end
+    end
+
+    context "with a ActiveRecord::RecordNotUnique" do
+      let(:error) do
+        ActiveRecord::RecordNotUnique.new(
+          "PG::UniqueViolation: ERROR: duplicate key value violates unique constraint " \
+            "\"example_constraint\"\nDETAIL: Key (email)=(foo@example.com) already exists."
+        )
+      end
+      before do
+        stub_const("ActiveRecord::RecordNotUnique", Class.new(StandardError))
+        transaction.add_error(error)
+      end
+
+      it "returns a sanizited error message" do
+        expect(transaction).to have_error(
+          "ActiveRecord::RecordNotUnique",
+          "PG::UniqueViolation: ERROR: duplicate key value violates unique constraint " \
+            "\"example_constraint\"\nDETAIL: Key (email)=(?) already exists."
+        )
+      end
+    end
+
+    context "with Rails module but without backtrace_cleaner method" do
+      it "returns the backtrace uncleaned" do
+        stub_const("Rails", Module.new)
+        error = ExampleStandardError.new("error message")
+        error.set_backtrace(["line 1", "line 2"])
+        transaction.add_error(error)
+
+        expect(last_transaction).to have_error(
+          "ExampleStandardError",
+          "error message",
+          ["line 1", "line 2"]
+        )
+      end
+    end
+
+    if rails_present?
+      context "with Rails" do
+        it "cleans the backtrace with the Rails backtrace cleaner" do
+          ::Rails.backtrace_cleaner.add_filter do |line|
+            line.tr("2", "?")
+          end
+
+          error = ExampleStandardError.new("error message")
+          error.set_backtrace(["line 1", "line 2"])
+          transaction.add_error(error)
+          expect(last_transaction).to have_error(
+            "ExampleStandardError",
+            "error message",
+            ["line 1", "line ?"]
+          )
+        end
+      end
+    end
   end
 
   describe "#_set_error" do
     let(:transaction) { new_transaction }
     let(:env) { http_request_env_with_data }
-    let(:error) { ExampleStandardError.new("test message") }
+    let(:error) do
+      ExampleStandardError.new("test message").tap do |e|
+        e.set_backtrace(["line 1"])
+      end
+    end
 
     it "responds to add_exception for backwards compatibility" do
       expect(transaction).to respond_to(:add_exception)
@@ -1716,7 +1796,6 @@ describe Appsignal::Transaction do
 
     context "for a http request" do
       it "sets an error on the transaction" do
-        allow(error).to receive(:backtrace).and_return(["line 1"])
         transaction.send(:_set_error, error)
 
         expect(transaction).to have_error(
@@ -1738,9 +1817,9 @@ describe Appsignal::Transaction do
     context "when the error has multiple causes" do
       let(:error) do
         e = ExampleStandardError.new("test message")
+        e.set_backtrace(["line 1"])
         e2 = RuntimeError.new("cause message")
         e3 = StandardError.new("cause message 2")
-        allow(e).to receive(:backtrace).and_return(["line 1"])
         allow(e).to receive(:cause).and_return(e2)
         allow(e2).to receive(:cause).and_return(e3)
         e
@@ -1795,8 +1874,7 @@ describe Appsignal::Transaction do
           allow(next_e).to receive(:cause).and_return(e)
           e = next_e
         end
-
-        allow(e).to receive(:backtrace).and_return(["line 1"])
+        e.set_backtrace(["line 1"])
         e
       end
 
@@ -1831,7 +1909,7 @@ describe Appsignal::Transaction do
       let(:error) do
         e = ExampleStandardError.new
         allow(e).to receive(:message).and_return(nil)
-        allow(e).to receive(:backtrace).and_return(["line 1"])
+        e.set_backtrace(["line 1"])
         e
       end
 
@@ -1985,80 +2063,6 @@ describe Appsignal::Transaction do
 
   # private
 
-  describe "#cleaned_backtrace" do
-    let(:transaction) { new_transaction }
-    subject { transaction.send(:cleaned_backtrace, ["line 1", "line 2"]) }
-
-    it "returns the backtrace" do
-      expect(subject).to eq ["line 1", "line 2"]
-    end
-
-    context "with Rails module but without backtrace_cleaner method" do
-      it "returns the backtrace uncleaned" do
-        stub_const("Rails", Module.new)
-        expect(subject).to eq ["line 1", "line 2"]
-      end
-    end
-
-    if rails_present?
-      context "with rails" do
-        it "cleans the backtrace with the Rails backtrace cleaner" do
-          ::Rails.backtrace_cleaner.add_filter do |line|
-            line.tr("2", "?")
-          end
-          expect(subject).to eq ["line 1", "line ?"]
-        end
-      end
-    end
-  end
-
-  describe "#cleaned_error_message" do
-    let(:transaction) { new_transaction }
-    let(:error) { StandardError.new("Error message") }
-    subject { transaction.send(:cleaned_error_message, error) }
-
-    it "returns the error message" do
-      expect(subject).to eq "Error message"
-    end
-
-    context "with a PG::UniqueViolation" do
-      before do
-        stub_const("PG::UniqueViolation", Class.new(StandardError))
-      end
-
-      let(:error) do
-        PG::UniqueViolation.new(
-          "ERROR: duplicate key value violates unique constraint " \
-            "\"index_users_on_email\" DETAIL: Key (email)=(test@test.com) already exists."
-        )
-      end
-
-      it "returns a sanizited error message" do
-        expect(subject).to eq "ERROR: duplicate key value violates unique constraint " \
-          "\"index_users_on_email\" DETAIL: Key (email)=(?) already exists."
-      end
-    end
-
-    context "with a ActiveRecord::RecordNotUnique" do
-      before do
-        stub_const("ActiveRecord::RecordNotUnique", Class.new(StandardError))
-      end
-
-      let(:error) do
-        ActiveRecord::RecordNotUnique.new(
-          "PG::UniqueViolation: ERROR: duplicate key value violates unique constraint " \
-            "\"example_constraint\"\nDETAIL: Key (email)=(foo@example.com) already exists."
-        )
-      end
-
-      it "returns a sanizited error message" do
-        expect(subject).to eq \
-          "PG::UniqueViolation: ERROR: duplicate key value violates unique constraint " \
-            "\"example_constraint\"\nDETAIL: Key (email)=(?) already exists."
-      end
-    end
-  end
-
   describe ".to_hash / .to_h" do
     let(:transaction) { new_transaction }
     subject { transaction.to_hash }

data/spec/spec_helper.rb

@@ -85,6 +85,10 @@ RSpec.configure do |config|
     File.join(tmp_dir, "system-tmp")
   end
 
+  config.before :suite do
+    WebMock.disable_net_connect!
+  end
+
   config.before :context do
     FileUtils.rm_rf(tmp_dir)
     FileUtils.mkdir_p(spec_system_tmp_dir)
@@ -94,6 +98,8 @@ RSpec.configure do |config|
     Appsignal.clear!
     Appsignal::Testing.clear!
     Appsignal::Loaders.clear!
+    Appsignal::CheckIn.clear!
+
     clear_current_transaction!
     stop_minutely_probes
     ENV["RAILS_ENV"] ||= "test"
@@ -168,13 +174,6 @@ RSpec.configure do |config|
   end
 
   def stop_minutely_probes
-    thread =
-      begin
-        Appsignal::Probes.class_variable_get(:@@thread) # Fetch old thread
-      rescue NameError
-        nil
-      end
     Appsignal::Probes.stop
-    thread&.join # Wait for old thread to exit
   end
 end

data/spec/support/helpers/api_request_helper.rb

@@ -17,4 +17,44 @@ module ApiRequestHelper
     endpoint = config[:endpoint] || Appsignal::Config::DEFAULT_CONFIG[:endpoint]
     stub_request(:post, "#{endpoint}/1/#{path}").with(options)
   end
+
+  def stub_check_in_request(events:, response: { :status => 200 })
+    config = Appsignal.config
+    options = {
+      :query => {
+        :api_key => config[:push_api_key],
+        :name => config[:name],
+        :environment => config.respond_to?(:env) ? config.env : config[:environment],
+        :hostname => config[:hostname],
+        :gem_version => Appsignal::VERSION
+      },
+      :headers => { "Content-Type" => "application/x-ndjson; charset=UTF-8" }
+    }
+
+    request_stub =
+      stub_request(
+        :post,
+        "#{config[:logging_endpoint]}/check_ins/json"
+      ).with(options) do |request|
+        # Parse each line as JSON per the NDJSON format
+        payloads = request.body.split("\n").map { |line| JSON.parse(line) }
+        formatted_events =
+          events.map do |event|
+            {
+              "identifier" => nil,
+              "digest" => kind_of(String),
+              "kind" => "start",
+              "timestamp" => kind_of(Integer),
+              "check_in_type" => "cron"
+            }.merge(event)
+          end
+        expect(payloads).to include(*formatted_events)
+      end
+
+    if response.is_a?(Exception)
+      request_stub.to_raise(response)
+    else
+      request_stub.to_return(response)
+    end
+  end
 end

data/spec/support/helpers/config_helpers.rb

@@ -46,7 +46,7 @@ module ConfigHelpers
   end
   module_function :build_config
 
-  def start_agent(env: "production", options: {})
+  def start_agent(env: "production", options: {}, internal_logger: nil)
     env = "production" if env == :default
     env ||= "production"
     Appsignal.configure(env, :root_path => project_fixture_path) do |config|
@@ -55,6 +55,7 @@ module ConfigHelpers
       end
     end
     Appsignal.start
+    Appsignal.internal_logger = internal_logger if internal_logger
   end
 
   def clear_integration_env_vars!

data/spec/support/helpers/dependency_helper.rb

@@ -127,6 +127,11 @@ module DependencyHelper
     dependency_present? "que"
   end
 
+  def que2_present?
+    que_present? &&
+      Gem.loaded_specs["que"].version >= Gem::Version.new("2.0.0")
+  end
+
   def hanami_present?
     dependency_present? "hanami"
   end

data/spec/support/matchers/contains_log.rb

@@ -1,14 +1,21 @@
 RSpec::Matchers.define :contains_log do |level, message|
-  expected_log_line = "[#{level.upcase}] #{message}"
+  log_level_prefix = level.upcase
 
   match do |actual|
-    actual.include?(expected_log_line)
+    case message
+    when Regexp
+      /\[#{log_level_prefix}\] #{message}/.match?(actual)
+    else
+      expected_log_line = "[#{log_level_prefix}] #{message}"
+      actual.include?(expected_log_line)
+    end
   end
 
   failure_message do |actual|
     <<~MESSAGE
       Did not contain log line:
-      #{expected_log_line}
+      Log level: #{log_level_prefix}
+      Message: #{message}
 
       Received logs:
       #{actual}

data/spec/support/mocks/hash_like.rb

@@ -0,0 +1,10 @@
+class HashLike < Hash
+  def initialize(value)
+    super
+    @value = value
+  end
+
+  def to_h
+    @value
+  end
+end

data/spec/support/mocks/puma_mock.rb

@@ -0,0 +1,43 @@
+class PumaMock
+  module MiniSSL
+    class SSLError < StandardError
+      def self.to_s
+        "Puma::MiniSSL::SSLError"
+      end
+    end
+  end
+
+  class HttpParserError < StandardError
+    def self.to_s
+      "Puma::HttpParserError"
+    end
+  end
+
+  class HttpParserError501 < StandardError
+    def self.to_s
+      "Puma::HttpParserError501"
+    end
+  end
+
+  def self.stats
+  end
+
+  def self.cli_config
+    @cli_config ||= CliConfig.new
+  end
+
+  class Server
+  end
+
+  module Const
+    VERSION = "6.0.0".freeze
+  end
+
+  class CliConfig
+    attr_accessor :options
+
+    def initialize
+      @options = {}
+    end
+  end
+end

data/spec/support/testing.rb

@@ -47,6 +47,15 @@ module Appsignal
     end
   end
 
+  module CheckIn
+    class << self
+      def clear!
+        @transmitter = nil
+        @scheduler = nil
+      end
+    end
+  end
+
   # @api private
   module Testing
     class << self