ddtrace 1.12.1 → 1.23.2

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,11 +24,19 @@ 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
 
-          @thr = Thread.new { poll(@interval) }
+          thread = Thread.new { poll(@interval) }
+          thread.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          thread.thread_variable_set(:fork_safe, true)
+          @thr = thread
 
           @started = true
           @starting = false
@@ -43,8 +51,6 @@ module Datadog
 
           acquire_lock
 
-          @stopping = true
-
           thread = @thr
 
           if thread
@@ -53,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/runtime/ext.rb

@@ -1,26 +1,36 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Runtime
       # @public_api
       module Ext
-        TAG_ID = 'runtime-id'.freeze
-        TAG_LANG = 'language'.freeze
-        TAG_PROCESS_ID = 'process_id'.freeze
+        TAG_ID = 'runtime-id'
+        TAG_LANG = 'language'
+        TAG_PROCESS_ID = 'process_id'
 
         # Metrics
         # @public_api
         module Metrics
-          ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'.freeze
+          ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'
 
-          METRIC_CLASS_COUNT = 'runtime.ruby.class_count'.freeze
-          METRIC_GC_PREFIX = 'runtime.ruby.gc'.freeze
-          METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'.freeze
-          METRIC_GLOBAL_CONSTANT_STATE = 'runtime.ruby.global_constant_state'.freeze
-          METRIC_GLOBAL_METHOD_STATE = 'runtime.ruby.global_method_state'.freeze
-          METRIC_CONSTANT_CACHE_INVALIDATIONS = 'runtime.ruby.constant_cache_invalidations'.freeze
-          METRIC_CONSTANT_CACHE_MISSES = 'runtime.ruby.constant_cache_misses'.freeze
+          METRIC_CLASS_COUNT = 'runtime.ruby.class_count'
+          METRIC_GC_PREFIX = 'runtime.ruby.gc'
+          METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'
+          METRIC_GLOBAL_CONSTANT_STATE = 'runtime.ruby.global_constant_state'
+          METRIC_GLOBAL_METHOD_STATE = 'runtime.ruby.global_method_state'
+          METRIC_CONSTANT_CACHE_INVALIDATIONS = 'runtime.ruby.constant_cache_invalidations'
+          METRIC_CONSTANT_CACHE_MISSES = 'runtime.ruby.constant_cache_misses'
+          METRIC_YJIT_CODE_GC_COUNT = 'runtime.ruby.yjit.code_gc_count'
+          METRIC_YJIT_CODE_REGION_SIZE = 'runtime.ruby.yjit.code_region_size'
+          METRIC_YJIT_FREED_CODE_SIZE = 'runtime.ruby.yjit.freed_code_size'
+          METRIC_YJIT_FREED_PAGE_COUNT = 'runtime.ruby.yjit.freed_page_count'
+          METRIC_YJIT_INLINE_CODE_SIZE = 'runtime.ruby.yjit.inline_code_size'
+          METRIC_YJIT_LIVE_PAGE_COUNT = 'runtime.ruby.yjit.live_page_count'
+          METRIC_YJIT_OBJECT_SHAPE_COUNT = 'runtime.ruby.yjit.object_shape_count'
+          METRIC_YJIT_OUTLINED_CODE_SIZE = 'runtime.ruby.yjit.outlined_code_size'
 
-          TAG_SERVICE = 'service'.freeze
+          TAG_SERVICE = 'service'
         end
       end
     end

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

@@ -5,6 +5,7 @@ require_relative '../environment/class_count'
 require_relative '../environment/gc'
 require_relative '../environment/thread_count'
 require_relative '../environment/vm_cache'
+require_relative '../environment/yjit'
 
 module Datadog
   module Core
@@ -78,6 +79,8 @@ module Datadog
               )
             end
           end
+
+          flush_yjit_stats
         end
 
         def gc_metrics
@@ -134,6 +137,46 @@ module Datadog
         def gauge_if_not_nil(metric_name, metric_value)
           gauge(metric_name, metric_value) if metric_value
         end
