scout_apm 6.2.0 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da81dd5963b5868fe7ab83e62c6bf6609679bb48de5935c2fd87c5695f5b3469
-  data.tar.gz: 8485eba7342b830f01b4e9345d116de1c83f373f7b228bbee0c2eac346931043
+  metadata.gz: fe18e4045997fdf6b731025ee98c13e2702096a0cfd13ac5f0f651d7a7f4a4db
+  data.tar.gz: d9b4593ef2b8d5df4983d7b93cb9eaf5cc3f7e6916d8288ae9814e59dd913007
 SHA512:
-  metadata.gz: f44f9ac827d187f2c775c20ae04031024913ba27f1b621a4e2e882308779502e29e9648be8da2d283a75dfd30d27ec7299c1dee7d49d0e78d4150ad79ab40d44
-  data.tar.gz: 1a2a82c2c17b935a048c6d3f200da1b161e8cdba3b37bc7860ecaf978cfe946f81df624ba0febfbd4e1d3a57b61a22c5a4385b4ee8178f422dcfa2857ace7ad9
+  metadata.gz: a5b838d8e12286496038899c7dd006b6c3d6507061bcba1a963fc10664fa96e36c603f71e315430eda9eeaa84dabadb21f91dee9e9aa9baf7009f6e03d8f3d9d
+  data.tar.gz: bee9ed547611139d56eb6f88cf6c1e730dc77dbdf575e89a8b1cd95f86756687174c78b64cf00acd389a74e90198f9750aec334e2dfba195340a0a9753c280bd

data/CHANGELOG.markdown

@@ -1,5 +1,16 @@
 # Pending
 
