datadog 2.43.0 → 2.45.0

data/lib/datadog/open_feature/component.rb

@@ -2,6 +2,7 @@
 
 require_relative "transport"
 require_relative "evaluation_engine"
+require_relative "../core/utils/time"
 require_relative "exposures/buffer"
 require_relative "exposures/worker"
 require_relative "exposures/deduplicator"
@@ -16,6 +17,10 @@ module Datadog
   module OpenFeature
     # This class is the entry point for the OpenFeature component
     class Component
+      CONFIGURATION_READY = :ready
+      CONFIGURATION_TIMEOUT = :timeout
+      CONFIGURATION_SHUTDOWN = :shutdown
+
       attr_reader :engine, :flag_eval_metrics_hook, :flag_eval_evp_hook, :span_enrichment_hook
 
       def self.build(settings, agent_settings, logger:, telemetry:)
@@ -29,7 +34,7 @@ module Datadog
           return
         end
 
-        if RUBY_ENGINE != "ruby"
+        unless ["ruby", "truffleruby"].include?(RUBY_ENGINE)
           message = "OpenFeature could not be enabled as MRI is required, " \
             "but running on #{RUBY_ENGINE.inspect}"
 
@@ -63,9 +68,56 @@ module Datadog
         @flag_eval_metrics_hook = create_flag_eval_metrics_hook
         @flag_eval_evp_hook = create_flag_eval_evp_hook
         @span_enrichment_hook = create_span_enrichment_hook
+
+        @configuration_mutex = Mutex.new
+        @reconfiguration_mutex = Mutex.new
+        @configuration_condition = ConditionVariable.new
+        @configuration_received = false
+        @configuration_shutdown = false
+      end
+
+      def reconfigure!(configuration)
+        @reconfiguration_mutex.synchronize do
+          return if configuration_shutdown?
+
+          @engine.reconfigure!(configuration)
+
+          @configuration_mutex.synchronize do
+            return if @configuration_shutdown
+
+            @configuration_received = !configuration.nil?
+            @configuration_condition.broadcast
+          end
+        end
+      end
+
+      def wait_for_configuration
+        timeout_seconds = @settings.feature_flags.initialization_timeout_ms / 1000.0
+        deadline = Core::Utils::Time.get_time + timeout_seconds
+
+        @configuration_mutex.synchronize do
+          loop do
+            return CONFIGURATION_SHUTDOWN if @configuration_shutdown
+            return CONFIGURATION_READY if @configuration_received
+
+            remaining = deadline - Core::Utils::Time.get_time
+            return CONFIGURATION_TIMEOUT unless remaining.positive?
+
+            @configuration_condition.wait(@configuration_mutex, remaining)
+          end
+        end
+      end
+
+      def configuration_received?
+        @configuration_mutex.synchronize { @configuration_received }
       end
 
       def shutdown!
+        @configuration_mutex.synchronize do
+          @configuration_shutdown = true
+          @configuration_condition.broadcast
+        end
+
         @worker.graceful_shutdown
         @flag_eval_evp_writer&.stop
         # Symmetric teardown: drop any accumulated span-enrichment state and
@@ -75,6 +127,10 @@ module Datadog
 
       private
 
+      def configuration_shutdown?
+        @configuration_mutex.synchronize { @configuration_shutdown }
+      end
+
       def create_flag_eval_metrics_hook
         return unless Hooks::FlagEvalMetricsHook.available?
 

