ddtrace 1.18.0 → 1.23.2

data/lib/datadog/core/git/ext.rb

@@ -5,32 +5,11 @@ module Datadog
     module Git
       # Defines constants for Git tags
       module Ext
-        GIT_SHA_LENGTH = 40
-
-        TAG_BRANCH = 'git.branch'
-        TAG_REPOSITORY_URL = 'git.repository_url'
-        TAG_TAG = 'git.tag'
-
-        TAG_COMMIT_AUTHOR_DATE = 'git.commit.author.date'
-        TAG_COMMIT_AUTHOR_EMAIL = 'git.commit.author.email'
-        TAG_COMMIT_AUTHOR_NAME = 'git.commit.author.name'
-        TAG_COMMIT_COMMITTER_DATE = 'git.commit.committer.date'
-        TAG_COMMIT_COMMITTER_EMAIL = 'git.commit.committer.email'
-        TAG_COMMIT_COMMITTER_NAME = 'git.commit.committer.name'
-        TAG_COMMIT_MESSAGE = 'git.commit.message'
-        TAG_COMMIT_SHA = 'git.commit.sha'
+        TAG_REPOSITORY_URL = '_dd.git.repository_url'
+        TAG_COMMIT_SHA = '_dd.git.commit.sha'
 
         ENV_REPOSITORY_URL = 'DD_GIT_REPOSITORY_URL'
         ENV_COMMIT_SHA = 'DD_GIT_COMMIT_SHA'
-        ENV_BRANCH = 'DD_GIT_BRANCH'
-        ENV_TAG = 'DD_GIT_TAG'
-        ENV_COMMIT_MESSAGE = 'DD_GIT_COMMIT_MESSAGE'
-        ENV_COMMIT_AUTHOR_NAME = 'DD_GIT_COMMIT_AUTHOR_NAME'
-        ENV_COMMIT_AUTHOR_EMAIL = 'DD_GIT_COMMIT_AUTHOR_EMAIL'
-        ENV_COMMIT_AUTHOR_DATE = 'DD_GIT_COMMIT_AUTHOR_DATE'
-        ENV_COMMIT_COMMITTER_NAME = 'DD_GIT_COMMIT_COMMITTER_NAME'
-        ENV_COMMIT_COMMITTER_EMAIL = 'DD_GIT_COMMIT_COMMITTER_EMAIL'
-        ENV_COMMIT_COMMITTER_DATE = 'DD_GIT_COMMIT_COMMITTER_DATE'
       end
     end
   end

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

@@ -53,7 +53,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
+            Base64.strict_encode64(binary)
           end
         end
       end

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

@@ -13,9 +13,7 @@ module Datadog
       # Configures the HTTP transport to communicate with the agent
       # to fetch and sync the remote configuration
       class Component
-        BARRIER_TIMEOUT = 1.0 # second
-
-        attr_reader :client
+        attr_reader :client, :healthy
 
         def initialize(settings, capabilities, agent_settings)
           transport_options = {}
@@ -24,14 +22,14 @@ module Datadog
           negotiation = Negotiation.new(settings, agent_settings)
           transport_v7 = Datadog::Core::Remote::Transport::HTTP.v7(**transport_options.dup)
 
-          @barrier = Barrier.new(BARRIER_TIMEOUT)
+          @barrier = Barrier.new(settings.remote.boot_timeout_seconds)
 
           @client = Client.new(transport_v7, capabilities)
-          healthy = false
+          @healthy = false
           Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
 
           @worker = Worker.new(interval: settings.remote.poll_interval_seconds) do
-            unless healthy || negotiation.endpoint?('/v0.7/config')
+            unless @healthy || negotiation.endpoint?('/v0.7/config')
               @barrier.lift
 
               next
@@ -39,7 +37,7 @@ module Datadog
 
             begin
               @client.sync
-              healthy ||= true
+              @healthy ||= true
             rescue Client::SyncError => e
               Datadog.logger.error do
                 "remote worker client sync error: #{e.message} location: #{Array(e.backtrace).first}. skipping sync"
@@ -57,7 +55,7 @@ module Datadog
 
               # client state is unknown, state might be corrupted
               @client = Client.new(transport_v7, capabilities)
-              healthy = false
+              @healthy = false
               Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
 
               # TODO: bail out if too many errors?
@@ -103,17 +101,32 @@ module Datadog
           def wait_once(timeout = nil)
             # TTAS (Test and Test-And-Set) optimisation
             # Since @once only ever goes from false to true, this is semantically valid
-            return if @once
+            return :pass if @once
 
             begin
               @mutex.lock
 
-              return if @once
+              return :pass if @once
 
               timeout ||= @timeout
 
