unleash 4.4.4 → 6.4.0

data/examples/extending_unleash_with_opentelemetry.rb

@@ -0,0 +1,63 @@
+# example on how to extend the unleash client with opentelemetry by monkey patching it.
+# to be added before initializing the client.
+# in rails it could be added, for example, at:
+# config/initializers/unleash.rb
+
+require 'opentelemetry-api'
+require 'unleash'
+
+module UnleashExtensions
+  module OpenTelemetry
+    TRACER = ::OpenTelemetry.tracer_provider.tracer('Unleash-Client', Unleash::VERSION)
+
+    module Client
+      def initialize(*opts)
+        UnleashExtensions::OpenTelemetry::TRACER.in_span("#{self.class.name}##{__method__}") do |_span|
+          super(*opts)
+        end
+      end
+
+      def is_enabled?(feature, *args)
+        UnleashExtensions::OpenTelemetry::TRACER.in_span("#{self.class.name}##{__method__}") do |span|
+          result = super(feature, *args)
+
+          # OpenTelemetry::SemanticConventions::Trace::FEATURE_FLAG_* is not in the `opentelemetry-semantic_conventions` gem yet
+          span.add_attributes({
+            'feature_flag.provider_name' => 'Unleash',
+            'feature_flag.key' => feature,
+            'feature_flag.variant' => result
+          })
+
+          result
+        end
+      end
+    end
+  end
+
+  module MetricsReporter
+    def post
+      UnleashExtensions::OpenTelemetry::TRACER.in_span("#{self.class.name}##{__method__}") do |_span|
+        super
+      end
+    end
+  end
+
+  module ToggleFetcher
+    def fetch
+      UnleashExtensions::OpenTelemetry::TRACER.in_span("#{self.class.name}##{__method__}") do |_span|
+        super
+      end
+    end
+
+    def save!
+      UnleashExtensions::OpenTelemetry::TRACER.in_span("#{self.class.name}##{__method__}") do |_span|
+        super
+      end
+    end
+  end
+end
+
+# MonkeyPatch here:
+::Unleash::Client.prepend UnleashExtensions::OpenTelemetry::Client
+::Unleash::MetricsReporter.prepend UnleashExtensions::OpenTelemetry::MetricsReporter
+::Unleash::ToggleFetcher.prepend UnleashExtensions::OpenTelemetry::ToggleFetcher

data/examples/simple.rb

@@ -18,8 +18,8 @@ puts ">> START simple.rb"
 # or:
 
 @unleash = Unleash::Client.new(
-  url: 'https://unleash.herokuapp.com/api',
-  custom_http_headers: { 'Authorization': '943ca9171e2c884c545c5d82417a655fb77cec970cc3b78a8ff87f4406b495d0' },
+  url: 'https://app.unleash-hosted.com/demo/api',
+  custom_http_headers: { 'Authorization': 'demo-app:dev.9fc74dd72d2b88bea5253c04240b21a54841f08d9918046ed55a06b5' },
   app_name: 'simple-test',
   instance_id: 'local-test-cli',
   refresh_interval: 2,
@@ -27,8 +27,7 @@ puts ">> START simple.rb"
   retry_limit: 2
 )
 
-# feature_name = "AwesomeFeature"
-feature_name = "4343443"
+feature_name = "example-flag"
 unleash_context = Unleash::Context.new
 unleash_context.user_id = 123
 

data/examples/streaming.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'unleash'
+require 'unleash/context'
+
+puts ">> START streaming.rb"
+
+@unleash = Unleash::Client.new(
+  url: 'https://app.unleash-hosted.com/demo/api',
+  custom_http_headers: { 'Authorization': 'demo-app:dev.9fc74dd72d2b88bea5253c04240b21a54841f08d9918046ed55a06b5' },
+  app_name: 'streaming-test',
+  instance_id: 'local-streaming-cli',
+  refresh_interval: 2,
+  metrics_interval: 2,
+  retry_limit: 2,
+  experimental_mode: { type: 'streaming' },
+  timeout: 5,
+  log_level: Logger::DEBUG
+)
+
+feature_name = "example-flag"
+unleash_context = Unleash::Context.new
+unleash_context.user_id = 123
+
+puts "Waiting for client to initialize..."
+sleep 2
+
+100.times do
+  if @unleash.is_enabled?(feature_name, unleash_context)
+    puts "> #{feature_name} is enabled"
+  else
+    puts "> #{feature_name} is not enabled"
+  end
+  sleep 1
+  puts "---"
+  puts ""
+  puts ""
+end
+feature_name = "foobar"
+if @unleash.is_enabled?(feature_name, unleash_context, true)
+  puts "> #{feature_name} is enabled"
+else
+  puts "> #{feature_name} is not enabled"
+end
+
+puts "> shutting down client..."
+
+@unleash.shutdown
+
+puts ">> END streaming.rb"

