dd-trace-rb/lib/datadog/core/remote/client/capabilities.rb at 9f0c6427b37a5670aaec00f0f6296ce4a325b1f5 · DataDog/dd-trace-rb · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
# frozen_string_literal: true

require_relative '../../utils/base64'
require_relative '../../../appsec/remote'
require_relative '../../../tracing/remote'
require_relative '../../../di/remote'
require_relative '../../../symbol_database/remote'
require_relative '../../../open_feature/remote'

module Datadog
  module Core
    module Remote
      class Client
        # Capabilities
        class Capabilities
          attr_reader :products, :capabilities, :receivers, :base64_capabilities

          def initialize(settings, telemetry)
            @capabilities = []
            @products = []
            @receivers = []
            @telemetry = telemetry

            register(settings)

            @base64_capabilities = capabilities_to_base64
          end

          private

          def register(settings)
            if settings.respond_to?(:appsec) && settings.appsec.enabled
              register_capabilities(Datadog::AppSec::Remote.capabilities)
              register_products(Datadog::AppSec::Remote.products)
              register_receivers(Datadog::AppSec::Remote.receivers(@telemetry))
            end

            if settings.respond_to?(:dynamic_instrumentation) && settings.dynamic_instrumentation.enabled
              register_capabilities(Datadog::DI::Remote.capabilities)
              register_products(Datadog::DI::Remote.products)
              register_receivers(Datadog::DI::Remote.receivers(@telemetry))

              # Symbol Database
              if settings.respond_to?(:symbol_database) && settings.symbol_database.enabled
                register_capabilities(Datadog::SymbolDatabase::Remote.capabilities)
                register_products(Datadog::SymbolDatabase::Remote.products)
                register_receivers(Datadog::SymbolDatabase::Remote.receivers(@telemetry))
              end
            end

            if settings.respond_to?(:open_feature) && settings.open_feature.enabled
              register_capabilities(Datadog::OpenFeature::Remote.capabilities)
              register_products(Datadog::OpenFeature::Remote.products)
              register_receivers(Datadog::OpenFeature::Remote.receivers(@telemetry))
            end

            register_capabilities(Datadog::Tracing::Remote.capabilities)
            register_products(Datadog::Tracing::Remote.products)
            register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))
          end

          def register_capabilities(capabilities)
            @capabilities.concat(capabilities)
          end

          def register_receivers(receivers)
            @receivers.concat(receivers)
          end

          def register_products(products)
            @products.concat(products)
          end

          def capabilities_to_base64
            return '' if capabilities.empty?

            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*')

            Datadog::Core::Utils::Base64.strict_encode64(binary)
          end
        end
      end
    end
  end
end