datadog 2.1.0 → 2.3.0

data/lib/datadog/tracing/contrib/rails/runner.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rails
+        # Instruments the `bin/rails runner` command.
+        # This command executes the provided code with the host Rails application loaded.
+        # The command can be either:
+        # * `-`: for code provided through the STDIN.
+        # * File path: for code provided through a local file.
+        # * `inline code`: for code provided directly as a command line argument.
+        # @see https://guides.rubyonrails.org/v6.1/command_line.html#bin-rails-runner
+        module Runner
+          # Limit the maximum size of the source code captured in the source tag.
+          MAX_TAG_VALUE_SIZE = 4096
+          private_constant :MAX_TAG_VALUE_SIZE
+
+          def runner(code_or_file = nil, *_command_argv)
+            if code_or_file == '-'
+              name = Ext::SPAN_RUNNER_STDIN
+              resource = nil
+              operation = Ext::TAG_OPERATION_STDIN
+              # The source is not yet available for STDIN, but it will be captured in `eval`.
+            elsif File.exist?(code_or_file)
+              name = Ext::SPAN_RUNNER_FILE
+              resource = code_or_file
+              operation = Ext::TAG_OPERATION_FILE
+              source = File.read(code_or_file)
+            else
+              name = Ext::SPAN_RUNNER_INLINE
+              resource = nil
+              operation = Ext::TAG_OPERATION_INLINE
+              source = code_or_file
+            end
+
+            Tracing.trace(
+              name,
+              service: Datadog.configuration.tracing[:rails][:service_name],
+              resource: resource,
+              tags: {
+                Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
+                Tracing::Metadata::Ext::TAG_OPERATION => operation,
+              }
+            ) do |span|
+              if source
+                span.set_tag(
+                  Ext::TAG_RUNNER_SOURCE,
+                  Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
+                )
+              end
+              Contrib::Analytics.set_rate!(span, Datadog.configuration.tracing[:rails])
+
+              super
+            end
+          end
+
+          # Capture the executed source code when provided from STDIN.
+          def eval(*args)
+            span = Datadog::Tracing.active_span
+            if span.name == Ext::SPAN_RUNNER_STDIN
+              source = args[0]
+              span.set_tag(
+                Ext::TAG_RUNNER_SOURCE,
+                Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
+              )
+            end
+
+            super
+          end
+
+          ruby2_keywords :eval if respond_to?(:ruby2_keywords, true)
+        end
+
+        # The instrumentation target, {Rails::Command::RunnerCommand} is only loaded
+        # right before `bin/rails runner` is executed. This means there's not much
+        # opportunity to patch it ahead of time.
+        # To ensure we can patch it successfully, we patch it's caller, {Rails::Command}
+        # and promptly patch {Rails::Command::RunnerCommand} when it is loaded.
+        module Command
+          def find_by_namespace(*args)
+            ret = super
+            # Patch RunnerCommand if it is loaded and not already patched.
+            if defined?(::Rails::Command::RunnerCommand) && !(::Rails::Command::RunnerCommand < Runner)
+              ::Rails::Command::RunnerCommand.prepend(Runner)
+            end
+            ret
+          end
+
+          ruby2_keywords :find_by_namespace if respond_to?(:ruby2_keywords, true)
+        end
+      end
+    end
+  end
+end

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

@@ -46,6 +46,11 @@ module Datadog
               o.default Contrib::Propagation::SqlComment::Ext::DISABLED
             end
 
+            option :append_comment do |o|
+              o.type :bool
+              o.default false
+            end
+
             option :peer_service do |o|
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE

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

@@ -49,13 +49,16 @@ module Datadog
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
+                span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, connection_options[:database])
                 span.set_tag(Ext::TAG_DB_NAME, connection_options[:database])
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, connection_options[:host])
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, connection_options[:port])
 
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
 
