ddtrace 1.12.1 → 1.18.0

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Environment
+      # Reports YJIT primitive runtime statistics.
+      module YJIT
+        module_function
+
+        # Inline code size
+        def inline_code_size
+          ::RubyVM::YJIT.runtime_stats[:inline_code_size]
+        end
+
+        # Outlined code size
+        def outlined_code_size
+          ::RubyVM::YJIT.runtime_stats[:outlined_code_size]
+        end
+
+        # GCed pages
+        def freed_page_count
+          ::RubyVM::YJIT.runtime_stats[:freed_page_count]
+        end
+
+        # GCed code size
+        def freed_code_size
+          ::RubyVM::YJIT.runtime_stats[:freed_code_size]
+        end
+
+        # Live pages
+        def live_page_count
+          ::RubyVM::YJIT.runtime_stats[:live_page_count]
+        end
+
+        # Code GC count
+        def code_gc_count
+          ::RubyVM::YJIT.runtime_stats[:code_gc_count]
+        end
+
+        # Size of memory region allocated for JIT code
+        def code_region_size
+          ::RubyVM::YJIT.runtime_stats[:code_region_size]
+        end
+
+        # Total number of object shapes
+        def object_shape_count
+          ::RubyVM::YJIT.runtime_stats[:object_shape_count]
+        end
+
+        def available?
+          defined?(::RubyVM::YJIT) \
+            && ::RubyVM::YJIT.enabled? \
+            && ::RubyVM::YJIT.respond_to?(:runtime_stats)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/error.rb

@@ -15,6 +15,7 @@ module Datadog
           when Array then new(*value)
           when Exception then new(value.class, value.message, full_backtrace(value))
           when ContainsMessage then new(value.class, value.message)
+          when String then new(nil, value)
           else BlankError
           end
         end

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

@@ -1,32 +1,36 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Git
       # Defines constants for Git tags
       module Ext
-        TAG_BRANCH = 'git.branch'.freeze
-        TAG_REPOSITORY_URL = 'git.repository_url'.freeze
-        TAG_TAG = 'git.tag'.freeze
+        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'.freeze
-        TAG_COMMIT_AUTHOR_EMAIL = 'git.commit.author.email'.freeze
-        TAG_COMMIT_AUTHOR_NAME = 'git.commit.author.name'.freeze
-        TAG_COMMIT_COMMITTER_DATE = 'git.commit.committer.date'.freeze
-        TAG_COMMIT_COMMITTER_EMAIL = 'git.commit.committer.email'.freeze
-        TAG_COMMIT_COMMITTER_NAME = 'git.commit.committer.name'.freeze
-        TAG_COMMIT_MESSAGE = 'git.commit.message'.freeze
-        TAG_COMMIT_SHA = 'git.commit.sha'.freeze
+        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'
 
-        ENV_REPOSITORY_URL = 'DD_GIT_REPOSITORY_URL'.freeze
-        ENV_COMMIT_SHA = 'DD_GIT_COMMIT_SHA'.freeze
-        ENV_BRANCH = 'DD_GIT_BRANCH'.freeze
-        ENV_TAG = 'DD_GIT_TAG'.freeze
-        ENV_COMMIT_MESSAGE = 'DD_GIT_COMMIT_MESSAGE'.freeze
-        ENV_COMMIT_AUTHOR_NAME = 'DD_GIT_COMMIT_AUTHOR_NAME'.freeze
-        ENV_COMMIT_AUTHOR_EMAIL = 'DD_GIT_COMMIT_AUTHOR_EMAIL'.freeze
-        ENV_COMMIT_AUTHOR_DATE = 'DD_GIT_COMMIT_AUTHOR_DATE'.freeze
-        ENV_COMMIT_COMMITTER_NAME = 'DD_GIT_COMMIT_COMMITTER_NAME'.freeze
-        ENV_COMMIT_COMMITTER_EMAIL = 'DD_GIT_COMMIT_COMMITTER_EMAIL'.freeze
-        ENV_COMMIT_COMMITTER_DATE = 'DD_GIT_COMMIT_COMMITTER_DATE'.freeze
+        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/logging/ext.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Logging
       module Ext
         # The technology from which the log originated.
         # @see https://docs.datadoghq.com/api/latest/logs/#send-logs
