datadog 2.38.0 → 2.47.0

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'datadog/tracing/utils'
+require "datadog/tracing/utils"
 
 module Datadog
   module OpenTelemetry
@@ -30,9 +30,9 @@ module Datadog
           if (span = datadog_span)
             # Sets the exception attributes as span error tags. The values in the attribute hash MUST
             # take precedence over the type, message and stacktrace inferred from the exception object
-            type = attributes&.[]('exception.type') || exception.class.to_s
-            message = attributes&.[]('exception.message') || exception.message
-            stacktrace = attributes&.[]('exception.stacktrace') || exception.full_message(highlight: false, order: :top)
+            type = attributes&.[]("exception.type") || exception.class.to_s
+            message = attributes&.[]("exception.message") || exception.message
+            stacktrace = attributes&.[]("exception.stacktrace") || exception.full_message(highlight: false, order: :top)
             span.set_error_tags([type, message, stacktrace])
           end
           res
@@ -67,22 +67,22 @@ module Datadog
 
         # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def self.enrich_name(kind, attrs)
-          if attrs.key?('http.request.method')
-            return 'http.server.request' if kind == :server
-            return 'http.client.request' if kind == :client
+          if attrs.key?("http.request.method")
+            return "http.server.request" if kind == :server
+            return "http.client.request" if kind == :client
           end
 
-          return "#{attrs["db.system"]}.query" if attrs.key?('db.system') && kind == :client
+          return "#{attrs["db.system"]}.query" if attrs.key?("db.system") && kind == :client
 
-          if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
+          if (attrs.key?("messaging.system") || attrs.key?("messaging.operation")) &&
               [:consumer, :producer, :server, :client].include?(kind)
 
             return "#{attrs["messaging.system"]}.#{attrs["messaging.operation"]}"
           end
 
-          if attrs.key?('rpc.system')
-            if attrs['rpc.system'] == 'aws-api' && kind == :client
-              service = attrs['rpc.service']
+          if attrs.key?("rpc.system")
+            if attrs["rpc.system"] == "aws-api" && kind == :client
+              service = attrs["rpc.service"]
               return "aws.#{service || "client"}.request"
             end
 
@@ -93,24 +93,24 @@ module Datadog
             end
           end
 
-          if attrs.key?('faas.invoked_provider') && attrs.key?('faas.invoked_name') && kind == :client
-            provider = attrs['faas.invoked_provider']
-            name = attrs['faas.invoked_name']
+          if attrs.key?("faas.invoked_provider") && attrs.key?("faas.invoked_name") && kind == :client
+            provider = attrs["faas.invoked_provider"]
+            name = attrs["faas.invoked_name"]
             return "#{provider}.#{name}.invoke"
           end
 
-          return "#{attrs["faas.trigger"]}.invoke" if attrs.key?('faas.trigger') && kind == :server
+          return "#{attrs["faas.trigger"]}.invoke" if attrs.key?("faas.trigger") && kind == :server
 
-          return 'graphql.server.request' if attrs.key?('graphql.operation.type')
+          return "graphql.server.request" if attrs.key?("graphql.operation.type")
 
           if kind == :server
-            protocol = attrs['network.protocol.name']
-            return protocol ? "#{protocol}.server.request" : 'server.request'
+            protocol = attrs["network.protocol.name"]
+            return protocol ? "#{protocol}.server.request" : "server.request"
           end
 
           if kind == :client
-            protocol = attrs['network.protocol.name']
-            return protocol ? "#{protocol}.client.request" : 'client.request'
+            protocol = attrs["network.protocol.name"]
+            return protocol ? "#{protocol}.client.request" : "client.request"
           end
 
           kind.to_s
@@ -129,7 +129,7 @@ module Datadog
           # DEV: clones the hash, causing unnecessary overhead.
           if @attributes.key?(key)
             # Try to find a richer operation name, unless an explicit override was provided.
-            if !@attributes.key?('operation.name') && (rich_name = Span.enrich_name(kind, @attributes))
+            if !@attributes.key?("operation.name") && (rich_name = Span.enrich_name(kind, @attributes))
               span.name = rich_name.downcase
             end
 
@@ -143,7 +143,7 @@ module Datadog
           else
             span.clear_tag(key)
 
-            if key == 'service.name'
+            if key == "service.name"
               # By removing the service name, we set it to the fallback default,
               # effectively removing the `service` attribute from OpenTelemetry's perspective.
               span.service = Datadog.send(:components).tracer.default_service
@@ -156,24 +156,24 @@ module Datadog
         # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
         # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def override_datadog_values(span, key, value)
