datadog 2.0.0.beta2 → 2.0.0

data/lib/datadog/core/remote/dispatcher.rb

@@ -7,8 +7,8 @@ module Datadog
       class Dispatcher
         attr_reader :receivers
 
-        def initialize
-          @receivers = []
+        def initialize(receivers)
+          @receivers = receivers
         end
 
         def dispatch(changes, repository)
@@ -45,7 +45,7 @@ module Datadog
             @block.call(path)
           end
 
-          # Matches on the produc's path
+          # Matches on the product's path
           class Product < Matcher
             def initialize(products)
               block = ->(path) { products.include?(path.product) }

data/lib/datadog/core/telemetry/emitter.rb

@@ -26,7 +26,7 @@ module Datadog
             seq_id = self.class.sequence.next
             payload = Request.build_payload(event, seq_id)
             res = @http_transport.request(request_type: event.type, payload: payload.to_json)
-            Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (status code: #{res.code})" }
+            Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (code: #{res.code.inspect})" }
             res
           rescue => e
             Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")

data/lib/datadog/core/telemetry/http/response.rb

@@ -34,6 +34,10 @@ module Datadog
             nil
           end
 
+          def code
+            nil
+          end
+
           def inspect
             "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
             "not_found?:#{not_found?}, client_error?:#{client_error?}, " \

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'trace/span'
+require_relative '../../tracing/span_link'
+require_relative '../../tracing/trace_digest'
 
 module Datadog
   module OpenTelemetry
@@ -87,6 +89,21 @@ module Datadog
           datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
           datadog_span.set_tags(span.attributes)
 
+          unless span.links.nil?
+            datadog_span.links = span.links.map do |link|
+              Datadog::Tracing::SpanLink.new(
+                Datadog::Tracing::TraceDigest.new(
+                  trace_id: link.span_context.hex_trace_id.to_i(16),
+                  span_id: link.span_context.hex_span_id.to_i(16),
+                  trace_sampling_priority: (link.span_context.trace_flags&.sampled? ? 1 : 0),
+                  trace_state: link.span_context.tracestate&.to_s,
+                  span_remote: link.span_context.remote?,
+                ),
+                attributes: link.attributes
+              )
+            end
+          end
+
           datadog_span
         end
 
@@ -95,6 +112,11 @@ module Datadog
           if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
             attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
           end
+
+          if attributes.key?('http.response.status_code')
+            attributes[Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE] = attributes.delete('http.response.status_code')
+          end
+
           attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
 
           kwargs = { start_time: ns_to_time(span.start_timestamp) }
@@ -119,7 +141,7 @@ module Datadog
           end
           attributes.flatten!(1)
 
-          kwargs[:tags] = attributes
+          kwargs[:tags] = attributes.to_h
 
           [name, kwargs]
         end

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -141,10 +141,12 @@ module Datadog
               value.casecmp('true') == 0 ? 1 : 0
             )
           end
+
+          span.set_tag('http.status_code', value) if key == 'http.response.status_code'
         end
 
         DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
-                                            'span.type'].freeze
+                                            'span.type', 'http.response.status_code'].freeze
 
         ::OpenTelemetry::SDK::Trace::Span.prepend(self)
       end

data/lib/datadog/profiling/component.rb

@@ -72,8 +72,10 @@ module Datadog
         exporter = build_profiler_exporter(settings, recorder, worker, internal_metadata: internal_metadata)
         transport = build_profiler_transport(settings, agent_settings)
         scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport, interval: upload_period_seconds)
+        crashtracker = build_crashtracker(settings, transport)
+        profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler, optional_crashtracker: crashtracker)
 
-        [Profiling::Profiler.new(worker: worker, scheduler: scheduler), { profiling_enabled: true }]
+        [profiler, { profiling_enabled: true }]
       end
 
       private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
@@ -110,6 +112,28 @@ module Datadog
           )
       end
 
