datadog 2.15.0 → 2.17.0

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../ext'
+
+module Datadog
+  module ErrorTracking
+    module Configuration
+      # Settings
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            # Error Tracking specific configurations.
+            # @public_api
+            settings :error_tracking do
+              # Enable automatic reporting of handled errors and defines the scope
+              # for which to report errors: user code, gems, or both. Possible
+              # values are: all | user | third_party.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors do |o|
+                o.type :string, nilable: true
+                o.default Ext::DEFAULT_HANDLED_ERRORS
+                o.env Ext::ENV_HANDLED_ERRORS
+                o.setter do |value|
+                  next value if Ext::VALID_HANDLED_ERRORS.include?(value)
+
+                  unless value.nil?
+                    Datadog.logger.warn(
+                      "Invalid handled errors scope: #{value}. " \
+                      "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
+                      'Deactivating the feature.'
+                    )
+                  end
+
+                  Ext::DEFAULT_HANDLED_ERRORS
+                end
+              end
+
+              # Enable automatic reporting of handled errors and specify what files should be
+              # instrumented. The value is a list of comma separated paths, filenames or gem names.
+              # The paths can be absolute, starting with '/' or relative to directory in which the program
+              # is launched, starting with './'.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS_MODULES' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors_include do |o|
+                o.type :array
+                o.default []
+                o.env Ext::ENV_HANDLED_ERRORS_INCLUDE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Configuration for ErrorTracking
+    module Configuration
+    end
+  end
+end
+
+require_relative 'configuration/settings'

data/lib/datadog/error_tracking/ext.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Error Tracking constants
+    module Ext
+      ENV_HANDLED_ERRORS = 'DD_ERROR_TRACKING_HANDLED_ERRORS'
+      ENV_HANDLED_ERRORS_INCLUDE = 'DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE'
+      HANDLED_ERRORS_ALL = 'all'
+      HANDLED_ERRORS_USER = 'user'
+      HANDLED_ERRORS_THIRD_PARTY = 'third_party'
+      DEFAULT_HANDLED_ERRORS = nil
+      VALID_HANDLED_ERRORS = [HANDLED_ERRORS_ALL, HANDLED_ERRORS_USER, HANDLED_ERRORS_THIRD_PARTY].freeze
+      SPAN_EVENTS_HAS_EXCEPTION = '_dd.span_events.has_exception'
+      RUBY_VERSION_WITH_RESCUE_EVENT = '3.3'
+    end
+  end
+end

data/lib/datadog/error_tracking/extensions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'configuration'
+require_relative '../core/configuration'
+
+module Datadog
+  module ErrorTracking
+    # Extends Datadog tracing with ErrorTracking features
+    module Extensions
+      # Inject Error Tracking into global objects.
+      def self.activate!
+        Core::Configuration::Settings.extend(Configuration::Settings)
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/filters.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Based on configuration, the TracePoint listening to :rescue or :raise
+    # may report more handled errors than we want to report. Therefore we need
+    # a function to filter the events. As the filter function both depends
+    # on configuration and is called numerous time, we generate it during
+    # during the initialization of the feature to have the best performance
+    # possible.
+    #
+    # @api private
+    module Filters
+      module_function
+
+      def get_gem_name(file_path)
+        regex = %r{gems/([^/]+)-\d}
+        regex_match = regex.match(file_path)
+        return unless regex_match
+
+        gem_name = regex_match[1]
+
+        begin
+          Gem::Specification.find_by_name(gem_name) # steep:ignore
+        rescue Gem::MissingSpecError
+          nil
+        end
+      end
+
+      def user_code?(file_path)
+        !get_gem_name(file_path)
+      end
+
+      def datadog_code?(file_path)
+        file_path.include?('lib/datadog/')
+      end
+
+      def third_party_code?(file_path)
+        gem_name = get_gem_name(file_path)
+        gem_name && gem_name != "datadog"
+      end
+
+      def file_included?(file_path, instrumented_files)
+        instrumented_files.include?(file_path)
+      end
+
+      # Generate the proc used in the TracePoint
+      def generate_filter(to_instrument_scope, handled_errors_include = nil)
+        case to_instrument_scope
+        # If DD_ERROR_TRACKING_HANDLED_ERRORS is set
+        when 'all'
+          proc { |file_path| !datadog_code?(file_path) }
+        when 'user'
+          # If DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
+          if handled_errors_include
+            proc { |file_path|
+              user_code?(file_path) || file_included?(file_path, handled_errors_include)
+            }
+          else
+            proc { |file_path| user_code?(file_path) }
+          end
+        when 'third_party'
+          if handled_errors_include
+            proc { |file_path|
+              third_party_code?(file_path) || file_included?(file_path, handled_errors_include)
+            }
+          else
+            proc { |file_path| third_party_code?(file_path) }
+          end
+        else
+          # If only DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
+          proc { |file_path| file_included?(file_path, handled_errors_include) }
+        end
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'error_tracking/collector'
+require_relative 'error_tracking/component'
+require_relative 'error_tracking/configuration'
+require_relative 'error_tracking/ext'
+require_relative 'error_tracking/extensions'
+require_relative 'error_tracking/filters'
+
+module Datadog
+  # Namespace for Datadog ErrorTracking.
+  #
+  # @api private
+  module ErrorTracking
+    # Expose ErrorTracking to global shared objects
+    Extensions.activate!
+  end
+end