-          span.name = value if key == 'operation.name'
-          span.resource = value if key == 'resource.name'
-          span.service = value if key == 'service.name'
-          span.type = value if key == 'span.type'
+          span.name = value if key == "operation.name"
+          span.resource = value if key == "resource.name"
+          span.service = value if key == "service.name"
+          span.type = value if key == "span.type"
 
-          if key == 'analytics.event' && value.respond_to?(:casecmp)
+          if key == "analytics.event" && value.respond_to?(:casecmp)
             Datadog::Tracing::Analytics.set_sample_rate(
               span,
-              (value.casecmp('true') == 0) ? 1 : 0
+              (value.casecmp("true") == 0) ? 1 : 0
             )
           end
 
-          span.set_tag('http.status_code', value) if key == 'http.response.status_code'
+          span.set_tag("http.status_code", value) if key == "http.response.status_code"
         end
         # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
-        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
-          'span.type', 'http.response.status_code'].freeze
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ["analytics.event", "operation.name", "resource.name", "service.name",
+          "span.type", "http.response.status_code"].freeze
 
         ::OpenTelemetry::SDK::Trace::Span.prepend(self)
       end

data/lib/datadog/opentelemetry/sdk.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative '../tracing/ext'
+require_relative "../tracing/ext"
 
 module Datadog
   module OpenTelemetry
     module SDK
-      TELEMETRY_TAGS = {'protocol' => 'http', 'encoding' => 'protobuf'}.freeze
+      TELEMETRY_TAGS = {"protocol" => "http", "encoding" => "protobuf"}.freeze
 
       def self.telemetry_inc(metric_name, value)
         telemetry&.inc(Datadog::Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: TELEMETRY_TAGS)

data/lib/datadog/opentelemetry/signal_configuration.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../core/configuration/ext'
-require_relative '../core/environment/socket'
+require_relative "../core/configuration/ext"
+require_relative "../core/environment/socket"
 
 module Datadog
   module OpenTelemetry
@@ -12,26 +12,27 @@ module Datadog
       def create_resource
         resource_attributes = {}
 
-        @settings.tags&.each do |key, value| # steep:ignore
+        @settings.tags&.each do |key, value|
           otel_key = case key
-          when 'service' then 'service.name'
-          when 'env' then 'deployment.environment'
-          when 'version' then 'service.version'
+          when "service" then "service.name"
+          when "env", "deployment.environment.name", "deployment.environment" then next
+          when "version" then "service.version"
           else key
           end
           resource_attributes[otel_key] = value
         end
 
-        resource_attributes['service.name'] = @settings.service_without_fallback || resource_attributes['service.name'] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME # steep:ignore
-        resource_attributes['deployment.environment'] = @settings.env if @settings.env # steep:ignore
-        resource_attributes['service.version'] = @settings.version if @settings.version # steep:ignore
+        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
+        environment = @settings.env || @settings.tags["env"] || @settings.tags["deployment.environment.name"] || @settings.tags["deployment.environment"]
+        resource_attributes["deployment.environment.name"] = environment if environment
+        resource_attributes["service.version"] = @settings.version if @settings.version
 
-        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings)
         if hostname
-          if hostname == @settings.hostname # steep:ignore
-            resource_attributes['host.name'] = hostname
-          elsif !resource_attributes.key?('host.name')
-            resource_attributes['host.name'] = hostname
+          if hostname == @settings.hostname
+            resource_attributes["host.name"] = hostname
+          elsif !resource_attributes.key?("host.name")
+            resource_attributes["host.name"] = hostname
           end
         end
 
@@ -41,9 +42,12 @@ module Datadog
       # Returns the signal-specific option value when explicitly set,
       # otherwise falls back to the general OTLP exporter config or computed_default.
       def config_or_exporter_fallback(signal:, option_name:, computed_default: nil)
-        signal_settings = @settings.opentelemetry.public_send(signal) # steep:ignore
+        signal_settings = case signal
+        when :logs then @settings.opentelemetry.logs
+        when :metrics then @settings.opentelemetry.metrics
+        end
         if signal_settings.using_default?(option_name)
-          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
         else
           signal_settings.public_send(option_name)
         end

data/lib/datadog/opentelemetry/trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../tracing/trace_digest'
+require_relative "../tracing/trace_digest"
 
 module Datadog
   module OpenTelemetry
@@ -50,6 +50,9 @@ module Datadog
             trace_service: digest.trace_service,
             trace_state: digest.trace_state,
             trace_state_unknown_fields: digest.trace_state_unknown_fields,
+            trace_otel_random_value: digest.trace_otel_random_value,
+            trace_otel_threshold: digest.trace_otel_threshold,
+            trace_otel_unknown_fields: digest.trace_otel_unknown_fields,
             span_remote: digest.span_remote,
           ).freeze
         end

data/lib/datadog/opentelemetry.rb