-              # rbs/core has a bug, timeout type is incorrectly ?Integer
-              @condition.wait(@mutex, _ = timeout)
+              # - starting with Ruby 3.2, ConditionVariable#wait returns nil on
+              #   timeout and an integer otherwise
+              # - before Ruby 3.2, ConditionVariable returns itself
+              # so we have to rely on @once having been set
+              if RUBY_VERSION >= '3.2'
+                lifted = @condition.wait(@mutex, timeout)
+              else
+                @condition.wait(@mutex, timeout)
+                lifted = @once
+              end
+
+              if lifted
+                :lift
+              else
+                @once = true
+                :timeout
+              end
             ensure
               @mutex.unlock
             end

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

@@ -6,6 +6,7 @@ module Datadog
       module Ext
         ENV_ENABLED = 'DD_REMOTE_CONFIGURATION_ENABLED'
         ENV_POLL_INTERVAL_SECONDS = 'DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS'
+        ENV_BOOT_TIMEOUT_SECONDS = 'DD_REMOTE_CONFIG_BOOT_TIMEOUT_SECONDS'
       end
     end
   end

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

@@ -7,12 +7,12 @@ module Datadog
     module Remote
       # Endpoint negotiation
       class Negotiation
-        def initialize(_settings, agent_settings)
+        def initialize(_settings, agent_settings, suppress_logging: {})
           transport_options = {}
           transport_options[:agent_settings] = agent_settings if agent_settings
 
           @transport_root = Datadog::Core::Remote::Transport::HTTP.root(**transport_options.dup)
-          @logged = {}
+          @logged = suppress_logging
         end
 
         def endpoint?(path)

data/lib/datadog/core/remote/tie/tracing.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../tie'
+
+module Datadog
+  module Core
+    module Remote
+      module Tie
+        # Extend Remote Configuration abilities with Tracing
+        module Tracing
+          # Tag per-request Remote Configuration metadata using Tracing
+          def self.tag(boot, span)
+            return if boot.nil?
+            return if span.nil?
+
+            return if Datadog::Core::Remote.active_remote.nil?
+
+            # TODO: this is not thread-consistent
+            ready = Datadog::Core::Remote.active_remote.healthy
+            status = ready ? 'ready' : 'disconnected'
+
+            span.set_tag('_dd.rc.client_id', Datadog::Core::Remote.active_remote.client.id)
+            span.set_tag('_dd.rc.status', status)
+
+            if boot.barrier != :pass
+              span.set_tag('_dd.rc.boot.time', boot.time)
+
+              if boot.barrier == :timeout
+                span.set_tag('_dd.rc.boot.timeout', true)
+              else
+                span.set_tag('_dd.rc.boot.ready', ready)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      # Provide Remote Configuration extensions to other components
+      module Tie
+        Boot = Struct.new(
+          :barrier,
+          :time,
+        )
+
+        def self.boot
+          return if Datadog::Core::Remote.active_remote.nil?
+
+          barrier = nil
+
+          t = Datadog::Core::Utils::Time.measure do
+            barrier = Datadog::Core::Remote.active_remote.barrier(:once)
+          end
+
+          Boot.new(barrier, t)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/remote/transport/http/config.rb

@@ -51,7 +51,7 @@ module Datadog
 
                 # TODO: these fallbacks should be improved
                 roots = payload[:roots] || []
-                targets = payload[:targets] || Base64.encode64('{}').chomp
+                targets = payload[:targets] || Base64.strict_encode64('{}')
                 target_files = payload[:target_files] || []
                 client_configs = payload[:client_configs] || []
 

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

@@ -10,8 +10,8 @@ module Datadog
           @thr = nil
 
           @starting = false
-          @stopping = false
           @started = false
+          @stopped = false
 
           @interval = interval
           raise ArgumentError, 'can not initialize a worker without a block' unless block
@@ -24,6 +24,11 @@ module Datadog
 
           acquire_lock
 
+          if @stopped
+            Datadog.logger.debug('remote worker: refusing to restart after previous stop')
+            return
+          end
+
           return if @starting || @started
 
           @starting = true
@@ -46,8 +51,6 @@ module Datadog
 
           acquire_lock
 
-          @stopping = true
-
           thread = @thr
 
           if thread
@@ -56,8 +59,8 @@ module Datadog
           end
 
           @started = false
-          @stopping = false
           @thr = nil
+          @stopped = true
 
           Datadog.logger.debug { 'remote worker stopped' }
         ensure

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,4 +1,4 @@
-require_relative 'event'
+require_relative 'request'
 require_relative 'http/transport'
 require_relative '../utils/sequence'
 require_relative '../utils/forking'
@@ -12,7 +12,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)
@@ -20,18 +19,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