data/lib/datadog/kit/identity.rb

@@ -70,7 +70,7 @@ module Datadog
             if Datadog::AppSec.active_context
               active_span.set_tag('_dd.appsec.user.collection_mode', 'sdk')
 
-              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id, others[:login])
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id, others[:login], session_id)
               ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
             end
           end

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

@@ -42,7 +42,7 @@ module Datadog
         end
 
         def generate_json
-          JSON.fast_generate(v1: seen_libraries.to_a)
+          JSON.generate(v1: seen_libraries.to_a)
         end
 
         private

data/lib/datadog/profiling/exporter.rb

@@ -49,7 +49,7 @@ module Datadog
         @internal_metadata = internal_metadata
         # NOTE: At the time of this comment collected info does not change over time so we'll hardcode
         #       it on startup to prevent serializing the same info on every flush.
-        @info_json = JSON.fast_generate(info_collector.info).freeze
+        @info_json = JSON.generate(info_collector.info).freeze
       end
 
       def flush

data/lib/datadog/profiling/ext.rb

@@ -19,7 +19,6 @@ module Datadog
           FORM_FIELD_TAG_RUNTIME = "runtime"
           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"
           FORM_FIELD_TAG_SERVICE = "service"
           FORM_FIELD_TAG_VERSION = "version"

data/lib/datadog/profiling/flush.rb

@@ -32,7 +32,7 @@ module Datadog
         @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)
+        @internal_metadata_json = JSON.generate(internal_metadata)
         @info_json = info_json
       end
     end

data/lib/datadog/profiling/http_transport.rb

@@ -29,12 +29,7 @@ module Datadog
         status, result = self.class._native_do_export(
           exporter_configuration,
           @upload_timeout_milliseconds,
-          flush,
-          # TODO: This is going to be removed once we move to libdatadog 17
-          flush.start.tv_sec,
-          flush.start.tv_nsec,
-          flush.finish.tv_sec,
-          flush.finish.tv_nsec,
+          flush
         )
 
         if status == :ok

data/lib/datadog/profiling/scheduler.rb

@@ -37,6 +37,7 @@ module Datadog
         @exporter = exporter
         @transport = transport
         @profiler_failed = false
+        @stop_requested = false
 
         # Workers::Async::Thread settings
         self.fork_policy = fork_policy
@@ -88,7 +89,7 @@ module Datadog
       end
 
       def work_pending?
-        !profiler_failed && exporter.can_flush?
+        !profiler_failed && exporter.can_flush? && (run_loop? || !stop_requested?)
       end
 
       def reset_after_fork
@@ -138,8 +139,14 @@ module Datadog
           Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end
 
+        @stop_requested = !run_loop?
+
         true
       end
+
+      def stop_requested?
+        @stop_requested
+      end
     end
   end
 end

data/lib/datadog/profiling/tag_builder.rb

@@ -19,12 +19,9 @@ module Datadog
         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,
@@ -41,7 +38,6 @@ module Datadog
           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
@@ -50,7 +46,7 @@ module Datadog
         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
+        # Make sure everything is an utf-8 string, to avoid encoding issues in native code/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

data/lib/datadog/tracing/analytics.rb

@@ -16,7 +16,7 @@ module Datadog
         def set_measured(span_op, value = true)
           return if span_op.nil?
 
-          value = value == true || value == 1 ? 1 : 0 # rubocop:disable Style/MultipleComparison
+          value = value == true || value == 1 ? 1 : 0
           span_op.set_metric(Metadata::Ext::Analytics::TAG_MEASURED, value)
         end
       end

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

@@ -62,7 +62,10 @@ module Datadog
               end
 
               def on_start(span, event, _id, payload)