-                propagation_mode = Contrib::Propagation::SqlComment::Mode.new(comment_propagation)
+                propagation_mode = Contrib::Propagation::SqlComment::Mode.new(
+                  comment_propagation, datadog_configuration[:append_comment]
+                )
 
                 Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
                 sql = Contrib::Propagation::SqlComment.prepend_comment(

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -14,8 +14,8 @@ module Datadog
 
         def self.collect_and_log!(responses: nil)
           if log?
-            env_data = EnvironmentCollector.collect_config!
-            log_configuration!('TRACING', env_data.to_json)
+            log_configuration!('TRACING', EnvironmentCollector.collect_config!.to_json)
+            log_debug!('TRACING INTEGRATIONS', EnvironmentCollector.collect_integrations_settings!.to_json)
 
             if responses
               err_data = EnvironmentCollector.collect_errors!(responses)
@@ -40,7 +40,6 @@ module Datadog
               sampling_rules: sampling_rules,
               integrations_loaded: integrations_loaded,
               partial_flushing_enabled: partial_flushing_enabled,
-              **instrumented_integrations_settings
             }
           end
 
@@ -128,6 +127,18 @@ module Datadog
             !!Datadog.configuration.tracing.partial_flush.enabled
           end
 
+          def collect_integrations_settings!
+            instrumented_integrations.each_with_object({}) do |(name, integration), result|
+              integration.configuration.to_h.each do |setting, value|
+                next if setting == :tracer # Skip internal objects
+
+                # Convert value to a string to avoid custom #to_json
+                # handlers possibly causing errors.
+                result[:"#{name}_#{setting}"] = value.to_s
+              end
+            end
+          end
+
           private
 
           def instrumented_integrations
@@ -139,19 +150,6 @@ module Datadog
 
             Datadog.configuration.tracing.instrumented_integrations
           end
-
-          # Capture all active integration settings into "integrationName_settingName: value" entries.
-          def instrumented_integrations_settings
-            instrumented_integrations.flat_map do |name, integration|
-              integration.configuration.to_h.flat_map do |setting, value|
-                next [] if setting == :tracer # Skip internal Ruby objects
-
-                # Convert value to a string to avoid custom #to_json
-                # handlers possibly causing errors.
-                [[:"integration_#{name}_#{setting}", value.to_s]]
-              end
-            end.to_h
-          end
         end
       end
     end

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

@@ -31,7 +31,7 @@ module Datadog
 
           # DEV: We need these to be hex encoded
           data[@trace_id_key] = format('%032x', digest.trace_id)