+      private_class_method def self.build_crashtracker(settings, transport)
+        return unless settings.profiling.advanced.experimental_crash_tracking_enabled
+
+        # By default, the transport is an instance of HttpTransport, which validates the configuration and makes
+        # it available for us to use here.
+        # But we support overriding the transport with a user-specific one, which may e.g. write stuff to a file,
+        # and thus can't really provide a valid configuration to talk to a Datadog agent. Thus, in this situation,
+        # we can't use the crashtracker, even if enabled.
+        unless transport.respond_to?(:exporter_configuration)
+          Datadog.logger.warn(
+            'Cannot enable profiling crash tracking as a custom settings.profiling.exporter.transport is configured'
+          )
+          return
+        end
+
+        Datadog::Profiling::Crashtracker.new(
+          exporter_configuration: transport.exporter_configuration,
+          tags: Datadog::Profiling::TagBuilder.call(settings: settings),
+          upload_timeout_seconds: settings.profiling.upload.timeout_seconds,
+        )
+      end
+
       private_class_method def self.enable_gc_profiling?(settings)
         return false unless settings.profiling.advanced.gc_enabled
 
@@ -243,7 +267,7 @@ module Datadog
 
       private_class_method def self.no_signals_workaround_enabled?(settings) # rubocop:disable Metrics/MethodLength
         setting_value = settings.profiling.advanced.no_signals_workaround_enabled