-                key = payload[:key]
+                # Since Rails 8, `dd_original_keys` contains the denormalized key provided by the user.
+                # In previous versions, the denormalized key is stored in the official `key` attribute.
+                # We fall back to `key`, even in Rails 8, as a defensive measure.
+                key = payload[:dd_original_keys] || payload[:key]
                 store = payload[:store]
 
                 mapping = MAPPING.fetch(event)

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

@@ -184,6 +184,39 @@ module Datadog
                 super(operation, key, polyfill_options)
               end
             end
+
+            # Save the original, user-supplied cache key, before it gets normalized.
+            #
+            # Normalized keys can include internal implementation detail,
+            # for example FileStore keys include temp directory names, which
+            # changes on every run, making it impossible to group by the cache key afterward.
+            # Also, the user is never exposed to the normalized key, and only sets/gets using the
+            # original key.
+            module PreserveOriginalKey
+              # Stores the original keys in the options hash, as an array of keys.
+              # It's important to keep all the keys for multi-key operations.
+              # For single-key operations, the key is stored as an array of a single element.
+              def normalize_key(key, options)
+                orig_keys = options[:dd_original_keys] || []
+                orig_keys << key
+                options[:dd_original_keys] = orig_keys
+
+                super
+              end
+
+              # Ensure we don't pollute the default Store instance `options` in {PreserveOriginalKey#normalize_key}.
+              # In most cases, `merged_options` returns a new hash,
+              # but we check for cases where it reuses the instance hash.
+              def merged_options(call_options)
+                ret = super
+
+                if ret.equal?(options)
+                  ret.dup
+                else
+                  ret
+                end
+              end
+            end
           end
         end
       end

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

@@ -22,6 +22,10 @@ module Datadog
             def patch
               Events.subscribe!
 
+              if Integration.version >= Gem::Version.new('8.0.0')
+                ::ActiveSupport::Cache::Store.prepend(Cache::Instrumentation::PreserveOriginalKey)
+              end
+
               # Backfill the `:store` key in the ActiveSupport event payload for older Rails.
               if Integration.version < Gem::Version.new('6.1.0')
                 ::ActiveSupport::Cache::Store.prepend(Cache::Instrumentation::Store)

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../../support'
 require_relative 'patcher'
 
 module Datadog
@@ -34,10 +35,7 @@ module Datadog
               # @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? &&
+                  Support.fully_loaded?(::ActiveSupport::Cache, :RedisCacheStore) &&
                   ::ActiveSupport::Cache::RedisCacheStore.instance_methods(false).include?(meth)
               end
 

data/lib/datadog/tracing/contrib/aws/instrumentation.rb

@@ -35,6 +35,16 @@ module Datadog
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
             span.name = Ext::SPAN_COMMAND
             span.resource = context.safely(:resource)
+
+            # Set error on the span if the Response Status Code is in error range
+            if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(context.safely(:status_code))
+              # At this point we do not have any additional diagnostics
+              # besides the HTTP status code which is recorded in the span tags
+              # later in this method.
+              # Just set the span as errored.
+              span.set_error(nil)
+            end
+
             aws_service = span.resource.split('.')[0]
             span.set_tag(Ext::TAG_AWS_SERVICE, aws_service)
             params = context.safely(:params)

data/lib/datadog/tracing/contrib/aws/parsed_context.rb

@@ -26,8 +26,12 @@ module Datadog
             context.params
           end
 
+          def http_response
+            context.http_response
+          end
+
           def status_code
-            context.http_response.status_code
+            http_response.status_code
           end
 
           def http_method

data/lib/datadog/tracing/contrib/http/instrumentation.rb

@@ -30,7 +30,7 @@ module Datadog
 
               return super(req, body, &block) if Contrib::HTTP.should_skip_tracing?(req)
 
-              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+              Tracing.trace(Ext::SPAN_REQUEST) do |span, trace|
                 span.service = service_name(host, request_options, client_config)
                 span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
                 span.resource = req.method
@@ -112,10 +112,6 @@ module Datadog
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
-            def annotate_span_with_error!(span, error)
-              span.set_error(error)
-            end
-
             def set_analytics_sample_rate(span, request_options)
               return unless analytics_enabled?(request_options)
 

data/lib/datadog/tracing/contrib/httpclient/instrumentation.rb

@@ -25,7 +25,7 @@ module Datadog
               request_options = datadog_configuration(host)
               client_config = Datadog.configuration_for(self)
 
-              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+              Tracing.trace(Ext::SPAN_REQUEST) do |span, trace|
                 begin
                   span.service = service_name(host, request_options, client_config)
                   span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -111,10 +111,6 @@ module Datadog
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
-            def annotate_span_with_error!(span, error)
-              span.set_error(error)
-            end
-
             def datadog_configuration(host = :default)
               Datadog.configuration.tracing[:httpclient, host]
             end

