ddtrace 1.22.0 → 1.23.3

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/http/response.rb

@@ -32,6 +32,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/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/datadog/profiling/exporter.rb

@@ -52,10 +52,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')
@@ -75,6 +76,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/stack_recorder.rb

@@ -31,11 +31,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
 
@@ -62,6 +62,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/ddtrace/version.rb

@@ -3,8 +3,8 @@
 module DDTrace
   module VERSION
     MAJOR = 1
-    MINOR = 22
-    PATCH = 0
+    MINOR = 23
+    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.22.0
+  version: 1.23.3
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-16 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
@@ -876,10 +878,19 @@ files:
 homepage: https://github.com/DataDog/dd-trace-rb
 licenses:
 - BSD-3-Clause
+- Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/master/CHANGELOG.md
-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
@@ -897,7 +908,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.21
 signing_key:
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications

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