ddtrace 1.8.0 → 1.9.0

data/lib/datadog/tracing/contrib/http/instrumentation.rb

@@ -58,7 +58,7 @@ module Datadog
                 end
 
                 # Add additional response specific tags to the span.
-                annotate_span_with_response!(span, response)
+                annotate_span_with_response!(span, response, request_options)
 
                 # Invoke hook, if set.
                 unless Contrib::HTTP::Instrumentation.after_request.nil?
@@ -90,15 +90,12 @@ module Datadog
               set_analytics_sample_rate(span, request_options)
             end
 
-            def annotate_span_with_response!(span, response)
+            def annotate_span_with_response!(span, response, request_options)
               return unless response && response.code
 
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.code)
 
-              case response.code.to_i
-              when 400...599
-                span.set_error(response)
-              end
+              span.set_error(response) if request_options[:error_status_codes].include? response.code.to_i
             end
 
             def annotate_span_with_error!(span, error)

data/lib/datadog/tracing/contrib/httpclient/configuration/settings.rb

@@ -33,6 +33,11 @@ module Datadog
               o.lazy
             end
 
+            option :error_status_codes do |o|
+              o.default { env_to_list(Ext::ENV_ERROR_STATUS_CODES, 400...600, comma_separated_only: false) }
+              o.lazy
+            end
+
             option :split_by_domain, default: false
           end
         end

data/lib/datadog/tracing/contrib/httpclient/ext.rb

@@ -11,6 +11,7 @@ module Datadog
           ENV_SERVICE_NAME = 'DD_TRACE_HTTPCLIENT_SERVICE_NAME'.freeze
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_HTTPCLIENT_ANALYTICS_ENABLED'.freeze
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_HTTPCLIENT_ANALYTICS_SAMPLE_RATE'.freeze
+          ENV_ERROR_STATUS_CODES = 'DD_TRACE_HTTPCLIENT_ERROR_STATUS_CODES'.freeze
           DEFAULT_PEER_SERVICE_NAME = 'httpclient'.freeze
           SPAN_REQUEST = 'httpclient.request'.freeze
           TAG_COMPONENT = 'httpclient'.freeze

data/lib/datadog/tracing/contrib/httpclient/instrumentation.rb

@@ -42,7 +42,7 @@ module Datadog
                 end
 
                 # Add additional response specific tags to the span.
-                annotate_span_with_response!(span, res)
+                annotate_span_with_response!(span, res, request_options)
 
                 res
               end
@@ -72,13 +72,12 @@ module Datadog
               set_analytics_sample_rate(span, req_options)
             end
 
-            def annotate_span_with_response!(span, response)
+            def annotate_span_with_response!(span, response, request_options)
               return unless response && response.status
 
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
 
-              case response.status.to_i
-              when 400...599
+              if request_options[:error_status_codes].include? response.code.to_i
                 span.set_error(["Error #{response.status}", response.body])
               end
             end

data/lib/datadog/tracing/contrib/httprb/configuration/settings.rb

@@ -33,6 +33,11 @@ module Datadog
               o.lazy
             end
 
+            option :error_status_codes do |o|
+              o.default { env_to_list(Ext::ENV_ERROR_STATUS_CODES, 400...600, comma_separated_only: false) }
+              o.lazy
+            end
+
             option :split_by_domain, default: false
           end
         end

data/lib/datadog/tracing/contrib/httprb/ext.rb

@@ -11,6 +11,7 @@ module Datadog
           ENV_SERVICE_NAME = 'DD_TRACE_HTTPRB_SERVICE_NAME'.freeze
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_HTTPRB_ANALYTICS_ENABLED'.freeze
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_EHTTPRB_ANALYTICS_SAMPLE_RATE'.freeze
+          ENV_ERROR_STATUS_CODES = 'DD_TRACE_HTTPCLIENT_ERROR_STATUS_CODES'.freeze
           DEFAULT_PEER_SERVICE_NAME = 'httprb'.freeze
           SPAN_REQUEST = 'httprb.request'.freeze
           TAG_COMPONENT = 'httprb'.freeze

data/lib/datadog/tracing/contrib/httprb/instrumentation.rb

@@ -42,7 +42,7 @@ module Datadog
                 end
 
                 # Add additional response specific tags to the span.
-                annotate_span_with_response!(span, res)
+                annotate_span_with_response!(span, res, request_options)
 
                 res
               end
@@ -81,13 +81,12 @@ module Datadog
               set_analytics_sample_rate(span, req_options)
             end
 
-            def annotate_span_with_response!(span, response)
+            def annotate_span_with_response!(span, response, request_options)
               return unless response && response.code
 
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.code)
 
