datadog 2.8.0 → 2.39.0

data/lib/datadog/profiling/stack_recorder.rb

@@ -9,12 +9,10 @@ module Datadog
     # Methods prefixed with _native_ are implemented in `stack_recorder.c`
     class StackRecorder
       def initialize(
-        cpu_time_enabled:,
         alloc_samples_enabled:,
         heap_samples_enabled:,
         heap_size_enabled:,
         heap_sample_every:,
-        timeline_enabled:,
         heap_clean_after_gc_enabled:
       )
         # This mutex works in addition to the fancy C-level mutexes we have in the native side (see the docs there).
@@ -23,68 +21,62 @@ module Datadog
         # This isn't something we expect to happen normally, but because it would break the assumptions of the
         # C-level mutexes (that there is a single serializer thread), we add it here as an extra safeguard against it
         # accidentally happening.
-        @no_concurrent_synchronize_mutex = Mutex.new
+        @no_concurrent_serialize_mutex = Mutex.new
 
         self.class._native_initialize(
           self_instance: self,
-          cpu_time_enabled: cpu_time_enabled,
           alloc_samples_enabled: alloc_samples_enabled,
           heap_samples_enabled: heap_samples_enabled,
           heap_size_enabled: heap_size_enabled,
           heap_sample_every: heap_sample_every,
-          timeline_enabled: timeline_enabled,
           heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
         )
       end
 
       def self.for_testing(
-        cpu_time_enabled: true,
         alloc_samples_enabled: false,
         heap_samples_enabled: false,
         heap_size_enabled: false,
         heap_sample_every: 1,
-        timeline_enabled: false,
         heap_clean_after_gc_enabled: true,
         **options
       )
         new(
-          cpu_time_enabled: cpu_time_enabled,
           alloc_samples_enabled: alloc_samples_enabled,
           heap_samples_enabled: heap_samples_enabled,
           heap_size_enabled: heap_size_enabled,
           heap_sample_every: heap_sample_every,
-          timeline_enabled: timeline_enabled,
           heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
           **options,
         )
       end
 
       def serialize
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
-          start, finish, encoded_pprof, profile_stats = result
+          start, finish, encoded_profile, profile_stats = result
 
           Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
 
-          [start, finish, encoded_pprof, profile_stats]
+          [start, finish, encoded_profile, profile_stats]
         else
           error_message = result
 
-          Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
-          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data")
+          Datadog.logger.warn("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data (#{error_message})")
 
           nil
         end
       end
 
       def serialize!
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
-          _start, _finish, encoded_pprof = result
+          _start, _finish, encoded_profile = result
 
-          encoded_pprof
+          encoded_profile
         else
           error_message = result
 

data/lib/datadog/profiling/tag_builder.rb

@@ -1,59 +1,59 @@
 # frozen_string_literal: true
 
+require_relative "../core/tag_builder"
 require_relative "../core/utils"
-require_relative "../core/environment/git"
+
+require "set"
 
 module Datadog
   module Profiling
     # Builds a hash of default plus user tags to be included in a profile
+    #
+    # @api private
     module TagBuilder
       include Datadog::Profiling::Ext::Transport::HTTP # Tag name constants
 
+      # When changing or adding profiling-related tags, make sure they are
+      # kept in sync with
+      # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/
+      # (Datadog internal link).
+      #
+      # For consistency between the different profilers, every tag should be
+      # vetted before it gets reported with a profile, as otherwise it's too
+      # easy to end up with different tags in different languages.
+      ALLOWED_TAGS = Set.new(
+        [
+          "env",
+          "service",
+          "version",
+          "git.commit.sha",
+          "git.repository_url",
+          "host",
+          "language",
+          "runtime",
+          "runtime_engine",
+          "runtime_platform",
+          "runtime_version",
+          "runtime-id",
+          "process_id",
+          "profiler_version",
+          "profile_seq",
+        ]
+      ).freeze
+
       def self.call(
         settings:,
-        # Unified service tagging
-        env: settings.env,
-        service: settings.service,
-        version: settings.version,
-        # Other metadata
-        host: Core::Environment::Socket.hostname,
-        language: Core::Environment::Identity.lang,
-        pid: Process.pid.to_s,
-        # TODO: If profiling is extracted and its version diverges from the datadog gem, this is inaccurate.
-        #       Update if this ever occurs.
-        profiler_version: Core::Environment::Identity.gem_datadog_version,
-        runtime_engine: Core::Environment::Identity.lang_engine,
-        runtime_id: Core::Environment::Identity.id,
-        runtime_platform: Core::Environment::Identity.lang_platform,
-        runtime_version: Core::Environment::Identity.lang_version,
-        git_repository_url: Core::Environment::Git.git_repository_url,
-        git_commit_sha: Core::Environment::Git.git_commit_sha,
-        # User-provided tags
-        user_tags: settings.tags
+        profile_seq:,
+        profiler_version: Core::Environment::Identity.gem_datadog_version
       )
