datadog 2.0.0.beta1 → 2.0.0.rc1

data/lib/datadog/core/configuration/components.rb

@@ -64,7 +64,8 @@ module Datadog
 
             Telemetry::Client.new(
               enabled: enabled,
-              heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds
+              heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
+              dependency_collection: settings.telemetry.dependency_collection
             )
           end
         end

data/lib/datadog/core/configuration/option.rb

@@ -8,7 +8,13 @@ module Datadog
       # Represents an instance of an integration configuration option
       # @public_api
       class Option
-        attr_reader :definition
+        # @!attribute [r] definition
+        #   The definition object that matches this option.
+        #   @return [Configuration::OptionDefinition]
+        # @!attribute [r] precedence_set
+        #   When this option was last set, what was the value precedence used?
+        #   @return [Precedence::Value]
+        attr_reader :definition, :precedence_set
 
         # Option setting precedence.
         module Precedence
@@ -305,10 +311,6 @@ module Datadog
                               "but '#{ENV[effective_env]}' was provided"
         end
 
-        # Used for testing
-        attr_reader :precedence_set
-        private :precedence_set
-
         # Anchor object that represents a value that is not set.
         # This is necessary because `nil` is a valid value to be set.
         UNSET = Object.new

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

@@ -271,59 +271,25 @@ module Datadog
 
             # Can be used to disable the gathering of names and versions of gems in use by the service, used to power
             # grouping and categorization of stack traces.
-            option :code_provenance_enabled, default: true
-
-            # Forces enabling of profiling of time/resources spent in Garbage Collection.
-            #
-            # Note that setting this to "false" (or not setting it) will not prevent the feature from being
-            # being automatically enabled in the future.
-            #
-            # This feature defaults to off for two reasons:
-            # 1. Currently this feature can add a lot of overhead for GC-heavy workloads.
-            # 2. Although this feature is safe on Ruby 2.x, on Ruby 3.x it can break in applications that make use of
-            #    Ractors due to two Ruby VM bugs:
-            #    https://bugs.ruby-lang.org/issues/19112 AND https://bugs.ruby-lang.org/issues/18464.
-            #    If you use Ruby 3.x and your application does not use Ractors (or if your Ruby has been patched), the
-            #    feature is fully safe to enable and this toggle can be used to do so.
-            #
-            # We expect the once the above issues are overcome, we'll automatically enable the feature on fixed Ruby
-            # versions.
-            #
-            # @default `DD_PROFILING_FORCE_ENABLE_GC` environment variable, otherwise `false`
-            option :force_enable_gc_profiling do |o|
-              o.env 'DD_PROFILING_FORCE_ENABLE_GC'
+            option :code_provenance_enabled do |o|
               o.type :bool
-              o.default false
+              o.default true
             end
 
-            # Can be used to enable/disable the Datadog::Profiling.allocation_count feature.
+            # Can be used to enable/disable garbage collection profiling.
             #
-            # @deprecated Use {:allocation_enabled} (outside of advanced section) instead.
-            option :allocation_counting_enabled do |o|
-              o.after_set do |_, _, precedence|
-                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
-                  Datadog.logger.warn(
-                    'The profiling.advanced.allocation_counting_enabled setting has been deprecated for removal and no ' \
-                    'longer does anything. Please remove it from your Datadog.configure block. ' \
-                    'Allocation counting is now controlled by the profiling.allocation_enabled setting instead.'
-                  )
-                end
-              end
-            end
-
-            # @deprecated Use {:allocation_enabled} (outside of advanced section) instead.
-            option :experimental_allocation_enabled do |o|
+            # @warn To avoid https://bugs.ruby-lang.org/issues/18464 even when enabled, GC profiling is only started
+            #       for Ruby versions 2.x, 3.1.4+, 3.2.3+ and 3.3.0+
+            #       (more details in {Datadog::Profiling::Component.enable_gc_profiling?})
+            #
+            # @warn Due to a VM bug in the Ractor implementation (https://bugs.ruby-lang.org/issues/19112) this feature
+            #       stops working when Ractors get garbage collected.
+            #
+            # @default `DD_PROFILING_GC_ENABLED` environment variable, otherwise `true`
+            option :gc_enabled do |o|
               o.type :bool
