ddtrace 1.10.1 → 1.11.0.beta1

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

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require_relative 'content'
+
+module Datadog
+  module Core
+    module Remote
+      class Configuration
+        # Repository
+        class Repository
+          attr_reader \
+            :contents,
+            :opaque_backend_state,
+            :root_version,
+            :targets_version
+
+          UNVERIFIED_ROOT_VERSION = 1
+
+          INITIAL_TARGETS_VERSION = 0
+
+          def initialize
+            @contents = ContentList.new
+            @opaque_backend_state = nil
+            @root_version = UNVERIFIED_ROOT_VERSION
+            @targets_version = INITIAL_TARGETS_VERSION
+          end
+
+          def paths
+            @contents.paths
+          end
+
+          def [](path)
+            @contents[path]
+          end
+
+          def transaction
+            transaction = Transaction.new
+
+            yield(self, transaction)
+
+            commit(transaction)
+          end
+
+          def commit(transaction)
+            previous = contents.dup
+
+            touched = transaction.operations.each_with_object([]) do |op, acc|
+              acc << op.apply(self)
+            end
+
+            changes = ChangeSet.new
+
+            touched.uniq.each do |path|
+              next if path.nil?
+
+              changes.add(path, previous[path], @contents[path])
+            end
+
+            changes.freeze
+          end
+
+          def state
+            State.new(self)
+          end
+
+          # State store the repository state
+          class State
+            attr_reader \
+              :root_version,
+              :targets_version,
+              :config_states,
+              :has_error,
+              :error,
+              :opaque_backend_state,
+              :cached_target_files
+
+            def initialize(repository)
+              @repository = repository
+              @root_version = repository.root_version
+              @targets_version = repository.targets_version
+              @config_states = []
+              @has_error = false
+              @error = ''
+              @opaque_backend_state = repository.opaque_backend_state
+              @cached_target_files = contents_to_cached_target_files(repository.contents)
+            end
+
+            private
+
+            def contents_to_cached_target_files(contents)
+              return [] if contents.empty?
+
+              contents.map do |content|
+                {
+                  path: content.path.to_s,
+                  length: content.length,
+                  hashes: content.hashes.map do |algorithm, hexdigest|
+                    {
+                      algorithm: algorithm,
+                      hash: hexdigest
+                    }
+                  end
+                }
+              end
+            end
+          end
+
+          # Encapsulates transaction operations
+          class Transaction
+            attr_reader :operations
+
+            def initialize
+              @operations = []
+            end
+
+            def delete(path)
+              @operations << Operation::Delete.new(path)
+            end
+
+            def insert(path, target, content)
+              @operations << Operation::Insert.new(path, target, content)
+            end
+
+            def update(path, target, content)
+              @operations << Operation::Update.new(path, target, content)
+            end
+
+            def set(**options)
+              @operations << Operation::Set.new(**options)
+            end
+          end
+
+          # Operation
+          module Operation
+            # Delete contents base on path
+            class Delete
+              attr_reader :path
+
+              def initialize(path)
+                super()
+                @path = path
+              end
+
+              def apply(repository)
+                return if repository[@path].nil?
+
+                repository.contents.delete(@path)
+
+                @path
+              end
+            end
+
+            # Insert content into the reporistory contents
+            class Insert
+              attr_reader :path, :target, :content
+
+              def initialize(path, target, content)
+                super()
+                @path = path
+                @target = target
+                @content = content
+              end
+
+              def apply(repository)
+                return unless repository[@path].nil?
+
+                repository.contents << @content
+
+                @path
+              end
+            end
+
+            # Update existimng repository's contents
+            class Update
+              attr_reader :path, :target, :content
+
+              def initialize(path, target, content)
+                super()
+                @path = path
+                @target = target
+                @content = content
+              end
+
+              def apply(repository)
+                return if repository[@path].nil?
+
+                repository.contents[@path] = @content
+
+                @path
+              end
+            end
+
+            # Set repository metadata
+            class Set
+              attr_reader :opaque_backend_state, :targets_version
+
+              def initialize(**options)
+                super()
+                @opaque_backend_state = options[:opaque_backend_state]
+                @targets_version = options[:targets_version]
+              end
+
+              def apply(repository)
+                repository.instance_variable_set(:@opaque_backend_state, @opaque_backend_state) if @opaque_backend_state
+
+                repository.instance_variable_set(:@targets_version, @targets_version) if @targets_version
+
+                nil
+              end
+            end
+          end
+
+          private_constant :Operation
+
+          module Change
+            # Delete change
+            class Deleted
+              attr_reader :path, :previous
+
+              def initialize(path, previous)
+                @path = path
+                @previous = previous
+              end
+            end
+
+            # Insert change
+            class Inserted
+              attr_reader :path, :content
+
+              def initialize(path, content)
+                @path = path
+                @content = content
+              end
+            end
+
+            # Update change
+            class Updated
+              attr_reader :path, :content, :previous
+
+              def initialize(path, content, previous)
+                @path = path
+                @content = content
+                @previous = previous
+              end
+            end
+          end
+
+          # Store list of Changes
+          class ChangeSet < Array
+            def paths
+              map(&:path)
+            end
+
+            def add(path, previous, content)
+              return if previous.nil? && content.nil?
+
+              return deleted(path, previous) if previous && content.nil?
+              return inserted(path, content) if content && previous.nil?
+              return updated(path, content, previous) if content && previous
+            end
+
+            def deleted(path, previous)
+              self << Change::Deleted.new(path, previous).freeze
+            end
+
+            def inserted(path, content)
+              self << Change::Inserted.new(path, content).freeze
+            end
+
+            def updated(path, content, previous)
+              self << Change::Updated.new(path, content, previous).freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'path'
+require_relative 'digest'
+
+module Datadog
+  module Core
+    module Remote
+      class Configuration
+        # TargetMap stores information regarding Configuration::Path and Configuration::Target
+        class TargetMap < Hash
+          class << self
+            def parse(hash)
+              opaque_backend_state = hash['signed']['custom']['opaque_backend_state']
+              version = hash['signed']['version']
+
+              map = new
+
+              map.instance_eval do
+                @opaque_backend_state = opaque_backend_state
+                @version = version
+              end
+
+              hash['signed']['targets'].each_with_object(map) do |(p, t), m|
+                path = Configuration::Path.parse(p)
+                target = Configuration::Target.parse(t)
+
+                m[path] = target
+              end
+            end
+          end
+
+          attr_reader :opaque_backend_state, :version
+
+          def initialize
+            super
+
+            @opaque_backend_state = nil
+            @version = nil
+          end
+
+          private_class_method :new
+        end
+
+        # Target stores digest information
+        class Target
+          class << self
+            def parse(hash)
+              length = Integer(hash['length'])
+              digests = Configuration::DigestList.parse(hash['hashes'])
+
+              new(digests: digests, length: length)
+            end
+          end
+
+          attr_reader :length, :digests
+
+          def initialize(digests:, length:)
+            @digests = digests
+            @length = length
+          end
+
+          private_class_method :new
+
+          def check(content)
+            digests.check(content)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'configuration/path'
+require_relative 'configuration/content'
+require_relative 'configuration/target'
+require_relative 'configuration/repository'
+
+module Datadog
+  module Core
+    module Remote
+      # Configuration
+      # rubocop:disable Lint/EmptyClass
+      class Configuration
+      end
+      # rubocop:enable Lint/EmptyClass
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      # Repository update dispatcher
+      class Dispatcher
+        attr_reader :receivers
+
+        def initialize
+          @receivers = []
+        end
+
+        def dispatch(changes, repository)
+          receivers.each do |receiver|
+            matching_changes = changes.select { |c| receiver.match?(c.path) }
+
+            receiver.call(repository, matching_changes) if matching_changes.any?
+          end
+        end
+
+        # Store Matcher and block to be executed on a match
+        class Receiver
+          def initialize(matcher, &block)
+            @block = block
+            @matcher = matcher
+          end
+
+          def match?(path)
+            @matcher.match?(path)
+          end
+
+          def call(repository, changes)
+            @block.call(repository, changes)
+          end
+        end
+
+        # Matcher checks if the path matches
+        class Matcher
+          def initialize(&block)
+            @block = block
+          end
+
+          def match?(path)
+            @block.call(path)
+          end
+
+          # Matches on the produc's path
+          class Product < Matcher
+            def initialize(products)
+              block = ->(path) { products.include?(path.product) }
+              super(&block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      module Ext
+        ENV_ENABLED = 'DD_REMOTE_CONFIGURATION_ENABLED'
+        ENV_POLL_INTERVAL_SECONDS = 'DD_REMOTE_CONFIGURATION_POLL_INTERVAL_SECONDS'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      # Worker executes a block every interval on a separate Thread
+      class Worker
+        def initialize(interval:, &block)
+          @mutex = Mutex.new
+          @thr = nil
+
+          @starting = false
+          @stopping = false
+          @started = false
+
+          @interval = interval
+          raise ArgumentError, 'can not initialize a worker without a block' unless block
+
+          @block = block
+        end
+
+        def start
+          Datadog.logger.debug { 'remote worker starting' }
+
+          acquire_lock
+
+          return if @starting || @started
+
+          @starting = true
+
+          @thr = Thread.new { poll(@interval) }
+
+          @started = true
+          @starting = false
+
+          Datadog.logger.debug { 'remote worker started' }
+        ensure
+          release_lock
+        end
+
+        def stop
+          Datadog.logger.debug { 'remote worker stopping' }
+
+          acquire_lock
+
+          @stopping = true
+
+          thread = @thr
+
+          if thread
+            thread.kill
+            thread.join
+          end
+
+          @started = false
+          @stopping = false
+          @thr = nil
+
+          Datadog.logger.debug { 'remote worker stopped' }
+        ensure
+          release_lock
+        end
+
+        def started?
+          @started
+        end
+
+        private
+
+        def acquire_lock
+          @mutex.lock
+        end
+
+        def release_lock
+          @mutex.unlock
+        end
+
+        def poll(interval)
+          loop do
+            break unless @mutex.synchronize { @starting || @started }
+
+            call
+
+            sleep(interval)
+          end
+        end
+
+        def call
+          Datadog.logger.debug { 'remote worker perform' }
+
+          @block.call
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/remote.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    # Module to interact with core remote component
+    module Remote
+      class << self
+        def active_remote
+          remote
+        end
+
+        private
+
+        def components
+          Datadog.send(:components)
+        end
+
+        def remote
+          components.remote
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ require 'etc'
 require_relative '../configuration/agent_settings_resolver'
 require_relative '../environment/ext'
 require_relative '../environment/platform'
+require_relative '../utils/hash'
 require_relative 'v1/application'
 require_relative 'v1/dependency'
 require_relative 'v1/host'
@@ -18,6 +19,7 @@ module Datadog
       # Module defining methods for collecting metadata for telemetry
       module Collector
         include Datadog::Core::Configuration
+        using Core::Utils::Hash::Refinement
 
         # Forms a hash of configuration key value pairs to be sent in the additional payload
         def additional_payload
@@ -41,12 +43,13 @@ module Datadog
 
         # Forms a hash of standard key value pairs to be sent in the app-started event configuration
         def configurations
-          configurations = {
+          hash = {
             DD_AGENT_HOST: Datadog.configuration.agent.host,
             DD_AGENT_TRANSPORT: agent_transport,
             DD_TRACE_SAMPLE_RATE: format_configuration_value(Datadog.configuration.tracing.sampling.default_rate),
           }
-          compact_hash(configurations)
+          hash.compact!
+          hash
         end
 
         # Forms a telemetry app-started dependencies object
@@ -134,7 +137,8 @@ module Datadog
           options['logger.instance'] = configuration.logger.instance.class.to_s
           options['appsec.enabled'] = configuration.dig('appsec', 'enabled') if configuration.respond_to?('appsec')
           options['tracing.opentelemetry.enabled'] = !defined?(Datadog::OpenTelemetry::LOADED).nil?
-          compact_hash(options)
+          options.compact!
+          options
         end
 
         def format_configuration_value(value)
@@ -147,11 +151,6 @@ module Datadog
           end
         end
 
-        # Manual implementation of hash.compact used because it is unsupported by older Ruby versions (<2.4)
-        def compact_hash(hash)
-          hash.delete_if { |_k, v| v.nil? }
-        end
-
         def env
           Datadog.configuration.env
         end
@@ -222,7 +221,7 @@ module Datadog
             desc += ", Patchable? #{integration.klass.class.patchable?}"
             desc
           else
-            patch_error_result.to_s
+            patch_error_result.compact.to_s
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../worker'
 require_relative '../workers/polling'
 

data/lib/datadog/core/telemetry/http/env.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Telemetry

data/lib/datadog/core/telemetry/http/transport.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../configuration/settings'
 require_relative 'env'
 require_relative 'ext'

data/lib/datadog/core/telemetry/v1/app_event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Telemetry

data/lib/datadog/core/telemetry/v1/application.rb

@@ -1,9 +1,13 @@
+require_relative '../../utils/hash'
+
 module Datadog
   module Core
     module Telemetry
       module V1
         # Describes attributes for application environment object
         class Application
+          using Core::Utils::Hash::Refinement
+
           ERROR_NIL_LANGUAGE_NAME_MESSAGE = ':language_name must not be nil'.freeze
           ERROR_NIL_LANGUAGE_VERSION_MESSAGE = ':language_version must not be nil'.freeze
           ERROR_NIL_SERVICE_NAME_MESSAGE = ':service_name must not be nil'.freeze
@@ -54,7 +58,7 @@ module Datadog
           end
 
           def to_h
-            {
+            hash = {
               env: @env,
               language_name: @language_name,
               language_version: @language_version,
@@ -66,6 +70,8 @@ module Datadog
               service_version: @service_version,
               tracer_version: @tracer_version
             }
+            hash.compact!
+            hash
           end
 
           private