ddtrace 1.23.1 → 1.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1957f7ac42439a5ec9b5c6c1d1700a91b226ccc06def53d0bf3fdd701c55436e
-  data.tar.gz: 3a9ad0d54e59350c3718eb69ee854a756819567b7bd6d4218f0539c87156078e
+  metadata.gz: 9e52d825fdd7cb0391c1e529a979862f24f8ec0412cbd1952f0ae21f3129b83f
+  data.tar.gz: 27ab67ddd6bd0c21a0f7de60c022c143ae2367051b4b1a744f33f01453c1d8e5
 SHA512:
-  metadata.gz: 60ce1f6e6e60cfbfe6f2a3241fc431b9357eefe3866912a82ea672838af323ba6ab441fe50f483a1bc6f26510d500fb00ab62107e770d4c427c6a5952225feac
-  data.tar.gz: 90c4037291c16fa50614509bab19bf45f6283937466e6f9ee6b28fbe7cde73d39ffd14ecc8fb082104aa1d70c7c748ebccff1683dcda772a3665e4f7c94ad619
+  metadata.gz: b0c94e18051c3fe9522493daf7321ae77246d9e5cf6d5888fd3b9c565668c882e684d3156d58867104743c6769f07437c4bc68f69f4884d0609c92279d1ea3bb
+  data.tar.gz: 83bab49e211de5749555906b2f59b0ee8cb8a501c2363ea625a52e6f2c318714be26dc0226e51aabfd8461b96f3036b15a856eb372729ce69bd29df7baa06ef8

data/CHANGELOG.md

@@ -2,11 +2,28 @@
 
 ## [Unreleased]
 
