appsignal 3.1.1 → 3.1.4

data/lib/appsignal/transaction.rb

@@ -35,10 +35,24 @@ module Appsignal
         end
       end
 
+      # Returns currently active transaction or a {NilTransaction} if none is
+      # active.
+      #
+      # @see .current?
+      # @return [Boolean]
       def current
         Thread.current[:appsignal_transaction] || NilTransaction.new
       end
 
+      # Returns if any transaction is currently active or not. A
+      # {NilTransaction} is not considered an active transaction.
+      #
+      # @see .current
+      # @return [Boolean]
+      def current?
+        current && !current.nil_transaction?
+      end
+
       def complete_current!
         current.complete
       rescue => e
@@ -52,11 +66,6 @@ module Appsignal
       def clear_current_transaction!
         Thread.current[:appsignal_transaction] = nil
       end
-
-      def garbage_collection_profiler
-        @garbage_collection_profiler ||=
-          Appsignal.config[:enable_gc_instrumentation] ? Appsignal::GarbageCollectionProfiler.new : NilGarbageCollectionProfiler.new
-      end
     end
 
     attr_reader :ext, :transaction_id, :action, :namespace, :request, :paused, :tags, :options, :discarded, :breadcrumbs
@@ -89,7 +98,7 @@ module Appsignal
       @ext = Appsignal::Extension.start_transaction(
         @transaction_id,
         @namespace,
-        self.class.garbage_collection_profiler.total_time
+        0
       ) || Appsignal::Extension::MockTransaction.new
     end
 
@@ -103,9 +112,7 @@ module Appsignal
           "because it was manually discarded."
         return
       end
-      if @ext.finish(self.class.garbage_collection_profiler.total_time)
-        sample_data
-      end
+      sample_data if @ext.finish(0)
       @ext.complete
     end
 
@@ -341,7 +348,7 @@ module Appsignal
 
     def start_event
       return if paused?
-      @ext.start_event(self.class.garbage_collection_profiler.total_time)
+      @ext.start_event(0)
     end
 
     def finish_event(name, title, body, body_format = Appsignal::EventFormatter::DEFAULT)
@@ -351,7 +358,7 @@ module Appsignal
         title || BLANK,
         body || BLANK,
         body_format || Appsignal::EventFormatter::DEFAULT,
-        self.class.garbage_collection_profiler.total_time
+        0
       )
     end
 
@@ -363,7 +370,7 @@ module Appsignal
         body || BLANK,
         body_format || Appsignal::EventFormatter::DEFAULT,
         duration,
-        self.class.garbage_collection_profiler.total_time
+        0
       )
     end
 

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.1.1".freeze
+  VERSION = "3.1.4".freeze
 end

data/lib/appsignal.rb

@@ -115,11 +115,6 @@ module Appsignal
             Appsignal::Environment.report_enabled("allocation_tracking")
           end
 
-          if config[:enable_gc_instrumentation]
-            GC::Profiler.enable
-            Appsignal::Environment.report_enabled("gc_instrumentation")
-          end
-
           Appsignal::Minutely.start if config[:enable_minutely_probes]
 
           collect_environment_metadata
@@ -298,7 +293,7 @@ require "appsignal/hooks"
 require "appsignal/probes"
 require "appsignal/marker"
 require "appsignal/minutely"
-require "appsignal/garbage_collection_profiler"
+require "appsignal/garbage_collection"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"

data/spec/lib/appsignal/config_spec.rb

@@ -156,7 +156,6 @@ describe Appsignal::Config do
         :debug                          => false,
         :dns_servers                    => [],
         :enable_allocation_tracking     => true,
-        :enable_gc_instrumentation      => false,
         :enable_host_metrics            => true,
         :enable_minutely_probes         => true,
         :enable_statsd                  => true,

data/spec/lib/appsignal/{garbage_collection_profiler_spec.rb → garbage_collection_spec.rb}

@@ -1,11 +1,33 @@
-describe Appsignal::GarbageCollectionProfiler do
+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
-    allow_any_instance_of(described_class)
-      .to receive(:internal_profiler)
-      .and_return(internal_profiler)
+    stub_const("GC::Profiler", internal_profiler)
   end
 
   context "on initialization" do