-              o.default false
-              o.after_set do |_, _, precedence|
-                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
-                  Datadog.logger.warn(
-                    'The profiling.advanced.experimental_allocation_enabled setting has been deprecated for removal and ' \
-                    'no longer does anything. Please remove it from your Datadog.configure block. ' \
-                    'Allocation profiling is now controlled by the profiling.allocation_enabled setting instead.'
-                  )
-                end
-              end
+              o.env 'DD_PROFILING_GC_ENABLED'
+              o.default true
             end
 
             # Can be used to enable/disable the collection of heap profiles.
@@ -353,22 +319,6 @@ module Datadog
               o.default true # This gets ANDed with experimental_heap_enabled in the profiler component.
             end
 
-            # Can be used to configure the allocation sampling rate: a sample will be collected every x allocations.
-            #
-            # This feature is now controlled via {:overhead_target_percentage}
-            option :experimental_allocation_sample_rate do |o|
-              o.after_set do |_, _, precedence|
-                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
-                  Datadog.logger.warn(
-                    'The profiling.advanced.experimental_allocation_sample_rate setting has been deprecated for removal ' \
-                    'and no longer does anything. Please remove it from your Datadog.configure block. ' \
-                    'Allocation sample rate is now handled by a dynamic sampler which will adjust the sampling rate to ' \
-                    'keep to the configured `profiling.advanced.overhead_target_percentage`.'
-                  )
-                end
-              end
-            end
-
             # Can be used to configure the heap sampling rate: a heap sample will be collected for every x allocation
             # samples.
             #
@@ -396,21 +346,6 @@ module Datadog
               o.default false
             end
 
-            # Enables data collection for the timeline feature. This is still experimental and not recommended yet.
-            #
-            # @default `DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED` environment variable as a boolean, otherwise `false`
-            option :experimental_timeline_enabled do |o|
-              o.after_set do |_, _, precedence|
-                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
-                  Datadog.logger.warn(
-                    'The profiling.advanced.experimental_timeline_enabled setting has been deprecated for removal ' \
-                    'and no longer does anything. Please remove it from your Datadog.configure block. ' \
-                    'The timeline feature counting is now controlled by the `timeline_enabled` setting instead.'
-                  )
-                end
-              end
-            end
-
             # Controls data collection for the timeline feature.
             #
             # If you needed to disable this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>,
@@ -480,6 +415,16 @@ module Datadog
               o.env 'DD_PROFILING_UPLOAD_PERIOD'
               o.default 60
             end
+
+            # Enables reporting of information when the Ruby VM crashes.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_CRASH_TRACKING_ENABLED` environment variable as a boolean,
+            # otherwise `false`
+            option :experimental_crash_tracking_enabled do |o|
+              o.type :bool
+              o.env 'DD_PROFILING_EXPERIMENTAL_CRASH_TRACKING_ENABLED'
+              o.default false
+            end
           end
 
           # @public_api
@@ -646,6 +591,16 @@ module Datadog
         # Client-side telemetry configuration
         # @public_api
         settings :telemetry do
+          # Whether the bundled Ruby gems as reported through telemetry.
+          #
+          # @default `DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED` environment variable, otherwise `true`.
+          # @return [Boolean]
+          option :dependency_collection do |o|
+            o.type :bool
+            o.env Core::Telemetry::Ext::ENV_DEPENDENCY_COLLECTION
+            o.default true
+          end
+
           # Enable telemetry collection. This allows telemetry events to be emitted to the telemetry API.
           #
           # @default `DD_INSTRUMENTATION_TELEMETRY_ENABLED` environment variable, otherwise `true`.

data/lib/datadog/core/configuration.rb

@@ -84,18 +84,23 @@ module Datadog
         configuration = self.configuration
         yield(configuration)
 
-        safely_synchronize do |write_components|
+        built_components = false
+
+        components = safely_synchronize do |write_components|
           write_components.call(
             if components?
               replace_components!(configuration, @components)
             else
               components = build_components(configuration)
-              components.telemetry.started!
+              built_components = true
               components
             end
           )
         end
 
+        # Should only be called the first time components are built
+        components.telemetry.started! if built_components
+
         configuration
       end
 
@@ -195,9 +200,20 @@ module Datadog
         current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components }
         return current_components if current_components || !allow_initialization
 
