datadog 2.0.0 → 2.2.0

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

@@ -92,25 +92,38 @@ module Datadog
 
             seen_files << file_path
 
-            _, found_library = libraries_by_path.find { |library_path, _| file_path.start_with?(library_path) }
-            seen_libraries << found_library if found_library
+            # NOTE: Don't use .find, it allocates a lot more memory (see commit that added this note for details)
+            libraries_by_path.any? do |library_path, library|
+              seen_libraries << library if file_path.start_with?(library_path)
+            end
           end
         end
 
         # Represents metadata we have for a ruby gem
+        #
+        # Important note: This class gets encoded to JSON with the built-in JSON gem. But, we've found that in some
+        # buggy cases, some Ruby gems monkey patch the built-in JSON gem and forget to call #to_json, and instead
+        # encode this class instance-field-by-instance-field.
+        #
+        # Thus, this class was setup to match the JSON output. Take this into consideration if you are adding new
+        # fields. (Also, we have a spec for this)
         class Library
-          attr_reader :kind, :name, :version, :path
+          attr_reader :kind, :name, :version
 
           def initialize(kind:, name:, version:, path:)
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @path = path.dup.freeze
+            @paths = [path.dup.freeze].freeze
             freeze
           end
 
           def to_json(arg = nil)
-            { kind: @kind, name: @name, version: @version, paths: [@path] }.to_json(arg)
+            { kind: @kind, name: @name, version: @version, paths: @paths }.to_json(arg)
+          end
+
+          def path
+            @paths.first
           end
         end
       end

data/lib/datadog/profiling/component.rb

@@ -75,6 +75,10 @@ module Datadog
         crashtracker = build_crashtracker(settings, transport)
         profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler, optional_crashtracker: crashtracker)
 
+        if dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
+          Datadog::Profiling::Ext::DirMonkeyPatches.apply!
+        end
+
         [profiler, { profiling_enabled: true }]
       end
 
@@ -397,8 +401,12 @@ module Datadog
 
       # See https://github.com/datadog/dd-trace-rb/issues/2976 for details.
       private_class_method def self.incompatible_passenger_version?
+        first_compatible_version = Gem::Version.new('6.0.19')
+
         if Gem.loaded_specs['passenger']
-          Gem.loaded_specs['passenger'].version < Gem::Version.new('6.0.19')
+          Gem.loaded_specs['passenger'].version < first_compatible_version
+        elsif defined?(PhusionPassenger::VERSION_STRING)
+          Gem::Version.new(PhusionPassenger::VERSION_STRING) < first_compatible_version
         else
           true
         end
@@ -445,6 +453,15 @@ module Datadog
           libmysqlclient_version < Gem::Version.new('5.0.0') &&
           header_version >= Gem::Version.new('10.0.0'))
       end
+
+      private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
+        return false if no_signals_workaround_enabled
+
+        # NOTE: In the future this method will evolve to check for Ruby versions affected and not apply the workaround
+        # when it's not needed but currently all known Ruby versions are affected.
+
+        settings.profiling.advanced.dir_interruption_workaround_enabled
+      end
     end
   end
 end

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.rb

@@ -136,6 +136,7 @@ module Datadog
       return false unless supported?
 
       require_relative 'profiling/ext/forking'
+      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'

data/lib/datadog/tracing/configuration/ext.rb

@@ -9,6 +9,7 @@ module Datadog
       # e.g. Env vars, default values, enums, etc...
       module Ext
         ENV_ENABLED = 'DD_TRACE_ENABLED'
+        ENV_OTEL_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER'
         ENV_HEADER_TAGS = 'DD_TRACE_HEADER_TAGS'
         ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
 
@@ -39,10 +40,14 @@ module Datadog
           # W3C Trace Context
           PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'
 
+          PROPAGATION_STYLE_SUPPORTED = [PROPAGATION_STYLE_DATADOG, PROPAGATION_STYLE_B3_MULTI_HEADER,
+                                         PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT].freeze
+
           # Sets both extract and inject propagation style tho the provided value.
           # Has lower precedence than `DD_TRACE_PROPAGATION_STYLE_INJECT` or
           # `DD_TRACE_PROPAGATION_STYLE_EXTRACT`.
           ENV_PROPAGATION_STYLE = 'DD_TRACE_PROPAGATION_STYLE'
+          ENV_OTEL_PROPAGATION_STYLE = 'OTEL_PROPAGATORS'
 
           ENV_PROPAGATION_STYLE_INJECT = 'DD_TRACE_PROPAGATION_STYLE_INJECT'
 
@@ -68,6 +73,8 @@ module Datadog
           ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'
           ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'
           ENV_RULES = 'DD_TRACE_SAMPLING_RULES'
+          ENV_OTEL_TRACES_SAMPLER = 'OTEL_TRACES_SAMPLER'
+          OTEL_TRACES_SAMPLER_ARG = 'OTEL_TRACES_SAMPLER_ARG'
 
           # @public_api
           module Span

data/lib/datadog/tracing/configuration/settings.rb

@@ -13,6 +13,8 @@ module Datadog
       # rubocop:disable Metrics/BlockLength
       # rubocop:disable Metrics/MethodLength
       # rubocop:disable Layout/LineLength
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       module Settings
         def self.extended(base)
           base.class_eval do
