ddtrace 1.19.0 → 1.20.0

data/ext/ddtrace_profiling_native_extension/collectors_discrete_dynamic_sampler.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+
+// A sampler that will sample discrete events based on the overhead of their
+// sampling.
+//
+// NOTE: For performance reasons, this sampler does systematic sampling via
+//       sampling intervals/skips that are dynamically adjusted over time.
+//       It will not perform truly random sampling by "throwing a coin" at
+//       every event and is thus, in theory, susceptible to some pattern
+//       biases. In practice, the dynamic readjustment of sampling interval
+//       and randomized starting point should help with avoiding heavy biases.
+typedef struct discrete_dynamic_sampler {
+  // --- Config ---
+  // Name of this sampler for debug logs.
+  const char *debug_name;
+  // Value in the range ]0, 100] representing the % of time we're willing to dedicate
+  // to sampling.
+  double target_overhead;
+
+  // -- Reference State ---
+  // Moving average of how many events per ns we saw over the recent past.
+  double events_per_ns;
+  // Moving average of the sampling time of each individual event.
+  long sampling_time_ns;
+  // Sampling probability being applied by this sampler.
+  double sampling_probability;
+  // Sampling interval/skip that drives the systematic sampling done by this sampler.
+  // NOTE: This is an inverted view of the probability.
+  // NOTE: A value of 0 works as +inf, effectively disabling sampling (to align with probability=0)
+  unsigned long sampling_interval;
+
+  // -- Sampling State --
+  // How many events have we seen since we last decided to sample.
+  unsigned long events_since_last_sample;
+  // Captures the time at which the last true-returning call to should_sample happened.
+  // This is used in after_sample to understand the total sample time.
+  long sample_start_time_ns;
+
+  // -- Adjustment State --
+  // Has this sampler already ran for at least one complete adjustment window?
+  bool has_completed_full_adjustment_window;
+  // Time at which we last readjust our sampling parameters.
+  long last_readjust_time_ns;
+  // How many events have we seen since the last readjustment.
+  unsigned long events_since_last_readjustment;
+  // How many samples have we seen since the last readjustment.
+  unsigned long samples_since_last_readjustment;
+  // How much time have we spent sampling since the last readjustment.
+  unsigned long sampling_time_since_last_readjustment_ns;
+  // A negative number that we add to target_overhead to serve as extra padding to
+  // try and mitigate observed overshooting of max sampling time.
+  double target_overhead_adjustment;
+} discrete_dynamic_sampler;
+
+
+// Init a new sampler with sane defaults.
+void discrete_dynamic_sampler_init(discrete_dynamic_sampler *sampler, const char *debug_name);
+
+// Reset a sampler, clearing all stored state.
+void discrete_dynamic_sampler_reset(discrete_dynamic_sampler *sampler);
+
+// Sets a new target_overhead for the provided sampler, resetting it in the process.
+// @param target_overhead A double representing the percentage of total time we are
+//        willing to use as overhead for the resulting sampling. Values are expected
+//        to be in the range ]0.0, 100.0].
+void discrete_dynamic_sampler_set_overhead_target_percentage(discrete_dynamic_sampler *sampler, double target_overhead);
+
+// Make a sampling decision.
+//
+// @return True if the event associated with this decision should be sampled, false
+//         otherwise.
+//
+// NOTE: If true is returned we implicitly assume the start of a sampling operation
+//       and it is expected that a follow-up after_sample call is issued.
+bool discrete_dynamic_sampler_should_sample(discrete_dynamic_sampler *sampler);
+
+// Signal the end of a sampling operation.
+//
+// @return Sampling time in nanoseconds for the sample operation we just finished.
+long discrete_dynamic_sampler_after_sample(discrete_dynamic_sampler *sampler);
+
+// Retrieve the current sampling probability ([0.0, 100.0]) being applied by this sampler.
+double discrete_dynamic_sampler_probability(discrete_dynamic_sampler *sampler);
+
+// Retrieve the current number of events seen since last sample.
+unsigned long discrete_dynamic_sampler_events_since_last_sample(discrete_dynamic_sampler *sampler);