-          data[@span_id_key] = format('%016x', digest.span_id)
+          data[@span_id_key] = format('%016x', digest.span_id || 0) # # Fall back to zero (invalid) if not present
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(

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

@@ -25,8 +25,10 @@ module Datadog
         def inject!(digest, env)
           return if digest.nil?
 
+          span_id = digest.span_id || 0 # Fall back to zero (invalid) if not present
+
           # DEV: We need these to be hex encoded
-          value = "#{format('%032x', digest.trace_id)}-#{format('%016x', digest.span_id)}"
+          value = "#{format('%032x', digest.trace_id)}-#{format('%016x', span_id)}"
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(

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

@@ -42,7 +42,7 @@ module Datadog
 
           data[@trace_id_key] = Tracing::Utils::TraceId.to_low_order(digest.trace_id).to_s
 
-          data[@parent_id_key] = digest.span_id.to_s
+          data[@parent_id_key] = digest.span_id.to_s if digest.span_id
           data[@sampling_priority_key] = digest.trace_sampling_priority.to_s if digest.trace_sampling_priority
           data[@origin_key] = digest.trace_origin.to_s if digest.trace_origin
 
@@ -109,7 +109,7 @@ module Datadog
 
           return tags if high_order == 0
 
-          tags.merge(Tracing::Metadata::Ext::Distributed::TAG_TID => high_order.to_s(16))
+          tags.merge(Tracing::Metadata::Ext::Distributed::TAG_TID => format('%016x', high_order))
         end
 
         # Side effect: Remove high order 64 bit hex-encoded `tid` tag from distributed tags

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

@@ -32,7 +32,9 @@ module Datadog
 
         # inject! populates the env with span ID, trace ID and sampling priority
         #
-        # This method will never raise errors, but instead log them to `Datadog.logger`.
+        # This method will never raise errors.
+        # It can propagate partial data, if deemed useful, instead of failing.
+        # In case of unrecoverable errors, it will log them to `Datadog.logger`.
         #
         # DEV-2.0: inject! should work without arguments, injecting the active_trace's digest
         # DEV-2.0: and returning a new Hash with the injected data.
@@ -45,7 +47,7 @@ module Datadog
         # @param digest [TraceDigest]
         # @param data [Hash]
         # @return [Boolean] `true` if injected successfully, `false` if no propagation style is configured
-        # @return [nil] in case of error, see `Datadog.logger` output for details.
+        # @return [nil] in case of unrecoverable errors, see `Datadog.logger` output for details.
         def inject!(digest, data)
           if digest.nil?
             ::Datadog.logger.debug('Cannot inject distributed trace data: digest is nil.')
@@ -54,6 +56,11 @@ module Datadog
 
           digest = digest.to_digest if digest.respond_to?(:to_digest)
 
+          if digest.trace_id.nil?
+            ::Datadog.logger.debug('Cannot inject distributed trace data: digest.trace_id is nil.')
+            return nil
+          end
+
           result = false
 
           # Inject all configured propagation styles

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

@@ -107,7 +107,7 @@ module Datadog
         def build_traceparent(digest)
           build_traceparent_string(
             digest.trace_id,
-            digest.span_id,
+            digest.span_id || 0, # Fall back to zero (invalid) if not present
             build_trace_flags(digest)
           )
         end
@@ -198,7 +198,8 @@ module Datadog
 
         def last_dd_parent_id(digest)
           if !digest.span_remote
-            "p:#{format('%016x', digest.span_id)};"
+            span_id = digest.span_id || 0 # Fall back to zero (invalid) if not present
+            "p:#{format('%016x', span_id)};"
           elsif digest.trace_distributed_tags&.key?(Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID)
             "p:#{digest.trace_distributed_tags[Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID]};"
           else

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

@@ -10,8 +10,16 @@ module Datadog
       # Adds error tagging behavior
       # @public_api
       module Errors
-        # Mark the span with the given error.
         def set_error(e)
+          Datadog::Core.log_deprecation do
+            'Errors.set_error(..) is deprecated. ' \
+            'Use Errors.set_error_tags(..) instead.'
+          end
+          set_error_tags(e)
+        end
+
+        # Mark the span with the given error.
+        def set_error_tags(e)
           e = Core::Error.build_from(e)
 
           set_tag(Ext::Errors::TAG_TYPE, e.type) unless e.type.empty?

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

@@ -14,6 +14,10 @@ module Datadog
         # Type of operation being performed (e.g. )
         TAG_OPERATION = 'operation'
         # Hostname of external service interacted with
+        #
+        # This tag also doesn't strictly need to be a “hostname”. It can be a raw IP address and in some cases it
+        # can even be a unix domain socket (i.e. postgres client setting host=/var/run/postgres).
+        # It should be whatever the client uses to point at the server it’s trying to talk to.
         TAG_PEER_HOSTNAME = 'peer.hostname'
         # Name of external service that performed the work
         TAG_PEER_SERVICE = 'peer.service'

data/lib/datadog/tracing/pipeline/span_filter.rb

@@ -10,8 +10,8 @@ module Datadog
       # This processor executes the configured `operation` for each {Datadog::Tracing::Span}
       # in a {Datadog::Tracing::TraceSegment}.
       #
-      # If `operation` returns a truthy value for a span, that span is kept,
-      # otherwise the span is removed from the trace.
+      # If `operation` returns a truthy value for a span, that span is dropped,
+      # otherwise the span is kept.
       #
       # @public_api
       class SpanFilter < SpanProcessor

data/lib/datadog/tracing/span.rb

@@ -27,6 +27,7 @@ module Datadog
         :resource,
         :service,
         :links,
+        :events,
         :type,
         :start_time,
         :status,
@@ -45,6 +46,7 @@ module Datadog
       # * +parent_id+: the identifier of the parent span
       # * +trace_id+: the identifier of the root span for this trace
       # * +service_entry+: whether it is a service entry span.
+      # * +events+: the list of events that occurred while a span was active.
       def initialize(
         name,
         duration: nil,
@@ -60,7 +62,8 @@ module Datadog
         type: nil,
         trace_id: nil,
         service_entry: nil,
-        links: nil
+        links: nil,
+        events: nil
       )
         @name = Core::Utils::SafeDup.frozen_or_dup(name)
         @service = Core::Utils::SafeDup.frozen_or_dup(service)
@@ -90,6 +93,8 @@ module Datadog
 
         @links = links || []
 
+        @events = events || []
+
         # Mark with the service entry span metric, if applicable
         set_metric(Metadata::Ext::TAG_TOP_LEVEL, 1.0) if service_entry
       end
@@ -112,7 +117,7 @@ module Datadog
 
       def set_error(e)
         @status = Metadata::Ext::Errors::STATUS
-        super
+        set_error_tags(e)
       end
 
       # Spans with the same ID are considered the same span
@@ -149,6 +154,8 @@ module Datadog
           h[:duration] = duration_nano
         end
 
+        h[:meta]['events'] = @events.map(&:to_hash).to_json unless @events.empty?
+
         h
       end
 

data/lib/datadog/tracing/span_event.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Datadog
+  module Tracing
+    # Represents a timestamped annotation on a span. It is analogous to structured log message.
+    # @public_api
+    class SpanEvent
+      # @!attribute [r] name
+      #   @return [Integer]
+      attr_reader :name
+
+      # @!attribute [r] attributes
+      #   @return [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+      attr_reader :attributes
+
+      # @!attribute [r] time_unix_nano
+      #   @return [Integer]
+      attr_reader :time_unix_nano
+
+      def initialize(
+        name,
+        attributes: nil,
+        time_unix_nano: nil
+      )
+        @name = name
+        @attributes = attributes || {}
+        # OpenTelemetry SDK stores span event timestamps in nanoseconds (not seconds).
+        # We will do the same here to avoid unnecessary conversions and inconsistencies.
+        @time_unix_nano = time_unix_nano || (Time.now.to_r * 1_000_000_000).to_i
+      end
+
+      def to_hash
+        h = { name: @name, time_unix_nano: @time_unix_nano }
+        h[:attributes] = attributes unless @attributes.empty?
+        h
+      end
+    end
+  end
+end

data/lib/datadog/tracing/span_operation.rb

@@ -35,7 +35,7 @@ module Datadog
         :start_time,
         :trace_id,
         :type
-      attr_accessor :links, :status
+      attr_accessor :links, :status, :span_events
 
       def initialize(
         name,
@@ -48,7 +48,9 @@ module Datadog
         tags: nil,
         trace_id: nil,
         type: nil,
-        links: nil
+        links: nil,
+        span_events: nil,
+        id: nil
       )
         # Ensure dynamically created strings are UTF-8 encoded.
         #
@@ -60,13 +62,15 @@ module Datadog
         self.type = type
         self.resource = resource
 
-        @id = Tracing::Utils.next_id
+        @id = id.nil? ? Tracing::Utils.next_id : id
         @parent_id = parent_id || 0
         @trace_id = trace_id || Tracing::Utils::TraceId.next_id
 
         @status = 0
         # stores array of span links
         @links = links || []
+        # stores array of span events
+        @span_events = span_events || []
 
         # start_time and end_time track wall clock. In Ruby, wall clock
         # has less accuracy than monotonic clock, so if possible we look to only use wall clock
@@ -264,7 +268,7 @@ module Datadog
 
       def set_error(e)
         @status = Metadata::Ext::Errors::STATUS
-        super
+        set_error_tags(e)
       end
 
       # Return a string representation of the span.
@@ -454,6 +458,7 @@ module Datadog
           type: @type,
           trace_id: @trace_id,
           links: @links,
+          events: @span_events,
           service_entry: parent.nil? || (service && parent.service != service)
         )
       end

data/lib/datadog/tracing/trace_operation.rb

@@ -181,6 +181,7 @@ module Datadog
         start_time: nil,
         tags: nil,
         type: nil,
+        id: nil,
         &block
       )
         # Don't allow more span measurements if the