@@ -54,7 +76,7 @@ describe Appsignal::GarbageCollectionProfiler do
 
       2.times do
         threads << Thread.new do
-          profiler = Appsignal::GarbageCollectionProfiler.new
+          profiler = Appsignal::GarbageCollection::Profiler.new
           results << profiler.total_time
         end
       end
@@ -65,7 +87,7 @@ describe Appsignal::GarbageCollectionProfiler do
   end
 end
 
-describe Appsignal::NilGarbageCollectionProfiler do
+describe Appsignal::GarbageCollection::NilProfiler do
   let(:profiler) { described_class.new }
 
   describe "#total_time" do

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

@@ -19,7 +19,8 @@ end
 
 describe Appsignal::Probes::MriProbe do
   let(:appsignal_mock) { AppsignalMock.new(:hostname => hostname) }
-  let(:probe) { described_class.new(appsignal_mock) }
+  let(:gc_profiler_mock) { instance_double("Appsignal::GarbageCollectionProfiler") }
+  let(:probe) { described_class.new(:appsignal => appsignal_mock, :gc_profiler => gc_profiler_mock) }
 
   describe ".dependencies_present?" do
     if DependencyHelper.running_jruby? || DependencyHelper.running_ruby_2_0?
@@ -36,6 +37,10 @@ describe Appsignal::Probes::MriProbe do
   unless DependencyHelper.running_jruby? || DependencyHelper.running_ruby_2_0?
     describe "#call" do
       let(:hostname) { nil }
+      before do
+        allow(gc_profiler_mock).to receive(:total_time)
+        allow(GC::Profiler).to receive(:enabled?).and_return(true)
+      end
 
       it "should track vm metrics" do
         probe.call
@@ -48,9 +53,56 @@ describe Appsignal::Probes::MriProbe do
         expect_gauge_value("thread_count")
       end
 
-      it "tracks GC total time" do
+      it "tracks GC time between measurements" do
+        expect(gc_profiler_mock).to receive(:total_time).and_return(10, 15)
+        probe.call
         probe.call
-        expect_gauge_value("gc_total_time")
+        expect_gauge_value("gc_time", 5)
+      end
+
+      context "when GC total time overflows" do
+        it "skips one report" do
+          expect(gc_profiler_mock).to receive(:total_time).and_return(10, 15, 0, 10)
+          probe.call # Normal call, create a cache
+          probe.call # Report delta value based on cached value
+          probe.call # The value overflows and reports no value. Then stores 0 in the cache
+          probe.call # Report new value based on cache of 0
+          expect_gauges([["gc_time", 5], ["gc_time", 10]])
+        end
+      end
+
+      context "when GC profiling is disabled" do
+        it "does not report a gc_time metric" do
+          allow(GC::Profiler).to receive(:enabled?).and_return(false)
+          expect(gc_profiler_mock).to_not receive(:total_time)
+          probe.call # Normal call, create a cache
+          probe.call # Report delta value based on cached value
+          metrics = appsignal_mock.gauges.map { |(key)| key }
+          expect(metrics).to_not include("gc_time")
+        end
+
+        it "does not report a gc_time metric while temporarily disabled" do
+          # While enabled
+          allow(GC::Profiler).to receive(:enabled?).and_return(true)
+          expect(gc_profiler_mock).to receive(:total_time).and_return(10, 15)
+          probe.call # Normal call, create a cache
+          probe.call # Report delta value based on cached value
+          expect_gauges([["gc_time", 5]])
+
+          # While disabled
+          allow(GC::Profiler).to receive(:enabled?).and_return(false)
+          probe.call # Call twice to make sure any caches resets wouldn't mess up the assertion
+          probe.call
+          # Does not include any newly reported metrics
+          expect_gauges([["gc_time", 5]])
+
+          # When enabled after being disabled for a while, it only reports the
+          # newly reported time since it was renabled
+          allow(GC::Profiler).to receive(:enabled?).and_return(true)
+          expect(gc_profiler_mock).to receive(:total_time).and_return(25)
+          probe.call
+          expect_gauges([["gc_time", 5], ["gc_time", 10]])
+        end
       end
 
       it "tracks GC run count" do
@@ -107,4 +159,15 @@ describe Appsignal::Probes::MriProbe do
       end
     end
   end
