datadog 2.7.0 → 2.8.0

data/lib/datadog/di.rb

@@ -12,6 +12,7 @@ require_relative 'di/probe_manager'
 require_relative 'di/probe_notification_builder'
 require_relative 'di/probe_notifier_worker'
 require_relative 'di/redactor'
+require_relative 'di/remote'
 require_relative 'di/serializer'
 require_relative 'di/transport'
 require_relative 'di/utils'
@@ -25,6 +26,9 @@ if defined?(ActiveRecord::Base)
   # and AR should be loaded before any application code is loaded, being
   # part of Rails, therefore for now we should be OK to just require the
   # AR integration from here.
+  #
+  # TODO this require might need to be delayed via Rails post-initialization
+  # logic?
   require_relative 'di/contrib/active_record'
 end
 
@@ -42,6 +46,8 @@ module Datadog
     # Expose DI to global shared objects
     Extensions.activate!
 
+    LOCK = Mutex.new
+
     class << self
       attr_reader :code_tracker
 
@@ -58,6 +64,32 @@ module Datadog
         (@code_tracker ||= CodeTracker.new).start
       end
 
+      # Activates code tracking if possible.
+      #
+      # This method does nothing if invoked in an environment that does not
+      # implement required trace points for code tracking (MRI Ruby < 2.6,
+      # JRuby) and rescues any exceptions that may be raised by downstream
+      # DI code.
+      def activate_tracking
+        # :script_compiled trace point was added in Ruby 2.6.
+        return unless RUBY_VERSION >= '2.6'
+
+        begin
+          # Activate code tracking by default because line trace points will not work
+          # without it.
+          Datadog::DI.activate_tracking!
+        rescue => exc
+          if defined?(Datadog.logger)
+            Datadog.logger.warn("Failed to activate code tracking for DI: #{exc.class}: #{exc}")
+          else
+            # We do not have Datadog logger potentially because DI code tracker is
+            # being loaded early in application boot process and the rest of datadog
+            # wasn't loaded yet. Output to standard error.
+            warn("Failed to activate code tracking for DI: #{exc.class}: #{exc}")
+          end
+        end
+      end
+
       # Deactivates code tracking. In normal usage of DI this method should
       # never be called, however it is used by DI's test suite to reset
       # state for individual tests.
@@ -76,30 +108,62 @@ module Datadog
         code_tracker&.active? || false
       end
 
+      # This method is called from DI Remote handler to issue DI operations
+      # to the probe manager (add or remove probes).
+      #
+      # When DI Remote is executing, Datadog.components should be initialized
+      # and we should be able to reference it to get to the DI component.
+      #
+      # Given that we need the current_component anyway for code tracker,
+      # perhaps we should delete the +component+ method and just use
+      # +current_component+ in all cases.
       def component
-        # TODO uncomment when remote is merged
-        #Datadog.send(:components).dynamic_instrumentation
+        Datadog.send(:components).dynamic_instrumentation
+      end
+
+      # DI code tracker is instantiated globally before the regular set of
+      # components is created, but the code tracker needs to call out to the
+      # "current" DI component to perform instrumentation when application
+      # code is loaded. Because this call may happen prior to Datadog
+      # components having been initialized, we maintain the "current component"
+      # which contains a reference to the most recently instantiated
+      # DI::Component. This way, if a DI component hasn't been instantiated,
+      # we do not try to reference Datadog.components.
+      def current_component
+        LOCK.synchronize do
+          @current_components&.last
+        end
+      end
+
+      # To avoid potential races with DI::Component being added and removed,
+      # we maintain a list of the components. Normally the list should contain
+      # either zero or one component depending on whether DI is enabled in
+      # Datadog configuration. However, if a new instance of DI::Component
+      # is created while the previous instance is still running, we are
+      # guaranteed to not end up with no component when one is running.
+      def add_current_component(component)
+        LOCK.synchronize do
+          @current_components ||= []
+          @current_components << component
+        end
+      end
+
+      def remove_current_component(component)
+        LOCK.synchronize do
+          @current_components&.delete(component)
+        end
       end
     end
   end
 end
 