+## [1.23.3] - 2024-07-01
+
+### Added
+
+* Add post install message about 2.x upgrade ([#3723][])
+
+### Fixed
+
+* Fix telemetry events blocking main thread ([#3740][])
+* Fix deadlock from telemetry threads ([#3745][])
+
+## [1.23.2] - 2024-06-13
+
+### Fixed
+
+* Profiling: Fix rpath for linking to libdatadog when loading from extension dir ([#3683][])
+
 ## [1.23.1] - 2024-06-06
 
 ### Fixed
 
-AppSec: Fix undefined method error when Tracing disabled ([#3650][])
+* AppSec: Fix undefined method error when Tracing disabled ([#3650][])
 
 ## [1.23.0] - 2024-05-09
 
@@ -2820,7 +2837,9 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.22.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.3...1.x-stable
+[1.23.3]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.2...v1.23.3
+[1.23.2]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.1...v1.23.2
 [1.23.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.23.0...v1.23.1
 [1.23.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.22.0...v1.23.0
 [1.22.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.21.1...v1.22.0
@@ -4134,6 +4153,8 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#3619]: https://github.com/DataDog/dd-trace-rb/issues/3619
 [#3623]: https://github.com/DataDog/dd-trace-rb/issues/3623
 [#3650]: https://github.com/DataDog/dd-trace-rb/issues/3650
+[#3683]: https://github.com/DataDog/dd-trace-rb/issues/3683
+[#3745]: https://github.com/DataDog/dd-trace-rb/issues/3745
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -4285,4 +4306,4 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@y-yagi]: https://github.com/y-yagi
 [@yujideveloper]: https://github.com/yujideveloper
 [@yukimurasawa]: https://github.com/yukimurasawa
-[@zachmccormick]: https://github.com/zachmccormick
+[@zachmccormick]: https://github.com/zachmccormick

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -225,13 +225,15 @@ unless have_type('atomic_int', ['stdatomic.h'])
   skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILER_ATOMIC_MISSING)
 end
 
-# See comments on the helper method being used for why we need to additionally set this.
+# See comments on the helper methods being used for why we need to additionally set this.
 # The extremely excessive escaping around ORIGIN below seems to be correct and was determined after a lot of
 # experimentation. We need to get these special characters across a lot of tools untouched...
-$LDFLAGS += \
-  ' -Wl,-rpath,$$$\\\\{ORIGIN\\}/' \
-  "#{Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_native_lib_folder}"
-Logging.message("[ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
+extra_relative_rpaths = [
+  Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_native_lib_folder,
+  *Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_ruby_extensions_folders,
+]
+extra_relative_rpaths.each { |folder| $LDFLAGS += " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder.to_str}" }
+Logging.message("[datadog] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
 
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -67,6 +67,52 @@ module Datadog
         Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
       end
 
+      # In https://github.com/DataDog/dd-trace-rb/pull/3582 we got a report of a customer for which the native extension
+      # only got installed into the extensions folder.
+      #
+      # But then this fix was not enough to fully get them moving because then they started to see the issue from
+      # https://github.com/DataDog/dd-trace-rb/issues/2067 / https://github.com/DataDog/dd-trace-rb/pull/2125 :
+      #
+      # > Profiling was requested but is not supported, profiling disabled: There was an error loading the profiling
+      # > native extension due to 'RuntimeError Failure to load datadog_profiling_native_extension.3.2.2_x86_64-linux
+      # > due to libdatadog_profiling.so: cannot open shared object file: No such file or directory
+      #
+      # The problem is that when loading the native extension from the extensions directory, the relative rpath we add
+      # with the #libdatadog_folder_relative_to_native_lib_folder helper above is not correct, we need to add a relative
+      # rpath to the extensions directory.
+      #
+      # So how do we find the full path where the native extension is placed?
+      # * From https://github.com/ruby/ruby/blob/83f02d42e0a3c39661dc99c049ab9a70ff227d5b/lib/bundler/runtime.rb#L166
+      #   `extension_dirs = Dir["#{Gem.dir}/extensions/*/*/*"] + Dir["#{Gem.dir}/bundler/gems/extensions/*/*/*"]`
+      #   we get that's in one of two fixed subdirectories of `Gem.dir`
+      # * From https://github.com/ruby/ruby/blob/83f02d42e0a3c39661dc99c049ab9a70ff227d5b/lib/rubygems/basic_specification.rb#L111-L115
+      #   we get the structure of the subdirectory (platform/extension_api_version/gem_and_version)
+      #
+      # Thus, `Gem.dir` of `/var/app/current/vendor/bundle/ruby/3.2.0` becomes (for instance)
+      # `/var/app/current/vendor/bundle/ruby/3.2.0/extensions/x86_64-linux/3.2.0/datadog-2.0.0/` or
+      # `/var/app/current/vendor/bundle/ruby/3.2.0/bundler/gems/extensions/x86_64-linux/3.2.0/datadog-2.0.0/`
+      #
+      # We then compute the relative path between these folders and the libdatadog folder, and use that as a relative path.
+      def self.libdatadog_folder_relative_to_ruby_extensions_folders(
+        gem_dir: Gem.dir,
+        libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
+      )
+        return unless libdatadog_pkgconfig_folder
+
+        # For the purposes of calculating a folder relative to the other, we don't actually NEED to fill in the
+        # platform, extension_api_version and gem version. We're basically just after how many folders it is deep from
+        # the Gem.dir.
+        expected_ruby_extensions_folders = [
+          "#{gem_dir}/extensions/platform/extension_api_version/datadog_version/",
+          "#{gem_dir}/bundler/gems/extensions/platform/extension_api_version/datadog_version/",
+        ]
+        libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
+
+        expected_ruby_extensions_folders.map do |folder|
+          Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(folder)).to_s
+        end
+      end
+
       # Used to check if profiler is supported, including user-visible clear messages explaining why their
       # system may not be supported.
       module Supported

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

@@ -4,7 +4,7 @@ require_relative '../diagnostics/environment_logger'
 require_relative '../diagnostics/health'
 require_relative '../logger'
 require_relative '../runtime/metrics'
-require_relative '../telemetry/client'
+require_relative '../telemetry/component'
 require_relative '../workers/runtime_metrics'
 
 require_relative '../remote/component'
@@ -60,7 +60,7 @@ module Datadog
               logger.debug { "Telemetry disabled. Agent network adapter not supported: #{agent_settings.adapter}" }
             end
 
-            Telemetry::Client.new(
+            Telemetry::Component.new(
               enabled: enabled,
               heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
               dependency_collection: settings.telemetry.dependency_collection
@@ -165,8 +165,9 @@ module Datadog
           unused_statsd = (old_statsd - (old_statsd & new_statsd))
           unused_statsd.each(&:close)
 
-          telemetry.stop!
+          # enqueue closing event before stopping telemetry so it will be send out on shutdown
           telemetry.emit_closing! unless replacement
+          telemetry.stop!
         end
       end
     end

data/lib/datadog/core/configuration.rb

@@ -81,23 +81,16 @@ module Datadog
         configuration = self.configuration
         yield(configuration)
 
-        built_components = false
-
-        components = safely_synchronize do |write_components|
+        safely_synchronize do |write_components|
           write_components.call(
             if components?
               replace_components!(configuration, @components)
             else
-              components = build_components(configuration)
-              built_components = true
-              components
+              build_components(configuration)
             end
           )
         end
 
-        # Should only be called the first time components are built
-        components.telemetry.started! if built_components
-
         configuration
       end
 
@@ -197,20 +190,13 @@ module Datadog
         current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components }
         return current_components if current_components || !allow_initialization
 
-        built_components = false
-
-        components = safely_synchronize do |write_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 && components.telemetry
-        components
       end
 
       private

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'emitter'
+require_relative 'event'
+require_relative 'worker'
+require_relative '../utils/forking'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle.
+      class Component
+        attr_reader :enabled
+
+        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.
+        # @param [Boolean] dependency_collection Whether to send the `app-dependencies-loaded` event
+        def initialize(heartbeat_interval_seconds:, dependency_collection:, enabled: true)
+          @enabled = enabled
+          @stopped = false
+
+          @worker = Telemetry::Worker.new(
+            enabled: @enabled,
+            heartbeat_interval_seconds: heartbeat_interval_seconds,
+            emitter: Emitter.new,
+            dependency_collection: dependency_collection
+          )
+          @worker.start
+        end
+
+        def disable!
+          @enabled = false
+          @worker.enabled = false
+        end
+
+        def stop!
+          return if @stopped
+
+          @worker.stop(true)
+          @stopped = true
+        end
+
+        def emit_closing!
+          return if !@enabled || forked?
+
+          @worker.enqueue(Event::AppClosing.new)
+        end
+
+        def integrations_change!
+          return if !@enabled || forked?
+
+          @worker.enqueue(Event::AppIntegrationsChange.new)
+        end
+
+        # Report configuration changes caused by Remote Configuration.
+        def client_configuration_change!(changes)
+          return if !@enabled || forked?
+
+          @worker.enqueue(Event::AppClientConfigurationChange.new(changes, 'remote_config'))
+        end
+      end
+    end
+  end
+end

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

@@ -38,6 +38,7 @@ module Datadog
           private
 
           def products
+            # @type var products: Hash[Symbol, Hash[Symbol, Object]]
             products = {
               appsec: {
                 enabled: Datadog::AppSec.enabled?,

data/lib/datadog/core/telemetry/http/adapters/net.rb

@@ -13,7 +13,7 @@ module Datadog
               :timeout,
               :ssl
 
-            DEFAULT_TIMEOUT = 30
+            DEFAULT_TIMEOUT = 2
 
             def initialize(hostname:, port: nil, timeout: DEFAULT_TIMEOUT, ssl: true)
               @hostname = hostname

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+
+require_relative '../utils/only_once_successful'
+require_relative '../workers/polling'
+require_relative '../workers/queue'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Accumulates events and sends them to the API at a regular interval, including heartbeat event.
+      class Worker
+        include Core::Workers::Queue
+        include Core::Workers::Polling
+
+        DEFAULT_BUFFER_MAX_SIZE = 1000
+        APP_STARTED_EVENT_RETRIES = 10
+
+        TELEMETRY_STARTED_ONCE = Utils::OnlyOnceSuccessful.new(APP_STARTED_EVENT_RETRIES)
+
+        def initialize(
+          heartbeat_interval_seconds:,
+          emitter:,
+          dependency_collection:,
+          enabled: true,
+          shutdown_timeout: Workers::Polling::DEFAULT_SHUTDOWN_TIMEOUT,
+          buffer_size: DEFAULT_BUFFER_MAX_SIZE
+        )
+          @emitter = emitter
+          @dependency_collection = dependency_collection
+
+          # Workers::Polling settings
+          self.enabled = enabled
+          # Workers::IntervalLoop settings
+          self.loop_base_interval = heartbeat_interval_seconds
+          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
+
+          @shutdown_timeout = shutdown_timeout
+          @buffer_size = buffer_size
+
+          self.buffer = buffer_klass.new(@buffer_size)
+        end
+
+        def start
+          return if !enabled? || forked?
+
+          # starts async worker
+          perform
+        end
+
+        def stop(force_stop = false, timeout = @shutdown_timeout)
+          buffer.close if running?
+
+          super
+        end
+
+        def enqueue(event)
+          return if !enabled? || forked?
+
+          buffer.push(event)
+        end
+
+        def sent_started_event?
+          TELEMETRY_STARTED_ONCE.success?
+        end
+
+        def failed_to_start?
+          TELEMETRY_STARTED_ONCE.failed?
+        end
+
+        private
+
+        def perform(*events)
+          return if !enabled? || forked?
+
+          started! unless sent_started_event?
+
+          heartbeat!
+
+          flush_events(events)
+        end
+
+        def flush_events(events)
+          return if events.nil?
+          return if !enabled? || !sent_started_event?
+
+          Datadog.logger.debug { "Sending #{events.count} telemetry events" }
+          events.each do |event|
+            send_event(event)
+          end
+        end
+
+        def heartbeat!
+          return if !enabled? || !sent_started_event?
+
+          send_event(Event::AppHeartbeat.new)
+        end
+
+        def started!
+          return unless enabled?
+
+          if failed_to_start?
+            Datadog.logger.debug('Telemetry app-started event exhausted retries, disabling telemetry worker')
+            self.enabled = false
+            return
+          end
+
+          TELEMETRY_STARTED_ONCE.run do
+            res = send_event(Event::AppStarted.new)
+
+            if res.ok?
+              Datadog.logger.debug('Telemetry app-started event is successfully sent')
+
+              send_event(Event::AppDependenciesLoaded.new) if @dependency_collection
+
+              true
+            else
+              Datadog.logger.debug('Error sending telemetry app-started event, retry after heartbeat interval...')
+              false
+            end
+          end
+        end
+
+        def send_event(event)
+          res = @emitter.request(event)
+
+          disable_on_not_found!(res)
+
+          res
+        end
+
+        def dequeue
+          buffer.pop
+        end
+
+        def work_pending?
+          run_loop? || !buffer.empty?
+        end
+
+        def buffer_klass
+          if Core::Environment::Ext::RUBY_ENGINE == 'ruby'
+            Core::Buffer::CRuby
+          else
+            Core::Buffer::ThreadSafe
+          end
+        end
+
+        def disable_on_not_found!(response)
+          return unless response.not_found?
+
+          Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.')
+          self.enabled = false
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/only_once_successful.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'only_once'
+
+module Datadog
+  module Core
+    module Utils
+      # Helper class to execute something with only one success.
+      #
+      # This is useful for cases where we want to ensure that a block of code is only executed once, and only if it
+      # succeeds. One such example is sending app-started telemetry event.
+      #
+      # Successful execution is determined by the return value of the block: any truthy value is considered success.
+      #
+      # Thread-safe when used correctly (e.g. be careful of races when lazily initializing instances of this class).
+      #
+      # Note: In its current state, this class is not Ractor-safe.
+      # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,
+      # including an alternative implementation that is Ractor-safe once spent.
+      class OnlyOnceSuccessful < OnlyOnce
+        def initialize(limit = 0)
+          super()
+
+          @limit = limit
+          @failed = false
+          @retries = 0
+        end
+
+        def run
+          @mutex.synchronize do
+            return if @ran_once
+
+            result = yield
+            @ran_once = !!result
+
+            if !@ran_once && limited?
+              @retries += 1
+              check_limit!
+            end
+
+            result
+          end
+        end
+
+        def success?
+          @mutex.synchronize { @ran_once && !@failed }
+        end
+
+        def failed?
+          @mutex.synchronize { @ran_once && @failed }
+        end
+
+        private
+
+        def check_limit!
+          if @retries >= @limit
+            @failed = true
+            @ran_once = true
+          end
+        end
+
+        def limited?
+          !@limit.nil? && @limit > 0
+        end
+
+        def reset_ran_once_state_for_tests
+          @mutex.synchronize do
+            @ran_once = false
+            @failed = false
+            @retries = 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/version.rb

@@ -4,7 +4,7 @@ module DDTrace
   module VERSION
     MAJOR = 1
     MINOR = 23
-    PATCH = 1
+    PATCH = 3
     PRE = nil
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 1.23.1
+  version: 1.23.3
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-06 00:00:00.000000000 Z
+date: 2024-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -81,6 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.8.1
 description: |
+  NOTICE: This gem has been renamed to `datadog` since 2.0.0. Please use `datadog` instead of `ddtrace`.
   ddtrace is Datadog's tracing client for Ruby. It is used to trace requests
   as they flow across web servers, databases and microservices so that developers
   have great visiblity into bottlenecks and troublesome requests.
@@ -295,17 +296,17 @@ files:
 - lib/datadog/core/remote/worker.rb
 - lib/datadog/core/runtime/ext.rb
 - lib/datadog/core/runtime/metrics.rb
-- lib/datadog/core/telemetry/client.rb
+- lib/datadog/core/telemetry/component.rb
 - lib/datadog/core/telemetry/emitter.rb
 - lib/datadog/core/telemetry/event.rb
 - lib/datadog/core/telemetry/ext.rb
-- lib/datadog/core/telemetry/heartbeat.rb
 - lib/datadog/core/telemetry/http/adapters/net.rb
 - lib/datadog/core/telemetry/http/env.rb
 - lib/datadog/core/telemetry/http/ext.rb
 - lib/datadog/core/telemetry/http/response.rb
 - lib/datadog/core/telemetry/http/transport.rb
 - lib/datadog/core/telemetry/request.rb
+- lib/datadog/core/telemetry/worker.rb
 - lib/datadog/core/transport/ext.rb
 - lib/datadog/core/transport/http/adapters/net.rb
 - lib/datadog/core/transport/http/adapters/registry.rb
@@ -326,6 +327,7 @@ files:
 - lib/datadog/core/utils/hash.rb
 - lib/datadog/core/utils/network.rb
 - lib/datadog/core/utils/only_once.rb
+- lib/datadog/core/utils/only_once_successful.rb
 - lib/datadog/core/utils/safe_dup.rb
 - lib/datadog/core/utils/sequence.rb
 - lib/datadog/core/utils/time.rb
@@ -879,9 +881,16 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v1.23.1/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v1.23.1
-post_install_message:
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v1.23.3/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v1.23.3
+post_install_message: |2
+      Thank you for installing ddtrace. We have released our next major version!
+
+      As of version 2, `ddtrace` gem has been renamed to `datadog`.
+      The 1.x series will now only receive maintenance updates for security and critical bug fixes.
+
+      To upgrade, please replace gem `ddtrace` with gem `datadog`.
+      For detailed instructions on migration, see: https://dtdg.co/ruby-v2-upgrade
 rdoc_options: []
 require_paths:
 - lib

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'emitter'
-require_relative 'event'
-require_relative 'heartbeat'
-require_relative '../utils/forking'
-
-module Datadog
-  module Core
-    module Telemetry
-      # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle.
-      class Client
-        attr_reader \
-          :enabled,
-          :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.
-        # @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
-
-        def disable!
-          @enabled = false
-          @worker.enabled = false
-        end
-
-        def started!
-          return if !@enabled || forked?
-
-          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
-
-          @emitter.request(Event::AppDependenciesLoaded.new) if @dependency_collection
-
-          @started = true
-        end
-
-        def emit_closing!
-          return if !@enabled || forked?
-
-          @emitter.request(Event::AppClosing.new)
-        end
-
-        def stop!
-          return if @stopped
-
-          @worker.stop(true, 0)
-          @stopped = true
-        end
-
-        def integrations_change!
-          return if !@enabled || forked?
-
-          @emitter.request(Event::AppIntegrationsChange.new)
-        end
-
-        # Report configuration changes caused by Remote Configuration.
-        def client_configuration_change!(changes)
-          return if !@enabled || forked?
-
-          @emitter.request(Event::AppClientConfigurationChange.new(changes, 'remote_config'))
-        end
-
-        private
-
-        def heartbeat!
-          return if !@enabled || forked?
-
-          @emitter.request(Event::AppHeartbeat.new)
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../worker'
-require_relative '../workers/polling'
-
-module Datadog
-  module Core
-    module Telemetry
-      # Periodically (every DEFAULT_INTERVAL_SECONDS) sends a heartbeat event to the telemetry API.
-      class Heartbeat < Core::Worker
-        include Core::Workers::Polling
-
-        def initialize(heartbeat_interval_seconds:, enabled: true, &block)
-          # Workers::Polling settings
-          self.enabled = enabled
-          # Workers::IntervalLoop settings
-          self.loop_base_interval = heartbeat_interval_seconds
-          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
-          super(&block)
-          start
-        end
-
-        def loop_wait_before_first_iteration?; end
-
-        private
-
-        def start
-          perform
-        end
-      end
-    end
-  end
-end