+
+  def expect_gauges(expected_metrics)
+    default_tags = { :hostname => Socket.gethostname }
+    keys = expected_metrics.map { |(key)| key }
+    metrics = expected_metrics.map do |metric|
+      key, value, tags = metric
+      [key, value, default_tags.merge(tags || {})]
+    end
+    found_gauges = appsignal_mock.gauges.select { |(key)| keys.include? key }
+    expect(found_gauges).to eq(metrics)
+  end
 end

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

@@ -3,20 +3,37 @@ if DependencyHelper.rails_present?
   end
 
   describe Appsignal::Rack::RailsInstrumentation do
-    before :context do
+    let(:log) { StringIO.new }
+    before do
       start_agent
+      Appsignal.logger = test_logger(log)
     end
 
+    let(:params) do
+      {
+        "controller" => "blog_posts",
+        "action" => "show",
+        "id" => "1",
+        "my_custom_param" => "my custom secret",
+        "password" => "super secret"
+      }
+    end
+    let(:env_extra) { {} }
     let(:app) { double(:call => true) }
     let(:env) do
-      http_request_env_with_data("action_dispatch.request_id" => "1").tap do |request|
-        request["action_controller.instance"] = double(
+      http_request_env_with_data({
+        :params => params,
+        :with_queue_start => true,
+        "action_dispatch.request_id" => "1",
+        "action_dispatch.parameter_filter" => [:my_custom_param, :password],
+        "action_controller.instance" => double(
           :class => MockController,
           :action_name => "index"
         )
-      end
+      }.merge(env_extra))
     end
     let(:middleware) { Appsignal::Rack::RailsInstrumentation.new(app, {}) }
+    around { |example| keep_transactions { example.run } }
 
     describe "#call" do
       before do
@@ -46,30 +63,62 @@ if DependencyHelper.rails_present?
       after { 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(
-          "1",
-          Appsignal::Transaction::HTTP_REQUEST,
-          kind_of(ActionDispatch::Request),
-          :params_method => :filtered_parameters
-        ).and_return(
-          instance_double(
-            "Appsignal::Transaction",
-            :set_action => nil,
-            :set_action_if_nil => nil,
-            :set_http_or_background_queue_start => nil,
-            :set_metadata => nil
+    describe "#call_with_appsignal_monitoring" do
+      def run
+        middleware.call(env)
+      end
+
+      it "calls the wrapped app" do
+        run
+        expect(app).to have_received(:call).with(env)
+      end
+
+      it "creates one transaction with metadata" do
+        run
+
+        expect(created_transactions.length).to eq(1)
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash).to include(
+          "namespace" => Appsignal::Transaction::HTTP_REQUEST,
+          "action" => "MockController#index",
+          "metadata" => hash_including(
+            "method" => "GET",
+            "path" => "/blog"
+          )
+        )
+        expect(last_transaction.ext.queue_start).to eq(
+          fixed_time * 1_000.0
+        )
+      end
+
+      it "filter parameters in Rails" do
+        run
+
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash).to include(
+          "sample_data" => hash_including(
+            "params" => params.merge(
+              "my_custom_param" => "[FILTERED]",
+              "password" => "[FILTERED]"
+            )
           )
         )
       end
 
-      it "should call the app" do
-        expect(app).to receive(:call).with(env)
+      context "with an invalid HTTP request method" do
+        let(:env_extra) { { :request_method => "FOO", "REQUEST_METHOD" => "FOO" } }
+
+        it "does not store the HTTP request method" do
+          run
+
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash["metadata"]).to_not have_key("method")
+          expect(log_contents(log)).to contains_log(:error, "Unable to report HTTP request method: '")
+        end
       end
 
-      context "with an exception", :error => true do
-        let(:error) { ExampleException }
+      context "with an exception" do
+        let(:error) { ExampleException.new("ExampleException message") }
         let(:app) do
           double.tap do |d|
             allow(d).to receive(:call).and_raise(error)
@@ -77,21 +126,16 @@ if DependencyHelper.rails_present?
         end
 
         it "records the exception" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
-        end
-      end
+          expect { run }.to raise_error(error)
 
-      it "should set metadata" do
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
-      end
-
-      it "should set the action and queue start" do
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("MockController#index")
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash["error"]).to include(
+            "name" => "ExampleException",
+            "message" => "ExampleException message",
+            "backtrace" => kind_of(String)
+          )
+        end
       end