@@ -9,21 +9,21 @@
 # components supported by Datadog.
 
 # Load Tracing
-require_relative 'tracing'
-require_relative 'tracing/contrib'
+require_relative "tracing"
+require_relative "tracing/contrib"
 
-require_relative 'opentelemetry/api/context'
-require_relative 'opentelemetry/api/baggage'
+require_relative "opentelemetry/api/context"
+require_relative "opentelemetry/api/baggage"
 
 # DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`
 # DEV: and checks for compatibility?
 # DEV: This is different from our existing OpenTracer API, but there are many safety
 # DEV: features built into Contrib instrumentation today.
-require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
-require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
+require_relative "opentelemetry/sdk/configurator" if defined?(OpenTelemetry::SDK)
+require_relative "opentelemetry/sdk/trace/span" if defined?(OpenTelemetry::SDK)
 
-require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
-require_relative 'opentelemetry/logs' if defined?(OpenTelemetry::SDK::Logs)
+require_relative "opentelemetry/metrics" if defined?(OpenTelemetry::SDK::Metrics)
+require_relative "opentelemetry/logs" if defined?(OpenTelemetry::SDK::Logs)
 
 module Datadog
   # Datadog OpenTelemetry integration.

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -33,6 +33,7 @@ module Datadog
         # @rbs allocation_counting_enabled: bool
         # @rbs gvl_profiling_enabled: bool
         # @rbs sighandler_sampling_enabled: bool