data/lib/datadog/open_feature/configuration/agentless_endpoint.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Datadog
+  module OpenFeature
+    module Configuration
+      # Validated endpoint for agentless Feature Flags configuration delivery.
+      class AgentlessEndpoint
+        DEFAULT_SITE = "datadoghq.com"
+        AGENTLESS_SUBDOMAIN = "ufc-server.ff-cdn"
+        CONFIGURATION_PATH = "/api/v2/feature-flagging/config/rules-based/server"
+        INVALID_SITE_CHARACTERS = /[\s\/?#@:]/
+        INTERNAL_WHITESPACE = /\s/
+
+        class << self
+          def build(site:, environment:, base_url: nil, logger: Datadog.logger)
+            if base_url
+              build_custom(base_url, logger)
+            else
+              build_managed(site, environment, logger)
+            end
+          end
+
+          private
+
+          def build_custom(base_url, logger)
+            unless base_url.ascii_only?
+              logger.warn("Feature Flags agentless base URL is invalid; agentless delivery is disabled")
+              return
+            end
+
+            if base_url.match?(INTERNAL_WHITESPACE)
+              logger.warn("Feature Flags agentless base URL contains whitespace; agentless delivery is disabled")
+              return
+            end
+
+            uri = URI.parse(base_url)
+            unless uri.is_a?(URI::HTTP) && uri.absolute? && uri.host
+              logger.warn("Feature Flags agentless base URL must be an absolute HTTP or HTTPS URL; agentless delivery is disabled")
+              return
+            end
+
+            uri.path = CONFIGURATION_PATH if uri.path.to_s.empty? || uri.path == "/"
+            new(uri, managed: false)
+          rescue URI::InvalidURIError
+            logger.warn("Feature Flags agentless base URL is invalid; agentless delivery is disabled")
+            nil
+          end
+
+          def build_managed(site, environment, logger)
+            string_site = site.to_s
+            unless string_site.ascii_only?
+              logger.warn("Feature Flags site is invalid; agentless delivery is disabled")
+              return
+            end
+
+            normalized_site = string_site.strip.downcase
+            normalized_site = DEFAULT_SITE if normalized_site.empty?
+            if normalized_site.match?(INVALID_SITE_CHARACTERS)
+              logger.warn("Feature Flags site is invalid; agentless delivery is disabled")
+              return
+            end
+
+            uri = URI::HTTPS.build(
+              host: "#{AGENTLESS_SUBDOMAIN}.#{normalized_site}",
+              path: CONFIGURATION_PATH,
+              query: environment.nil? ? nil : URI.encode_www_form(dd_env: environment),
+            )
+            new(uri, managed: true)
+          rescue URI::InvalidComponentError
+            logger.warn("Feature Flags site is invalid; agentless delivery is disabled")
+            nil
+          end
+        end
+
+        attr_reader :uri
+
+        def initialize(uri, managed:)
+          @uri = uri
+          @managed = managed
+        end
+
+        def managed?
+          @managed
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/configuration/source/resolution.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Configuration
+      module Source
+        class Resolution
+          attr_reader :source
+
+          def initialize(source, enabled:)
+            @source = source
+            @enabled = enabled
+          end
+
+          def enabled?
+            @enabled
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/configuration/source.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "source/resolution"
+
+module Datadog
+  module OpenFeature
+    module Configuration
+      module Source
+        AGENTLESS = "agentless"
+        REMOTE_CONFIG = "remote_config"
+        OFFLINE = "offline"
+
+        class << self
+          def resolve(settings, logger: Datadog.logger)
+            feature_flags = settings.feature_flags
+            source = resolve_source(feature_flags, legacy: settings.open_feature, logger: logger)
+            enabled = feature_flags.enabled && source != OFFLINE
+
+            Resolution.new(source, enabled: enabled)
+          end
+
+          private
+
+          def resolve_source(settings, legacy:, logger:)
+            configured_source = settings.configuration_source
+            if !settings.using_default?(:configuration_source) && !configured_source.empty?
+              return configured_source if configured_source == AGENTLESS ||
+                configured_source == REMOTE_CONFIG ||
+                configured_source == OFFLINE
+
+              logger.warn("Unsupported Feature Flags configuration source; Feature Flags are disabled")
+              OFFLINE
+            elsif !legacy.using_default?(:enabled)
+              legacy.enabled ? REMOTE_CONFIG : OFFLINE
+            else
+              AGENTLESS
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/configuration.rb

@@ -5,6 +5,25 @@ module Datadog
     module Configuration
       # A settings class for the OpenFeature component.
       module Settings
+        DEFAULT_POLL_INTERVAL_SECONDS = 30
+        DEFAULT_REQUEST_TIMEOUT_SECONDS = 5
+        DEFAULT_INITIALIZATION_TIMEOUT_MS = 30_000
+
+        MAX_REQUEST_TIMEOUT_SECONDS = 300
+        MAX_INITIALIZATION_TIMEOUT_MS = 2_147_483_647
+
+        def self.configure_integer_option(option, environment_variable:, default:, setting_name:)
+          option.type :int
+          option.env environment_variable
+          option.env_parser do |value|
+            Integer(value, 10)
+          rescue ArgumentError
+            Datadog.logger.warn("#{setting_name} must be an integer; using the default")
+            default
+          end
+          option.default default
+        end
+
         def self.extended(base)
           base = base.singleton_class unless base.is_a?(Class)
           add_settings!(base)
@@ -15,10 +34,19 @@ module Datadog
             # Steep does not update `self` for this `class_eval` block.
             # @type self: Datadog::Core::Configuration::Base::_DslContext
             settings :open_feature do
+              # Deprecated switch retained for existing Remote Configuration adopters.
               option :enabled do |o|
                 o.type :bool
                 o.env "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"
                 o.default false
+                o.after_set do |_, _, precedence|
+                  next if precedence == Core::Configuration::Option::Precedence::DEFAULT
+
+                  Datadog.logger.warn(
+                    "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED is deprecated; use " \
+                    "DD_FEATURE_FLAGS_ENABLED and DD_FEATURE_FLAGS_CONFIGURATION_SOURCE instead"
+                  )
+                end
               end
 
               # Opt-in gate for APM feature-flag span enrichment. When enabled,
@@ -42,6 +70,96 @@ module Datadog
                 o.default true
               end
             end
+
+            settings :feature_flags do
+              option :enabled do |o|
+                o.type :bool
+                o.env "DD_FEATURE_FLAGS_ENABLED"
+                o.default true
+              end
+
+              option :configuration_source do |o|
+                o.type :string
+                o.env "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE"
+                o.default "agentless"
+                o.setter do |value|
+                  value.to_s.strip.downcase
+                end
+              end
+
+              settings :agentless do
+                option :base_url do |o|
+                  o.type :string, nilable: true
+                  o.env "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL"
+                  o.skip_telemetry true
+                  o.setter do |value|
+                    next unless value
+
+                    stripped_value = value.to_s.strip
+                    stripped_value.empty? ? nil : stripped_value
+                  end
+                end
+
+                option :poll_interval_seconds do |o|
+                  Settings.configure_integer_option(
+                    o,
+                    environment_variable: "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS",
+                    default: Settings::DEFAULT_POLL_INTERVAL_SECONDS,
+                    setting_name: "Feature Flags agentless poll interval",
+                  )
+                  o.setter do |value|
+                    if value.is_a?(Integer) && value > 0
+                      value
+                    else
+                      Datadog.logger.warn(
+                        "Feature Flags agentless poll interval must be positive; using the default"
+                      )
+                      Settings::DEFAULT_POLL_INTERVAL_SECONDS
+                    end
+                  end
+                end
+
+                option :request_timeout_seconds do |o|
+                  Settings.configure_integer_option(
+                    o,
+                    environment_variable: "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS",
+                    default: Settings::DEFAULT_REQUEST_TIMEOUT_SECONDS,
+                    setting_name: "Feature Flags agentless request timeout",
+                  )
+                  o.setter do |value|
+                    if value.is_a?(Integer) && value > 0 && value <= Settings::MAX_REQUEST_TIMEOUT_SECONDS
+                      value
+                    else
+                      Datadog.logger.warn(
+                        "Feature Flags agentless request timeout must be within (0, " \
+                        "#{Settings::MAX_REQUEST_TIMEOUT_SECONDS}]; using the default"
+                      )
+                      Settings::DEFAULT_REQUEST_TIMEOUT_SECONDS
+                    end
+                  end
+                end
+              end
+
+              option :initialization_timeout_ms do |o|
+                Settings.configure_integer_option(
+                  o,
+                  environment_variable: "DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS",
+                  default: Settings::DEFAULT_INITIALIZATION_TIMEOUT_MS,
+                  setting_name: "Feature Flags provider initialization timeout",
+                )
+                o.setter do |value|
+                  if value.is_a?(Integer) && value > 0 && value <= Settings::MAX_INITIALIZATION_TIMEOUT_MS
+                    value
+                  else
+                    Datadog.logger.warn(
+                      "Feature Flags provider initialization timeout must be within (0, " \
+                      "#{Settings::MAX_INITIALIZATION_TIMEOUT_MS}]; using the default"
+                    )
+                    Settings::DEFAULT_INITIALIZATION_TIMEOUT_MS
+                  end
+                end
+              end
+            end
           end
         end
       end

data/lib/datadog/open_feature/native_evaluator.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
 require_relative "../core/feature_flags"
 require_relative "ext"
 require_relative "resolution_details"
@@ -16,7 +15,7 @@ module Datadog
       #       in the format expected by `libdatadog` without any modifications
       def initialize(configuration)
         @configuration = Core::FeatureFlags::Configuration.new(configuration)
-        @observe_full_evaluation_data = parse_observe_full_evaluation_data(configuration)
+        @observe_full_evaluation_data = @configuration.observe_full_evaluation_data
       end
 
       attr_reader :observe_full_evaluation_data
@@ -42,18 +41,6 @@ module Datadog
 
       private
 
-      # Parse observe_full_evaluation_data from the top level of the UFC JSON (a sibling
-      # of `environment`). Absent, null, or wrong-typed values return false.
-      def parse_observe_full_evaluation_data(configuration)
-        return false unless configuration.is_a?(String) && !configuration.empty?
-
-        parsed = JSON.parse(configuration)
-        parsed.is_a?(Hash) && parsed["observeFullEvaluationData"] == true
-      rescue
-        # This secondary policy parse must not reject configuration accepted by the native evaluator.
-        false
-      end
-
       def build_resolution_details(result, default_value)
         ResolutionDetails.new(
           value: result.variant.nil? ? default_value : result.value,

data/lib/datadog/open_feature/remote.rb

@@ -19,11 +19,11 @@ module Datadog
           FFE_PRODUCTS
         end
 
-        def receivers(telemetry)
+        def receivers(telemetry, component_provider:)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(FFE_PRODUCTS)
           receiver = Core::Remote::Dispatcher::Receiver.new(matcher) do |repository, changes|
-            engine = OpenFeature.engine
-            next unless engine
+            component = component_provider.call
+            next unless component
 
             changes.each do |change|
               content = repository[change.path]
@@ -38,7 +38,7 @@ module Datadog
               when :insert, :update
                 begin
                   # @type var content: Core::Remote::Configuration::Content
-                  engine.reconfigure!(read_content(content))
+                  component.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
                   content.errored("Error applying OpenFeature configuration: #{e.class}: #{e.message}")
@@ -46,7 +46,7 @@ module Datadog
               when :delete
                 # NOTE: For now, we treat deletion as clearing the configuration
                 #       In a multi-config scenario, we might track configs per path
-                engine.reconfigure!(nil)
+                component.reconfigure!(nil)
               end
             end
           end

data/lib/datadog/opentelemetry/signal_configuration.rb

@@ -12,23 +12,24 @@ module Datadog
       def create_resource
         resource_attributes = {}
 
-        @settings.tags&.each do |key, value| # steep:ignore
+        @settings.tags&.each do |key, value|
           otel_key = case key
           when "service" then "service.name"
-          when "env" then "deployment.environment"
+          when "env", "deployment.environment.name", "deployment.environment" then next
           when "version" then "service.version"
           else key
           end
           resource_attributes[otel_key] = value
         end
 
-        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME # steep:ignore
-        resource_attributes["deployment.environment"] = @settings.env if @settings.env # steep:ignore
-        resource_attributes["service.version"] = @settings.version if @settings.version # steep:ignore
+        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
+        environment = @settings.env || @settings.tags["env"] || @settings.tags["deployment.environment.name"] || @settings.tags["deployment.environment"]
+        resource_attributes["deployment.environment.name"] = environment if environment
+        resource_attributes["service.version"] = @settings.version if @settings.version
 
-        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings)
         if hostname
-          if hostname == @settings.hostname # steep:ignore
+          if hostname == @settings.hostname
             resource_attributes["host.name"] = hostname
           elsif !resource_attributes.key?("host.name")
             resource_attributes["host.name"] = hostname
@@ -41,9 +42,12 @@ module Datadog
       # Returns the signal-specific option value when explicitly set,
       # otherwise falls back to the general OTLP exporter config or computed_default.
       def config_or_exporter_fallback(signal:, option_name:, computed_default: nil)
-        signal_settings = @settings.opentelemetry.public_send(signal) # steep:ignore
+        signal_settings = case signal
+        when :logs then @settings.opentelemetry.logs
+        when :metrics then @settings.opentelemetry.metrics
+        end
         if signal_settings.using_default?(option_name)
-          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
         else
           signal_settings.public_send(option_name)
         end

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

@@ -51,7 +51,7 @@ module Datadog
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
           skip_idle_samples_for_testing: false,
-          idle_sampling_helper: IdleSamplingHelper.new(thread_context_collector: thread_context_collector)
+          idle_sampling_helper: IdleSamplingHelper.new
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -98,7 +98,7 @@ module Datadog
 
             Datadog.logger.debug { "Starting thread for: #{self}" }
 
-            @idle_sampling_helper.start
+            @idle_sampling_helper.start(self)
 
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
@@ -147,6 +147,11 @@ module Datadog
           end
         end
 
+        # @rbs return: Datadog::Profiling::StackRecorder
+        def prepare_serialize
+          self.class._native_prepare_serialize(self)
+        end
+
         #: () -> true
         def reset_after_fork
           self.class._native_reset_after_fork(self)

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

@@ -10,7 +10,6 @@ module Datadog
       class IdleSamplingHelper
         # @rbs @worker_thread: untyped
         # @rbs @start_stop_mutex: ::Thread::Mutex
-        # @rbs @thread_context_collector: Datadog::Profiling::Collectors::ThreadContext?
 
         private
 
@@ -18,15 +17,14 @@ module Datadog
 
         public
 
-        #: (thread_context_collector: Datadog::Profiling::Collectors::ThreadContext) -> void
-        def initialize(thread_context_collector:)
+        #: () -> void
+        def initialize
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
-          @thread_context_collector = thread_context_collector
         end
 
-        #: () -> (nil | true)
-        def start
+        #: (CpuAndWallTimeWorker cpu_and_wall_time_worker) -> true?
+        def start(cpu_and_wall_time_worker)
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
 
@@ -39,7 +37,7 @@ module Datadog
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
 
-              self.class._native_idle_sampling_loop(self, @thread_context_collector)
+              self.class._native_idle_sampling_loop(self, cpu_and_wall_time_worker)
 
               Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
             rescue Exception => e # rubocop:disable Lint/RescueException

data/lib/datadog/profiling/component.rb

@@ -73,7 +73,7 @@ module Datadog
           heap_sample_every: heap_sample_every,
         }.freeze
 