-
-      after(:error => false) { middleware.call(env) }
-      after(:error => true) { expect { middleware.call(env) }.to raise_error(error) }
     end
 
     describe "#request_id" do

data/spec/lib/appsignal/transaction_spec.rb

@@ -85,7 +85,9 @@ describe Appsignal::Transaction do
     end
 
     describe ".current" do
-      subject { Appsignal::Transaction.current }
+      def current_transaction
+        Appsignal::Transaction.current
+      end
 
       context "when there is a current transaction" do
         let!(:transaction) do
@@ -93,13 +95,17 @@ describe Appsignal::Transaction do
         end
 
         it "reads :appsignal_transaction from the current Thread" do
-          expect(subject).to eq Thread.current[:appsignal_transaction]
-          expect(subject).to eq transaction
+          expect(current_transaction).to eq Thread.current[:appsignal_transaction]
+          expect(current_transaction).to eq transaction
         end
 
         it "is not a NilTransaction" do
-          expect(subject.nil_transaction?).to eq false
-          expect(subject).to be_a Appsignal::Transaction
+          expect(current_transaction.nil_transaction?).to eq false
+          expect(current_transaction).to be_a Appsignal::Transaction
+        end
+
+        it "returns true for current?" do
+          expect(Appsignal::Transaction.current?).to be(true)
         end
       end
 
@@ -109,8 +115,12 @@ describe Appsignal::Transaction do
         end
 
         it "returns a NilTransaction stub" do
-          expect(subject.nil_transaction?).to eq true
-          expect(subject).to be_a Appsignal::Transaction::NilTransaction
+          expect(current_transaction.nil_transaction?).to eq true
+          expect(current_transaction).to be_a Appsignal::Transaction::NilTransaction
+        end
+
+        it "returns false for current?" do
+          expect(Appsignal::Transaction.current?).to be(false)
         end
       end
     end
@@ -782,23 +792,6 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe "#garbage_collection_profiler" do
-      before { Appsignal::Transaction.instance_variable_set(:@garbage_collection_profiler, nil) }
-
-      it "returns the NilGarbageCollectionProfiler" do
-        expect(Appsignal::Transaction.garbage_collection_profiler).to be_a(Appsignal::NilGarbageCollectionProfiler)
-      end
-
-      context "when gc profiling is enabled" do
-        before { Appsignal.config.config_hash[:enable_gc_instrumentation] = true }
-        after { Appsignal.config.config_hash[:enable_gc_instrumentation] = false }
-
-        it "returns the GarbageCollectionProfiler" do
-          expect(Appsignal::Transaction.garbage_collection_profiler).to be_a(Appsignal::GarbageCollectionProfiler)
-        end
-      end
-    end
-
     describe "#start_event" do
       it "starts the event in the extension" do
         expect(transaction.ext).to receive(:start_event).with(0).and_call_original
@@ -817,11 +810,7 @@ describe Appsignal::Transaction do
     end
 
     describe "#finish_event" do