@@ -89,7 +91,7 @@ module Datadog
               # @return [Array<String>]
               option :propagation_style do |o|
                 o.type :array
-                o.env Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE
+                o.env [Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE, Configuration::Ext::Distributed::ENV_OTEL_PROPAGATION_STYLE]
                 o.default []
                 o.after_set do |styles|
                   next if styles.empty?
@@ -97,6 +99,14 @@ module Datadog
                   # Make values case-insensitive
                   styles.map!(&:downcase)
 
+                  styles.select! do |s|
+                    if Configuration::Ext::Distributed::PROPAGATION_STYLE_SUPPORTED.include?(s)
+                      true
+                    else
+                      Datadog.logger.warn("Unsupported propagation style: #{s}")
+                      false
+                    end
+                  end
                   set_option(:propagation_style_extract, styles)
                   set_option(:propagation_style_inject, styles)
                 end
@@ -121,9 +131,23 @@ module Datadog
               # @default `DD_TRACE_ENABLED` environment variable, otherwise `true`
               # @return [Boolean]
               option :enabled do |o|
-                o.env Tracing::Configuration::Ext::ENV_ENABLED
+                o.env [Tracing::Configuration::Ext::ENV_ENABLED, Tracing::Configuration::Ext::ENV_OTEL_TRACES_EXPORTER]
                 o.default true
                 o.type :bool
+                o.env_parser do |value|
+                  value = value&.downcase
+                  # Tracing is disabled when OTEL_TRACES_EXPORTER is none or
+                  # DD_TRACE_ENABLED is 0 or false.
+                  if ['none', 'false', '0'].include?(value)
+                    false
+                  # Tracing is enabled when DD_TRACE_ENABLED is true or 1
+                  elsif ['true', '1'].include?(value)
+                    true
+                  else
+                    Datadog.logger.warn("Unsupported value for exporting datadog traces: #{value}. Traces will be sent to Datadog.")
+                    nil
+                  end
+                end
               end
 
               # Comma-separated, case-insensitive list of header names that are reported in incoming and outgoing HTTP requests.
@@ -245,7 +269,30 @@ module Datadog
                 # @return [Float, nil]
                 option :default_rate do |o|
                   o.type :float, nilable: true
-                  o.env Tracing::Configuration::Ext::Sampling::ENV_SAMPLE_RATE
+                  o.env [Tracing::Configuration::Ext::Sampling::ENV_SAMPLE_RATE, Tracing::Configuration::Ext::Sampling::ENV_OTEL_TRACES_SAMPLER]
+                  o.env_parser do |value|
+                    # Parse the value as a float
+                    next if value.nil?
+
+                    value = value&.downcase
+                    if ['always_on', 'always_off', 'traceidratio'].include?(value)
+                      Datadog.logger.warn("The value '#{value}' is not yet supported. 'parentbased_#{value}' will be used instead.")
+                      value = "parentbased_#{value}"
+                    end
+                    # OTEL_TRACES_SAMPLER can be set to always_on, always_off, traceidratio, and/or parentbased value.
+                    # These values are mapped to a sample rate.
+                    # DD_TRACE_SAMPLE_RATE sets the sample rate to float.
+                    case value
+                    when 'parentbased_always_on'
+                      1.0
+                    when 'parentbased_always_off'
+                      0.0
+                    when 'parentbased_traceidratio'
+                      ENV.fetch(Tracing::Configuration::Ext::Sampling::OTEL_TRACES_SAMPLER_ARG, 1.0).to_f
+                    else
+                      value.to_f
+                    end
+                  end
                 end
 
                 # Rate limit for number of spans per second.
@@ -417,6 +464,8 @@ module Datadog
       # rubocop:enable Metrics/BlockLength
       # rubocop:enable Metrics/MethodLength
       # rubocop:enable Layout/LineLength
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/datadog/tracing/contrib/action_cable/event.rb

@@ -46,7 +46,7 @@ module Datadog
           module ClassMethods
             include Contrib::ActionCable::Event::ClassMethods
 
-            def subscription(*args)
+            def subscription(*args, **kwargs)
               super.tap do |subscription|
                 subscription.before_trace { ensure_clean_context! }
               end

data/lib/datadog/tracing/contrib/action_cable/events/broadcast.rb

@@ -34,7 +34,7 @@ module Datadog
               Tracing::Metadata::Ext::AppTypes::TYPE_WEB
             end
 
-            def process(span, _event, _id, payload)
+            def on_start(span, _event, _id, payload)
               channel = payload[:broadcasting] # Channel has high cardinality
               span.service = configuration[:service_name] if configuration[:service_name]
               span.type = span_type

data/lib/datadog/tracing/contrib/action_cable/events/perform_action.rb

@@ -33,7 +33,7 @@ module Datadog
               Tracing::Metadata::Ext::AppTypes::TYPE_WEB
             end
 
-            def process(span, _event, _id, payload)
+            def on_start(span, _event, _id, payload)
               channel_class = payload[:channel_class]
               action = payload[:action]
 

data/lib/datadog/tracing/contrib/action_cable/events/transmit.rb

@@ -33,7 +33,7 @@ module Datadog
               Tracing::Metadata::Ext::AppTypes::TYPE_WEB
             end
 
-            def process(span, _event, _id, payload)
+            def on_start(span, _event, _id, payload)
               channel_class = payload[:channel_class]
 
               span.service = configuration[:service_name] if configuration[:service_name]