@@ -197,7 +198,8 @@ module Datadog
           service: service,
           start_time: start_time,
           tags: tags,
-          type: type
+          type: type,
+          id: id
         )
 
         # Start span measurement
@@ -212,7 +214,8 @@ module Datadog
         service: nil,
         start_time: nil,
         tags: nil,
-        type: nil
+        type: nil,
+        id: nil
       )
         begin
           # Resolve span options:
@@ -249,7 +252,8 @@ module Datadog
             start_time: start_time,
             tags: tags,
             trace_id: trace_id,
-            type: type
+            type: type,
+            id: id
           )
         rescue StandardError => e
           Datadog.logger.debug { "Failed to build new span: #{e}" }

data/lib/datadog/tracing/trace_segment.rb

@@ -132,10 +132,13 @@ module Datadog
           || sampling_priority == Sampling::Ext::Priority::USER_KEEP
       end
 
+      # Returns the high order part of the trace id as a hexadecimal string; the most significant 64 bits.
+      # The String returned is padded with zeros, having a fixed length of 16 characters.
+      # If the high order part is zero, it returns nil.
       def high_order_tid
         high_order = Tracing::Utils::TraceId.to_high_order(@id)
 
-        high_order.to_s(16) if high_order != 0
+        format('%016x', high_order) if high_order != 0
       end
 
       protected