+
+        def flush_yjit_stats
+          # Only on Ruby >= 3.2
+          try_flush do
+            if Core::Environment::YJIT.available?
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_CODE_GC_COUNT,
+                Core::Environment::YJIT.code_gc_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_CODE_REGION_SIZE,
+                Core::Environment::YJIT.code_region_size
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_FREED_CODE_SIZE,
+                Core::Environment::YJIT.freed_code_size
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_FREED_PAGE_COUNT,
+                Core::Environment::YJIT.freed_page_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_INLINE_CODE_SIZE,
+                Core::Environment::YJIT.inline_code_size
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_LIVE_PAGE_COUNT,
+                Core::Environment::YJIT.live_page_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_OBJECT_SHAPE_COUNT,
+                Core::Environment::YJIT.object_shape_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_OUTLINED_CODE_SIZE,
+                Core::Environment::YJIT.outlined_code_size
+              )
+            end
+          end
+        end
       end
     end
   end

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

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require_relative 'emitter'
+require_relative 'event'
 require_relative 'heartbeat'
 require_relative '../utils/forking'
 
@@ -8,20 +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
-        def initialize(enabled: true)
+        # @param heartbeat_interval_seconds [Float] How frequently heartbeats will be reported, in seconds.
+        # @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
-          @worker = Telemetry::Heartbeat.new(enabled: @enabled) do
+          @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
@@ -34,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!
@@ -61,7 +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(Event::AppClientConfigurationChange.new(changes, 'remote_config'))
         end
 
         private
@@ -69,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,16 +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
-        def request(request_type)
+        def request(event)
           begin
-            request = Datadog::Core::Telemetry::Event.new.telemetry_request(
-              request_type: request_type,
-              seq_id: self.class.sequence.next
-            ).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

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

@@ -1,65 +1,271 @@
-require_relative 'collector'
-require_relative 'v1/app_event'
-require_relative 'v1/telemetry_request'
+# frozen_string_literal: true
 
 module Datadog
   module Core
     module Telemetry
-      # Class defining methods to construct a Telemetry event
       class Event
-        include Telemetry::Collector
+        # Base class for all Telemetry V2 events.
+        class Base
+          # The type of the event.
+          # It must be one of the stings defined in the Telemetry V2
+          # specification for event names.
+          def type; end
 