-        DD_SOURCE = 'ruby'.freeze
+        DD_SOURCE = 'ruby'
       end
     end
   end

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

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Metrics
       # @public_api
       module Ext
-        DEFAULT_HOST = '127.0.0.1'.freeze
+        DEFAULT_HOST = '127.0.0.1'
         DEFAULT_PORT = 8125
 
-        TAG_LANG = 'language'.freeze
-        TAG_LANG_INTERPRETER = 'language-interpreter'.freeze
-        TAG_LANG_VERSION = 'language-version'.freeze
-        TAG_TRACER_VERSION = 'tracer-version'.freeze
+        TAG_LANG = 'language'
+        TAG_LANG_INTERPRETER = 'language-interpreter'
+        TAG_LANG_VERSION = 'language-version'
+        TAG_TRACER_VERSION = 'tracer-version'
       end
     end
   end

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

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require_relative '../../../appsec/remote'
+require_relative '../../../tracing/remote'
 
 module Datadog
   module Core
     module Remote
       class Client
-        # Capbailities
+        # Capabilities
         class Capabilities
           attr_reader :products, :capabilities, :receivers, :base64_capabilities
 
@@ -28,6 +29,10 @@ module Datadog
               register_products(Datadog::AppSec::Remote.products)
               register_receivers(Datadog::AppSec::Remote.receivers)
             end
+
+            register_capabilities(Datadog::Tracing::Remote.capabilities)
+            register_products(Datadog::Tracing::Remote.products)
+            register_receivers(Datadog::Tracing::Remote.receivers)
           end
 
           def register_capabilities(capabilities)

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

@@ -10,6 +10,7 @@ module Datadog
     module Remote
       # Client communicates with the agent and sync remote configuration
       class Client
+        class TransportError < StandardError; end
         class SyncError < StandardError; end
 
         attr_reader :transport, :repository, :id, :dispatcher
@@ -107,6 +108,8 @@ module Datadog
             else
               dispatcher.dispatch(changes, repository)
             end
+          elsif response.internal_error?
+            raise TransportError, response.to_s
           end
         end
         # rubocop:enable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity

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

@@ -3,7 +3,7 @@
 require_relative 'worker'
 require_relative 'client/capabilities'
 require_relative 'client'
-require_relative '../transport/http'
+require_relative 'transport/http'
 require_relative '../remote'
 require_relative 'negotiation'
 
@@ -22,7 +22,7 @@ module Datadog
           transport_options[:agent_settings] = agent_settings if agent_settings
 
           negotiation = Negotiation.new(settings, agent_settings)
-          transport_v7 = Datadog::Core::Transport::HTTP.v7(**transport_options.dup)
+          transport_v7 = Datadog::Core::Remote::Transport::HTTP.v7(**transport_options.dup)
 
           @barrier = Barrier.new(BARRIER_TIMEOUT)
 
@@ -45,6 +45,11 @@ module Datadog
                 "remote worker client sync error: #{e.message} location: #{Array(e.backtrace).first}. skipping sync"
               end
             rescue StandardError => e
+              # In case of unexpected errors, reset the negotiation object
+              # given external conditions have changed and the negotiation
+              # negotiation object stores error logging state that should be reset.
+              negotiation = Negotiation.new(settings, agent_settings)
+
               Datadog.logger.error do
                 "remote worker error: #{e.class.name} #{e.message} location: #{Array(e.backtrace).first}. "\
                 'reseting client state'
@@ -62,13 +67,22 @@ module Datadog
           end
         end
 
-        def barrier(kind)
+        # Starts the Remote Configuration worker without waiting for first run
+        def start
           @worker.start
+        end
 
-          case kind
-          when :once
-            @barrier.wait_once
-          end
+        # Is the Remote Configuration worker running?
+        def started?
+          @worker.started?
+        end
+
+        # If the worker is not initialized, initialize it.
+        #
+        # Then, waits for one client sync to be executed if `kind` is `:once`.
+        def barrier(_kind)
+          start
+          @barrier.wait_once
         end
 
         def shutdown!