data/lib/datadog/tracing/tracer.rb

@@ -114,6 +114,7 @@ module Datadog
       # @param [Time] start_time time which the span should have started.
       # @param [Hash<String,String>] tags extra tags which should be added to the span.
       # @param [String] type the type of the span. See {Datadog::Tracing::Metadata::Ext::AppTypes}.
+      # @param [Integer] the id of the new span.
       # @return [Object] If a block is provided, returns the result of the block execution.
       # @return [Datadog::Tracing::SpanOperation] If no block is provided, returns the active,
       #         unfinished {Datadog::Tracing::SpanOperation}.
@@ -130,6 +131,7 @@ module Datadog
         start_time: nil,
         tags: nil,
         type: nil,
+        id: nil,
         &block
       )
         return skip_trace(name, &block) unless enabled
@@ -162,6 +164,7 @@ module Datadog
               tags: tags,
               type: type,
               _trace: trace,
+              id: id,
               &block
             )
           end
@@ -178,7 +181,8 @@ module Datadog
             start_time: start_time,
             tags: tags,
             type: type,
-            _trace: trace
+            _trace: trace,
+            id: id
           )
         end
       end
@@ -375,6 +379,7 @@ module Datadog
         tags: nil,
         type: nil,
         _trace: nil,
+        id: nil,
         &block
       )
         trace = _trace || start_trace(continue_from: continue_from)
@@ -391,6 +396,7 @@ module Datadog
             service: service,
             tags: resolve_tags(tags),
             type: type,
+            id: id,
             &block
           )
         else
@@ -403,7 +409,8 @@ module Datadog
             service: service,
             start_time: start_time,
             tags: resolve_tags(tags),
-            type: type
+            type: type,
+            id: id
           )
 
           span.start(start_time)

data/lib/datadog/tracing/transport/serializable_trace.rb

@@ -72,6 +72,9 @@ module Datadog
             packer.write_map_header(number_of_elements_to_write) # Set header with how many elements in the map
           end
 
+          # serialize span events as meta tags
+          span.set_tag('events', span.events.map(&:to_hash).to_json) if span.events.any?
+
           # DEV: We use strings as keys here, instead of symbols, as
           # DEV: MessagePack will ultimately convert them to strings.
           # DEV: By providing strings directly, we skip this indirection operation.

data/lib/datadog/tracing.rb

@@ -23,6 +23,7 @@ module Datadog
         start_time: nil,
         tags: nil,
         type: nil,
+        id: nil,
         &block
       )
 
@@ -35,6 +36,7 @@ module Datadog
           start_time: start_time,
           tags: tags,
           type: type,
+          id: id,
           &block
         )
       end
@@ -117,9 +119,11 @@ module Datadog
       # # dd.env=prod dd.service=auth dd.version=13.8 dd.trace_id=5458478252992251 dd.span_id=7117552347370098 My message
       # ```
       #
-      # @return [String] correlation information
+      # @return [String] correlation information; or an empty String if Tracing is disabled (`!enabled?`)
       # @public_api
       def log_correlation
+        return '' unless enabled?
+
         correlation.to_log_format
       end
 

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 1
+    MINOR = 3
     PATCH = 0
     PRE = nil
     BUILD = nil
@@ -21,6 +21,6 @@ module Datadog
     # To allow testing with the next unreleased version of Ruby, the version check is performed
     # as `< #{MAXIMUM_RUBY_VERSION}`, meaning prereleases of MAXIMUM_RUBY_VERSION are allowed
     # but not stable MAXIMUM_RUBY_VERSION releases.
-    MAXIMUM_RUBY_VERSION = '3.4'
+    MAXIMUM_RUBY_VERSION = '3.5'
   end
 end