cw-datadog 2.23.0.2

data/lib/datadog/profiling/ext/dir_monkey_patches.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    # Monkey patches needed for profiler features and compatibility
+    module Ext
+      # All Ruby versions as of this writing have bugs in the dir class implementation, causing issues such as
+      # https://github.com/DataDog/dd-trace-rb/issues/3450 .
+      # See also https://bugs.ruby-lang.org/issues/20586 for more details.
+      #
+      # This monkey patch for the Ruby `Dir` class works around these bugs for affected Ruby versions by temporarily
+      # blocking the profiler from interrupting system calls.
+      #
+      # A lot of these APIs do very similar things -- they're provided by Ruby as helpers so users don't need to keep
+      # reimplementing them but share the same underlying buggy code. And so our monkey patches are a bit repetitive
+      # as well.
+      # We don't DRY out this file to have minimal overhead.
+      #
+      # These monkey patches are applied by the profiler when the "dir_interruption_workaround_enabled" setting is
+      # enabled. See the profiling settings for more detail.
+      module DirMonkeyPatches
+        def self.apply!
+          ::Dir.singleton_class.prepend(Datadog::Profiling::Ext::DirClassMonkeyPatches)
+          ::Dir.prepend(Datadog::Profiling::Ext::DirInstanceMonkeyPatches)
+
+          true
+        end
+      end
+
+      if RUBY_VERSION.start_with?("2.")
+        # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
+        module DirClassMonkeyPatches
+          def [](*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def children(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # NOTE: When wrapping methods that yield, it's OK if the `yield` raises an exception while signals are
+          # enabled. This is because:
+          # * We can call `_native_resume_signals` many times in a row, both because it's idempotent, as well as it's
+          #   very low overhead (see benchmarks/profiler_hold_resume_interruptions.rb)
+          # * When an exception is being raised, the iteration will stop anyway, so there's no longer a concern of a
+          #   signal causing Ruby to return an incorrect value
+          def each_child(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          def empty?(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def entries(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # See note on methods that yield above.
+          def foreach(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          # See note on methods that yield above.
+          def glob(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              begin
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            end
+          end
+
+          def home(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      else
+        # Monkey patches for Dir.singleton_class (Ruby 3 version). See DirMonkeyPatches above for more details.
+        module DirClassMonkeyPatches
+          def [](*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def children(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # See note on methods that yield above.
+          def each_child(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          def empty?(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def entries(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # See note on methods that yield above.
+          def foreach(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          # See note on methods that yield above.
+          def glob(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              begin
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            end
+          end
+
+          def home(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      end
+
+      if RUBY_VERSION.start_with?("2.")
+        # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
+        module DirInstanceMonkeyPatches
+          # See note on methods that yield above.
+          def each(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals # <-- End critical region
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
+            # See note on methods that yield above.
+            def each_child(*args, &block)
+              if block
+                begin
+                  # <-- Begin critical region
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                  super do |entry_name|
+                    Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                    # <-- We're safe now while running customer code
+                    yield entry_name
+                    # <-- We'll go back to the Dir internals, critical region again
+                    Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                  end
+                ensure
+                  # <-- End critical region
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                end
+              else
+                # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+                # other branch once it gets going.
+                super
+              end
+            end
+
+            def children(*args, &block)
+              Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+              super
+            ensure
+              Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+            end
+          end
+
+          def tell(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def pos(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      else
+        # Monkey patches for Dir (Ruby 3 version). See DirMonkeyPatches above for more details.
+        module DirInstanceMonkeyPatches
+          # See note on methods that yield above.
+          def each(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals # <-- End critical region
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          # See note on methods that yield above.
+          def each_child(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          def children(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def tell(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def pos(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/ext.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Ext
+      ENV_ENABLED = "DD_PROFILING_ENABLED"
+      ENV_UPLOAD_TIMEOUT = "DD_PROFILING_UPLOAD_TIMEOUT"
+      ENV_MAX_FRAMES = "DD_PROFILING_MAX_FRAMES"
+      ENV_ENDPOINT_COLLECTION_ENABLED = "DD_PROFILING_ENDPOINT_COLLECTION_ENABLED"
+
+      # WARNING: This should not be used, only for internal testing
+      ENV_AGENTLESS = "DD_PROFILING_AGENTLESS" # rubocop:disable CustomCops/EnvStringValidationCop
+      module Transport
+        module HTTP
+          FORM_FIELD_TAG_PROFILER_VERSION = "profiler_version"
+
+          CODE_PROVENANCE_FILENAME = "code-provenance.json"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/flush.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Datadog
+  module Profiling
+    # Entity class used to represent metadata for a given profile
+    class Flush
+      attr_reader \
+        :start,
+        :finish,
+        :encoded_profile,
+        :code_provenance_file_name,
+        :code_provenance_data,
+        :tags_as_array,
+        :internal_metadata_json,
+        :info_json
+
+      def initialize(
+        start:,
+        finish:,
+        encoded_profile:,
+        code_provenance_file_name:,
+        code_provenance_data:,
+        tags_as_array:,
+        internal_metadata:,
+        info_json:
+      )
+        @start = start
+        @finish = finish
+        @encoded_profile = encoded_profile
+        @code_provenance_file_name = code_provenance_file_name
+        @code_provenance_data = code_provenance_data
+        @tags_as_array = tags_as_array
+        @internal_metadata_json = JSON.generate(internal_metadata)
+        @info_json = info_json
+      end
+    end
+  end
+end

data/lib/datadog/profiling/http_transport.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../core/transport/ext"
+require_relative "../core/telemetry/logger"
+
+module Datadog
+  module Profiling
+    # Used to report profiling data to Datadog.
+    # Methods prefixed with _native_ are implemented in `http_transport.c`
+    class HttpTransport
+      attr_reader :exporter_configuration
+
+      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
+        @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
+
+        @exporter_configuration =
+          if agentless?(site, api_key)
+            [:agentless, site, api_key].freeze
+          else
+            [:agent, agent_settings.url].freeze
+          end
+
+        status, result = self.class._native_validate_exporter(exporter_configuration)
+
+        raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
+      end
+
+      def export(flush)
+        status, result = self.class._native_do_export(
+          exporter_configuration,
+          @upload_timeout_milliseconds,
+          flush
+        )
+
+        if status == :ok
+          if (200..299).cover?(result)
+            Datadog.logger.debug("Successfully reported profiling data")
+            true
+          else
+            Datadog.logger.warn(
+              "Failed to report profiling data (#{config_without_api_key}): " \
+              "server returned unexpected HTTP #{result} status code"
+            )
+            Datadog::Core::Telemetry::Logger.error(
+              "Failed to report profiling data: unexpected HTTP #{result} status code"
+            )
+            false
+          end
+        else
+          Datadog.logger.warn("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
+          false
+        end
+      end
+
+      private
+
+      def agentless?(site, api_key)
+        site && api_key && %w[1 true].include?(ENV[Profiling::Ext::ENV_AGENTLESS] || '') # rubocop:disable CustomCops/EnvUsageCop
+      end
+
+      def config_without_api_key
+        "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
+      end
+    end
+  end
+end

data/lib/datadog/profiling/load_native_extension.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+begin
+  require "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+rescue LoadError => e
+  raise LoadError,
+    "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
+    "(Details: #{e.message})"
+end

data/lib/datadog/profiling/native_extension.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    # This module contains classes and methods which are implemented using native code in the
+    # ext/datadog_profiling_native_extension folder, as well as some Ruby-level utilities that don't make sense to
+    # write using C
+    module NativeExtension
+      private_class_method def self.working?
+        native_working?
+      end
+
+      unless singleton_class.private_method_defined?(:native_working?)
+        private_class_method def self.native_working?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/preload.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "../../datadog"
+
+Datadog::Profiling.start_if_enabled

data/lib/datadog/profiling/profiler.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    # Profiling entry point, which coordinates the worker and scheduler threads
+    class Profiler
+      include Datadog::Core::Utils::Forking
+
+      private
+
+      attr_reader :worker, :scheduler
+
+      public
+
+      def initialize(worker:, scheduler:)
+        @worker = worker
+        @scheduler = scheduler
+      end
+
+      def start
+        after_fork! do
+          worker.reset_after_fork
+          scheduler.reset_after_fork
+        end
+
+        worker.start(on_failure_proc: proc { component_failed(:worker) })
+        scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
+      end
+
+      def shutdown!
+        Datadog.logger.debug("Shutting down profiler")
+
+        stop_worker
+        stop_scheduler
+      end
+
+      private
+
+      def stop_worker
+        worker.stop
+      end
+
+      def stop_scheduler
+        scheduler.enabled = false
+        scheduler.stop(true)
+      end
+
+      def component_failed(failed_component)
+        Datadog.logger.warn(
+          "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
+          "See previous log messages for details."
+        )
+        Datadog::Core::Telemetry::Logger
+          .error("Detected issue with profiler (#{failed_component} component), stopping profiling")
+
+        # We explicitly not stop the crash tracker in this situation, under the assumption that, if a component failed,
+        # we're operating in a degraded state and crash tracking may still be helpful.
+
+        if failed_component == :worker
+          scheduler.mark_profiler_failed
+          stop_scheduler
+        elsif failed_component == :scheduler
+          stop_worker
+        else
+          raise ArgumentError, "Unexpected failed_component: #{failed_component.inspect}"
+        end
+      end
+    end
+  end
+end