data/lib/datadog/tracing/contrib/httprb/instrumentation.rb

@@ -25,7 +25,7 @@ module Datadog
               request_options = datadog_configuration(host)
               client_config = Datadog.configuration_for(self)
 
-              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+              Tracing.trace(Ext::SPAN_REQUEST) do |span, trace|
                 begin
                   span.service = service_name(host, request_options, client_config)
                   span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -121,10 +121,6 @@ module Datadog
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
-            def annotate_span_with_error!(span, error)
-              span.set_error(error)
-            end
-
             def datadog_configuration(host = :default)
               Datadog.configuration.tracing[:httprb, host]
             end

data/lib/datadog/tracing/contrib/karafka/distributed/propagation.rb

@@ -31,6 +31,8 @@ module Datadog
                     Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
                     Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                    Tracing::Distributed::Baggage.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
                 },
                 propagation_style_inject: propagation_style_inject,

data/lib/datadog/tracing/contrib/karafka/monitor.rb

@@ -15,7 +15,7 @@ module Datadog
             worker.processed
           ].freeze
 
-          def instrument(event_id, payload = EMPTY_HASH, &block)
+          def instrument(event_id, payload = {}, &block)
             return super unless TRACEABLE_EVENTS.include?(event_id)
 
             Datadog::Tracing.trace(Ext::SPAN_WORKER_PROCESS) do |span|

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

@@ -48,6 +48,14 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            # Serializes the command to JSON format, which is the desired format for the agent and Datadog UI.
+            # Setting this to false is deprecated and does not have any advantages.
+            option :json_command do |o|
+              o.type :bool
+              o.env Ext::ENV_JSON_COMMAND
+              o.default false
+            end
           end
         end
       end

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

@@ -13,6 +13,7 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_MONGO_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MONGO_ANALYTICS_SAMPLE_RATE'
+          ENV_JSON_COMMAND = 'DD_TRACE_MONGO_JSON_COMMAND'
           DEFAULT_PEER_SERVICE_NAME = 'mongodb'
           SPAN_COMMAND = 'mongo.cmd'
           SPAN_TYPE_COMMAND = 'mongodb'

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../ext'
@@ -30,7 +32,7 @@ module Datadog
 
             # build a quantized Query using the Parser module
             query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
-            serialized_query = query.to_s
+            serialized_query = serialize_query(query)
 
             if datadog_configuration[:peer_service]
               span.set_tag(
@@ -109,6 +111,21 @@ module Datadog
 
           private
 
+          def serialize_query(query)
+            if datadog_configuration[:json_command]
+              query.to_json
+            else
+              # Incorrect Hash#to_s serialization. The Mongo command should only be encoded as JSON.
+              # This code path should be removed, and is only kept to avoid a breaking change.
+              Datadog::Core.log_deprecation(key: :mongo_json_command) do
+                'MongoDB integration: `json_command: false` causes invalid command serialization. '\
+                'Use `json_command: true` or `DD_TRACE_MONGO_JSON_COMMAND=1` instead.'
+              end
+
+              query.to_s
+            end
+          end
+
           def get_span(event)
             Thread.current[:datadog_mongo_span] \
               && Thread.current[:datadog_mongo_span][event.request_id]

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

@@ -20,8 +20,11 @@ module Datadog
         # @public_api
         module CommonMethods
           attr_accessor \
-            :patch_error_result,
-            :patch_successful
+            :patch_error_result
+
+          def patch_successful
+            !!@patch_successful
+          end
 
           def patch_name
             self.class != Class && self.class != Module ? self.class.name : name

data/lib/datadog/tracing/contrib/support.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Miscellaneous support methods to aid in the creation of integrations.
+      module Support
+        module_function
+
+        # Checks if a constant is loaded in a module, handling autoloaded constants correctly.
+        #
+        # This method is particularly useful when you need to check if a constant is fully loaded,
+        # not just defined. It handles the special case of autoloaded constants, which return
+        # non-nil for `defined?` even when they haven't been loaded yet.
+        #
+        # @param base_module [Module] the module to check for the constant
+        # @param constant [Symbol] the name of the constant to check
+        # @return [Boolean] true if the constant has been loaded, false otherwise
+        def fully_loaded?(base_module, constant)
+          # Autoload constants return `constant` for `defined?`, but that doesn't mean they are loaded...
+          base_module.const_defined?(constant) &&
+            # ... to check that we need to call `autoload?`. If it returns `nil`, it's loaded.
+            base_module.autoload?(constant).nil?
+        end
+      end
+    end
+  end
+end