data/ext/ddtrace_profiling_native_extension/extconf.rb

@@ -115,6 +115,7 @@ add_compiler_flag '-Wall'
 add_compiler_flag '-Wextra'
 
 if ENV['DDTRACE_DEBUG']
+  $defs << '-DDD_DEBUG'
   CONFIG['optflags'] = '-O0'
   CONFIG['debugflags'] = '-ggdb3'
 end
@@ -130,6 +131,8 @@ if RUBY_PLATFORM.include?('linux')
   $defs << '-DHAVE_PTHREAD_GETCPUCLOCKID'
 end
 
+have_func 'malloc_stats'
+
 # On older Rubies, rb_postponed_job_preregister/rb_postponed_job_trigger did not exist
 $defs << '-DNO_POSTPONED_TRIGGER' if RUBY_VERSION < '3.3'
 

data/ext/ddtrace_profiling_native_extension/helpers.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <stdint.h>
+
 // Used to mark symbols to be exported to the outside of the extension.
 // Consider very carefully before tagging a function with this.
 #define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
@@ -17,3 +19,5 @@ inline static uint64_t uint64_max_of(uint64_t a, uint64_t b) { return a > b ? a
 inline static uint64_t uint64_min_of(uint64_t a, uint64_t b) { return a > b ? b : a; }
 inline static long long_max_of(long a, long b) { return a > b ? a : b; }
 inline static long long_min_of(long a, long b) { return a > b ? b : a; }
+inline static double double_max_of(double a, double b) { return a > b ? a : b; }
+inline static double double_min_of(double a, double b) { return a > b ? b : a; }

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -1,6 +1,9 @@
 #include <ruby.h>
 #include <ruby/thread.h>
 #include <errno.h>
+#ifdef HAVE_MALLOC_STATS
+  #include <malloc.h>
+#endif
 
 #include "clock_id.h"
 #include "helpers.h"
@@ -11,6 +14,7 @@
 
 // Each class/module here is implemented in their separate file
 void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module);
+void collectors_discrete_dynamic_sampler_init(VALUE profiling_module);
 void collectors_dynamic_sampling_rate_init(VALUE profiling_module);
 void collectors_idle_sampling_helper_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
@@ -32,6 +36,7 @@ static void holding_the_gvl_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_U
 static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VALUE _self, VALUE background_thread);
 static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE with_gvl);
 static void *trigger_enforce_success(void *trigger_args);
+static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self);
 
 void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
@@ -43,6 +48,7 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
 
   ruby_helpers_init();
   collectors_cpu_and_wall_time_worker_init(profiling_module);
+  collectors_discrete_dynamic_sampler_init(profiling_module);
   collectors_dynamic_sampling_rate_init(profiling_module);
   collectors_idle_sampling_helper_init(profiling_module);
   collectors_stack_init(profiling_module);
@@ -65,6 +71,7 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   rb_define_singleton_method(testing_module, "_native_install_holding_the_gvl_signal_handler", _native_install_holding_the_gvl_signal_handler, 0);
   rb_define_singleton_method(testing_module, "_native_trigger_holding_the_gvl_signal_handler_on", _native_trigger_holding_the_gvl_signal_handler_on, 1);
   rb_define_singleton_method(testing_module, "_native_enforce_success", _native_enforce_success, 2);
+  rb_define_singleton_method(testing_module, "_native_malloc_stats", _native_malloc_stats, 0);
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
@@ -249,3 +256,12 @@ static void *trigger_enforce_success(void *trigger_args) {
   ENFORCE_SUCCESS_NO_GVL(syserr_errno);
   return NULL;
 }
+
+static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self) {
+  #ifdef HAVE_MALLOC_STATS
+    malloc_stats();
+    return Qtrue;
+  #else
+    return Qfalse;
+  #endif
+}

data/ext/ddtrace_profiling_native_extension/time_helpers.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <stdbool.h>
+
 #define SECONDS_AS_NS(value) (value * 1000 * 1000 * 1000L)
 #define MILLIS_AS_NS(value) (value * 1000 * 1000L)
 

