datadog 2.0.0.beta1

data/lib/datadog/profiling/flush.rb

@@ -0,0 +1,43 @@
+# 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,
+        :pprof_file_name,
+        :pprof_data, # gzipped pprof bytes
+        :code_provenance_file_name,
+        :code_provenance_data, # gzipped json bytes
+        :tags_as_array,
+        :internal_metadata_json,
+        :info_json
+
+      def initialize(
+        start:,
+        finish:,
+        pprof_file_name:,
+        pprof_data:,
+        code_provenance_file_name:,
+        code_provenance_data:,
+        tags_as_array:,
+        internal_metadata:,
+        info_json:
+      )
+        @start = start
+        @finish = finish
+        @pprof_file_name = pprof_file_name
+        @pprof_data = pprof_data
+        @code_provenance_file_name = code_provenance_file_name
+        @code_provenance_data = code_provenance_data
+        @tags_as_array = tags_as_array
+        @internal_metadata_json = JSON.fast_generate(internal_metadata)
+        @info_json = info_json
+      end
+    end
+  end
+end

data/lib/datadog/profiling/http_transport.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative '../core/transport/ext'
+
+module Datadog
+  module Profiling
+    # Used to report profiling data to Datadog.
+    # Methods prefixed with _native_ are implemented in `http_transport.c`
+    class HttpTransport
+      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
+        @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
+
+        validate_agent_settings(agent_settings)
+
+        @exporter_configuration =
+          if agentless?(site, api_key)
+            [:agentless, site, api_key]
+          else
+            [:agent, base_url_from(agent_settings)]
+          end
+
+        status, result = validate_exporter(@exporter_configuration)
+
+        raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
+      end
+
+      def export(flush)
+        status, result = do_export(
+          exporter_configuration: @exporter_configuration,
+          upload_timeout_milliseconds: @upload_timeout_milliseconds,
+
+          # why "timespec"?
+          # libdatadog represents time using POSIX's struct timespec, see
+          # https://www.gnu.org/software/libc/manual/html_node/Time-Types.html
+          # aka it represents the seconds part separate from the nanoseconds part
+          start_timespec_seconds: flush.start.tv_sec,
+          start_timespec_nanoseconds: flush.start.tv_nsec,
+          finish_timespec_seconds: flush.finish.tv_sec,
+          finish_timespec_nanoseconds: flush.finish.tv_nsec,
+
+          pprof_file_name: flush.pprof_file_name,
+          pprof_data: flush.pprof_data,
+          code_provenance_file_name: flush.code_provenance_file_name,
+          code_provenance_data: flush.code_provenance_data,
+
+          tags_as_array: flush.tags_as_array,
+          internal_metadata_json: flush.internal_metadata_json,
+
+          info_json: flush.info_json
+        )
+
+        if status == :ok
+          if (200..299).cover?(result)
+            Datadog.logger.debug('Successfully reported profiling data')
+            true
+          else
+            Datadog.logger.error(
+              "Failed to report profiling data (#{config_without_api_key}): " \
+              "server returned unexpected HTTP #{result} status code"
+            )
+            false
+          end
+        else
+          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          false
+        end
+      end
+
+      # Used to log soft failures in `ddog_Vec_tag_push` (e.g. we still report the profile in these cases)
+      # Called from native code
+      def self.log_failure_to_process_tag(failure_details)
+        Datadog.logger.warn("Failed to add tag to profiling request: #{failure_details}")
+      end
+
+      private
+
+      def base_url_from(agent_settings)
+        case agent_settings.adapter
+        when Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+          "#{agent_settings.ssl ? 'https' : 'http'}://#{agent_settings.hostname}:#{agent_settings.port}/"
+        when Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
+          "unix://#{agent_settings.uds_path}"
+        else
+          raise ArgumentError, "Unexpected adapter: #{agent_settings.adapter}"
+        end
+      end
+
+      def validate_agent_settings(agent_settings)
+        supported_adapters = [Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
+                              Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER]
+        unless supported_adapters.include?(agent_settings.adapter)
+          raise ArgumentError,
+            "Unsupported transport configuration for profiling: Adapter #{agent_settings.adapter} " \
+                        ' is not supported'
+        end
+      end
+
+      def agentless?(site, api_key)
+        site && api_key && Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
+      end
+
+      def validate_exporter(exporter_configuration)
+        self.class._native_validate_exporter(exporter_configuration)
+      end
+
+      def do_export(
+        exporter_configuration:,
+        upload_timeout_milliseconds:,
+        start_timespec_seconds:,
+        start_timespec_nanoseconds:,
+        finish_timespec_seconds:,
+        finish_timespec_nanoseconds:,
+        pprof_file_name:,
+        pprof_data:,
+        code_provenance_file_name:,
+        code_provenance_data:,
+        tags_as_array:,
+        internal_metadata_json:,
+        info_json:
+      )
+        self.class._native_do_export(
+          exporter_configuration,
+          upload_timeout_milliseconds,
+          start_timespec_seconds,
+          start_timespec_nanoseconds,
+          finish_timespec_seconds,
+          finish_timespec_nanoseconds,
+          pprof_file_name,
+          pprof_data,
+          code_provenance_file_name,
+          code_provenance_data,
+          tags_as_array,
+          internal_metadata_json,
+          info_json,
+        )
+      end
+
+      def config_without_api_key
+        [@exporter_configuration[0..1]].to_h
+      end
+    end
+  end
+end