-        tags = {
-          # When changing or adding these, make sure they are kept in sync with
-          # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/ (Datadog internal link)
-          FORM_FIELD_TAG_HOST => host,
-          FORM_FIELD_TAG_LANGUAGE => language,
-          FORM_FIELD_TAG_PID => pid,
+        hash = Core::TagBuilder.tags(settings).merge(
           FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
-          FORM_FIELD_TAG_RUNTIME => language, # This is known to be repeated from language, above
-          FORM_FIELD_TAG_RUNTIME_ENGINE => runtime_engine,
-          FORM_FIELD_TAG_RUNTIME_ID => runtime_id,
-          FORM_FIELD_TAG_RUNTIME_PLATFORM => runtime_platform,
-          FORM_FIELD_TAG_RUNTIME_VERSION => runtime_version,
-        }
-        tags[FORM_FIELD_TAG_ENV] = env if env
-        tags[FORM_FIELD_TAG_SERVICE] = service if service
-        tags[FORM_FIELD_TAG_VERSION] = version if version
-        tags[TAG_GIT_REPOSITORY_URL] = git_repository_url if git_repository_url
-        tags[TAG_GIT_COMMIT_SHA] = git_commit_sha if git_commit_sha
+          "profile_seq" => profile_seq.to_s,
+        )
 
-        # Make sure everything is an utf-8 string, to avoid encoding issues in native code/libddprof/further downstream
-        user_tags.merge(tags).map do |key, value|
-          [Datadog::Core::Utils.utf8_encode(key), Datadog::Core::Utils.utf8_encode(value)]
-        end.to_h
+        user_tag_keys = settings.tags.keys
+        hash.keep_if { |tag| user_tag_keys.include?(tag) || ALLOWED_TAGS.include?(tag) }
+        Core::Utils.encode_tags(hash)
       end
     end
   end

data/lib/datadog/profiling/tasks/exec.rb

@@ -5,17 +5,20 @@ module Datadog
     module Tasks
       # Wraps command with Datadog profiling
       class Exec
-        attr_reader :args
+        attr_reader :args #: untyped
 
+        #: (untyped) -> void
         def initialize(args)
           @args = args
         end
 
+        #: () -> untyped
         def run
           set_rubyopt!
           exec_with_error_handling(args)
         end
 
+        #: () -> ::Array["-rdatadog/profiling/preload"]
         def rubyopts
           [
             "-rdatadog/profiling/preload"
@@ -24,10 +27,11 @@ module Datadog
 
         private
 
+        #: () -> untyped
         def set_rubyopt!
-          existing_rubyopt = ENV["RUBYOPT"]
+          existing_rubyopt = ENV["RUBYOPT"] # rubocop:disable CustomCops/EnvUsageCop
 
-          ENV["RUBYOPT"] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(" ")}" : rubyopts.join(" ")
+          ENV["RUBYOPT"] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(" ")}" : rubyopts.join(" ") # rubocop:disable CustomCops/EnvUsageCop
         end
 
         # If there's an error here, rather than throwing a cryptic stack trace, let's instead have clearer messages, and
@@ -35,13 +39,14 @@ module Datadog
         # See also:
         # * https://www.gnu.org/software/bash/manual/html_node/Exit-Status.html
         # * https://github.com/rubygems/rubygems/blob/dd93966cac224532035deda533cba2685dfa30cc/bundler/lib/bundler/cli/exec.rb#L45