@@ -105,18 +119,6 @@ module Datadog
             end
           end
 
-          # Wait for next lift to happen
-          def wait_next(timeout = nil)
-            @mutex.lock
-
-            timeout ||= @timeout
-
-            # rbs/core has a bug, timeout type is incorrectly ?Integer
-            @condition.wait(@mutex, _ = timeout)
-          ensure
-            @mutex.unlock
-          end
-
           # Release all current waiters
           def lift
             @mutex.lock
@@ -130,26 +132,15 @@ module Datadog
         end
 
         class << self
+          # Because the agent might not be available yet, we can't perform agent-specific checks yet, as they
+          # would prevent remote configuration from ever running.
+          #
+          # Those checks are instead performed inside the worker loop.
+          # This allows users to upgrade their agent while keeping their application running.
           def build(settings, agent_settings)
             return unless settings.remote.enabled
 
-            capabilities = Client::Capabilities.new(settings)
-
-            return if capabilities.products.empty?
-
-            negotiation = Negotiation.new(settings, agent_settings)
-
-            unless negotiation.endpoint?('/v0.7/config')
-              Datadog.logger.error do
-                'endpoint unavailable: disabling remote configuration for this process.'
-              end
-
-              return
-            end
-
-            Datadog.logger.debug { 'agent reachable and reports remote configuration endpoint' }
-
-            new(settings, capabilities, agent_settings)
+            new(settings, Client::Capabilities.new(settings), agent_settings)
           end
         end
       end

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

@@ -18,12 +18,14 @@ module Datadog
             end
           end
 
-          attr_reader :path, :data, :hashes
+          attr_reader :path, :data, :hashes, :apply_state, :apply_error
           attr_accessor :version
 
           def initialize(path:, data:)
             @path = path
             @data = data
+            @apply_state = ApplyState::UNACKNOWLEDGED
+            @apply_error = nil
             @hashes = {}
             @version = 0
           end
@@ -36,6 +38,31 @@ module Datadog
             @length ||= @data.size
           end
 
+          # Sets this configuration as successfully applied.
+          def applied
+            @apply_state = ApplyState::ACKNOWLEDGED
+            @apply_error = nil
+          end
+
+          # Sets this configuration as not successfully applied, with
+          # a message describing the error.
+          def errored(error_message)
+            @apply_state = ApplyState::ERROR
+            @apply_error = error_message
+          end
+
+          module ApplyState
+            # Default state of configurations.
+            # Set until the component consuming the configuration has acknowledged it was applied.
+            UNACKNOWLEDGED = 1
+
+            # Set when the configuration has been successfully applied.
+            ACKNOWLEDGED = 2
+
+            # Set when the configuration has been unsuccessfully applied.
+            ERROR = 3
+          end
+
           private
 
           def compute_and_store_hash(type)

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

@@ -94,7 +94,9 @@ module Datadog
                 {
                   id: content.path.config_id,
                   version: content.version,
-                  product: content.path.product
+                  product: content.path.product,
+                  apply_state: content.apply_state,
+                  apply_error: content.apply_error,
                 }
               end
             end

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

@@ -5,7 +5,7 @@ module Datadog
     module Remote
       module Ext
         ENV_ENABLED = 'DD_REMOTE_CONFIGURATION_ENABLED'
-        ENV_POLL_INTERVAL_SECONDS = 'DD_REMOTE_CONFIGURATION_POLL_INTERVAL_SECONDS'
+        ENV_POLL_INTERVAL_SECONDS = 'DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS'
       end
     end
   end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../transport/http'
+require_relative 'transport/http'
 
 module Datadog
   module Core
@@ -11,32 +11,45 @@ module Datadog
           transport_options = {}
           transport_options[:agent_settings] = agent_settings if agent_settings
 
-          @transport_root = Datadog::Core::Transport::HTTP.root(**transport_options.dup)
+          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(**transport_options.dup)
+          @logged = {}
         end
 
         def endpoint?(path)
           res = @transport_root.send_info
 
           if res.internal_error? && network_error?(res.error)