-        API_VERSION = 'v1'.freeze
+          # The JSON payload for the event.
+          # @param seq_id [Integer] The sequence ID for the event.
+          def payload(seq_id)
+            {}
+          end
+        end
+
+        # Telemetry class for the 'app-started' event
+        class AppStarted < Base
+          def type
+            'app-started'
+          end
+
+          def payload(seq_id)
+            @seq_id = seq_id
+            {
+              products: products,
+              configuration: configuration,
+              install_signature: install_signature,
+              # DEV: Not implemented yet
+              # error: error, # Start-up errors
+            }
+          end
+
+          private
+
+          def products
+            products = {
+              appsec: {
+                enabled: Datadog::AppSec.enabled?,
+              },
+              profiler: {
+                enabled: Datadog::Profiling.enabled?,
+              },
+              # DEV: Not implemented yet
+              # dynamic_instrumentation: {
+              #   enabled: true,
+              # }
+            }
+
+            if (unsupported_reason = Datadog::Profiling.unsupported_reason)
+              products[:profiler][:error] = {
+                code: 1, # Error code. 0 if no error.
+                message: unsupported_reason,
+              }
+            end
+
+            products
+          end
+
+          TARGET_OPTIONS = %w[
+            logger.level
+            profiling.advanced.code_provenance_enabled
+            profiling.advanced.endpoint.collection.enabled
+            profiling.enabled
+            runtime_metrics.enabled
+            tracing.analytics.enabled
+            tracing.distributed_tracing.propagation_inject_style
+            tracing.distributed_tracing.propagation_extract_style
+            tracing.enabled
+            tracing.log_injection
+            tracing.partial_flush.enabled
+            tracing.partial_flush.min_spans_threshold
+            tracing.report_hostname
+            tracing.sampling.rate_limit
+          ].freeze
+
+          # rubocop:disable Metrics/AbcSize
+          def configuration
+            config = Datadog.configuration
+
+            list = [
+              conf_value('DD_AGENT_HOST', config.agent.host),
+              conf_value('DD_AGENT_TRANSPORT', agent_transport(config)),
+              conf_value('DD_TRACE_SAMPLE_RATE', to_value(config.tracing.sampling.default_rate)),
+              conf_value(
+                'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED',
+                config.tracing.contrib.global_default_service_name.enabled
+              ),
+            ]
+
+            peer_service_mapping_str = ''
+            unless config.tracing.contrib.peer_service_mapping.empty?
+              peer_service_mapping = config.tracing.contrib.peer_service_mapping
+              peer_service_mapping_str = peer_service_mapping.map { |key, value| "#{key}:#{value}" }.join(',')
+            end
+            list << conf_value('DD_TRACE_PEER_SERVICE_MAPPING', peer_service_mapping_str)
+
+            # Whitelist of configuration options to send in additional payload object
+            TARGET_OPTIONS.each do |option|
+              split_option = option.split('.')
+              list << conf_value(option, to_value(config.dig(*split_option)))
+            end
+
+            # Add some more custom additional payload values here
+            list.push(
+              conf_value('tracing.auto_instrument.enabled', !defined?(Datadog::AutoInstrument::LOADED).nil?),
+              conf_value('tracing.writer_options.buffer_size', to_value(config.tracing.writer_options[:buffer_size])),
+              conf_value('tracing.writer_options.flush_interval', to_value(config.tracing.writer_options[:flush_interval])),
+              conf_value('tracing.opentelemetry.enabled', !defined?(Datadog::OpenTelemetry::LOADED).nil?),
+            )
+            list << conf_value('logger.instance', config.logger.instance.class.to_s) if config.logger.instance
+            list << conf_value('appsec.enabled', config.dig('appsec', 'enabled')) if config.respond_to?('appsec')
+            list << conf_value('ci.enabled', config.dig('ci', 'enabled')) if config.respond_to?('ci')
+
+            list.reject! { |entry| entry[:value].nil? }
+            list
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def agent_transport(config)
+            adapter = Core::Configuration::AgentSettingsResolver.call(config).adapter
+            if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
+              'UDS'
+            else
+              'TCP'
+            end
+          end
+
+          def conf_value(name, value, origin = 'code')
+            {
+              name: name,
+              value: value,
+              origin: origin,
+              seq_id: @seq_id,
+            }
+          end
+
+          def to_value(value)
+            # TODO: Add float if telemetry starts accepting it
+            case value
+            when Integer, String, true, false, nil
+              value
+            else
+              value.to_s
+            end
+          end
 
-        attr_reader \
-          :api_version
+          def install_signature
+            config = Datadog.configuration
+            {
+              install_id: config.dig('telemetry', 'install_id'),
+              install_type: config.dig('telemetry', 'install_type'),
+              install_time: config.dig('telemetry', 'install_time'),
+            }
+          end
+        end
+
+        # Telemetry class for the 'app-dependencies-loaded' event
+        class AppDependenciesLoaded < Base
+          def type
+            'app-dependencies-loaded'
+          end
+
+          def payload(seq_id)
+            { dependencies: dependencies }
+          end
+
+          private
 
-        def initialize
-          @api_version = API_VERSION
+          def dependencies
+            Gem.loaded_specs.collect do |name, gem|
+              {
+                name: name,
+                version: gem.version.to_s,
+                # hash: nil,
+              }
+            end
+          end
         end
 