+        #: (untyped) -> untyped
         def exec_with_error_handling(args)
           Kernel.exec(*args)
         rescue Errno::ENOENT => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class}: #{e.message} (command was '#{args.join(" ")}')"
           Kernel.exit 127
         rescue Errno::EACCES, Errno::ENOEXEC => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class}: #{e.message} (command was '#{args.join(" ")}')"
           Kernel.exit 126
         end
       end

data/lib/datadog/profiling/tasks/help.rb

@@ -5,6 +5,7 @@ module Datadog
     module Tasks
       # Prints help message for usage of `ddprofrb`
       class Help
+        #: () -> untyped
         def run
           puts %(
   Usage: ddprofrb [command] [arguments]

data/lib/datadog/profiling/tasks/setup.rb

@@ -16,9 +16,10 @@ module Datadog
             setup_at_fork_hooks
           rescue StandardError, ScriptError => e
             Datadog.logger.warn do
-              "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
+              "Profiler extensions unavailable. Cause: #{e.class}: #{e.message} " \
               "Location: #{Array(e.backtrace).first}"
             end
+            Datadog::Core::Telemetry::Logger.report(e, description: "Profiler extensions unavailable")
           end
         end
 
@@ -30,9 +31,10 @@ module Datadog
             Profiling.start_if_enabled
           rescue => e
             Datadog.logger.warn do
-              "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
+              "Error during post-fork hooks. Cause: #{e.class}: #{e.message} " \
               "Location: #{Array(e.backtrace).first}"
             end
+            Datadog::Core::Telemetry::Logger.report(e, description: "Error during post-fork hooks")
           end
         end
       end

data/lib/datadog/profiling.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'core'
-require_relative 'core/environment/variable_helpers'
-require_relative 'core/utils/only_once'
+require_relative "core"
+require_relative "core/environment/variable_helpers"
+require_relative "core/utils/only_once"
 
 module Datadog
   # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
@@ -61,9 +61,7 @@ module Datadog
     end
 
     def self.enabled?
-      profiler = Datadog.send(:components).profiler
-      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
-      !!profiler&.send(:scheduler)&.running?
+      !!Datadog.send(:components).profiler
     end
 
     def self.wait_until_running(timeout_seconds: 5)
@@ -73,13 +71,16 @@ module Datadog
         worker = profiler.send(:worker)
         worker.wait_until_running(timeout_seconds: timeout_seconds)
       else
-        raise 'Profiler not enabled or available'
+        raise "Profiler not enabled or available"
       end
     end
 
     private_class_method def self.replace_noop_allocation_count
-      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
-        Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+      class << self
+        remove_method :allocation_count
+        def allocation_count
+          Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+        end
       end
     end
 
@@ -108,25 +109,23 @@ module Datadog
 
       unless success
         if exception
-          'There was an error loading the profiling native extension due to ' \
+          "There was an error loading the profiling native extension due to " \
           "'#{exception.class.name} #{exception.message}' at '#{Array(exception.backtrace).first}'"
         else
-          'The profiling native extension did not load correctly. ' \
-          'For help solving this issue, please contact Datadog support at <https://docs.datadoghq.com/help/>.' \
+          "The profiling native extension did not load correctly. " \
+          "For help solving this issue, please contact Datadog support at <https://docs.datadoghq.com/help/>." \
         end
       end
     end
 
     private_class_method def self.try_loading_native_library
-      begin
-        require_relative 'profiling/load_native_extension'
+      require_relative "profiling/load_native_extension"
 
-        success =
-          defined?(Profiling::NativeExtension) && Profiling::NativeExtension.send(:native_working?)
-        [success, nil]
-      rescue StandardError, LoadError => e
-        [false, e]
-      end
+      success =
+        defined?(Profiling::NativeExtension) && Profiling::NativeExtension.send(:native_working?)
+      [success, nil]
+    rescue StandardError, LoadError => e
+      [false, e]
     end
 
     # All requires for the profiler should be directly added here; and everything should be loaded eagerly.
@@ -136,23 +135,25 @@ module Datadog
     private_class_method def self.load_profiling
       return false unless supported?
 
-      require_relative 'profiling/ext/dir_monkey_patches'
-      require_relative 'profiling/collectors/info'
-      require_relative 'profiling/collectors/code_provenance'
-      require_relative 'profiling/collectors/cpu_and_wall_time_worker'
-      require_relative 'profiling/collectors/dynamic_sampling_rate'
-      require_relative 'profiling/collectors/idle_sampling_helper'
-      require_relative 'profiling/collectors/stack'
-      require_relative 'profiling/collectors/thread_context'
-      require_relative 'profiling/stack_recorder'
-      require_relative 'profiling/exporter'
-      require_relative 'profiling/flush'
-      require_relative 'profiling/scheduler'
-      require_relative 'profiling/tasks/setup'
-      require_relative 'profiling/profiler'
-      require_relative 'profiling/native_extension'
-      require_relative 'profiling/tag_builder'
-      require_relative 'profiling/http_transport'
+      require_relative "profiling/ext/dir_monkey_patches"
+      require_relative "profiling/collectors/info"
+      require_relative "profiling/collectors/code_provenance"
+      require_relative "profiling/collectors/cpu_and_wall_time_worker"
+      require_relative "profiling/collectors/dynamic_sampling_rate"
+      require_relative "profiling/collectors/idle_sampling_helper"
+      require_relative "profiling/collectors/stack"
+      require_relative "profiling/collectors/thread_context"
+      require_relative "profiling/stack_recorder"
+      require_relative "profiling/exporter"
+      require_relative "profiling/encoded_profile"
+      require_relative "profiling/flush"
+      require_relative "profiling/scheduler"
+      require_relative "profiling/tasks/setup"
+      require_relative "profiling/profiler"
+      require_relative "profiling/native_extension"
+      require_relative "profiling/tag_builder"
+      require_relative "profiling/http_transport"
+      require_relative "profiling/sequence_tracker"
 
       replace_noop_allocation_count
 

data/lib/datadog/ruby_version.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  # Compares the running Ruby against version requirements.
+  #
+  # Lexical comparisons against `RUBY_VERSION` are subtly wrong: `RUBY_VERSION < "3.2.3"` is also
+  # `true` on 3.2.10 and 3.2.11, since those sort *before* "3.2.3" as strings.
+  #
+  # @example
+  #   RubyVersion.is?(">= 3.2", "< 3.2.3") # => true on Ruby 3.2.0, 3.2.1, 3.2.2 (NOT 3.2.3+, NOT 3.2.10+)
+  module RubyVersion
+    extend RubyVersion # steep currently needs this (instead of extend self or def self.is?) for the inline rbs to work
+
+    CURRENT_RUBY_VERSION = Gem::Version.new(RUBY_VERSION) #: ::Gem::Version
+    private_constant :CURRENT_RUBY_VERSION
+
+    # Returns `true` when the running Ruby satisfies ALL of the given requirements. Each uses the
+    # same syntax as a gem dependency (e.g. `">= 3.1"`, `">= 3.2"`, `"< 3.2.3"`).
+    #
+    # @rbs (*String requirements, ?ruby_version: ::Gem::Version) -> bool
+    def is?(*requirements, ruby_version: CURRENT_RUBY_VERSION)
+      Gem::Requirement.new(*requirements).satisfied_by?(ruby_version)
+    end
+  end
+end

data/lib/datadog/single_step_instrument.rb

@@ -5,8 +5,17 @@
 #
 # This file's path is private. Do not reference this file.
 #
+
+module Datadog
+  # This module handles conditional loading of single step auto-instrumentation,
+  # which enables Datadog tracing and profiling features when available.
+  module SingleStepInstrument
+  end
+end
+
 begin
-  require_relative 'auto_instrument'
+  require_relative "auto_instrument"
+  Datadog::SingleStepInstrument.const_set(:LOADED, true)
 rescue StandardError, LoadError => e
-  warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+  warn "Single step instrumentation failed: #{e.class}: #{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
 end