ddtrace 1.23.2 → 1.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 836f8f52564c86b8ee1a4681309d3d168b1689f3742dfed4d1a8171e23852ffa
-  data.tar.gz: f0ad632313b36e6550e33f952da8e7ea89349fd8abc2122f41d649292a700028
+  metadata.gz: 9e52d825fdd7cb0391c1e529a979862f24f8ec0412cbd1952f0ae21f3129b83f
+  data.tar.gz: 27ab67ddd6bd0c21a0f7de60c022c143ae2367051b4b1a744f33f01453c1d8e5
 SHA512:
-  metadata.gz: 1021b4efd906f5cf362e27be17249ce82fad3100b62b9a39ba2fd65d508c07ac520cb94971d6986a5171d1575a7fc8e219ed2dc4785166d0bd0ec774cd447d19
-  data.tar.gz: 6ef6b7f391bb98e8e7f039cd72d6df56ee821df539803d3398ef7aaebe2c414eef87f4c2f0cf361ef3a066faf0490bb4b75831563a17729d11115c84243ab349
+  metadata.gz: b0c94e18051c3fe9522493daf7321ae77246d9e5cf6d5888fd3b9c565668c882e684d3156d58867104743c6769f07437c4bc68f69f4884d0609c92279d1ea3bb
+  data.tar.gz: 83bab49e211de5749555906b2f59b0ee8cb8a501c2363ea625a52e6f2c318714be26dc0226e51aabfd8461b96f3036b15a856eb372729ce69bd29df7baa06ef8

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [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
@@ -2826,7 +2837,8 @@ 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.23.2...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
@@ -4142,6 +4154,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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

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 = 2
+    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.2
+  version: 1.23.3
 platform: ruby
 authors:
 - Datadog, Inc.
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-13 00:00:00.000000000 Z
+date: 2024-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -296,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
@@ -327,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
@@ -880,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.2/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v1.23.2
-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
@@ -900,8 +908,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.4.21
+signing_key:
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications
 test_files: []

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