-              case response.code.to_i
-              when 400...599
+              if request_options[:error_status_codes].include? response.code.to_i
                 # https://github.com/DataDog/dd-trace-rb/issues/1116
                 # parsing the response body message will alter downstream application behavior
                 span.set_error(["Error #{response.code}", 'Error'])

data/lib/datadog/tracing/contrib/pg/instrumentation.rb

@@ -20,63 +20,66 @@ module Datadog
 
           # PG::Connection patch methods
           module InstanceMethods
-            def exec(sql, *args)
-              trace(Ext::SPAN_EXEC, sql: sql) do |sql_statement|
-                super(sql_statement, *args)
+            def exec(sql, *args, &block)
+              trace(Ext::SPAN_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def exec_params(sql, params, *args)
-              trace(Ext::SPAN_EXEC_PARAMS, sql: sql) do |sql_statement|
-                super(sql_statement, params, *args)
+            def exec_params(sql, params, *args, &block)
+              trace(Ext::SPAN_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
-            def exec_prepared(statement_name, params, *args)
-              trace(Ext::SPAN_EXEC_PREPARED, statement_name: statement_name) do
-                super(statement_name, params, *args)
+            def exec_prepared(statement_name, params, *args, &block)
+              trace(Ext::SPAN_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
+                super(statement_name, params, *args, &wrapped_block)
               end
             end
 
-            def async_exec(sql, *args)
-              trace(Ext::SPAN_ASYNC_EXEC, sql: sql) do |sql_statement|
-                super(sql_statement, *args)
+            # async_exec is an alias to exec
+            def async_exec(sql, *args, &block)
+              trace(Ext::SPAN_ASYNC_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def async_exec_params(sql, params, *args)
-              trace(Ext::SPAN_ASYNC_EXEC_PARAMS, sql: sql) do |sql_statement|
-                super(sql_statement, params, *args)
+            # async_exec_params is an alias to exec_params
+            def async_exec_params(sql, params, *args, &block)
+              trace(Ext::SPAN_ASYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
-            def async_exec_prepared(statement_name, params, *args)
-              trace(Ext::SPAN_ASYNC_EXEC_PREPARED, statement_name: statement_name) do
-                super(statement_name, params, *args)
+            # async_exec_prepared is an alias to exec_prepared
+            def async_exec_prepared(statement_name, params, *args, &block)
+              trace(Ext::SPAN_ASYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
+                super(statement_name, params, *args, &wrapped_block)
               end
             end
 
-            def sync_exec(sql, *args)
-              trace(Ext::SPAN_SYNC_EXEC, sql: sql) do |sql_statement|
-                super(sql_statement, *args)
+            def sync_exec(sql, *args, &block)
+              trace(Ext::SPAN_SYNC_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def sync_exec_params(sql, params, *args)
-              trace(Ext::SPAN_SYNC_EXEC_PARAMS, sql: sql) do |sql_statement|
-                super(sql_statement, params, *args)
+            def sync_exec_params(sql, params, *args, &block)
+              trace(Ext::SPAN_SYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
+                super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
-            def sync_exec_prepared(statement_name, params, *args)
-              trace(Ext::SPAN_SYNC_EXEC_PREPARED, statement_name: statement_name) do
-                super(statement_name, params, *args)
+            def sync_exec_prepared(statement_name, params, *args, &block)
+              trace(Ext::SPAN_SYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
+                super(statement_name, params, *args, &wrapped_block)
               end
             end
 
             private
 
-            def trace(name, sql: nil, statement_name: nil)
+            def trace(name, sql: nil, statement_name: nil, block: nil)
               service = Datadog.configuration_for(self, :service_name) || datadog_configuration[:service_name]
               resource = statement_name || sql
 
@@ -101,9 +104,18 @@ module Datadog
                   )
                 end
 
-                result = yield(propagated_sql_statement)
-                annotate_span_with_result!(span, result)
-                result
+                # Read metadata from PG::Result
+                if block
+                  yield(propagated_sql_statement, proc do |result|
+                    ret = block.call(result)
+                    annotate_span_with_result!(span, result)
+                    ret
+                  end)
+                else
+                  result = yield(propagated_sql_statement)
+                  annotate_span_with_result!(span, result)
+                  result
+                end
               end
             end
 
@@ -128,6 +140,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_DESTINATION_PORT, port)
             end
 
+            # @param [PG::Result] result
             def annotate_span_with_result!(span, result)
               span.set_tag(Contrib::Ext::DB::TAG_ROW_COUNT, result.ntuples)
             end

data/lib/datadog/tracing/contrib/stripe/configuration/settings.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        module Configuration
+          # Custom settings for the Stripe integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+
+            option :analytics_enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+              o.lazy
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+              o.lazy
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/stripe/ext.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        # Stripe integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_STRIPE_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_STRIPE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_STRIPE_ANALYTICS_SAMPLE_RATE'
+          SPAN_REQUEST = 'stripe.request'
+          SPAN_TYPE_REQUEST = 'custom'
+          TAG_COMPONENT = 'stripe'
+          TAG_OPERATION_REQUEST = 'request'
+          TAG_REQUEST_HTTP_STATUS = 'stripe.request.http_status'
+          TAG_REQUEST_ID = 'stripe.request.id'
+          TAG_REQUEST_METHOD = 'stripe.request.method'
+          TAG_REQUEST_NUM_RETRIES = 'stripe.request.num_retries'
+          TAG_REQUEST_PATH = 'stripe.request.path'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/stripe/integration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        # Description of Stripe integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('5.15.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :stripe
+
+          def self.version
+            Gem.loaded_specs['stripe'] && Gem.loaded_specs['stripe'].version
+          end
+
+          def self.loaded?
+            !defined?(::Stripe).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/stripe/patcher.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# typed: false
+
+require_relative '../patcher'
+require_relative 'request'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        # Provides instrumentation for `stripe` through the Stripe instrumentation framework
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::Stripe::Instrumentation.subscribe(:request_begin, :datadog_tracing) { |event| Request.start_span(event) }
+            ::Stripe::Instrumentation.subscribe(:request_end, :datadog_tracing) { |event| Request.finish_span(event) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/stripe/request.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../../analytics'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        # Defines instrumentation for Stripe requests
+        module Request
+          module_function
+
+          def start_span(event)
+            # Start a trace
+            Tracing.trace(Ext::SPAN_REQUEST).tap do |span|
+              event.user_data[:datadog_span] = span
+            end
+          end
+
+          def finish_span(event)
+            span = event.user_data[:datadog_span]
+            # If no active span, return.
+            return nil if span.nil?
+
+            begin
+              tag_span(span, event)
+            ensure
+              # Finish the span
+              span.finish
+            end
+          end
+
+          def tag_span(span, event)
+            # dependent upon stripe/stripe-ruby#1168
+            span.resource = "stripe.#{event.object_name}" if event.respond_to?(:object_name) && event.object_name
+
+            span.span_type = Ext::SPAN_TYPE_REQUEST
+            span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            span.set_tag(Ext::TAG_REQUEST_ID, event.request_id)
+            span.set_tag(Ext::TAG_REQUEST_HTTP_STATUS, event.http_status.to_s)
+            span.set_tag(Ext::TAG_REQUEST_METHOD, event.method)
+            span.set_tag(Ext::TAG_REQUEST_PATH, event.path)
+            span.set_tag(Ext::TAG_REQUEST_NUM_RETRIES, event.num_retries.to_s)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:stripe]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib.rb

@@ -75,4 +75,5 @@ require_relative 'contrib/shoryuken/integration'
 require_relative 'contrib/sidekiq/integration'
 require_relative 'contrib/sinatra/integration'
 require_relative 'contrib/sneakers/integration'
+require_relative 'contrib/stripe/integration'
 require_relative 'contrib/sucker_punch/integration'

data/lib/datadog/tracing/distributed/trace_context.rb

@@ -43,7 +43,7 @@ module Datadog
 
           return unless trace_id # Could not parse traceparent
 
-          tracestate, sampling_priority, origin, tags = extract_tracestate(fetcher[@tracestate_key])
+          tracestate, sampling_priority, origin, tags, unknown_fields = extract_tracestate(fetcher[@tracestate_key])
 
           sampling_priority = parse_priority_sampling(sampled, sampling_priority)
 
@@ -54,8 +54,9 @@ module Datadog
             trace_sampling_priority: sampling_priority,
             trace_distributed_tags: tags,
             trace_distributed_id: trace_id,
+            trace_flags: trace_flags,
             trace_state: tracestate,
-            trace_flags: trace_flags
+            trace_state_unknown_fields: unknown_fields,
           )
         end
 
@@ -152,6 +153,8 @@ module Datadog
             end
           end
 
+          tracestate << digest.trace_state_unknown_fields if digest.trace_state_unknown_fields
+
           # Is there any Datadog-specific information to propagate.
           # Check for > 3 size because the empty prefix `dd=` has 3 characters.
           if tracestate.size > 3
@@ -268,21 +271,23 @@ module Datadog
           vendors = split_tracestate(tracestate)
 
           # Find Datadog's `dd=` tracestate field.
-          dd_tracestate = vendors.find { |v| v.start_with?('dd=') }
-          return tracestate unless dd_tracestate
+          idx = vendors.index { |v| v.start_with?('dd=') }
+          return tracestate unless idx
 
           # Delete `dd=` prefix
+          dd_tracestate = vendors.delete_at(idx)
           dd_tracestate.slice!(0..2)
 
-          origin, sampling_priority, tags = extract_datadog_fields(dd_tracestate)
+          origin, sampling_priority, tags, unknown_fields = extract_datadog_fields(dd_tracestate)
 
-          [tracestate, sampling_priority, origin, tags]
+          [vendors.join(','), sampling_priority, origin, tags, unknown_fields]
         end
 
         def extract_datadog_fields(dd_tracestate)
           sampling_priority = nil
           origin = nil
           tags = nil
+          unknown_fields = nil
 
           # DEV: Since Ruby 2.6 `split` can receive a block, so `each` can be removed then.
           dd_tracestate.split(';').each do |pair|
@@ -299,10 +304,14 @@ module Datadog
 
               tags ||= {}
               tags["#{Tracing::Metadata::Ext::Distributed::TAGS_PREFIX}#{key}"] = value
+            else
+              unknown_fields ||= String.new
+              unknown_fields << pair
+              unknown_fields << ';'
             end
           end
 
-          [origin, sampling_priority, tags]
+          [origin, sampling_priority, tags, unknown_fields]
         end
 
         # Restore `:` back to `=`.

data/lib/datadog/tracing/metadata/tagging.rb

@@ -110,6 +110,12 @@ module Datadog
           metrics.delete(key)
         end
 
+        # Returns a copy of all metadata.
+        # Keys for `@meta` and `@metrics` don't collide, by construction.
+        def tags
+          @meta.merge(@metrics)
+        end
+
         protected
 
         def meta

data/lib/datadog/tracing/trace_digest.rb

@@ -59,15 +59,22 @@ module Datadog
       #   This attribute will preserve the original id, while `trace_id` will only contain the lower 64 bits.
       #   @return [Integer]
       #   @see https://www.w3.org/TR/trace-context/#trace-id
-      # @!attribute [r] trace_tracestate
-      #   The W3C "tracestate" extracted from a distributed context.
-      #   This field is a string representing vendor-specific distribution data.
-      #   @return [String]
-      #   @see https://www.w3.org/TR/trace-context/#tracestate-header
       # @!attribute [r] trace_flags
       #   The W3C "trace-flags" extracted from a distributed context. This field is an 8-bit unsigned integer.
       #   @return [Integer]
       #   @see https://www.w3.org/TR/trace-context/#trace-flags
+      # @!attribute [r] trace_state
+      #   The W3C "tracestate" extracted from a distributed context.
+      #   This field is a string representing vendor-specific distribution data.
+      #   The `dd=` entry is removed from `trace_state` as its value is dynamically calculated
+      #   on every propagation injection.
+      #   @return [String]
+      #   @see https://www.w3.org/TR/trace-context/#tracestate-header
+      # @!attribute [r] trace_state_unknown_fields
+      #   From W3C "tracestate"'s `dd=` entry, when keys are not recognized they are stored here long with their values.
+      #   This allows later propagation to include those unknown fields, as they can represent future versions of the spec
+      #   sending data through this service. This value ends in a trailing `;` to facilitate serialization.
+      #   @return [String]
       # TODO: The documentation for the last attribute above won't be rendered.
       # TODO: This might be a YARD bug as adding an attribute, making it now second-last attribute, renders correctly.
       attr_reader \
@@ -88,7 +95,8 @@ module Datadog
         :trace_service,
         :trace_distributed_id,
         :trace_flags,
-        :trace_state
+        :trace_state,
+        :trace_state_unknown_fields
 
       def initialize(
         span_id: nil,
@@ -108,7 +116,8 @@ module Datadog
         trace_service: nil,
         trace_distributed_id: nil,
         trace_flags: nil,
-        trace_state: nil
+        trace_state: nil,
+        trace_state_unknown_fields: nil
       )
         @span_id = span_id
         @span_name = span_name && span_name.dup.freeze
@@ -128,6 +137,7 @@ module Datadog
         @trace_distributed_id = trace_distributed_id
         @trace_flags = trace_flags
         @trace_state = trace_state && trace_state.dup.freeze
+        @trace_state_unknown_fields = trace_state_unknown_fields && trace_state_unknown_fields.dup.freeze
 
         freeze
       end

data/lib/datadog/tracing/trace_operation.rb

@@ -463,6 +463,14 @@ module Datadog
       def distributed_tags
         meta.select { |name, _| name.start_with?(Metadata::Ext::Distributed::TAGS_PREFIX) }
       end
+
+      def reset
+        @root_span = nil
+        @active_span = nil
+        @active_span_count = 0
+        @finished = false
+        @spans = []
+      end
     end
   end
 end

data/lib/ddtrace/version.rb

@@ -3,7 +3,7 @@
 module DDTrace
   module VERSION
     MAJOR = 1
-    MINOR = 8
+    MINOR = 9
     PATCH = 0
     PRE = nil