+# 6.3.0
+
+- Fix span leak on `ActionController::Live` streaming requests (#631)
+
+# 6.2.1
+
+- Fix `SystemStackError` with `grape >= 3.3.0` by falling back to `prepend` instrumentation when Grape owns `Endpoint#run` itself (#624)
+- Fix a GraphQL layer leak where an unhandled exception skipping `end_execute_field` could leave stale layers on the request (#626)
+- Honor `SCOUT_LOG_LEVEL` during agent bootstrap instead of always logging at the default level (#628)
+- Use `HEROKU_BUILD_COMMIT` for Heroku git revision detection, since `HEROKU_SLUG_COMMIT` is deprecated (#625)
+
 # 6.2.0
 
 - Fix compatibility with `http >= 6.0.0` (#613)

data/gems/instruments-ruby4.gemfile

@@ -10,3 +10,4 @@ gem 'moped'
 gem 'actionpack'
 gem 'actionview'
 gem 'httpx'
+gem 'grape'

data/gems/instruments.gemfile

@@ -7,3 +7,4 @@ gem 'moped'
 gem 'actionpack'
 gem 'actionview'
 gem 'httpx'
+gem 'grape'

data/lib/scout_apm/agent_context.rb

@@ -259,7 +259,7 @@ module ScoutApm
     end
 
     def self.build_minimal_logger
-      ScoutApm::Logger.new(nil, :stdout => true)
+      ScoutApm::Logger.new(nil, :stdout => true, :log_level => ENV["SCOUT_LOG_LEVEL"])
     end
   end
 end

data/lib/scout_apm/git_revision.rb

@@ -26,7 +26,9 @@ module ScoutApm
     end
 
     def detect_from_heroku
-      ENV['HEROKU_SLUG_COMMIT']
+      # HEROKU_SLUG_COMMIT is deprecated in favor of HEROKU_BUILD_COMMIT.
+      # https://devcenter.heroku.com/articles/dyno-metadata#usage
+      ENV['HEROKU_BUILD_COMMIT'] || ENV['HEROKU_SLUG_COMMIT']
     end
 
     # Config will locate the value from:

data/lib/scout_apm/instrument_manager.rb

@@ -41,6 +41,7 @@ module ScoutApm
       install_instrument(ScoutApm::Instruments::Elasticsearch)
       install_instrument(ScoutApm::Instruments::OpenSearch)
       install_instrument(ScoutApm::Instruments::Grape)
+      install_instrument(ScoutApm::Instruments::GraphQL)
     rescue
       logger.warn "Exception loading instruments:"
       logger.warn $!.message

data/lib/scout_apm/instruments/grape.rb

@@ -20,16 +20,35 @@ module ScoutApm
         if defined?(::Grape) && defined?(::Grape::Endpoint)
           @installed = true
 
-          logger.info "Instrumenting Grape::Endpoint"
+          # Grape >= 3.3.0 prepends a module of its own (Grape::Testing::RunBeforeEach)
+          # in front of Grape::Endpoint#run. An alias-method chain built on a method
+          # owned by a prepended module recurses infinitely (SystemStackError), because
+          # the aliased copy's `super` resolves back into our wrapper. Whenever #run is
+          # not owned by Grape::Endpoint itself, prepend is the only safe option.
+          prepend = true unless endpoint_owns_run?
 
-          ::Grape::Endpoint.class_eval do
-            include ScoutApm::Instruments::GrapeEndpointInstruments
+          logger.info "Instrumenting Grape::Endpoint. Prepend: #{prepend}"
 
-            alias run_without_scout_instruments run
-            alias run run_with_scout_instruments
+          if prepend
+            ::Grape::Endpoint.send(:prepend, GrapeEndpointInstrumentsPrepend)
+          else
+            ::Grape::Endpoint.class_eval do
+              include ScoutApm::Instruments::GrapeEndpointInstruments
+
+              alias run_without_scout_instruments run
+              alias run run_with_scout_instruments
+            end
           end
         end
       end
+
+      private
+
+      def endpoint_owns_run?
+        ::Grape::Endpoint.instance_method(:run).owner == ::Grape::Endpoint
+      rescue NameError
+        true
+      end
     end
 
     module GrapeEndpointInstruments
@@ -68,6 +87,42 @@ module ScoutApm
         end
       end
     end
+
+    module GrapeEndpointInstrumentsPrepend
+      def run(*args)
+        request = ::Grape::Request.new(env || args.first)
+        req = ScoutApm::RequestManager.lookup
+
+        path = ScoutApm::Agent.instance.context.config.value("uri_reporting") == 'path' ? request.path : request.fullpath
+        req.annotate_request(:uri => path)
+
+        # IP Spoofing Protection can throw an exception, just move on w/o remote ip
+        req.context.add_user(:ip => request.ip) rescue nil
+
+        req.set_headers(request.headers)
+
+        begin
+          name = ["Grape",
+                  self.options[:method].first,
+                  self.options[:for].to_s,
+                  self.namespace.sub(%r{\A/}, ''), # removing leading slashes
+                  self.options[:path].first,
+          ].compact.map{ |n| n.to_s }.join("/")
+        rescue => e
+          ScoutApm::Agent.instance.context.logger.info("Error getting Grape Endpoint Name. Error: #{e.message}. Options: #{self.options.inspect}")
+          name = "Grape/Unknown"
+        end
+
+        req.start_layer( ScoutApm::Layer.new("Controller", name) )
+        begin
+          super(*args)
+        rescue
+          req.error!
+          raise
+        ensure
+          req.stop_layer
+        end
+      end
+    end
   end
 end
-

data/lib/scout_apm/instruments/graphql.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ScoutApm
+  module Instruments
+    class GraphQL
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+        @installed = false
+      end
+
+      def logger
+        context.logger
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install(prepend: false)
+        return unless defined?(::GraphQL::Tracing::ScoutTrace)
+
+        @installed = true
+        logger.info "Instrumenting GraphQL::Tracing::ScoutTrace"
+        ::GraphQL::Tracing::ScoutTrace.prepend(ScoutApm::Instruments::GraphQLExecuteFieldGuard)
+      end
+    end
+
+    # Prepended onto GraphQL::Tracing::ScoutTrace to guarantee that every
+    # Scout layer opened during a GraphQL multiplex is closed before control
+    # returns to the Scout Rack middleware.
+    #
+    # graphql-ruby's interpreter calls begin_execute_field / end_execute_field
+    # around each field resolver. When an unhandled exception causes
+    # end_execute_field to be skipped (runtime.rb lines 465-479), the
+    # corresponding ScoutApm::Layer is never popped from TrackedRequest#@layers.
+    # finalized? never returns true, record! is never called, and
+    # Thread.current[:scout_request] accumulates every subsequent request's
+    # layers without bound.
+    #
+    # This guard snapshots the open layer count before executing the multiplex
+    # and pops any excess layers in an ensure block, independent of whichever
+    # internal trace hooks graphql-ruby happens to use. It has no dependency on
+    # MonitorTrace's field-tracing condition or event slot architecture, so it
+    # remains correct even if those internals change.
+    module GraphQLExecuteFieldGuard
+      def execute_multiplex(multiplex:)
+        req = ScoutApm::RequestManager.lookup
+        layers_before = req.layer_count
+        super
+      ensure
+        extra = req.layer_count - layers_before
+        extra.times { req.stop_layer } if extra > 0
+      end
+    end
+  end
+end

data/lib/scout_apm/request_manager.rb

@@ -7,11 +7,23 @@ module ScoutApm
       find || create
     end
 
-    # Get the current Thread local, and detecting, and not returning a stale request
+    # Get the current Thread local, detecting and not returning a stale request,
+    # nor a request that belongs to a different thread.
     def self.find
       req = Thread.current[:scout_request]
+      return nil unless req
 
-      if req && (req.stopping? || req.recorded?)
+      # ActionController::Live runs the controller action in a child thread and
+      # copies the parent thread's raw Thread.current locals (including
+      # :scout_request) into it. Without this check the parent (Rack) thread and
+      # the child (streaming) thread would share and concurrently mutate a single
+      # TrackedRequest -- racing on @layers/@stopping -- which corrupts the layer
+      # stack, drops the transaction, and leaks layers across requests. If the
+      # resident request was created on a different thread, treat it as absent so
+      # lookup creates a fresh one owned by this thread.
+      return nil if req.creating_thread_id != Thread.current.object_id
+
+      if req.stopping? || req.recorded?
         nil
       else
         req

data/lib/scout_apm/tracked_request.rb

@@ -74,9 +74,24 @@ module ScoutApm
       @recorder = agent_context.recorder
       @real_request = false
       @transaction_id = ScoutApm::Utils::TransactionId.new.to_s
+      # The thread this request was created on. ActionController::Live copies the
+      # raw Thread.current locals (including :scout_request) into its streaming
+      # child thread, which would otherwise cause two threads to share and race
+      # on one TrackedRequest. RequestManager uses this to detect an inherited
+      # request and give the child its own instead. See RequestManager.find.
+      @creating_thread_id = Thread.current.object_id
       ignore_request! if @recorder.nil?
     end
 
+    # The object_id of the Thread that created this request. Used to detect a
+    # TrackedRequest that was inherited by a different thread (e.g. an
+    # ActionController::Live streaming thread) rather than created for it.
+    attr_reader :creating_thread_id
+
+    def layer_count
+      @layers.size
+    end
+
     def start_layer(layer)
       # If we're already stopping, don't do additional layers
       return if stopping?
@@ -364,14 +379,21 @@ module ScoutApm
       end
     end
 
-    # This request is a job transaction iff it has a 'Job' layer
-    # Use this only during recording
+    # True iff this request has a 'Job' layer. Only reliable during recording --
+    # see #web? for why.
     def job?
       layer_finder.job != nil
     end
 
-    # This request is a web transaction iff it has a 'Controller' layer
-    # Use this only during recording
+    # True iff this request has a 'Controller' layer.
+    #
+    # Only reliable during recording; returns false mid-request even for a real
+    # web request. #layer_finder walks root_layer's child *tree*, but layers are
+    # attached to that tree only in #stop_layer (via add_child), not in
+    # #start_layer. Controller/Job are top-level spans, so they stop last --
+    # meaning web?/job? only resolve as the request unwinds into recording.
+    # (Negative results aren't memoized, so an early false doesn't poison a
+    # later check.)
     def web?
       layer_finder.controller != nil
     end

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "6.2.0"
+  VERSION = "6.3.0"
 end

data/lib/scout_apm.rb

@@ -102,6 +102,7 @@ require 'scout_apm/instruments/middleware_summary'
 require 'scout_apm/instruments/middleware_detailed' # Disabled by default, see the file for more details
 require 'scout_apm/instruments/rails_router'
 require 'scout_apm/instruments/grape'
+require 'scout_apm/instruments/graphql'
 require 'scout_apm/instruments/sinatra'
 require 'allocations'
 

data/test/unit/agent_context_test.rb

@@ -3,6 +3,15 @@ require "test_helper"
 require "scout_apm/agent_context"
 
 class AgentContextTest < Minitest::Test
+  def test_bootstrap_logger_uses_scout_log_level
+    original_log_level = ENV["SCOUT_LOG_LEVEL"]
+    ENV["SCOUT_LOG_LEVEL"] = "error"
+
+    assert_equal ::Logger::ERROR, ScoutApm::AgentContext.new.logger.log_level
+  ensure
+    ENV["SCOUT_LOG_LEVEL"] = original_log_level
+  end
+
   def test_has_error_service_ignored_exceptions
     context = ScoutApm::AgentContext.new
     assert ScoutApm::ErrorService::IgnoredExceptions, context.ignored_exceptions.class
@@ -26,4 +35,4 @@ class AgentContextTest < Minitest::Test
     context.slow_request_policy.add(TestPolicy.new)
     assert 5, context.slow_request_policy.policies
   end
-end
+end

data/test/unit/git_revision_test.rb

@@ -34,6 +34,19 @@ class GitRevisionTest < Minitest::Test
     assert_equal 'heroku_slug', revision.sha
   end
 
+  def test_sha_from_heroku_build_commit
+    ENV['HEROKU_BUILD_COMMIT'] = 'heroku_build'
+    revision = ScoutApm::GitRevision.new(ScoutApm::AgentContext.new)
+    assert_equal 'heroku_build', revision.sha
+  end
+
+  def test_sha_from_heroku_prefers_build_commit_over_deprecated_slug_commit
+    ENV['HEROKU_BUILD_COMMIT'] = 'heroku_build'
+    ENV['HEROKU_SLUG_COMMIT'] = 'heroku_slug'
+    revision = ScoutApm::GitRevision.new(ScoutApm::AgentContext.new)
+    assert_equal 'heroku_build', revision.sha
+  end
+
   def test_sha_from_capistrano
     Dir.mktmpdir do |dir|
       context = context_with_file_in_root(File.join(dir, 'REVISION'), 'capistrano_sha')

data/test/unit/instruments/grape_test.rb

@@ -0,0 +1,83 @@
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
+
+  require 'test_helper'
+
+  require 'grape'
+  require 'scout_apm/instruments/grape'
+
+  class GrapeTest < Minitest::Test
+    # Captured before the instrument is installed. On grape >= 3.3.0 #run is
+    # owned by the prepended Grape::Testing::RunBeforeEach module, not the
+    # Grape::Endpoint class itself.
+    GRAPE_ENDPOINT_OWNS_RUN = ::Grape::Endpoint.instance_method(:run).owner == ::Grape::Endpoint
+
+    class HelloAPI < ::Grape::API
+      format :json
+
+      get :hello do
+        { message: 'hello' }
+      end
+    end
+
+    # Install exactly once for the entire test run. Re-running an
+    # alias-method install would alias the wrapper onto itself.
+    def self.install_instruments
+      @install_instruments ||= begin
+        context = ScoutApm::AgentContext.new
+        instrument_manager = ScoutApm::InstrumentManager.new(context)
+        instance = ScoutApm::Instruments::Grape.new(context)
+        instance.install(prepend: instrument_manager.prepend_for_instrument?(instance.class))
+        instance
+      end
+    end
+
+    def setup
+      @instance = self.class.install_instruments
+    end
+
+    def test_installed
+      assert @instance.installed?
+    end
+
+    # Grape >= 3.3.0 prepends Grape::Testing::RunBeforeEach in front of
+    # Grape::Endpoint#run. Building an alias-method chain on top of the
+    # prepended method caused infinite recursion (SystemStackError) as soon
+    # as any endpoint was called.
+    def test_endpoint_runs_without_infinite_recursion
+      status, _headers, body = HelloAPI.call(Rack::MockRequest.env_for('/hello'))
+
+      assert_equal 200, status
+
+      body_content = "".dup
+      body.each { |chunk| body_content << chunk }
+      assert_includes body_content, 'hello'
+    end
+
+    # Either instrumentation method is valid: alias_method is the default,
+    # prepend is used when configured (`use_prepend`/`prepend_instruments`)
+    # or when the instrument falls back to it for safety.
+    def test_installs_using_prepend_or_alias_method
+      assert prepended? || aliased?, "expected Grape::Endpoint to be instrumented via prepend or alias_method"
+
+      unless GRAPE_ENDPOINT_OWNS_RUN
+        # On grape >= 3.3.0 #run is owned by a module prepended onto
+        # Grape::Endpoint, where an alias-method chain would recurse, so the
+        # instrument must have used prepend even though alias_method is the
+        # default.
+        assert prepended?, "grape >= 3.3.0 requires the prepend instrumentation method"
+        refute aliased?, "the alias-method chain must not be installed over a prepended #run"
+      end
+    end
+
+    private
+
+    def prepended?
+      ::Grape::Endpoint.ancestors.include?(ScoutApm::Instruments::GrapeEndpointInstrumentsPrepend)
+    end
+
+    def aliased?
+      ::Grape::Endpoint.method_defined?(:run_without_scout_instruments) ||
+        ::Grape::Endpoint.private_method_defined?(:run_without_scout_instruments)
+    end
+  end
+end

data/test/unit/request_manager_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+# Tests for RequestManager's thread-local handling, in particular that a
+# TrackedRequest created on one thread is NOT shared with another thread.
+#
+# ActionController::Live runs the controller action in a child thread and copies
+# the parent (Rack) thread's raw Thread.current locals -- including
+# :scout_request -- into it. Without protection both threads would share and
+# concurrently mutate a single TrackedRequest, racing on @layers/@stopping,
+# which drops the transaction and leaks layers. RequestManager must give the
+# inheriting thread its own request instead.
+class RequestManagerTest < Minitest::Test
+  def teardown
+    # Never let a test leak the thread-local into sibling tests.
+    Thread.current[:scout_request] = nil
+  end
+
+  def test_lookup_reuses_the_request_on_the_same_thread
+    first  = ScoutApm::RequestManager.lookup
+    second = ScoutApm::RequestManager.lookup
+
+    assert_same first, second,
+      "lookup should return the same TrackedRequest on repeated calls within one thread"
+  end
+
+  def test_lookup_in_a_child_thread_that_inherited_the_local_gets_its_own_request
+    parent_request = ScoutApm::RequestManager.lookup
+    inherited = Thread.current[:scout_request]
+
+    child_request = nil
+    child_local_before = nil
+
+    t = Thread.new do
+      # Simulate ActionController::Live copying the parent's raw thread local
+      # into the streaming child thread.
+      Thread.current[:scout_request] = inherited
+      child_local_before = Thread.current[:scout_request]
+
+      child_request = ScoutApm::RequestManager.lookup
+    end
+    t.join
+
+    # The child observed the inherited (parent's) request as its raw local...
+    assert_same parent_request, child_local_before
+
+    # ...but lookup must NOT hand it the parent's request to mutate.
+    refute_nil child_request
+    refute_same parent_request, child_request,
+      "a thread that inherited another thread's :scout_request must get its own TrackedRequest"
+
+    # And the parent's request must be left untouched (still the parent's).
+    assert_same parent_request, Thread.current[:scout_request]
+  end
+
+  def test_find_treats_a_foreign_thread_request_as_absent
+    # A request that reports it was created on a different thread should not be
+    # returned by find (so lookup falls through to create).
+    foreign = ScoutApm::TrackedRequest.new(ScoutApm::Agent.instance.context, ScoutApm::FakeStore.new)
+    foreign.stubs(:creating_thread_id).returns(Thread.current.object_id + 1)
+    Thread.current[:scout_request] = foreign
+
+    assert_nil ScoutApm::RequestManager.find,
+      "find should treat a request created on another thread as absent"
+  end
+
+  def test_find_returns_a_same_thread_request
+    own = ScoutApm::RequestManager.lookup
+    assert_same own, ScoutApm::RequestManager.find
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.3.0
 platform: ruby
 authors:
 - Derek Haynes
@@ -314,6 +314,7 @@ files:
 - lib/scout_apm/instruments/active_record.rb
 - lib/scout_apm/instruments/elasticsearch.rb
 - lib/scout_apm/instruments/grape.rb
+- lib/scout_apm/instruments/graphql.rb
 - lib/scout_apm/instruments/http.rb
 - lib/scout_apm/instruments/http_client.rb
 - lib/scout_apm/instruments/httpx.rb
@@ -464,6 +465,7 @@ files:
 - test/unit/instruments/fixtures/test/_test_partial.html.erb
 - test/unit/instruments/fixtures/test/_test_partial_collection.html.erb
 - test/unit/instruments/fixtures/test_view.html.erb
+- test/unit/instruments/grape_test.rb
 - test/unit/instruments/http_client_test.rb
 - test/unit/instruments/http_test.rb
 - test/unit/instruments/httpx_test.rb
@@ -484,6 +486,7 @@ files:
 - test/unit/remote/route_test.rb
 - test/unit/remote/server_test.rb
 - test/unit/request_histograms_test.rb
+- test/unit/request_manager_test.rb
 - test/unit/sampling_test.rb
 - test/unit/scored_item_set_test.rb
 - test/unit/serializers/payload_serializer_test.rb
@@ -520,7 +523,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Ruby application performance monitoring
 test_files: []