-      let(:fake_gc_time) { 123 }
-      before do
-        expect(described_class.garbage_collection_profiler)
-          .to receive(:total_time).at_least(:once).and_return(fake_gc_time)
-      end
+      let(:fake_gc_time) { 0 }
 
       it "should finish the event in the extension" do
         expect(transaction.ext).to receive(:finish_event).with(
@@ -868,11 +857,7 @@ describe Appsignal::Transaction do
     end
 
     describe "#record_event" do
-      let(:fake_gc_time) { 123 }
-      before do
-        expect(described_class.garbage_collection_profiler)
-          .to receive(:total_time).at_least(:once).and_return(fake_gc_time)
-      end
+      let(:fake_gc_time) { 0 }
 
       it "should record the event in the extension" do
         expect(transaction.ext).to receive(:record_event).with(

data/spec/lib/appsignal_spec.rb

@@ -54,20 +54,12 @@ describe Appsignal do
         Appsignal.start
       end
 
-      context "when allocation tracking and gc instrumentation have been enabled" do
+      context "when allocation tracking has been enabled" do
         before do
-          allow(GC::Profiler).to receive(:enable)
           Appsignal.config.config_hash[:enable_allocation_tracking] = true
-          Appsignal.config.config_hash[:enable_gc_instrumentation] = true
           capture_environment_metadata_report_calls
         end
 
-        it "should enable Ruby's GC::Profiler" do
-          expect(GC::Profiler).to receive(:enable)
-          Appsignal.start
-          expect_environment_metadata("ruby_gc_instrumentation_enabled", "true")
-        end
-
         unless DependencyHelper.running_jruby?
           it "installs the allocation event hook" do
             expect(Appsignal::Extension).to receive(:install_allocation_event_hook)
@@ -78,29 +70,17 @@ describe Appsignal do
         end
       end
 
-      context "when allocation tracking and gc instrumentation have been disabled" do
+      context "when allocation tracking has been disabled" do
         before do
           Appsignal.config.config_hash[:enable_allocation_tracking] = false
-          Appsignal.config.config_hash[:enable_gc_instrumentation] = false
           capture_environment_metadata_report_calls
         end
 
-        it "should not enable Ruby's GC::Profiler" do
-          expect(GC::Profiler).not_to receive(:enable)
-          Appsignal.start
-        end
-
         it "should not install the allocation event hook" do
           expect(Appsignal::Minutely).not_to receive(:install_allocation_event_hook)
           Appsignal.start
           expect_not_environment_metadata("ruby_allocation_tracking_enabled")
         end
-
-        it "should not add the gc probe to minutely" do
-          expect(Appsignal::Minutely).not_to receive(:register_garbage_collection_probe)
-          Appsignal.start
-          expect_not_environment_metadata("ruby_gc_instrumentation_enabled")
-        end
       end
 
       context "when minutely metrics has been enabled" do
@@ -511,7 +491,14 @@ describe Appsignal do
       before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
 
       context "with transaction" do
-        let(:transaction) { double }
+        let(:transaction) { http_request_transaction }
+        around do |example|
+          Appsignal.config = project_fixture_config
+          set_current_transaction transaction do
+            example.run
+          end
+        end
+
         it "should call add_breadcrumb on transaction" do
           expect(transaction).to receive(:add_breadcrumb)
             .with("Network", "http", "User made network request", { :response => 200 }, fixed_time)

data/spec/support/helpers/env_helpers.rb

@@ -1,7 +1,8 @@
 module EnvHelpers
   def http_request_env_with_data(args = {})
+    with_queue_start = args.delete(:with_queue_start)
     path = args.delete(:path) || "/blog"
-    Rack::MockRequest.env_for(
+    request = Rack::MockRequest.env_for(
       path,
       :params => args[:params] || {
         "controller" => "blog_posts",
@@ -18,6 +19,13 @@ module EnvHelpers
       :db_runtime => 500,
       :metadata => { :key => "value" }
     ).merge(args)
+
+    # Set default queue value
+    if with_queue_start
+      request["HTTP_X_QUEUE_START"] = "t=#{(fixed_time * 1_000).to_i}" # in milliseconds
+    end
+
+    request
   end
 
   def background_env_with_data(args = {})

data/spec/support/helpers/transaction_helpers.rb

@@ -46,8 +46,14 @@ module TransactionHelpers
 
   # Set current transaction manually.
   # Cleared by {clear_current_transaction!}
+  #
+  # When a block is given, the current transaction is automatically unset after
+  # the block.
   def set_current_transaction(transaction) # rubocop:disable Naming/AccessorMethodName
     Thread.current[:appsignal_transaction] = transaction
+    yield if block_given?
+  ensure
+    clear_current_transaction! if block_given?
   end
 
   # Use when {Appsignal::Transaction.clear_current_transaction!} is stubbed to

data/spec/support/testing.rb

@@ -50,6 +50,17 @@ module Appsignal
 
   class Extension
     class Transaction
+      if Appsignal.extension_loaded?
+        attr_reader :queue_start
+        alias original_set_queue_start set_queue_start
+        # Temporary helper until the extension returns this information
+        # https://github.com/appsignal/appsignal-agent/issues/293
+        def set_queue_start(start) # rubocop:disable Naming/AccessorMethodName
+          @queue_start = start
+          original_set_queue_start(start)
+        end
+      end
+
       alias original_finish finish if method_defined? :finish
 
       # Override default {Extension::Transaction#finish} behavior to always