-        # Forms a TelemetryRequest object based on the event request_type
-        # @param request_type [String] the type of telemetry request to collect data for
-        # @param seq_id [Integer] the ID of the request; incremented each time a telemetry request is sent to the API
-        def telemetry_request(request_type:, seq_id:)
-          Telemetry::V1::TelemetryRequest.new(
-            api_version: @api_version,
-            application: application,
-            host: host,
-            payload: payload(request_type),
-            request_type: request_type,
-            runtime_id: runtime_id,
-            seq_id: seq_id,
-            tracer_time: tracer_time,
-          )
+        # Telemetry class for the 'app-integrations-change' event
+        class AppIntegrationsChange < Base
+          def type
+            'app-integrations-change'
+          end
+
+          def payload(seq_id)
+            { integrations: integrations }
+          end
+
+          private
+
+          def integrations
+            instrumented_integrations = Datadog.configuration.tracing.instrumented_integrations
+            Datadog.registry.map do |integration|
+              is_instrumented = instrumented_integrations.include?(integration.name)
+
+              is_enabled = is_instrumented ? !!integration.klass.patcher.patch_successful : false
+
+              version = integration.klass.class.version ? integration.klass.class.version.to_s : nil
+
+              res = {
+                name: integration.name.to_s,
+                enabled: is_enabled,
+                version: version,
+                compatible: integration.klass.class.compatible?,
+                error: (patch_error(integration) if is_instrumented && !is_enabled),
+                # TODO: Track if integration is instrumented by manual configuration or by auto instrumentation
+                # auto_enabled: is_enabled && ???,
+              }
+              res.reject! { |_, v| v.nil? }
+              res
+            end
+          end
+
+          def patch_error(integration)
+            patch_error_result = integration.klass.patcher.patch_error_result
+            return patch_error_result.compact.to_s if patch_error_result
+
+            # If no error occurred during patching, but integration is still not instrumented
+            "Available?: #{integration.klass.class.available?}" \
+            ", Loaded? #{integration.klass.class.loaded?}" \
+            ", Compatible? #{integration.klass.class.compatible?}" \
+            ", Patchable? #{integration.klass.class.patchable?}"
+          end
         end
 
-        private
+        # Telemetry class for the 'app-client-configuration-change' event
+        class AppClientConfigurationChange < Base
+          def type
+            'app-client-configuration-change'
+          end
 
-        def payload(request_type)
-          case request_type
-          when :'app-started'
-            app_started
-          when :'app-closing', :'app-heartbeat'
-            {}
-          when :'app-integrations-change'
-            app_integrations_change
-          else
-            raise ArgumentError, "Request type invalid, received request_type: #{@request_type}"
+          def initialize(changes, origin)
+            super()
+            @changes = changes
+            @origin = origin
+          end
+
+          def payload(seq_id)
+            {
+              configuration: @changes.map do |name, value|
+                {
+                  name: name,
+                  value: value,
+                  origin: @origin,
+                }
+              end
+            }
           end
         end
 
-        def app_started
-          Telemetry::V1::AppEvent.new(
-            dependencies: dependencies,
-            integrations: integrations,
-            configuration: configurations,
-            additional_payload: additional_payload
-          )
+        # Telemetry class for the 'app-heartbeat' event
+        class AppHeartbeat < Base
+          def type
+            'app-heartbeat'
+          end
         end
 
-        def app_integrations_change
-          Telemetry::V1::AppEvent.new(integrations: integrations)
+        # Telemetry class for the 'app-closing' event
+        class AppClosing < Base
+          def type
+            'app-closing'
+          end
         end
       end
     end

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

@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Telemetry
       module Ext
-        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'.freeze
+        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'
+        ENV_HEARTBEAT_INTERVAL = 'DD_TELEMETRY_HEARTBEAT_INTERVAL'
+        ENV_DEPENDENCY_COLLECTION = 'DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED'
+        ENV_INSTALL_ID = 'DD_INSTRUMENTATION_INSTALL_ID'
+        ENV_INSTALL_TYPE = 'DD_INSTRUMENTATION_INSTALL_TYPE'
+        ENV_INSTALL_TIME = 'DD_INSTRUMENTATION_INSTALL_TIME'
       end
     end
   end

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

@@ -10,21 +10,17 @@ module Datadog
       class Heartbeat < Core::Worker
         include Core::Workers::Polling
 
-        DEFAULT_INTERVAL_SECONDS = 60
-
-        def initialize(enabled: true, interval: DEFAULT_INTERVAL_SECONDS, &block)
+        def initialize(heartbeat_interval_seconds:, enabled: true, &block)
           # Workers::Polling settings
           self.enabled = enabled
           # Workers::IntervalLoop settings
-          self.loop_base_interval = interval
+          self.loop_base_interval = heartbeat_interval_seconds
           self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
           super(&block)
           start
         end
 
-        def loop_wait_before_first_iteration?
-          true
-        end
+        def loop_wait_before_first_iteration?; end
 
         private