cw-datadog 2.23.0.2

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      class Configuration
+        # Path stores path information
+        class Path
+          class ParseError < StandardError; end
+
+          class << self
+            RE = %r{
+              ^
+              (?<source>
+                datadog/(?<org_id>\d+)
+                |
+                employee
+              )
+              /
+              (?<product>[^/]+)
+              /
+              (?<config_id>[^/]+)
+              /
+              (?<name>[^/]+)
+              $
+            }mx.freeze
+
+            def parse(path)
+              m = RE.match(path)
+
+              raise ParseError, "could not parse: #{path.inspect}" if m.nil?
+
+              org_id = m['org_id']&.to_i
+
+              source = m['source']
+              raise ParseError, 'missing source value' unless source
+
+              source = source.delete("/#{org_id}") if org_id
+
+              product = m['product']
+              raise ParseError, 'missing product value' unless product
+
+              config_id = m['config_id']
+              raise ParseError, 'missing config_id value' unless config_id
+
+              name = m['name']
+              raise ParseError, 'missing name value' unless name
+
+              new(source: source, org_id: org_id, product: product, config_id: config_id, name: name)
+            end
+          end
+
+          attr_reader :source, :org_id, :product, :config_id, :name
+
+          def initialize(source:, product:, config_id:, name:, org_id: nil)
+            @source = source
+            @org_id = org_id
+            @product = product
+            @config_id = config_id
+            @name = name
+          end
+
+          private_class_method :new
+
+          def to_s
+            if org_id
+              "#{source}/#{org_id}/#{product}/#{config_id}/#{name}"
+            else
+              "#{source}/#{product}/#{config_id}/#{name}"
+            end
+          end
+
+          def ==(other)
+            return false unless other.is_a?(Path)
+
+            to_s == other.to_s
+          end
+
+          def hash
+            to_s.hash
+          end
+
+          def eql?(other)
+            hash == other.hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,307 @@
+# 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 = contents_to_config_states(repository.contents)
+              @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_config_states(contents)
+              return [] if contents.empty?
+
+              contents.map do |content|
+                {
+                  id: content.path.config_id,
+                  version: content.version,
+                  product: content.path.product,
+                  apply_state: content.apply_state,
+                  apply_error: content.apply_error,
+                }
+              end
+            end
+
+            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 repository 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?
+
+                @content.version = @target.version
+                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?
+
+                @content.version = @target.version
+                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
+
+              def type
+                :delete
+              end
+            end
+
+            # Insert change
+            class Inserted
+              attr_reader :path, :content
+
+              def initialize(path, content)
+                @path = path
+                @content = content
+              end
+
+              def type
+                :insert
+              end
+            end
+
+            # Update change
+            class Updated
+              attr_reader :path, :content, :previous
+
+              def initialize(path, content, previous)
+                @path = path
+                @content = content
+                @previous = previous
+              end
+
+              def type
+                :update
+              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?
+
+              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,74 @@
+# 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'])
+              version = Integer(hash['custom']['v'])
+
+              new(digests: digests, length: length, version: version)
+            end
+          end
+
+          attr_reader :length, :digests, :version
+
+          def initialize(digests:, length:, version:)
+            @digests = digests
+            @length = length
+            @version = version
+          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)
+          @receivers = 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 product'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,13 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      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
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'transport/http'
+
+module Datadog
+  module Core
+    module Remote
+      # Endpoint negotiation
+      class Negotiation
+        attr_reader :logger
+
+        def initialize(_settings, agent_settings, logger: Datadog.logger, suppress_logging: {})
+          @logger = logger
+          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(agent_settings: agent_settings, logger: logger)
+          @logged = suppress_logging
+        end
+
+        def endpoint?(path)
+          res = @transport_root.send_info
+
+          if res.internal_error? && network_error?(res.error)
+            unless @logged[:agent_unreachable]
+              logger.warn { "agent unreachable: cannot negotiate #{path}" }
+              @logged[:agent_unreachable] = true
+            end
+
+            return false
+          end
+
+          if res.not_found?
+            unless @logged[:no_info_endpoint]
+              logger.warn { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+              @logged[:no_info_endpoint] = true
+            end
+
+            return false
+          end
+
+          unless res.ok?
+            unless @logged[:unexpected_response]
+              logger.warn { "agent reachable but unexpected response: cannot negotiate #{path}" }
+              @logged[:unexpected_response] = true
+            end
+
+            return false
+          end
+
+          unless res.endpoints.include?(path)
+            unless @logged[:no_config_endpoint]
+              logger.warn { "agent reachable but does not report #{path}" }
+              @logged[:no_config_endpoint] = true
+            end
+
+            return false
+          end
+
+          logger.debug { "agent reachable and reports #{path}" }
+
+          true
+        end
+
+        private
+
+        def network_error?(error)
+          error.is_a?(Errno::ECONNREFUSED)
+        end
+      end
+    end
+  end
+end

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,29 @@
+# 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
+
+          # steep does not permit the next line due to
+          # https://github.com/soutaro/steep/issues/1231
+          Boot.new(barrier, t)
+        end
+      end
+    end
+  end
+end