data/lib/unleash/bootstrap/handler.rb

@@ -15,7 +15,8 @@ module Unleash
         return configuration.data unless self.configuration.data.nil?
         return configuration.block.call if self.configuration.block.is_a?(Proc)
         return Provider::FromFile.read(configuration.file_path) unless self.configuration.file_path.nil?
-        return Provider::FromUrl.read(configuration.url, configuration.url_headers) unless self.configuration.url.nil?
+
+        Provider::FromUrl.read(configuration.url, configuration.url_headers) unless self.configuration.url.nil?
       end
     end
   end

data/lib/unleash/client.rb

@@ -2,8 +2,10 @@ require 'unleash/configuration'
 require 'unleash/toggle_fetcher'
 require 'unleash/metrics_reporter'
 require 'unleash/scheduled_executor'
-require 'unleash/feature_toggle'
+require 'unleash/streaming_client_executor'
+require 'unleash/variant'
 require 'unleash/util/http'
+require 'unleash/util/event_source_wrapper'
 require 'logger'
 require 'time'
 
@@ -11,14 +13,18 @@ module Unleash
   class Client
     attr_accessor :fetcher_scheduled_executor, :metrics_scheduled_executor
 
+    # rubocop:disable Metrics/AbcSize
     def initialize(*opts)
       Unleash.configuration = Unleash::Configuration.new(*opts) unless opts.empty?
       Unleash.configuration.validate!
 
       Unleash.logger = Unleash.configuration.logger.clone
       Unleash.logger.level = Unleash.configuration.log_level
+      Unleash.engine = YggdrasilEngine.new
+      Unleash.engine.register_custom_strategies(Unleash.configuration.strategies.custom_strategies)
+
+      Unleash.toggle_fetcher = Unleash::ToggleFetcher.new Unleash.engine unless Unleash.configuration.streaming_mode?
 
-      Unleash.toggle_fetcher = Unleash::ToggleFetcher.new
       if Unleash.configuration.disable_client
         Unleash.logger.warn "Unleash::Client is disabled! Will only return default (or bootstrapped if available) results!"
         Unleash.logger.warn "Unleash::Client is disabled! Metrics and MetricsReporter are also disabled!"
@@ -27,9 +33,12 @@ module Unleash
       end
 
       register
-      start_toggle_fetcher
+
+      initialize_client_mode
+
       start_metrics unless Unleash.configuration.disable_metrics
     end
+    # rubocop:enable Metrics/AbcSize
 
     def is_enabled?(feature, context = nil, default_value_param = false, &fallback_blk)
       Unleash.logger.debug "Unleash::Client.is_enabled? feature: #{feature} with context #{context}"
@@ -40,16 +49,16 @@ module Unleash
                         default_value_param
                       end
 
-      toggle_as_hash = Unleash&.toggles&.select{ |toggle| toggle['name'] == feature }&.first
-
-      if toggle_as_hash.nil?
+      toggle_enabled = Unleash.engine.enabled?(feature, context)
+      if toggle_enabled.nil?
         Unleash.logger.debug "Unleash::Client.is_enabled? feature: #{feature} not found"
+        Unleash.engine.count_toggle(feature, false)
         return default_value
       end
 
-      toggle = Unleash::FeatureToggle.new(toggle_as_hash, Unleash&.segment_cache)
+      Unleash.engine.count_toggle(feature, toggle_enabled)
 
-      toggle.is_enabled?(context)
+      toggle_enabled
     end
 
     def is_disabled?(feature, context = nil, default_value_param = true, &fallback_blk)
@@ -72,23 +81,19 @@ module Unleash
     end
 
     def get_variant(feature, context = Unleash::Context.new, fallback_variant = disabled_variant)