-        exporter = build_profiler_exporter(settings, recorder, worker, internal_metadata: internal_metadata)
+        exporter = build_profiler_exporter(settings, worker, internal_metadata: internal_metadata)
         transport = build_profiler_transport(settings, agent_settings)
         scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport, interval: upload_period_seconds)
         profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler)
@@ -109,13 +109,12 @@ module Datadog
         )
       end
 
-      private_class_method def self.build_profiler_exporter(settings, recorder, worker, internal_metadata:)
+      private_class_method def self.build_profiler_exporter(settings, worker, internal_metadata:)
         info_collector = Profiling::Collectors::Info.new(settings)
         code_provenance_collector =
           (Profiling::Collectors::CodeProvenance.new if settings.profiling.advanced.code_provenance_enabled)
 
         Profiling::Exporter.new(
-          pprof_recorder: recorder,
           worker: worker,
           info_collector: info_collector,
           code_provenance_collector: code_provenance_collector,

data/lib/datadog/profiling/exporter.rb

@@ -20,7 +20,6 @@ module Datadog
 
       private
 
-      attr_reader :pprof_recorder #: Datadog::Profiling::StackRecorder
       # The code provenance collector acts both as collector and as a recorder
       attr_reader :code_provenance_collector #: Datadog::Profiling::Collectors::CodeProvenance?
       attr_reader :minimum_duration_seconds #: ::Integer
@@ -33,7 +32,6 @@ module Datadog
 
       public
 
-      # @rbs pprof_recorder: Datadog::Profiling::StackRecorder
       # @rbs worker: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
       # @rbs info_collector: Datadog::Profiling::Collectors::Info
       # @rbs code_provenance_collector: Datadog::Profiling::Collectors::CodeProvenance?
@@ -43,7 +41,6 @@ module Datadog
       # @rbs sequence_tracker: singleton(Datadog::Profiling::SequenceTracker)
       # @rbs return: void
       def initialize(
-        pprof_recorder:,
         worker:,
         info_collector:,
         code_provenance_collector:,
@@ -52,7 +49,6 @@ module Datadog
         time_provider: Time,
         sequence_tracker: Datadog::Profiling::SequenceTracker
       )
-        @pprof_recorder = pprof_recorder
         @worker = worker
         @code_provenance_collector = code_provenance_collector
         @minimum_duration_seconds = minimum_duration_seconds
@@ -68,6 +64,7 @@ module Datadog
 
       #: () -> Datadog::Profiling::Flush?
       def flush
+        pprof_recorder = @worker.prepare_serialize
         worker_stats = @worker.stats_and_reset_not_thread_safe
         serialization_result = pprof_recorder.serialize
         return if serialization_result.nil?
@@ -111,7 +108,7 @@ module Datadog
               worker_stats: worker_stats,
               profile_stats: profile_stats,
               recorder_stats: pprof_recorder.stats,
-              gc: GC.stat,
+              gc: gc_stats,
             }
           ),
           info_json: info_json,
@@ -131,6 +128,11 @@ module Datadog
 
       private
 
+      # @rbs return: Hash[Symbol, Integer | bool]
+      def gc_stats
+        GC.stat.merge(auto_compact: GC.respond_to?(:auto_compact) && GC.auto_compact)
+      end
+
       #: (::Time, ::Time) -> bool
       def duration_below_threshold?(start, finish)
         (finish - start) < minimum_duration_seconds