-        legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?('2.3.', '2.4.', '2.5.')
+        legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?('2.5.')
 
         unless [true, false, :auto].include?(setting_value)
           Datadog.logger.error(

data/lib/datadog/profiling/crashtracker.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'libdatadog'
+
+module Datadog
+  module Profiling
+    # Used to report Ruby VM crashes.
+    # The interesting bits are implemented as native code and using libdatadog.
+    #
+    # NOTE: The crashtracker native state is a singleton; so even if you create multiple instances of `Crashtracker`
+    # and start them, it only works as "last writer wins". Same for stop -- there's only one state, so calling stop
+    # on it will stop the crash tracker, regardless of which instance started it.
+    #
+    # Methods prefixed with _native_ are implemented in `crashtracker.c`
+    class Crashtracker
+      private
+
+      attr_reader \
+        :exporter_configuration,
+        :tags_as_array,
+        :path_to_crashtracking_receiver_binary,
+        :ld_library_path,
+        :upload_timeout_seconds
+
+      public
+
+      def initialize(
+        exporter_configuration:,
+        tags:,
+        upload_timeout_seconds:,
+        path_to_crashtracking_receiver_binary: Libdatadog.path_to_crashtracking_receiver_binary,
+        ld_library_path: Libdatadog.ld_library_path
+      )
+        @exporter_configuration = exporter_configuration
+        @tags_as_array = tags.to_a
+        @upload_timeout_seconds = upload_timeout_seconds
+        @path_to_crashtracking_receiver_binary = path_to_crashtracking_receiver_binary
+        @ld_library_path = ld_library_path
+      end
+
+      def start
+        start_or_update_on_fork(action: :start)
+      end
+
+      def reset_after_fork
+        start_or_update_on_fork(action: :update_on_fork)
+      end
+
+      def stop
+        begin
+          self.class._native_stop
+          Datadog.logger.debug('Crash tracking stopped successfully')
+        rescue => e
+          Datadog.logger.error("Failed to stop crash tracking: #{e.message}")
+        end
+      end
+
+      private
+
+      def start_or_update_on_fork(action:)
+        unless path_to_crashtracking_receiver_binary
+          Datadog.logger.warn(
+            "Cannot #{action} profiling crash tracking as no path_to_crashtracking_receiver_binary was found"
+          )
+          return
+        end
+
+        unless ld_library_path
+          Datadog.logger.warn(
+            "Cannot #{action} profiling crash tracking as no ld_library_path was found"
+          )
+          return
+        end
+
+        begin
+          self.class._native_start_or_update_on_fork(
+            action: action,
+            exporter_configuration: exporter_configuration,
+            path_to_crashtracking_receiver_binary: path_to_crashtracking_receiver_binary,
+            ld_library_path: ld_library_path,
+            tags_as_array: tags_as_array,
+            upload_timeout_seconds: Integer(upload_timeout_seconds),
+          )
+          Datadog.logger.debug("Crash tracking #{action} successful")
+        rescue => e
+          Datadog.logger.error("Failed to #{action} crash tracking: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/exporter.rb

@@ -54,10 +54,11 @@ module Datadog
 
       def flush
         worker_stats = @worker.stats_and_reset_not_thread_safe
-        start, finish, compressed_pprof = pprof_recorder.serialize
-        @last_flush_finish_at = finish
+        serialization_result = pprof_recorder.serialize
+        return if serialization_result.nil?
 
-        return if compressed_pprof.nil? # We don't want to report empty profiles
+        start, finish, compressed_pprof, profile_stats = serialization_result
+        @last_flush_finish_at = finish
 
         if duration_below_threshold?(start, finish)
           Datadog.logger.debug('Skipped exporting profiling events as profile duration is below minimum')
@@ -77,6 +78,8 @@ module Datadog
           internal_metadata: internal_metadata.merge(
             {
               worker_stats: worker_stats,
+              profile_stats: profile_stats,
+              recorder_stats: pprof_recorder.stats,
               gc: GC.stat,
             }
           ),

data/lib/datadog/profiling/http_transport.rb

@@ -7,6 +7,8 @@ module Datadog
     # Used to report profiling data to Datadog.
     # Methods prefixed with _native_ are implemented in `http_transport.c`
     class HttpTransport
+      attr_reader :exporter_configuration
+
       def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
         @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
 
@@ -14,19 +16,19 @@ module Datadog
 
         @exporter_configuration =
           if agentless?(site, api_key)
-            [:agentless, site, api_key]
+            [:agentless, site, api_key].freeze
           else
-            [:agent, base_url_from(agent_settings)]
+            [:agent, base_url_from(agent_settings)].freeze
           end
 
-        status, result = validate_exporter(@exporter_configuration)
+        status, result = validate_exporter(exporter_configuration)
 
         raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
       end
 
       def export(flush)
         status, result = do_export(
-          exporter_configuration: @exporter_configuration,
+          exporter_configuration: exporter_configuration,
           upload_timeout_milliseconds: @upload_timeout_milliseconds,
 
           # why "timespec"?
@@ -66,12 +68,6 @@ module Datadog
         end
       end
 
-      # Used to log soft failures in `ddog_Vec_tag_push` (e.g. we still report the profile in these cases)
-      # Called from native code
-      def self.log_failure_to_process_tag(failure_details)
-        Datadog.logger.warn("Failed to add tag to profiling request: #{failure_details}")
-      end
-
       private
 
       def base_url_from(agent_settings)
@@ -136,7 +132,7 @@ module Datadog
       end
 
       def config_without_api_key
-        [@exporter_configuration[0..1]].to_h
+        [exporter_configuration[0..1]].to_h
       end
     end
   end

data/lib/datadog/profiling/profiler.rb

@@ -8,21 +8,24 @@ module Datadog
 
       private
 
-      attr_reader :worker, :scheduler
+      attr_reader :worker, :scheduler, :optional_crashtracker
 
       public
 
-      def initialize(worker:, scheduler:)
+      def initialize(worker:, scheduler:, optional_crashtracker:)
         @worker = worker
         @scheduler = scheduler
+        @optional_crashtracker = optional_crashtracker
       end
 
       def start
         after_fork! do
+          optional_crashtracker.reset_after_fork if optional_crashtracker
           worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
+        optional_crashtracker.start if optional_crashtracker
         worker.start(on_failure_proc: proc { component_failed(:worker) })
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
@@ -32,6 +35,7 @@ module Datadog
 
         stop_worker
         stop_scheduler
+        optional_crashtracker.stop if optional_crashtracker
       end
 
       private
@@ -51,6 +55,9 @@ module Datadog
           'See previous log messages for details.'
         )
 
+        # We explicitly not stop the crash tracker in this situation, under the assumption that, if a component failed,
+        # we're operating in a degraded state and crash tracking may still be helpful.
+
         if failed_component == :worker
           stop_scheduler
         elsif failed_component == :scheduler

data/lib/datadog/profiling/stack_recorder.rb

@@ -33,11 +33,11 @@ module Datadog
         status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
-          start, finish, encoded_pprof = result
+          start, finish, encoded_pprof, profile_stats = result
 
           Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
 
-          [start, finish, encoded_pprof]
+          [start, finish, encoded_pprof, profile_stats]
         else
           error_message = result
 
@@ -64,6 +64,10 @@ module Datadog
       def reset_after_fork
         self.class._native_reset_after_fork(self)
       end
+
+      def stats
+        self.class._native_stats(self)
+      end
     end
   end
 end

data/lib/datadog/profiling.rb

@@ -143,6 +143,7 @@ module Datadog
       require_relative 'profiling/collectors/idle_sampling_helper'
       require_relative 'profiling/collectors/stack'
       require_relative 'profiling/collectors/thread_context'
+      require_relative 'profiling/crashtracker'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/exporter'
       require_relative 'profiling/flush'

data/lib/datadog/tracing/component.rb

@@ -124,9 +124,13 @@ module Datadog
       end
 
       WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK = lambda do |_, responses|
-        Tracing::Diagnostics::EnvironmentLogger.collect_and_log!(responses: responses)
+        WRITER_RECORD_ENVIRONMENT_INFORMATION_ONLY_ONCE.run do
+          Tracing::Diagnostics::EnvironmentLogger.collect_and_log!(responses: responses)
+        end
       end
 
+      WRITER_RECORD_ENVIRONMENT_INFORMATION_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
       # Create new lambda for writer callback,
       # capture the current sampler in the callback closure.
       def writer_update_priority_sampler_rates_callback(sampler)

data/lib/datadog/tracing/configuration/dynamic.rb

@@ -53,8 +53,46 @@ module Datadog
           end
         end
 
+        # Dynamic configuration for `DD_TRACE_SAMPLING_RULES`.
+        class TracingSamplingRules < SimpleOption
+          def initialize
+            super('tracing_sampling_rules', 'DD_TRACE_SAMPLING_RULES', :rules)
+          end
+
+          # Ensures sampler is rebuilt and new configuration is applied
+          def call(tracing_sampling_rules)
+            # Modify the remote configuration value that it matches the
+            # local environment variable it configures.
+            if tracing_sampling_rules
+              tracing_sampling_rules.each do |rule|
+                next unless (tags = rule['tags'])
+
+                # Tag maps come in as arrays of 'key' and `value_glob`.
+                # We need to convert them into a hash for local use.
+                tag_array = tags.map! do |tag|
+                  [tag['key'], tag['value_glob']]
+                end
+
+                rule['tags'] = tag_array.to_h
+              end
+
+              # The configuration is stored as JSON, so we need to convert it back
+              tracing_sampling_rules = tracing_sampling_rules.to_json
+            end
+
+            super(tracing_sampling_rules)
+            Datadog.send(:components).reconfigure_live_sampler
+          end
+
+          protected
+
+          def configuration_object
+            Datadog.configuration.tracing.sampling
+          end
+        end
+
         # List of all tracing dynamic configuration options supported.
-        OPTIONS = [LogInjectionEnabled, TracingHeaderTags, TracingSamplingRate].map do |option_class|
+        OPTIONS = [LogInjectionEnabled, TracingHeaderTags, TracingSamplingRate, TracingSamplingRules].map do |option_class|
           option = option_class.new
           [option.name, option.env_var, option]
         end

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

@@ -274,6 +274,7 @@ module Datadog
                 # @return [String,nil]
                 # @public_api
                 option :rules do |o|
+                  o.type :string, nilable: true
                   o.default { ENV.fetch(Configuration::Ext::Sampling::ENV_RULES, nil) }
                 end
 

data/lib/datadog/tracing/contrib/active_record/configuration/resolver.rb

@@ -32,6 +32,7 @@ module Datadog
           # based on addition order (`#add`).
           class Resolver < Contrib::Configuration::Resolver
             prepend MakaraResolver
+            prepend Contrib::Configuration::CachingResolver
 
             def initialize(active_record_configuration = nil)
               super()

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

@@ -4,6 +4,7 @@ require_relative 'configuration/resolver'
 require_relative 'configuration/settings'
 require_relative 'events'
 require_relative 'patcher'
+require_relative '../component'
 require_relative '../integration'
 require_relative '../rails/ext'
 require_relative '../rails/utils'
@@ -50,6 +51,15 @@ module Datadog
           def resolver
             @resolver ||= Configuration::Resolver.new
           end
+
+          def reset_resolver_cache
+            @resolver&.reset_cache
+          end
+
+          Contrib::Component.register('activerecord') do |_config|
+            # Ensure resolver cache is reset on configuration change
+            Datadog.configuration.tracing.fetch_integration(:active_record).reset_resolver_cache
+          end
         end
       end
     end

data/lib/datadog/tracing/contrib/configuration/resolver.rb

@@ -79,6 +79,49 @@ module Datadog
             matcher
           end
         end
+
+        # The {CachingResolver} is a mixin that provides caching functionality to the {Resolver} class.
+        # This is useful when {Resolver#resolve} values that are expensive to compute.
+        # This is a size-limited, FIFO cache.
+        #
+        # @example
+        #   class MyResolver < Datadog::Tracing::Contrib::Configuration::Resolver
+        #     prepend Datadog::Tracing::Contrib::Configuration::CachingResolver
+        #     # ...
+        #   end
+        module CachingResolver
+          # @param [Integer] cache_limit maximum number of entries to cache
+          def initialize(*args, cache_limit: 200)
+            super(*args)
+
+            @cache_limit = cache_limit
+            @cache = {}
+          end
+
+          # (see Resolver#resolve)
+          def resolve(value)
+            if @cache.key?(value)
+              @cache[value]
+            else
+              if @cache.size >= @cache_limit
+                @cache.shift # Remove the oldest entry if cache is full
+              end
+
+              @cache[value] = super
+            end
+          end
+
+          # (see Resolver#add)
+          def add(matcher, value)
+            reset_cache # Bust the cache when a new matcher is added
+            super
+          end
+
+          # Clears the internal cache.
+          def reset_cache
+            @cache.clear
+          end
+        end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module Datadog
 
               Tracing.trace(Ext::SPAN_QUERY, service: service) do |span, trace_op|
                 span.resource = sql
-                span.span_type = Tracing::Metadata::Ext::SQL::TYPE
+                span.type = Tracing::Metadata::Ext::SQL::TYPE
 
                 if datadog_configuration[:peer_service]
                   span.set_tag(

data/lib/datadog/tracing/correlation.rb

@@ -73,12 +73,7 @@ module Datadog
         end
 
         def trace_id
-          if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled &&
-              !Tracing::Utils::TraceId.to_high_order(@trace_id).zero?
-            Kernel.format('%032x', @trace_id)
-          else
-            Tracing::Utils::TraceId.to_low_order(@trace_id).to_s
-          end
+          Correlation.format_trace_id(@trace_id)
         end
       end
 
@@ -97,6 +92,15 @@ module Datadog
           trace_id: digest.trace_id,
         )
       end
+
+      def format_trace_id(trace_id)
+        if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled &&
+            !Tracing::Utils::TraceId.to_high_order(trace_id).zero?
+          Kernel.format('%032x', trace_id)
+        else
+          Tracing::Utils::TraceId.to_low_order(trace_id).to_s
+        end
+      end
     end
   end
 end

data/lib/datadog/tracing/remote.rb

@@ -12,12 +12,16 @@ module Datadog
       class << self
         PRODUCT = 'APM_TRACING'
 
+        CAPABILITIES = [
+          1 << 29 # APM_TRACING_SAMPLE_RULES: Dynamic trace sampling rules configuration
+        ].freeze
+
         def products
           [PRODUCT]
         end
 
         def capabilities
-          [] # No capabilities advertised
+          CAPABILITIES
         end
 
         def process_config(config, content)

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

@@ -40,7 +40,7 @@ module Datadog
           DEFAULT = '-0'
           # The sampling rate received in the agent's http response.
           AGENT_RATE = '-1'
-          # Sampling rule or sampling rate based on tracer config.
+          # Locally configured rule.
           TRACE_SAMPLING_RULE = '-3'
           # User directly sets sampling priority via {Tracing.reject!} or {Tracing.keep!},
           # or by a custom sampler implementation.
@@ -49,6 +49,10 @@ module Datadog
           ASM = '-5'
           # Single Span Sampled.
           SPAN_SAMPLING_RATE = '-8'
+          # Dynamically configured rule, explicitly created by the user.
+          REMOTE_USER_RULE = '-11'
+          # Dynamically configured  rule, automatically generated by Datadog.
+          REMOTE_DYNAMIC_RULE = '-12'
         end
       end
     end