+        # @rbs waiting_for_gvl_threshold_ns: ::Integer
         # @rbs skip_idle_samples_for_testing: false
         # @rbs return: void
         def initialize(
@@ -45,11 +46,12 @@ module Datadog
           gvl_profiling_enabled:,
           sighandler_sampling_enabled:,
           cpu_sampling_interval_ms:,
+          waiting_for_gvl_threshold_ns:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
           skip_idle_samples_for_testing: false,
-          idle_sampling_helper: IdleSamplingHelper.new(thread_context_collector: thread_context_collector)
+          idle_sampling_helper: IdleSamplingHelper.new
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -78,6 +80,7 @@ module Datadog
             sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
             cpu_sampling_interval_ms: cpu_sampling_interval_ms,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -95,7 +98,7 @@ module Datadog
 
             Datadog.logger.debug { "Starting thread for: #{self}" }
 
-            @idle_sampling_helper.start
+            @idle_sampling_helper.start(self)
 
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
@@ -144,6 +147,11 @@ module Datadog
           end
         end
 
+        # @rbs return: Datadog::Profiling::StackRecorder
+        def prepare_serialize
+          self.class._native_prepare_serialize(self)
+        end
+
         #: () -> true
         def reset_after_fork
           self.class._native_reset_after_fork(self)

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -10,7 +10,6 @@ module Datadog
       class IdleSamplingHelper
         # @rbs @worker_thread: untyped
         # @rbs @start_stop_mutex: ::Thread::Mutex
-        # @rbs @thread_context_collector: Datadog::Profiling::Collectors::ThreadContext?
 
         private
 
@@ -18,15 +17,14 @@ module Datadog
 
         public
 
-        #: (thread_context_collector: Datadog::Profiling::Collectors::ThreadContext) -> void
-        def initialize(thread_context_collector:)
+        #: () -> void
+        def initialize
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
-          @thread_context_collector = thread_context_collector
         end
 
-        #: () -> (nil | true)
-        def start
+        #: (CpuAndWallTimeWorker cpu_and_wall_time_worker) -> true?
+        def start(cpu_and_wall_time_worker)
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
 
@@ -39,7 +37,7 @@ module Datadog
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
 
-              self.class._native_idle_sampling_loop(self, @thread_context_collector)
+              self.class._native_idle_sampling_loop(self, cpu_and_wall_time_worker)
 
               Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
             rescue Exception => e # rubocop:disable Lint/RescueException

data/lib/datadog/profiling/collectors/info.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "set"
-require "time"
+require "json"
 require "libdatadog"
+require_relative "../../core/utils/time"
 
 module Datadog
   module Profiling
@@ -10,11 +10,11 @@ module Datadog
       # Collects information of relevance for profiler. This will get sent alongside
       # the profile and show up in the UI or potentially influence processing in some way.
       #
-      # Information is currently collected and frozen at construction time. A full collector
-      # could be seen as overkill for this case but it allows us to centralize information
-      # gathering and easily support more flexible/dynamic info collection in the future.
+      # Most information is static: collected and frozen at construction time. The exception is
+      # what `collect_dynamic_info` collects, which can change during the process lifetime.
       class Info
-        # @rbs @info: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        # @rbs @static_info: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        # @rbs @info_json_cache: [::Hash[::Symbol, bool], ::String]?
         # @rbs @platform_info: ::Hash[::Symbol, untyped]
         # @rbs @runtime_info: ::Hash[::Symbol, untyped]
         # @rbs @application_info: ::Hash[::Symbol, untyped]
@@ -25,18 +25,48 @@ module Datadog
         def initialize(settings)
           @profiler_info = nil
 
-          @info = {
+          @static_info = {
             platform: collect_platform_info,
             runtime: collect_runtime_info,
             application: collect_application_info(settings),
             profiler: collect_profiler_info(settings),
           }.freeze
+          @info_json_cache = nil
         end
 
-        attr_reader :info #: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        #: () -> ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        def info
+          build_info(collect_dynamic_info)
+        end
+
+        # Serializing the same info on every flush would be wasteful, so the latest result is
+        # cached and reused for as long as the dynamic info is unchanged.
+        #: () -> ::String
+        def info_json
+          dynamic_info = collect_dynamic_info
+          cached_dynamic_info, cached_json = @info_json_cache
+          return cached_json if cached_json && cached_dynamic_info == dynamic_info
+
+          json = JSON.generate(build_info(dynamic_info)).freeze
+          @info_json_cache = [dynamic_info, json].freeze #: [::Hash[::Symbol, bool], ::String]
+          json
+        end
 
         private
 
+        #: (::Hash[::Symbol, bool]) -> ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        def build_info(dynamic_info)
+          @static_info.merge(runtime: @static_info.fetch(:runtime).merge(dynamic_info))
+        end
+
+        #: () -> ::Hash[::Symbol, bool]
+        def collect_dynamic_info
+          {
+            yjit_enabled: defined?(::RubyVM::YJIT) ? ::RubyVM::YJIT.enabled? : false,
+            zjit_enabled: defined?(::RubyVM::ZJIT) ? ::RubyVM::ZJIT.enabled? : false,
+          }
+        end
+
         # Ruby GC tuning environment variables
         RUBY_GC_TUNING_ENV_VARS = [
           "RUBY_GC_HEAP_FREE_SLOTS",
@@ -71,10 +101,7 @@ module Datadog
         # Instead of trying to figure out real process start time by checking
         # /proc or some other complex/non-portable way, approximate start time
         # by time of requirement of this file.
-        #
-        # Note: this does not use Core::Utils::Time.now because this constant
-        # gets initialized before a user has a chance to configure the library.
-        START_TIME = Time.now.utc.freeze
+        START_TIME = Datadog::Core::Utils::Time.now.utc.freeze
 
         #: () -> ::Hash[::Symbol, untyped]
         def collect_platform_info
@@ -83,7 +110,7 @@ module Datadog
             hostname: Datadog::Core::Environment::Platform.hostname,
             kernel_name: Datadog::Core::Environment::Platform.kernel_name,
             kernel_release: Datadog::Core::Environment::Platform.kernel_release,
-            kernel_version: Datadog::Core::Environment::Platform.kernel_version
+            kernel_version: Datadog::Core::Environment::Platform.kernel_version,
           }.freeze
         end
 

data/lib/datadog/profiling/collectors/thread_context.rb

@@ -19,9 +19,9 @@ module Datadog
           max_frames:,
           tracer:,
           endpoint_collection_enabled:,
-          waiting_for_gvl_threshold_ns:,
           otel_context_enabled:,
-          native_filenames_enabled:
+          native_filenames_enabled:,
+          show_classes:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
@@ -30,9 +30,9 @@ module Datadog
             max_frames: max_frames,
             tracer_context_key: tracer_context_key,
             endpoint_collection_enabled: endpoint_collection_enabled,
-            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
-            native_filenames_enabled: validate_native_filenames(native_filenames_enabled),
+            native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
             overhead_filename: __FILE__,
           )
         end
@@ -42,9 +42,9 @@ module Datadog
           max_frames: 400,
           tracer: nil,
           endpoint_collection_enabled: false,
-          waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
           native_filenames_enabled: true,
+          show_classes: false,
           trigger_global_reset: true,
           **options
         )
@@ -53,9 +53,9 @@ module Datadog
             max_frames: max_frames,
             tracer: tracer,
             endpoint_collection_enabled: endpoint_collection_enabled,
-            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
             native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
             **options,
           )
 
@@ -90,17 +90,6 @@ module Datadog
           context = provider.instance_variable_get(:@context)
           context&.instance_variable_get(:@key)
         end
-
-        def validate_native_filenames(native_filenames_enabled)
-          if native_filenames_enabled && !Datadog::Profiling::Collectors::Stack._native_filenames_available?
-            Datadog.logger.debug(
-              "Native filenames are enabled, but the required dladdr API was not available. Disabling native filenames."
-            )
-            false
-          else
-            native_filenames_enabled
-          end
-        end
       end
     end
   end