-            Datadog.logger.error { "agent unreachable: cannot negotiate #{path}" }
+            unless @logged[:agent_unreachable]
+              Datadog.logger.error { "agent unreachable: cannot negotiate #{path}" }
+              @logged[:agent_unreachable] = true
+            end
 
             return false
           end
 
           if res.not_found?
-            Datadog.logger.error { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+            unless @logged[:no_info_endpoint]
+              Datadog.logger.error { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+              @logged[:no_info_endpoint] = true
+            end
 
             return false
           end
 
           unless res.ok?
-            Datadog.logger.error { "agent reachable but unexpected response: cannot negotiate #{path}" }
+            unless @logged[:unexpected_response]
+              Datadog.logger.error { "agent reachable but unexpected response: cannot negotiate #{path}" }
+              @logged[:unexpected_response] = true
+            end
 
             return false
           end
 
           unless res.endpoints.include?(path)
-            Datadog.logger.error { "agent reachable but does not report #{path}" }
+            unless @logged[:no_config_endpoint]
+              Datadog.logger.error { "agent reachable but does not report #{path}" }
+              @logged[:no_config_endpoint] = true
+            end
 
             return false
           end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/request'
+require_relative '../../../core/transport/parcel'
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module Config
+          # Data transfer object for encoded traces
+          class EncodedParcel
+            include Datadog::Core::Transport::Parcel
+
+            def count
+              data.length
+            end
+          end
+
+          # Config request
+          class Request < Datadog::Core::Transport::Request
+          end
+
+          # Config response
+          module Response
+            attr_reader :roots, :targets, :target_files, :client_configs
+
+            def empty?
+              @empty
+            end
+          end
+
+          # Config transport
+          class Transport
+            attr_reader :client, :apis, :default_api, :current_api_id
+
+            def initialize(apis, default_api)
+              @apis = apis
+
+              @client = HTTP::Client.new(current_api)
+            end
+
+            ##### there is only one transport! it's negotiation!
+            def send_config(payload)
+              json = JSON.dump(payload)
+              parcel = EncodedParcel.new(json)
+              request = Request.new(parcel)
+
+              @client.send_config_payload(request)
+            end
+
+            def current_api
+              @apis[HTTP::API::V7]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/remote/transport/http/api/instance.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          module API
+            # An API configured with adapter and routes
+            class Instance
+              attr_reader \
+                :adapter,
+                :headers,
+                :spec
+
+              def initialize(spec, adapter, options = {})
+                @spec = spec
+                @adapter = adapter
+                @headers = options.fetch(:headers, {})
+              end
+
+              def encoder
+                spec.encoder
+              end
+
+              def call(env)
+                # Add headers to request env, unless empty.
+                env.headers.merge!(headers) unless headers.empty?
+
+                # Send request env to the adapter.
+                adapter.call(env)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/remote/transport/http/api/spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          module API
+            # Specification for an HTTP API
+            # Defines behaviors without specific configuration details.
+            class Spec
+              def initialize
+                yield(self) if block_given?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../../encoding'
+require_relative '../../../transport/http/api/map'
+
+# TODO: Decouple standard transport/http/api/instance
+#
+# Separate classes are needed because transport/http/traces includes
+# Trace::API::Instance which closes over and uses a single spec, which is
+# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
+# need an independent toplevel path at the endpoint level.
+#
+# Separate classes are needed because of `include Trace::API::Instance`.
+#
+# Below should be:
+# require_relative '../../../../ddtrace/transport/http/api/spec'
+require_relative 'api/spec'
+
+# TODO: only needed for Negotiation::API::Endpoint
+require_relative 'negotiation'
+
+# TODO: only needed for Config::API::Endpoint
+require_relative 'config'
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          # Namespace for API components
+          module API
+            # Default API versions
+            ROOT = 'root'
+            V7 = 'v0.7'
+
+            module_function
+
+            def defaults
+              Datadog::Core::Transport::HTTP::API::Map[
+                ROOT => Spec.new do |s|
+                  s.info = Negotiation::API::Endpoint.new(
+                    '/info',
+                  )
+                end,
+                V7 => Spec.new do |s|
+                  s.config = Config::API::Endpoint.new(
+                    '/v0.7/config',
+                    Core::Encoding::JSONEncoder,
+                  )
+                end,
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end