Move Grape span resource setting to beginning of request

As of #1623, the profiler records the `resource` of the root span,
on top of the span id and trace id during sampling.

Also, as discusssed in the description of #1623 (in the
"Getting the correct `resource`" section) integrations where the
`resource` is only set at the end pose an extra challenge, as the
request may not be finished in time for the `resource` to be included
in the profiler payload.
This means that the profiler may miss the `resource` for some of the
requests, depending on timing of when the sampling happens and when the
request finishes.
(Note that in this case, the trace id and span id will still be
propagated, so the samples will always be able to be tied back to the
trace that originated them; it's just the `resource` that will not be
included in the profiler data).

To avoid this issue for many of our customers, let's move the Grape
`resource` setting to the beginning of the request, thus avoiding
the issue altogether for this integration.

(Note: This is similar to what we did for Rails in #1626 and Sinatra
in #1628)

Author: ivoanjo

Gemfile

@@ -75,3 +75,6 @@ gem 'google-protobuf', ['~> 3.0', '!= 3.7.0', '!= 3.7.1'] if RUBY_PLATFORM != 'j
 # For type checking
 gem 'sorbet', '>= 0.5.6513', '< 0.6' if RUBY_VERSION >= '2.3.0'
 gem 'spoom', '~> 1.1' if RUBY_VERSION >= '2.4.0'
+
+gem 'grape'
+gem 'rack-test'

lib/ddtrace/contrib/grape/endpoint.rb

@@ -34,17 +34,27 @@ def subscribe
             end
           end
 
-          def endpoint_start_process(*)
+          def endpoint_start_process(_name, _start, _finish, _id, payload)
             return if Thread.current[KEY_RUN]
             return unless enabled?
 
+            # collect endpoint details
+            endpoint = payload.fetch(:endpoint)
+            api_view = api_view(endpoint.options[:for])
+            request_method = endpoint.options.fetch(:method).first
+            path = endpoint_expand_path(endpoint)
+            resource = "#{api_view} #{request_method} #{path}"
+
             # Store the beginning of a trace
-            tracer.trace(
+            span = tracer.trace(
               Ext::SPAN_ENDPOINT_RUN,
               service: service_name,
-              span_type: Datadog::Ext::HTTP::TYPE_INBOUND
+              span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
+              resource: resource,
             )
 
+            try_setting_rack_request_resource(payload, span.resource)
+
             Thread.current[KEY_RUN] = true
           rescue StandardError => e
             Datadog.logger.error(e.message)
@@ -62,20 +72,12 @@ def endpoint_run(name, start, finish, id, payload)
 
             begin
               # collect endpoint details
-              api = payload[:endpoint].options[:for]
+              endpoint = payload.fetch(:endpoint)
+              api_view = api_view(endpoint.options[:for])
+              request_method = endpoint.options.fetch(:method).first
+              path = endpoint_expand_path(endpoint)
 
-              api_view = api_view(api)
-
-              request_method = payload[:endpoint].options[:method].first
-              path = endpoint_expand_path(payload[:endpoint])
-              resource = "#{api_view} #{request_method} #{path}"
-              span.resource = resource
-
-              # set the request span resource if it's a `rack.request` span
-              request_span = payload[:env][Datadog::Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
-              if !request_span.nil? && request_span.name == Datadog::Contrib::Rack::Ext::SPAN_REQUEST
-                request_span.resource = resource
-              end
+              try_setting_rack_request_resource(payload, span.resource)
 
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
@@ -230,6 +232,13 @@ def enabled?
           def datadog_configuration
             Datadog.configuration[:grape]
           end
+
+          def try_setting_rack_request_resource(payload, resource)
+            request_span = payload[:env][Datadog::Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+            if !request_span.nil? && request_span.name == Datadog::Contrib::Rack::Ext::SPAN_REQUEST
+              request_span.resource = resource
+            end
+          end
         end
       end
     end

lib/ddtrace/contrib/grape/instrumentation.rb

@@ -24,7 +24,7 @@ def generate_api_method(*params, &block)
         # InstanceMethods - implementing instrumentation
         module InstanceMethods
           def run(*args)
-            ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process')
+            ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process', endpoint: self, env: env)
             super
           end
         end

spec/ddtrace/contrib/grape/tracer_spec.rb

@@ -16,8 +16,11 @@
   let(:run_span) { spans.find { |x| x.name == Datadog::Contrib::Grape::Ext::SPAN_ENDPOINT_RUN } }
   let(:run_filter_span) { spans.find { |x| x.name == Datadog::Contrib::Grape::Ext::SPAN_ENDPOINT_RUN_FILTERS } }
   let(:span) { spans.last }
+  let(:observed) { {} }
 
   let(:testing_api) do
+    observed = self.observed
+
     # patch Grape before the application
     Datadog::Contrib::Grape::Patcher.patch
 
@@ -80,10 +83,20 @@
           end
         end
       end
+
+      resource :span_resource do
+        get :span_resource do
+          root_span = Datadog.tracer.active_root_span
+          observed[:root_span] = { name: root_span.name, resource: root_span.resource }
+          'OK'
+        end
+      end
     end)
   end
 
   let(:rack_testing_api) do
+    observed = self.observed
+
     # patch Grape before the application
     Datadog::Contrib::Grape::Patcher.patch
 
@@ -97,6 +110,22 @@
       get :hard_failure do
         raise StandardError, 'Ouch!'
       end
+
+      resource :span_resource_rack do
+        get :span_resource do
+          endpoint_span = Datadog.tracer.active_span.parent
+          observed[:endpoint_span] = { name: endpoint_span.name, resource: endpoint_span.resource }
+          root_span = Datadog.tracer.active_root_span
+          observed[:root_span] = { name: root_span.name, resource: root_span.resource }
+          'OK'
+        end
+
+        get :custom_span_resource do
+          endpoint_span = Datadog.tracer.active_span.parent
+          endpoint_span.resource = 'CustomSpanResource'
+          'OK'
+        end
+      end
     end)
 
     # create a custom Rack application with the Rack middleware and a Grape API
@@ -498,6 +527,19 @@
         end
       end
     end
+
+    describe 'span resource' do
+      subject(:response) { get '/span_resource/span_resource' }
+
+      before do
+        is_expected.to be_ok
+      end
+
+      it 'sets the request (root) span resource before calling the endpoint' do
+        expect(observed[:root_span])
+          .to eq(name: 'grape.endpoint_run', resource: 'TestingAPI GET /span_resource/span_resource')
+      end
+    end
   end
 
   context 'with rack' do
@@ -519,7 +561,7 @@
         let(:analytics_sample_rate_var) { Datadog::Contrib::Grape::Ext::ENV_ANALYTICS_SAMPLE_RATE }
       end
 
-      it 'intergrates with the Rack integration' do
+      it 'integrates with the Rack integration' do
         is_expected.to be_ok
         expect(response.body).to eq('OK')
         expect(spans.length).to eq(3)
@@ -634,5 +676,31 @@
         expect(rack_span.parent).to be_nil
       end
     end
+
+    describe 'span resource' do
+      subject(:response) { get '/api/span_resource_rack/span_resource' }
+
+      before do
+        is_expected.to be_ok
+      end
+
+      it 'sets the request (grape) span resource before calling the endpoint' do
+        expect(observed[:endpoint_span])
+          .to eq(name: 'grape.endpoint_run', resource: 'RackTestingAPI GET /span_resource_rack/span_resource')
+      end
+
+      it 'sets the rack (root) span resource before calling the endpoint' do
+        expect(observed[:root_span])
+          .to eq(name: 'rack.request', resource: 'RackTestingAPI GET /span_resource_rack/span_resource')
+      end
+
+      context 'when a custom request span resource is applied' do
+        subject(:response) { get '/api/span_resource_rack/custom_span_resource' }
+
+        it 'propagates the custom request span resource to the rack (root) span resource' do
+          expect(spans.last.resource).to eq('CustomSpanResource')
+        end
+      end
+    end
   end
 end