-=begin not yet enabled
-# :script_compiled trace point was added in Ruby 2.6.
-if RUBY_VERSION >= '2.6'
-  begin
-    # Activate code tracking by default because line trace points will not work
-    # without it.
-    Datadog::DI.activate_tracking!
-  rescue => exc
-    if defined?(Datadog.logger)
-      Datadog.logger.warn("Failed to activate code tracking for DI: #{exc.class}: #{exc}")
-    else
-      # We do not have Datadog logger potentially because DI code tracker is
-      # being loaded early in application boot process and the rest of datadog
-      # wasn't loaded yet. Output to standard error.
-      warn("Failed to activate code tracking for DI: #{exc.class}: #{exc}")
-    end
-  end
+if %w(1 true).include?(ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED']) # steep:ignore
+  # For initial release of Dynamic Instrumentation, activate code tracking
+  # only if DI is explicitly requested in the environment.
+  # Code tracking is required for line probes to work; see the comments
+  # above for the implementation of the method.
+  #
+  # If DI is enabled programmatically, the application can (and must,
+  # for line probes to work) activate tracking in an initializer.
+  Datadog::DI.activate_tracking
 end
-=end

data/lib/datadog/profiling/component.rb

@@ -207,28 +207,16 @@ module Datadog
 
         return false unless heap_profiling_enabled
 
-        if RUBY_VERSION.start_with?("2.") && RUBY_VERSION < "2.7"
+        if RUBY_VERSION < "3.1"
           Datadog.logger.warn(
-            "Heap profiling currently relies on features introduced in Ruby 2.7 and will be forcibly disabled. " \
-            "Please upgrade to Ruby >= 2.7 in order to use this feature."
+            "Current Ruby version (#{RUBY_VERSION}) cannot support heap profiling due to VM limitations. " \
+            "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
           )
           return false
         end
 
-        if RUBY_VERSION < "3.1"
-          Datadog.logger.debug(
-            "Current Ruby version (#{RUBY_VERSION}) supports forced object recycling which has a bug that the " \
-            "heap profiler is forced to work around to remain accurate. This workaround requires force-setting " \
-            "the SEEN_OBJ_ID flag on objects that should have it but don't. Full details can be found in " \
-            "https://github.com/DataDog/dd-trace-rb/pull/3360. This workaround should be safe but can be " \
-            "bypassed by disabling the heap profiler or upgrading to Ruby >= 3.1 where forced object recycling " \
-            "was completely removed (https://bugs.ruby-lang.org/issues/18290)."
-          )
-        end
-
         unless allocation_profiling_enabled
-          raise ArgumentError,
-            "Heap profiling requires allocation profiling to be enabled"
+          raise ArgumentError, "Heap profiling requires allocation profiling to be enabled"
         end
 
         Datadog.logger.warn(

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

@@ -368,22 +368,18 @@ module Datadog
                 end
               end
 
-              # [Continuous Integration Visibility](https://docs.datadoghq.com/continuous_integration/) configuration.
+              # This is only for internal Datadog use via https://github.com/DataDog/datadog-ci-rb . It should not be
+              # used directly.
+              #
+              # DEV-3.0: Make this a non-public API in the next release.
               # @public_api
               settings :test_mode do
-                # Enable test mode. This allows the tracer to collect spans from test runs.
-                #
-                # It also prevents the tracer from collecting spans in a production environment. Only use in a test environment.
-                #
-                # @default `DD_TRACE_TEST_MODE_ENABLED` environment variable, otherwise `false`
-                # @return [Boolean]
                 option :enabled do |o|
                   o.type :bool
                   o.default false
                   o.env Tracing::Configuration::Ext::Test::ENV_MODE_ENABLED
                 end
 
-                # Use async writer in test mode
                 option :async do |o|
                   o.type :bool
                   o.default false

data/lib/datadog/tracing/contrib/active_support/cache/redis.rb

@@ -22,17 +22,29 @@ module Datadog
               # For Rails >= 5.2 w/o redis-activesupport...
               # ActiveSupport includes a Redis cache store internally, and does not require these overrides.
               # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/cache/redis_cache_store.rb
-              def patch_redis?(meth)
+              def patch_redis_store?(meth)
                 !Gem.loaded_specs['redis-activesupport'].nil? \
                   && defined?(::ActiveSupport::Cache::RedisStore) \
                   && ::ActiveSupport::Cache::RedisStore.instance_methods(false).include?(meth)
               end
 
+              # Patches the Rails built-in Redis cache backend `redis_cache_store`, added in Rails 5.2.
+              # We avoid loading the RedisCacheStore class, as it invokes the statement `gem "redis", ">= 4.0.1"` which
+              # fails if the application is using an old version of Redis, or not using Redis at all.
+              # @see https://github.com/rails/rails/blob/d0dcb8fa6073a0c4d42600c15e82e3bb386b27d3/activesupport/lib/active_support/cache/redis_cache_store.rb#L4
+              def patch_redis_cache_store?(meth)
+                Gem.loaded_specs['redis'] &&
+                  # Autoload constants return `constant` for `defined?`, but that doesn't mean they are loaded...
+                  defined?(::ActiveSupport::Cache::RedisCacheStore) &&
+                  # ... to check that we need to call `autoload?` and check if it returns `nil`, meaning it's loaded.
+                  ::ActiveSupport::Cache.autoload?(:RedisCacheStore).nil? &&
+                  ::ActiveSupport::Cache::RedisCacheStore.instance_methods(false).include?(meth)
+              end
+
               def cache_store_class(meth)
-                if patch_redis?(meth)
+                if patch_redis_store?(meth)
                   [::ActiveSupport::Cache::RedisStore, ::ActiveSupport::Cache::Store]
-                elsif Gem.loaded_specs['redis'] && defined?(::ActiveSupport::Cache::RedisCacheStore) \
-                    && ::ActiveSupport::Cache::RedisCacheStore.instance_methods(false).include?(meth)
+                elsif patch_redis_cache_store?(meth)
                   [::ActiveSupport::Cache::RedisCacheStore, ::ActiveSupport::Cache::Store]
                 else
                   super

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

@@ -49,6 +49,10 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            option :on_error do |o|
+              o.type :proc, nilable: true
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/elasticsearch/patcher.rb

@@ -40,6 +40,7 @@ module Datadog
               # `Client#transport` is the most convenient object both for this integration and the library
               # as users have shared access to it across all `elasticsearch` versions.
               service ||= Datadog.configuration_for(transport, :service_name) || datadog_configuration[:service_name]
+              on_error = Datadog.configuration_for(transport, :on_error) || datadog_configuration[:on_error]
 
               method = args[0]
               path = args[1]
@@ -49,7 +50,11 @@ module Datadog
               url = full_url.path
               response = nil
 
-              Tracing.trace(Datadog::Tracing::Contrib::Elasticsearch::Ext::SPAN_QUERY, service: service) do |span|
+              Tracing.trace(
+                Datadog::Tracing::Contrib::Elasticsearch::Ext::SPAN_QUERY,
+                service: service,
+                on_error: on_error
+              ) do |span|
                 begin
                   connection = transport.connections.first
                   host = connection.host[:host] if connection

data/lib/datadog/tracing/tracer.rb

@@ -442,7 +442,7 @@ module Datadog
                         tags || @tags.dup
                       end
         # Remove version tag if service is not the default service
-        if merged_tags.key?(Core::Environment::Ext::TAG_VERSION) && service != @default_service
+        if merged_tags.key?(Core::Environment::Ext::TAG_VERSION) && service && service != @default_service
           merged_tags.delete(Core::Environment::Ext::TAG_VERSION)
         end
         merged_tags

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 7
+    MINOR = 8
     PATCH = 0
     PRE = nil
     BUILD = nil

data/lib/datadog.rb

@@ -7,4 +7,7 @@ require_relative 'datadog/tracing/contrib'
 # Load other products (must follow tracing)
 require_relative 'datadog/profiling'
 require_relative 'datadog/appsec'
+# Line probes will not work on Ruby < 2.6 because of lack of :script_compiled
+# trace point. Only load DI on supported Ruby versions.
+require_relative 'datadog/di' if RUBY_VERSION >= '2.6'
 require_relative 'datadog/kit'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Datadog, Inc.
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-13 00:00:00.000000000 Z
+date: 2024-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.15.0.0.0
+        version: 1.18.0.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.15.0.0.0
+        version: 1.18.0.0.0
 - !ruby/object:Gem::Dependency
   name: libdatadog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 14.1.0.1.0
+        version: 14.3.1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 14.1.0.1.0
+        version: 14.3.1.1.0
 description: |
   datadog is Datadog's client library for Ruby. It includes a suite of tools
   which provide visibility into the performance and security of Ruby applications,
@@ -151,6 +151,9 @@ files:
 - lib/datadog/appsec/component.rb
 - lib/datadog/appsec/configuration.rb
 - lib/datadog/appsec/configuration/settings.rb
+- lib/datadog/appsec/contrib/active_record/instrumentation.rb
+- lib/datadog/appsec/contrib/active_record/integration.rb
+- lib/datadog/appsec/contrib/active_record/patcher.rb
 - lib/datadog/appsec/contrib/auto_instrument.rb
 - lib/datadog/appsec/contrib/devise/event.rb
 - lib/datadog/appsec/contrib/devise/ext.rb
@@ -208,7 +211,6 @@ files:
 - lib/datadog/appsec/monitor/gateway/watcher.rb
 - lib/datadog/appsec/monitor/reactive/set_user.rb
 - lib/datadog/appsec/processor.rb
-- lib/datadog/appsec/processor/actions.rb
 - lib/datadog/appsec/processor/context.rb
 - lib/datadog/appsec/processor/rule_loader.rb
 - lib/datadog/appsec/processor/rule_merger.rb
@@ -370,6 +372,7 @@ files:
 - lib/datadog/di/contrib/active_record.rb
 - lib/datadog/di/error.rb
 - lib/datadog/di/extensions.rb
+- lib/datadog/di/init.rb
 - lib/datadog/di/instrumenter.rb
 - lib/datadog/di/probe.rb
 - lib/datadog/di/probe_builder.rb
@@ -377,6 +380,7 @@ files:
 - lib/datadog/di/probe_notification_builder.rb
 - lib/datadog/di/probe_notifier_worker.rb
 - lib/datadog/di/redactor.rb
+- lib/datadog/di/remote.rb
 - lib/datadog/di/serializer.rb
 - lib/datadog/di/transport.rb
 - lib/datadog/di/utils.rb
@@ -898,9 +902,9 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.7.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.7.0
-post_install_message:
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.8.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.8.0
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -918,8 +922,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.4.10
+signing_key: 
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications
 test_files: []

data/lib/datadog/appsec/processor/actions.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    class Processor
-      # Actions store the actions information in memory
-      # Also, takes care of merging when RC send new information
-      module Actions
-        class << self
-          def actions
-            @actions ||= []
-          end
-
-          def fetch_configuration(action)
-            actions.find { |action_configuration| action_configuration['id'] == action }
-          end
-
-          def merge(actions_to_merge)
-            return if actions_to_merge.empty?
-
-            if actions.empty?
-              @actions = actions_to_merge
-            else
-              merged_actions = []
-              actions_dup = actions.dup
-
-              actions_to_merge.each do |new_action|
-                existing_action = actions_dup.find { |action| new_action['id'] == action['id'] }
-
-                # the old action is discard and the new kept
-                actions_dup.delete(existing_action) if existing_action
-                merged_actions << new_action
-              end
-
-              @actions = merged_actions.concat(actions_dup)
-            end
-          end
-
-          private
-
-          # Used in tests
-          def reset
-            @actions = []
-          end
-        end
-      end
-    end
-  end
-end