data/lib/datadog/profiling/load_native_extension.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# This file is used to load the profiling native extension. It works in two steps:
+#
+# 1. Load the datadog_profiling_loader extension. This extension will be used to load the actual extension, but in
+#    a special way that avoids exposing native-level code symbols. See `datadog_profiling_loader.c` for more details.
+#
+# 2. Use the Datadog::Profiling::Loader exposed by the datadog_profiling_loader extension to load the actual
+#    profiling native extension.
+#
+# All code on this file is on-purpose at the top-level; this makes it so this file is executed only once,
+# the first time it gets required, to avoid any issues with the native extension being initialized more than once.
+
+begin
+  require "datadog_profiling_loader.#{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
+
+extension_name = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+full_file_path = "#{__dir__}/../../#{extension_name}.#{RbConfig::CONFIG['DLEXT']}"
+init_function_name = "Init_#{extension_name.split('.').first}"
+
+status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
+
+raise "Failure to load #{extension_name} due to #{result}" if status == :error

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,64 @@
+# 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.'
+        )
+
+        if failed_component == :worker
+          stop_scheduler
+        elsif failed_component == :scheduler
+          stop_worker
+        else
+          raise ArgumentError, "Unexpected failed_component: #{failed_component.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/scheduler.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils/time'
+
+require_relative '../core/worker'
+require_relative '../core/workers/polling'
+
+module Datadog
+  module Profiling
+    # Periodically (every interval, 60 seconds by default) takes a profile from the `Exporter` and reports it using the
+    # configured transport. Runs on its own background thread.
+    class Scheduler < Core::Worker
+      include Core::Workers::Polling
+
+      MINIMUM_INTERVAL_SECONDS = 0
+
+      # We sleep for at most this duration seconds before reporting data to avoid multi-process applications all
+      # reporting profiles at the exact same time
+      DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS = 3
+
+      private
+
+      attr_reader \
+        :exporter,
+        :transport
+
+      public
+
+      def initialize(
+        exporter:,
+        transport:,
+        interval:, fork_policy: Core::Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default, # seconds
+        enabled: true
+      )
+        @exporter = exporter
+        @transport = transport
+
+        # Workers::Async::Thread settings
+        self.fork_policy = fork_policy
+
+        # Workers::IntervalLoop settings
+        self.loop_base_interval = interval
+
+        # Workers::Polling settings
+        self.enabled = enabled
+      end
+
+      def start(on_failure_proc: nil)
+        perform(on_failure_proc)
+      end
+
+      def perform(on_failure_proc)
+        begin
+          # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
+          # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
+          # successfully finish in the strict timeout.
+          # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
+          interrupted = true
+
+          flush_and_wait
+          interrupted = false
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.warn(
+            'Profiling::Scheduler thread error. ' \
+            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          on_failure_proc&.call
+          raise
+        ensure
+          Datadog.logger.debug('#flush was interrupted or failed before it could complete') if interrupted
+        end
+      end
+
+      # Configure Workers::IntervalLoop to not report immediately when scheduler starts
+      #
+      # When a scheduler gets created (or reset), we don't want it to immediately try to flush; we want it to wait for
+      # the loop wait time first. This avoids an issue where the scheduler reported a mostly-empty profile if the
+      # application just started but this thread took a bit longer so there's already profiling data in the exporter.
+      def loop_wait_before_first_iteration?
+        true
+      end
+
+      def work_pending?
+        exporter.can_flush?
+      end
+
+      def reset_after_fork
+        exporter.reset_after_fork
+      end
+
+      private
+
+      def flush_and_wait
+        run_time = Core::Utils::Time.measure do
+          flush_events
+        end
+
+        # Update wait time to try to wake consistently on time.
+        # Don't drop below the minimum interval.
+        self.loop_wait_time = [loop_base_interval - run_time, MINIMUM_INTERVAL_SECONDS].max
+      end
+
+      def flush_events
+        # Collect data to be exported
+        flush = exporter.flush
+
+        return false unless flush
+
+        # Sleep for a bit to cause misalignment between profilers in multi-process applications
+        #
+        # When not being run in a loop, it means the scheduler has not been started or was stopped, and thus
+        # a) it's being shut down (and is trying to report the last profile)
+        # b) it's being run as a one-shot, usually in a test
+        # ...so in those cases we don't sleep
+        #
+        # During PR review (https://github.com/DataDog/dd-trace-rb/pull/1807) we discussed the possible alternative of
+        # just sleeping before starting the scheduler loop. We ended up not going with that option to avoid the first
+        # profile containing up to interval + DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS instead of the
+        # usual interval seconds.
+        if run_loop?
+          jitter_seconds = rand * DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS # floating point number between (0.0...maximum)
+          sleep(jitter_seconds)
+        end
+
+        begin
+          transport.export(flush)
+        rescue StandardError => e
+          Datadog.logger.error(
+            "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/datadog/profiling/stack_recorder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    # Stores stack samples in a native libdatadog data structure and expose Ruby-level serialization APIs
+    # Note that `record_sample` is only accessible from native code.
+    # 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:
+      )
+        # This mutex works in addition to the fancy C-level mutexes we have in the native side (see the docs there).
+        # It prevents multiple Ruby threads calling serialize at the same time -- something like
+        # `10.times { Thread.new { stack_recorder.serialize } }`.
+        # 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
+
+        self.class._native_initialize(
+          self,
+          cpu_time_enabled,
+          alloc_samples_enabled,
+          heap_samples_enabled,
+          heap_size_enabled,
+          heap_sample_every,
+          timeline_enabled,
+        )
+      end
+
+      def serialize
+        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+
+        if status == :ok
+          start, finish, encoded_pprof = result
+
+          Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
+
+          [start, finish, encoded_pprof]
+        else
+          error_message = result
+
+          Datadog.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) }
+
+        if status == :ok
+          _start, _finish, encoded_pprof = result
+
+          encoded_pprof
+        else
+          error_message = result
+
+          raise("Failed to serialize profiling data: #{error_message}")
+        end
+      end
+
+      def reset_after_fork
+        self.class._native_reset_after_fork(self)
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tag_builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils'
+require_relative '../core/environment/git'
+
+module Datadog
+  module Profiling
+    # Builds a hash of default plus user tags to be included in a profile
+    module TagBuilder
+      include Datadog::Profiling::Ext::Transport::HTTP # Tag name constants
+
+      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
+      )
+        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,
+          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
+
+        # 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Wraps command with Datadog profiling
+      class Exec
+        attr_reader :args
+
+        def initialize(args)
+          @args = args
+        end
+
+        def run
+          set_rubyopt!
+          exec_with_error_handling(args)
+        end
+
+        def rubyopts
+          [
+            '-rdatadog/profiling/preload'
+          ]
+        end
+
+        private
+
+        def set_rubyopt!
+          existing_rubyopt = ENV['RUBYOPT']
+
+          ENV['RUBYOPT'] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(' ')}" : rubyopts.join(' ')
+        end
+
+        # If there's an error here, rather than throwing a cryptic stack trace, let's instead have clearer messages, and
+        # follow the same status codes as the shell uses
+        # 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
+        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.exit 127
+        rescue Errno::EACCES, Errno::ENOEXEC => e
+          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(' ')}')"
+          Kernel.exit 126
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Tasks
+      # Prints help message for usage of `ddprofrb`
+      class Help
+        def run
+          puts %(
+  Usage: ddprofrb [command] [arguments]
+    exec [command]: Executes command with profiling preloaded.
+    help:           Prints this help message.
+          )
+        end
+      end
+    end
+  end
+end