-      Unleash.logger.debug "Unleash::Client.get_variant for feature: #{feature} with context #{context}"
-
-      toggle_as_hash = Unleash&.toggles&.select{ |toggle| toggle['name'] == feature }&.first
-
-      if toggle_as_hash.nil?
-        Unleash.logger.debug "Unleash::Client.get_variant feature: #{feature} not found"
-        return fallback_variant
-      end
-
-      toggle = Unleash::FeatureToggle.new(toggle_as_hash)
-      variant = toggle.get_variant(context, fallback_variant)
+      variant = Unleash.engine.get_variant(feature, context)
 
       if variant.nil?
         Unleash.logger.debug "Unleash::Client.get_variant variants for feature: #{feature} not found"
+        Unleash.engine.count_toggle(feature, false)
         return fallback_variant
       end
 
+      variant = Variant.new(variant)
+
+      Unleash.engine.count_variant(feature, variant.name)
+      Unleash.engine.count_toggle(feature, variant.feature_enabled)
+
       # TODO: Add to README: name, payload, enabled (bool)
 
       variant
@@ -97,7 +102,6 @@ module Unleash
     # safe shutdown: also flush metrics to server and toggles to disk
     def shutdown
       unless Unleash.configuration.disable_client
-        Unleash.toggle_fetcher.save!
         Unleash.reporter.post unless Unleash.configuration.disable_metrics
         shutdown!
       end
@@ -106,7 +110,7 @@ module Unleash
     # quick shutdown: just kill running threads
     def shutdown!
       unless Unleash.configuration.disable_client
-        self.fetcher_scheduled_executor.exit
+        self.fetcher_scheduled_executor&.exit
         self.metrics_scheduled_executor.exit unless Unleash.configuration.disable_metrics
       end
     end
@@ -117,10 +121,15 @@ module Unleash
       {
         'appName': Unleash.configuration.app_name,
         'instanceId': Unleash.configuration.instance_id,
-        'sdkVersion': "unleash-client-ruby:" + Unleash::VERSION,
-        'strategies': Unleash.strategies.keys,
+        'connectionId': Unleash.configuration.connection_id,
+        'sdkVersion': "unleash-ruby-sdk:" + Unleash::VERSION,
+        'strategies': Unleash.strategies.known_strategies,
         'started': Time.now.iso8601(Unleash::TIME_RESOLUTION),
-        'interval': Unleash.configuration.metrics_interval_in_millis
+        'interval': Unleash.configuration.metrics_interval_in_millis,
+        'platformName': RUBY_ENGINE,
+        'platformVersion': RUBY_VERSION,
+        'yggdrasilVersion': "0.13.3",
+        'specVersion': Unleash::CLIENT_SPECIFICATION_VERSION
       }
     end
 
@@ -136,8 +145,12 @@ module Unleash
       end
     end
 
+    def start_streaming_client
+      self.fetcher_scheduled_executor = Unleash::StreamingClientExecutor.new('StreamingExecutor', Unleash.engine)
+      self.fetcher_scheduled_executor.run
+    end
+
     def start_metrics