-        safely_synchronize do |write_components|
-          (defined?(@components) && @components) || write_components.call(build_components(configuration))
+        built_components = false
+
+        components = safely_synchronize do |write_components|
+          if defined?(@components) && @components
+            @components
+          else
+            built_components = true
+            write_components.call(build_components(configuration))
+          end
         end
+
+        # Should only be called the first time components are built
+        components&.telemetry&.started! if built_components
+        components
       end
 
       private

data/lib/datadog/core/environment/platform.rb

@@ -11,12 +11,18 @@ module Datadog
       module Platform
         module_function
 
+        # @return [String] ISA of host; `uname -m`
+        def architecture
+          Identity.lang_version >= '2.2' ? Etc.uname[:machine] : Gem::Platform.local.cpu
+        end
+
         # @return [String] name of host; `uname -n`
         def hostname
           Identity.lang_version >= '2.2' ? Etc.uname[:nodename] : nil
         end
 
-        # @return [String] name of kernel; `uname -s`
+        # System name, normally `Linux` or `Darwin` (but 'Mac OS X' on JRuby);
+        # @return [String] name of kernel; `uname -s`.
         def kernel_name
           Identity.lang_version >= '2.2' ? Etc.uname[:sysname] : Gem::Platform.local.os.capitalize
         end

data/lib/datadog/core/remote/client/capabilities.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../../utils/base64'
 require_relative '../../../appsec/remote'
 require_relative '../../../tracing/remote'
 
@@ -53,7 +54,7 @@ module Datadog
             cap_to_hexs = capabilities.reduce(:|).to_s(16).tap { |s| s.size.odd? && s.prepend('0') }.scan(/\h\h/)
             binary = cap_to_hexs.each_with_object([]) { |hex, acc| acc << hex }.map { |e| e.to_i(16) }.pack('C*')
 
-            Base64.encode64(binary).chomp
+            Datadog::Core::Utils::Base64.strict_encode64(binary)
           end
         end
       end

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

@@ -20,12 +20,8 @@ module Datadog
 
           @repository = repository
           @id = SecureRandom.uuid
-          @dispatcher = Dispatcher.new
           @capabilities = capabilities
-
-          @capabilities.receivers.each do |receiver|
-            dispatcher.receivers << receiver
-          end
+          @dispatcher = Dispatcher.new(@capabilities.receivers)
         end
 
         # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity

data/lib/datadog/core/remote/configuration/repository.rb

@@ -164,7 +164,7 @@ module Datadog
               end
             end
 
-            # Insert content into the reporistory contents
+            # Insert content into the repository contents
             class Insert
               attr_reader :path, :target, :content
 

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/remote/transport/http/config.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'base64'
 
 require_relative '../config'
 require_relative 'client'
+require_relative '../../../utils/base64'
 require_relative '../../../transport/http/response'
 require_relative '../../../transport/http/api/endpoint'
 
@@ -51,7 +51,7 @@ module Datadog
 
                 # TODO: these fallbacks should be improved
                 roots = payload[:roots] || []
-                targets = payload[:targets] || Base64.encode64('{}').chomp
+                targets = payload[:targets] || Datadog::Core::Utils::Base64.strict_encode64('{}')
                 target_files = payload[:target_files] || []
                 client_configs = payload[:client_configs] || []
 
@@ -61,7 +61,7 @@ module Datadog
                   raise TypeError.new(String, root) unless root.is_a?(String)
 
                   decoded = begin
-                    Base64.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
+                    Datadog::Core::Utils::Base64.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
                   rescue ArgumentError
                     raise DecodeError.new(:roots, root)
                   end
@@ -81,7 +81,7 @@ module Datadog
 
                 @targets = begin
                   decoded = begin
-                    Base64.strict_decode64(targets)
+                    Datadog::Core::Utils::Base64.strict_decode64(targets)
                   rescue ArgumentError
                     raise DecodeError.new(:targets, targets)
                   end
@@ -109,7 +109,7 @@ module Datadog
                   raise TypeError.new(String, raw) unless raw.is_a?(String)
 
                   content = begin
-                    Base64.strict_decode64(raw)
+                    Datadog::Core::Utils::Base64.strict_decode64(raw)
                   rescue ArgumentError
                     raise DecodeError.new(:target_files, raw)
                   end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'emitter'