data/lib/datadog/appsec/contrib/rack/request_middleware.rb

@@ -26,7 +26,8 @@ module Datadog
           def call(env)
             return @app.call(env) unless Datadog::AppSec.enabled?
 
-            Datadog::Core::Remote.active_remote.barrier(:once) unless Datadog::Core::Remote.active_remote.nil?
+            boot = Datadog::Core::Remote::Tie.boot
+            Datadog::Core::Remote::Tie::Tracing.tag(boot, active_span)
 
             processor = nil
             ready = false

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

@@ -369,14 +369,16 @@ module Datadog
 
             # Can be used to configure the allocation sampling rate: a sample will be collected every x allocations.
             #
-            # The lower the value, the more accuracy in allocation and heap tracking but the bigger the overhead. In
-            # particular, a value of 1 will sample ALL allocations.
-            #
-            # @default `DD_PROFILING_EXPERIMENTAL_ALLOCATION_SAMPLE_RATE` environment variable, otherwise `50`.
+            # This feature is now controlled via {:overhead_target_percentage}
             option :experimental_allocation_sample_rate do |o|
-              o.type :int
-              o.env 'DD_PROFILING_EXPERIMENTAL_ALLOCATION_SAMPLE_RATE'
-              o.default 50
+              o.after_set do
+                Datadog.logger.warn(
+                  'The profiling.advanced.experimental_allocation_sample_rate setting has been deprecated for removal ' \
+                  'and no longer does anything. Please remove it from your Datadog.configure block. ' \
+                  'Allocation sample rate is now handled by a dynamic sampler which will adjust the sampling rate to ' \
+                  'keep to the configured `profiling.advanced.overhead_target_percentage`.'
+                )
+              end
             end
 
             # Can be used to configure the heap sampling rate: a heap sample will be collected for every x allocation
@@ -747,6 +749,19 @@ module Datadog
             o.default 5.0
           end
 
+          # Tune remote configuration boot timeout.
+          # Early operations such as requests are blocked until RC is ready. In
+          # order to not block the application indefinitely a timeout is
+          # enforced allowing requests to proceed with the local configuration.
+          #
+          # @default `DD_REMOTE_CONFIG_BOOT_TIMEOUT` environment variable, otherwise `1.0` seconds.
+          # @return [Float]
+          option :boot_timeout_seconds do |o|
+            o.env Core::Remote::Ext::ENV_BOOT_TIMEOUT_SECONDS
+            o.type :float
+            o.default 1.0
+          end
+
           # Declare service name to bind to remote configuration. Use when
           # DD_SERVICE does not match the correct integration for which remote
           # configuration applies.

data/lib/datadog/core/environment/class_count.rb

@@ -5,15 +5,15 @@ module Datadog
     module Environment
       # Retrieves number of classes from runtime
       module ClassCount
-        module_function
-
-        def value
+        def self.value
           ::ObjectSpace.count_objects[:T_CLASS]
         end
 
-        def available?
-          ::ObjectSpace.respond_to?(:count_objects) \
-           && ::ObjectSpace.count_objects.key?(:T_CLASS)
+        def self.available?
+          return @class_count_available if defined?(@class_count_available)
+
+          @class_count_available =
+            ::ObjectSpace.respond_to?(:count_objects) && ::ObjectSpace.count_objects.key?(:T_CLASS)
         end
       end
     end

data/lib/datadog/core/remote/component.rb

@@ -13,9 +13,7 @@ module Datadog
       # Configures the HTTP transport to communicate with the agent
       # to fetch and sync the remote configuration
       class Component
-        BARRIER_TIMEOUT = 1.0 # second
-
-        attr_reader :client
+        attr_reader :client, :healthy
 
         def initialize(settings, capabilities, agent_settings)
           transport_options = {}
@@ -24,14 +22,14 @@ module Datadog
           negotiation = Negotiation.new(settings, agent_settings)
           transport_v7 = Datadog::Core::Remote::Transport::HTTP.v7(**transport_options.dup)
 