-      Unleash.toggle_metrics = Unleash::Metrics.new
       Unleash.reporter = Unleash::MetricsReporter.new
       self.metrics_scheduled_executor = Unleash::ScheduledExecutor.new(
         'MetricsReporter',
@@ -163,11 +176,19 @@ module Unleash
     end
 
     def disabled_variant
-      @disabled_variant ||= Unleash::FeatureToggle.disabled_variant
+      @disabled_variant ||= Unleash::Variant.disabled_variant
     end
 
     def first_fetch_is_eager
       Unleash.configuration.use_bootstrap?
     end
+
+    def initialize_client_mode
+      if Unleash.configuration.streaming_mode?
+        start_streaming_client
+      else
+        start_toggle_fetcher
+      end
+    end
   end
 end

data/lib/unleash/configuration.rb

@@ -21,7 +21,10 @@ module Unleash
       :logger,
       :log_level,
       :bootstrap_config,
-      :strategies
+      :strategies,
+      :use_delta_api,
+      :experimental_mode
+    attr_reader :connection_id
 
     def initialize(opts = {})
       validate_custom_http_headers!(opts[:custom_http_headers]) if opts.has_key?(:custom_http_headers)
@@ -40,9 +43,9 @@ module Unleash
     def validate!
       return if self.disable_client
 
-      raise ArgumentError, "URL and app_name are required parameters." if self.app_name.nil? || self.url.nil?
+      raise ArgumentError, "app_name is a required parameter." if self.app_name.nil?
 
-      validate_custom_http_headers!(self.custom_http_headers)
+      validate_custom_http_headers!(self.custom_http_headers) unless self.url.nil?
     end
 
     def refresh_backup_file!
@@ -50,15 +53,29 @@ module Unleash
     end
 
     def http_headers
-      {
+      headers = {
+        'User-Agent' => "UnleashClientRuby/#{Unleash::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION} [#{RUBY_PLATFORM}]",
         'UNLEASH-INSTANCEID' => self.instance_id,
         'UNLEASH-APPNAME' => self.app_name,
-        'Unleash-Client-Spec' => '4.2.2'
+        'Unleash-Client-Spec' => CLIENT_SPECIFICATION_VERSION,
+        'UNLEASH-SDK' => "unleash-ruby-sdk:#{Unleash::VERSION}"
       }.merge!(generate_custom_http_headers)
+      headers['UNLEASH-CONNECTION-ID'] = @connection_id
+      headers
     end
 
     def fetch_toggles_uri
-      uri = URI("#{self.url_stripped_of_slash}/client/features")
+      uri = nil
+      ## Personal feeling but Rubocop's suggestion here is too dense to be properly readable
+      # rubocop:disable Style/ConditionalAssignment
+      if streaming_mode?
+        uri = URI("#{self.url_stripped_of_slash}/client/streaming")
+      elsif self.use_delta_api || polling_with_delta?
+        uri = URI("#{self.url_stripped_of_slash}/client/delta")
+      else
+        uri = URI("#{self.url_stripped_of_slash}/client/features")
+      end
+      # rubocop:enable Style/ConditionalAssignment
       uri.query = "project=#{self.project_name}" unless self.project_name.nil?
       uri
     end
@@ -79,6 +96,17 @@ module Unleash
       self.bootstrap_config&.valid?
     end
 
+    def streaming_mode?
+      validate_streaming_support! if streaming_configured?
+      streaming_configured?
+    end
+
+    def polling_with_delta?
+      self.experimental_mode.is_a?(Hash) &&
+        self.experimental_mode[:type] == 'polling' &&
+        self.experimental_mode[:format] == 'delta'
+    end
+
     private
 
     def set_defaults
@@ -89,7 +117,7 @@ module Unleash
       self.project_name     = nil
       self.disable_client   = false
       self.disable_metrics  = false
-      self.refresh_interval = 10
+      self.refresh_interval = 15
       self.metrics_interval = 60
       self.timeout          = 30
       self.retry_limit      = Float::INFINITY
@@ -97,8 +125,11 @@ module Unleash
       self.log_level        = Logger::WARN
       self.bootstrap_config = nil
       self.strategies       = Unleash::Strategies.new
+      self.use_delta_api    = false
+      self.experimental_mode = nil
 
       self.custom_http_headers = {}
+      @connection_id = SecureRandom.uuid
     end
 
     def initialize_default_logger
@@ -133,5 +164,15 @@ module Unleash
     rescue NoMethodError
       raise ArgumentError, "unknown configuration parameter '#{val}'"
     end
+
+    def streaming_configured?
+      self.experimental_mode.is_a?(Hash) && self.experimental_mode[:type] == 'streaming'
+    end
+
+    def validate_streaming_support!
+      return unless RUBY_ENGINE == 'jruby'
+
+      raise "Streaming mode is not supported on JRuby. Please use polling mode instead or switch to MRI/CRuby."
+    end
   end
 end

data/lib/unleash/context.rb

@@ -7,20 +7,36 @@ module Unleash
     def initialize(params = {})
       raise ArgumentError, "Unleash::Context must be initialized with a hash." unless params.is_a?(Hash)
 
-      self.app_name    = value_for('appName', params, Unleash&.configuration&.app_name)
-      self.environment = value_for('environment', params, Unleash&.configuration&.environment || 'default')
-      self.user_id     = value_for('userId', params)&.to_s
-      self.session_id  = value_for('sessionId', params)
-      self.remote_address = value_for('remoteAddress', params)
-      self.current_time = value_for('currentTime', params, Time.now.utc.iso8601.to_s)
-
-      properties = value_for('properties', params)
+      self.app_name = value_for("appName", params, Unleash.configuration&.app_name)
+      self.environment = value_for("environment", params, Unleash.configuration&.environment || "default")
+      self.user_id = value_for("userId", params)&.to_s
+      self.session_id = value_for("sessionId", params)
+      self.remote_address = value_for("remoteAddress", params)
+      self.current_time = value_for("currentTime", params, Time.now.utc.iso8601.to_s)
+
+      properties = value_for("properties", params)
       self.properties = properties.is_a?(Hash) ? properties.transform_keys(&:to_sym) : {}
     end
 
     def to_s
       "<Context: user_id=#{@user_id},session_id=#{@session_id},remote_address=#{@remote_address},properties=#{@properties}" \
-        ",app_name=#{@app_name},environment=#{@environment}>"
+      ",app_name=#{@app_name},environment=#{@environment},current_time=#{@current_time}>"
+    end
+
+    def as_json(*_options)
+      {
+        appName: to_safe_value(self.app_name),
+        environment: to_safe_value(self.environment),
+        userId: to_safe_value(self.user_id),
+        sessionId: to_safe_value(self.session_id),
+        remoteAddress: to_safe_value(self.remote_address),
+        currentTime: to_safe_value(self.current_time),
+        properties: self.properties.transform_values{ |value| to_safe_value(value) }
+      }
+    end
+
+    def to_json(*options)
+      as_json(*options).to_json(*options)
     end
 
     def to_h
@@ -52,6 +68,16 @@ module Unleash
       params.values_at(key, key.to_sym, underscore(key), underscore(key).to_sym).compact.first || default_value
     end
 
+    def to_safe_value(value)
+      return nil if value.nil?
+
+      if value.is_a?(Time)
+        value.utc.iso8601
+      else
+        value.to_s
+      end
+    end
+
     # converts CamelCase to snake_case
     def underscore(camel_cased_word)
       camel_cased_word.to_s.gsub(/(.)([A-Z])/, '\1_\2').downcase

data/lib/unleash/metrics_reporter.rb

@@ -1,5 +1,4 @@
 require 'unleash/configuration'
-require 'unleash/metrics'
 require 'net/http'
 require 'json'
 require 'time'
@@ -15,48 +14,60 @@ module Unleash
     end
 
     def generate_report
-      now = Time.now
+      metrics = Unleash.engine&.get_metrics
+      return nil if metrics.nil?
 
-      start = self.last_time
-      stop  = now
-      self.last_time = now
+      generate_report_from_bucket metrics
+    end
+
+    def post
+      Unleash.logger.debug "post() Report"
+
+      report = build_report
+      return unless report
 
-      report = {
+      send_report(report)
+    end
+
+    private
+
+    def generate_report_from_bucket(bucket)
+      {
+        'platformName': RUBY_ENGINE,
+        'platformVersion': RUBY_VERSION,
+        'yggdrasilVersion': "0.13.3",
+        'specVersion': Unleash::CLIENT_SPECIFICATION_VERSION,
         'appName': Unleash.configuration.app_name,
         'instanceId': Unleash.configuration.instance_id,
-        'bucket': {
-          'start': start.iso8601(Unleash::TIME_RESOLUTION),
-          'stop': stop.iso8601(Unleash::TIME_RESOLUTION),
-          'toggles': Unleash.toggle_metrics.features
-        }
+        'connectionId': Unleash.configuration.connection_id,
+        'bucket': bucket
       }
-      Unleash.toggle_metrics.reset
-
-      report
     end
 
-    def post
-      Unleash.logger.debug "post() Report"
-
-      if bucket_empty? && (Time.now - self.last_time < LONGEST_WITHOUT_A_REPORT) # and last time is less then 10 minutes...
-        Unleash.logger.debug "Report not posted to server, as it would have been empty. (and has been empty for up to 10 min)"
+    def build_report
+      report = generate_report
+      return nil if report.nil? && Time.now - self.last_time < LONGEST_WITHOUT_A_REPORT
 
-        return
-      end
+      report || generate_report_from_bucket({
+        'start': self.last_time.utc.iso8601,
+        'stop': Time.now.utc.iso8601,
+        'toggles': {}
+      })
+    end
 
-      response = Unleash::Util::Http.post(Unleash.configuration.client_metrics_uri, self.generate_report.to_json)
+    def send_report(report)
+      self.last_time = Time.now
+      headers = (Unleash.configuration.http_headers || {}).dup
+      headers.merge!({ 'UNLEASH-INTERVAL' => Unleash.configuration.metrics_interval.to_s })
+      response = Unleash::Util::Http.post(Unleash.configuration.client_metrics_uri, report.to_json, headers)
 
       if ['200', '202'].include? response.code
         Unleash.logger.debug "Report sent to unleash server successfully. Server responded with http code #{response.code}"
       else
+        # :nocov:
         Unleash.logger.error "Error when sending report to unleash server. Server responded with http code #{response.code}."
+        # :nocov:
       end
     end
-
-    private
-
-    def bucket_empty?
-      Unleash.toggle_metrics.features.empty?
-    end
   end
 end

data/lib/unleash/spec_version.rb

@@ -0,0 +1,3 @@
+module Unleash
+  CLIENT_SPECIFICATION_VERSION = "5.2.0".freeze
+end

data/lib/unleash/strategies.rb

@@ -1,80 +1,33 @@
-require 'unleash/strategy/base'
-Gem.find_files('unleash/strategy/**/*.rb').each{ |path| require path }
-
 module Unleash
+  class DefaultOverrideError < RuntimeError
+  end
+
   class Strategies
+    attr_accessor :strategies
+
     def initialize
       @strategies = {}
-      register_strategies
-    end
-
-    def keys
-      @strategies.keys
     end
 
     def includes?(name)
-      @strategies.has_key?(name.to_s)
-    end
-
-    def fetch(name)
-      raise Unleash::Strategy::NotImplemented, "Strategy is not implemented" unless (strategy = @strategies[name.to_s])
-
-      strategy
+      @strategies.has_key?(name.to_s) || DEFAULT_STRATEGIES.include?(name.to_s)
     end
 
     def add(strategy)
-      @strategies[strategy.name] = strategy
-    end
-
-    def []=(key, strategy)
-      warn_deprecated_registration(strategy, 'modifying Unleash::STRATEGIES')
-      @strategies[key.to_s] = strategy
-    end
-
-    def [](key)
-      @strategies[key.to_s]
-    end
+      raise DefaultOverrideError, "Cannot override a default strategy" if DEFAULT_STRATEGIES.include?(strategy.name)
 
-    def register_strategies
-      register_base_strategies
-      register_custom_strategies
+      @strategies[strategy.name] = strategy
     end
 
-    protected
-
-    # Deprecated: Use Unleash.configuration to add custom strategies
-    def register_custom_strategies
-      Unleash::Strategy.constants
-        .select{ |c| Unleash::Strategy.const_get(c).is_a? Class }
-        .reject{ |c| ['NotImplemented', 'Base'].include?(c.to_s) } # Reject abstract classes
-        .map{ |c| Object.const_get("Unleash::Strategy::#{c}") }
-        .reject{ |c| DEFAULT_STRATEGIES.include?(c) } # Reject base classes
-        .each do |c|
-        strategy = c.new
-        warn_deprecated_registration(strategy, 'adding custom class into Unleash::Strategy namespace')
-        self.add(strategy)
-      end
+    def custom_strategies
+      @strategies.values
     end
 
-    def register_base_strategies
-      DEFAULT_STRATEGIES.each{ |c| self.add(c.new) }
+    def known_strategies
+      @strategies.keys.map{ |key| { name: key } }
     end
 
-    DEFAULT_STRATEGIES = [
-      Unleash::Strategy::ApplicationHostname,
-      Unleash::Strategy::Default,
-      Unleash::Strategy::FlexibleRollout,
-      Unleash::Strategy::GradualRolloutRandom,
-      Unleash::Strategy::GradualRolloutSessionId,
-      Unleash::Strategy::GradualRolloutUserId,
-      Unleash::Strategy::RemoteAddress,
-      Unleash::Strategy::UserWithId
-    ].freeze
-
-    def warn_deprecated_registration(strategy, method)
-      warn "[DEPRECATED] Registering custom Unleash strategy by #{method} is deprecated.
-             Please use Unleash configuration to register custom strategy: " \
-           "`Unleash.configure {|c| c.strategies.add(#{strategy.class.name}.new) }`"
-    end
+    DEFAULT_STRATEGIES = ['applicationHostname', 'default', 'flexibleRollout', 'gradualRolloutRandom', 'gradualRolloutSessionId',
+                          'gradualRolloutUserId', 'remoteAddress', 'userWithId'].freeze
   end
 end