+require_relative 'event'
 require_relative 'heartbeat'
 require_relative '../utils/forking'
 
@@ -10,21 +11,25 @@ module Datadog
       # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle.
       class Client
         attr_reader \
-          :emitter,
           :enabled,
-          :unsupported,
-          :worker
+          :unsupported
 
         include Core::Utils::Forking
 
         # @param enabled [Boolean] Determines whether telemetry events should be sent to the API
         # @param heartbeat_interval_seconds [Float] How frequently heartbeats will be reported, in seconds.
-        def initialize(heartbeat_interval_seconds:, enabled: true)
+        # @param [Boolean] dependency_collection Whether to send the `app-dependencies-loaded` event
+        def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: true)
           @enabled = enabled
           @emitter = Emitter.new
           @stopped = false
           @unsupported = false
+          @started = false
+          @dependency_collection = dependency_collection
+
           @worker = Telemetry::Heartbeat.new(enabled: @enabled, heartbeat_interval_seconds: heartbeat_interval_seconds) do
+            next unless @started # `started!` should be the first event, thus ensure that `heartbeat!` is not sent first.
+
             heartbeat!
           end
         end
@@ -37,21 +42,24 @@ module Datadog
         def started!
           return if !@enabled || forked?
 
-          res = @emitter.request(:'app-started')
+          res = @emitter.request(Event::AppStarted.new)
 
           if res.not_found? # Telemetry is only supported by agent versions 7.34 and up
             Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.')
             disable!
             @unsupported = true # Prevent telemetry from getting re-enabled
+            return res
           end
 
-          res
+          @emitter.request(Event::AppDependenciesLoaded.new) if @dependency_collection
+
+          @started = true
         end
 
         def emit_closing!
           return if !@enabled || forked?
 
-          @emitter.request(:'app-closing')
+          @emitter.request(Event::AppClosing.new)
         end
 
         def stop!
@@ -64,14 +72,14 @@ module Datadog
         def integrations_change!
           return if !@enabled || forked?
 
-          @emitter.request(:'app-integrations-change')
+          @emitter.request(Event::AppIntegrationsChange.new)
         end
 
         # Report configuration changes caused by Remote Configuration.
         def client_configuration_change!(changes)
           return if !@enabled || forked?
 
-          @emitter.request('app-client-configuration-change', data: { changes: changes, origin: 'remote_config' })
+          @emitter.request(Event::AppClientConfigurationChange.new(changes, 'remote_config'))
         end
 
         private
@@ -79,7 +87,7 @@ module Datadog
         def heartbeat!
           return if !@enabled || forked?
 
-          @emitter.request(:'app-heartbeat')
+          @emitter.request(Event::AppHeartbeat.new)
         end
       end
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'event'
+require_relative 'request'
 require_relative 'http/transport'
 require_relative '../utils/sequence'
 require_relative '../utils/forking'
@@ -14,7 +14,6 @@ module Datadog
 
         extend Core::Utils::Forking
 
-        # @param sequence [Datadog::Core::Utils::Sequence] Sequence object that stores and increments a counter
         # @param http_transport [Datadog::Core::Telemetry::Http::Transport] Transport object that can be used to send
         #   telemetry requests via the agent
         def initialize(http_transport: Datadog::Core::Telemetry::Http::Transport.new)
@@ -22,18 +21,15 @@ module Datadog
         end
 
         # Retrieves and emits a TelemetryRequest object based on the request type specified
-        # @param request_type [String] the type of telemetry request to collect data for
-        # @param data [Object] arbitrary object to be passed to the respective `request_type` handler
-        def request(request_type, data: nil)
+        def request(event)
           begin
-            request = Datadog::Core::Telemetry::Event.new.telemetry_request(
-              request_type: request_type,
-              seq_id: self.class.sequence.next,
-              data: data,
-            ).to_h
-            @http_transport.request(request_type: request_type.to_s, payload: request.to_json)
-          rescue StandardError => e
-            Datadog.logger.debug("Unable to send telemetry request for event `#{request_type}`: #{e}")
+            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}` (code: #{res.code.inspect})" }
+            res
+          rescue => e
+            Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")
             Telemetry::Http::InternalErrorResponse.new(e)
           end
         end