-          @barrier = Barrier.new(BARRIER_TIMEOUT)
+          @barrier = Barrier.new(settings.remote.boot_timeout_seconds)
 
           @client = Client.new(transport_v7, capabilities)
-          healthy = false
+          @healthy = false
           Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
 
           @worker = Worker.new(interval: settings.remote.poll_interval_seconds) do
-            unless healthy || negotiation.endpoint?('/v0.7/config')
+            unless @healthy || negotiation.endpoint?('/v0.7/config')
               @barrier.lift
 
               next
@@ -39,7 +37,7 @@ module Datadog
 
             begin
               @client.sync
-              healthy ||= true
+              @healthy ||= true
             rescue Client::SyncError => e
               Datadog.logger.error do
                 "remote worker client sync error: #{e.message} location: #{Array(e.backtrace).first}. skipping sync"
@@ -57,7 +55,7 @@ module Datadog
 
               # client state is unknown, state might be corrupted
               @client = Client.new(transport_v7, capabilities)
-              healthy = false
+              @healthy = false
               Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
 
               # TODO: bail out if too many errors?
@@ -103,17 +101,32 @@ module Datadog
           def wait_once(timeout = nil)
             # TTAS (Test and Test-And-Set) optimisation
             # Since @once only ever goes from false to true, this is semantically valid
-            return if @once
+            return :pass if @once
 
             begin
               @mutex.lock
 
-              return if @once
+              return :pass if @once
 
               timeout ||= @timeout
 
-              # rbs/core has a bug, timeout type is incorrectly ?Integer
-              @condition.wait(@mutex, _ = timeout)
+              # - starting with Ruby 3.2, ConditionVariable#wait returns nil on
+              #   timeout and an integer otherwise
+              # - before Ruby 3.2, ConditionVariable returns itself
+              # so we have to rely on @once having been set
+              if RUBY_VERSION >= '3.2'
+                lifted = @condition.wait(@mutex, timeout)
+              else
+                @condition.wait(@mutex, timeout)
+                lifted = @once
+              end
+
+              if lifted
+                :lift
+              else
+                @once = true
+                :timeout
+              end
             ensure
               @mutex.unlock
             end

data/lib/datadog/core/remote/ext.rb

@@ -6,6 +6,7 @@ module Datadog
       module Ext
         ENV_ENABLED = 'DD_REMOTE_CONFIGURATION_ENABLED'
         ENV_POLL_INTERVAL_SECONDS = 'DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS'
+        ENV_BOOT_TIMEOUT_SECONDS = 'DD_REMOTE_CONFIG_BOOT_TIMEOUT_SECONDS'
       end
     end
   end

data/lib/datadog/core/remote/tie/tracing.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../tie'
+
+module Datadog
+  module Core
+    module Remote
+      module Tie
+        # Extend Remote Configuration abilities with Tracing
+        module Tracing
+          # Tag per-request Remote Configuration metadata using Tracing
+          def self.tag(boot, span)
+            return if boot.nil?
+            return if span.nil?
+
+            return if Datadog::Core::Remote.active_remote.nil?
+
+            # TODO: this is not thread-consistent
+            ready = Datadog::Core::Remote.active_remote.healthy
+            status = ready ? 'ready' : 'disconnected'
+
+            span.set_tag('_dd.rc.client_id', Datadog::Core::Remote.active_remote.client.id)
+            span.set_tag('_dd.rc.status', status)
+
+            if boot.barrier != :pass
+              span.set_tag('_dd.rc.boot.time', boot.time)
+
+              if boot.barrier == :timeout
+                span.set_tag('_dd.rc.boot.timeout', true)
+              else
+                span.set_tag('_dd.rc.boot.ready', ready)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/remote/tie.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      # Provide Remote Configuration extensions to other components
+      module Tie
+        Boot = Struct.new(
+          :barrier,
+          :time,
+        )
+
+        def self.boot
+          return if Datadog::Core::Remote.active_remote.nil?
+
+          barrier = nil
+
+          t = Datadog::Core::Utils::Time.measure do
+            barrier = Datadog::Core::Remote.active_remote.barrier(:once)
+          end
+
+          Boot.new(barrier, t)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/propagator.rb

@@ -29,9 +29,10 @@ module Datadog
           carrier, context: ::OpenTelemetry::Context.current,
           getter: ::OpenTelemetry::Context::Propagation.text_map_getter
         )
-          unless getter == ::OpenTelemetry::Context::Propagation.text_map_getter
+          if getter != ::OpenTelemetry::Context::Propagation.text_map_getter &&
+              getter != ::OpenTelemetry::Common::Propagation.rack_env_getter
             Datadog.logger.error(
-              'Custom getter is not supported. Please inform the `ddtrace` team at ' \
+              "Custom getter #{getter} is not supported. Please inform the `ddtrace` team at " \
             ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
             'OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter.'
             )

data/lib/datadog/opentelemetry.rb

@@ -8,7 +8,10 @@
 # This file activates the integrations of all OpenTelemetry
 # components supported by Datadog.
 
+# Load Tracing
 require_relative 'tracing'
+require_relative 'tracing/contrib'
+
 require_relative 'opentelemetry/api/context'
 
 # DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`

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

@@ -18,7 +18,6 @@ module Datadog
           no_signals_workaround_enabled:,
           thread_context_collector:,
           dynamic_sampling_rate_overhead_target_percentage:,
-          allocation_sample_every:,
           allocation_profiling_enabled:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
@@ -39,7 +38,6 @@ module Datadog
             no_signals_workaround_enabled,
             dynamic_sampling_rate_enabled,
             dynamic_sampling_rate_overhead_target_percentage,
-            allocation_sample_every,
             allocation_profiling_enabled,
           )
           @worker_thread = nil

data/lib/datadog/profiling/component.rb

@@ -41,8 +41,7 @@ module Datadog
 
         no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
         timeline_enabled = settings.profiling.advanced.experimental_timeline_enabled
-        allocation_sample_every = get_allocation_sample_every(settings)
-        allocation_profiling_enabled = enable_allocation_profiling?(settings, allocation_sample_every)
+        allocation_profiling_enabled = enable_allocation_profiling?(settings)
         heap_sample_every = get_heap_sample_every(settings)
         heap_profiling_enabled = enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_every)
         heap_size_profiling_enabled = enable_heap_size_profiling?(settings, heap_profiling_enabled)
@@ -64,14 +63,12 @@ module Datadog
           no_signals_workaround_enabled: no_signals_workaround_enabled,
           thread_context_collector: thread_context_collector,
           dynamic_sampling_rate_overhead_target_percentage: overhead_target_percentage,
-          allocation_sample_every: allocation_sample_every,
           allocation_profiling_enabled: allocation_profiling_enabled,
         )
 
         internal_metadata = {
           no_signals_workaround_enabled: no_signals_workaround_enabled,
           timeline_enabled: timeline_enabled,
-          allocation_sample_every: allocation_sample_every,
           heap_sample_every: heap_sample_every,
         }.freeze
 
@@ -129,16 +126,6 @@ module Datadog
         end
       end
 
-      private_class_method def self.get_allocation_sample_every(settings)
-        allocation_sample_rate = settings.profiling.advanced.experimental_allocation_sample_rate
-
-        if allocation_sample_rate <= 0
-          raise ArgumentError, "Allocation sample rate must be a positive integer. Was #{allocation_sample_rate}"
-        end
-
-        allocation_sample_rate
-      end
-
       private_class_method def self.get_heap_sample_every(settings)
         heap_sample_rate = settings.profiling.advanced.experimental_heap_sample_rate
 
@@ -147,7 +134,7 @@ module Datadog
         heap_sample_rate
       end
 
-      private_class_method def self.enable_allocation_profiling?(settings, allocation_sample_every)
+      private_class_method def self.enable_allocation_profiling?(settings)
         unless settings.profiling.advanced.experimental_allocation_enabled
           # Allocation profiling disabled, short-circuit out
           return false
@@ -193,8 +180,7 @@ module Datadog
         end
 
         Datadog.logger.warn(
-          "Enabled experimental allocation profiling: allocation_sample_rate=#{allocation_sample_every}. This is " \
-          'experimental, not recommended, and will increase overhead!'
+          'Enabled experimental allocation profiling. This is experimental, not recommended, and will increase overhead!'
         )
 
         true

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

@@ -18,7 +18,6 @@ module Datadog
           ENV_PEER_SERVICE_MAPPING = 'DD_TRACE_PEER_SERVICE_MAPPING'
         end
 
-        # @public_api
         module Analytics
           ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'
         end

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

@@ -23,10 +23,11 @@ module Datadog
               # @configure_with {Datadog::Tracing}
               # @deprecated Use [Trace Retention and Ingestion](https://docs.datadoghq.com/tracing/trace_retention_and_ingestion/)
               #   controls.
-              # @public_api
+              # @!visibility private
               settings :analytics do
                 # @default `DD_TRACE_ANALYTICS_ENABLED` environment variable, otherwise `nil`
                 # @return [Boolean,nil]
+                # @!visibility private
                 option :enabled do |o|
                   o.type :bool, nilable: true
                   o.env Tracing::Configuration::Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED

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

@@ -17,6 +17,7 @@ module Datadog
               o.default true
             end
 
+            # @!visibility private
             option :analytics_enabled do |o|
               o.type :bool
               o.env Ext::ENV_ANALYTICS_ENABLED

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

@@ -8,6 +8,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_ACTION_CABLE_ENABLED'
+          # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_CABLE_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_CABLE_ANALYTICS_SAMPLE_RATE'
           SPAN_ACTION = 'action_cable.action'

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

@@ -17,6 +17,7 @@ module Datadog
               o.default true
             end
 
+            # @!visibility private
             option :analytics_enabled do |o|
               o.type :bool
               o.env Ext::ENV_ANALYTICS_ENABLED

data/lib/datadog/tracing/contrib/action_mailer/ext.rb

@@ -8,6 +8,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_ACTION_MAILER_ENABLED'
+          # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_MAILER_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_MAILER_ANALYTICS_SAMPLE_RATE'
           SPAN_PROCESS = 'action_mailer.process'

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

@@ -17,6 +17,7 @@ module Datadog
               o.default true
             end
 
+            # @!visibility private
             option :analytics_enabled do |o|
               o.type :bool, nilable: true
               o.env Ext::ENV_ANALYTICS_ENABLED

data/lib/datadog/tracing/contrib/action_pack/ext.rb

@@ -8,6 +8,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_ACTION_PACK_ENABLED'
+          # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_PACK_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_PACK_ANALYTICS_SAMPLE_RATE'
           SPAN_ACTION_CONTROLLER = 'rails.action_controller'

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

@@ -15,6 +15,7 @@ module Datadog
               o.default true
             end
 
+            # @!visibility private
             option :analytics_enabled do |o|
               o.type :bool
               o.env Ext::ENV_ANALYTICS_ENABLED

data/lib/datadog/tracing/contrib/action_view/ext.rb

@@ -8,6 +8,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_ACTION_VIEW_ENABLED'
+          # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_VIEW_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_VIEW_ANALYTICS_SAMPLE_RATE'
           SPAN_RENDER_PARTIAL = 'rails.render_partial'

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

@@ -18,6 +18,7 @@ module Datadog
               o.default true
             end
 
+            # @!visibility private
             option :analytics_enabled do |o|
               o.type :bool
               o.env Ext::ENV_ANALYTICS_ENABLED

data/lib/datadog/tracing/contrib/active_job/ext.rb

@@ -7,6 +7,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_ACTIVE_JOB_ENABLED'
+          # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_JOB_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_JOB_ANALYTICS_SAMPLE_RATE'
 

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

@@ -17,6 +17,7 @@ module Datadog
               o.default true
             end
 
+            # @!visibility private
             option :analytics_enabled do |o|
               o.type :bool
               o.env Ext::ENV_ANALYTICS_ENABLED