unleash 0.1.1

data/examples/simple.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'unleash'
+require 'unleash/context'
+
+puts ">> START simple.rb"
+
+# Unleash.configure do |config|
+#   config.url = 'http://unleash.herokuapp.com/api'
+#   config.app_name = 'simple-test'
+#   config.refresh_interval = 2
+#   config.metrics_interval = 2
+#   config.retry_limit = 2
+# end
+# @unleash = Unleash::Client.new
+
+# or:
+
+@unleash = Unleash::Client.new( url: 'http://unleash.herokuapp.com/api', app_name: 'simple-test',
+  instance_id: 'local-test-cli',
+  refresh_interval: 2,
+  metrics_interval: 2,
+  retry_limit: 2,
+  log_level: Logger::DEBUG,
+)
+
+# feature_name = "AwesomeFeature"
+feature_name = "4343443"
+unleash_context = Unleash::Context.new
+unleash_context.user_id = 123
+
+sleep 1
+3.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
+
+sleep 3
+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 ">> END simple.rb"

data/lib/unleash.rb

@@ -0,0 +1,28 @@
+require 'unleash/version'
+require 'unleash/configuration'
+require 'unleash/context'
+require 'unleash/client'
+require 'logger'
+
+module Unleash
+  TIME_RESOLUTION = 3
+
+  class << self
+    attr_accessor :configuration, :toggle_fetcher, :toggles, :toggle_metrics, :reporter, :logger
+  end
+
+  def self.initialize
+    self.toggles = []
+    self.toggle_metrics = {}
+  end
+
+  # Support for configuration via yield:
+  def self.configure()
+    self.configuration ||= Unleash::Configuration.new
+    yield(configuration)
+
+    self.configuration.validate!
+    self.configuration.refresh_backup_file!
+  end
+
+end

data/lib/unleash/activation_strategy.rb

@@ -0,0 +1,17 @@
+
+
+module Unleash
+  class ActivationStrategy
+    attr_accessor :name, :params
+
+    def initialize(name, params = {})
+      self.name = name
+      if params.is_a?(Hash)
+        self.params = params
+      else
+        Unleash.logger.warning "Invalid params provided for ActivationStrategy #{params}"
+        self.params = {}
+      end
+    end
+  end
+end

data/lib/unleash/client.rb

@@ -0,0 +1,74 @@
+require 'unleash/configuration'
+require 'unleash/toggle_fetcher'
+require 'unleash/metrics_reporter'
+require 'unleash/feature_toggle'
+require 'logger'
+require 'time'
+
+module Unleash
+
+  class Client
+    def initialize(*opts)
+      Unleash.configuration ||= Unleash::Configuration.new(*opts)
+      Unleash.configuration.validate!
+
+      Unleash.logger = Unleash.configuration.logger
+      Unleash.logger.level = Unleash.configuration.log_level
+
+      Unleash.toggle_fetcher = Unleash::ToggleFetcher.new
+
+      unless Unleash.configuration.disable_metrics
+        Unleash.toggle_metrics = Unleash::Metrics.new
+        Unleash.reporter = Unleash::MetricsReporter.new
+        scheduledExecutor = Unleash::ScheduledExecutor.new('MetricsReporter', Unleash.configuration.metrics_interval)
+        scheduledExecutor.run do
+          Unleash.reporter.send
+        end
+      end
+      register
+    end
+
+    def is_enabled?(feature, context = nil, default_value = false)
+        Unleash.logger.debug "Unleash::Client.is_enabled? 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.is_enabled? feature: #{feature} not found"
+          return default_value
+        end
+
+        toggle = Unleash::FeatureToggle.new(toggle_as_hash)
+        toggle_result = toggle.is_enabled?(context, default_value)
+
+        return toggle_result
+    end
+
+    private
+    def info
+      return {
+        'appName':  Unleash.configuration.app_name,
+        'instanceId': Unleash.configuration.instance_id,
+        'sdkVersion': "unleash-client-ruby:" + Unleash::VERSION,
+        'strategies': Unleash::STRATEGIES.keys,
+        'started': Time.now.iso8601(Unleash::TIME_RESOLUTION),
+        'interval': Unleash.configuration.metrics_interval_in_millis
+      }
+    end
+
+    def register
+      Unleash.logger.debug "register()"
+
+      uri = URI(Unleash.configuration.client_register_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = Unleash.configuration.timeout # in seconds
+      http.read_timeout = Unleash.configuration.timeout # in seconds
+      headers = {'Content-Type' => 'application/json'}
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+      request.body = info.to_json
+
+      # Send the request
+      response = http.request(request)
+    end
+  end
+end

data/lib/unleash/configuration.rb

@@ -0,0 +1,68 @@
+require 'securerandom'
+require 'tmpdir'
+
+module Unleash
+  class Configuration
+    attr_accessor :url, :app_name, :instance_id,
+      :disable_metrics, :timeout, :retry_limit,
+      :refresh_interval, :metrics_interval,
+      :backup_file, :logger, :log_level
+
+    def initialize(opts = {})
+      self.app_name      = opts[:app_name]    || nil
+      self.url           = opts[:url]         || nil
+      self.instance_id   = opts[:instance_id] || SecureRandom.uuid
+
+      self.disable_metrics  = opts[:disable_metrics]  || false
+      self.refresh_interval = opts[:refresh_interval] || 15
+      self.metrics_interval = opts[:metrics_interval] || 10
+      self.timeout          = opts[:timeout] || 30
+      self.retry_limit      = opts[:retry_limit] || 1
+
+      self.backup_file   = opts[:backup_file] || nil
+
+      self.logger    = opts[:logger] || Logger.new(STDOUT)
+      self.log_level = opts[:log_level] || Logger::ERROR
+
+
+      if opts[:logger].nil?
+        # on default logger, use custom formatter that includes thread_name:
+        self.logger.formatter = proc do |severity, datetime, progname, msg|
+          thread_name = (Thread.current[:name] || "Unleash").rjust(16, ' ')
+          "[#{datetime.iso8601(6)} #{thread_name} #{severity.ljust(5, ' ')}] : #{msg}\n"
+        end
+      end
+
+      refresh_backup_file!
+    end
+
+    def metrics_interval_in_millis
+      self.metrics_interval * 1_000
+    end
+
+    def validate!
+      if self.app_name.nil? or self.url.nil?
+        raise ArgumentError, "URL and app_name are required"
+      end
+    end
+
+    def refresh_backup_file!
+      if self.backup_file.nil?
+        self.backup_file = Dir.tmpdir + "/unleash-#{app_name}-repo.json"
+      end
+    end
+
+    def fetch_toggles_url
+      self.url + '/features'
+    end
+
+    def client_metrics_url
+      self.url + '/client/metrics'
+    end
+
+    def client_register_url
+      self.url + '/client/register'
+    end
+
+  end
+end

data/lib/unleash/context.rb

@@ -0,0 +1,18 @@
+module Unleash
+
+  class Context
+    attr_accessor :user_id, :session_id, :remote_address, :properties
+
+    def initialize(params = {})
+      params_is_a_hash = params.is_a?(Hash)
+      self.user_id    = params_is_a_hash ? params.fetch(:user_id, '') : ''
+      self.session_id = params_is_a_hash ? params.fetch(:session_id, '') : ''
+      self.remote_address = params_is_a_hash ? params.fetch(:remote_address, '') : ''
+      self.properties = params_is_a_hash && params[:properties].is_a?(Hash) ? params.fetch(:properties, {}) : {}
+    end
+
+    def to_s
+      "<Context: user_id=#{self.user_id},session_id=#{self.session_id},remote_address=#{self.remote_address},properties=#{self.properties}>"
+    end
+  end
+end

data/lib/unleash/feature_toggle.rb

@@ -0,0 +1,67 @@
+require 'unleash/activation_strategy'
+require 'unleash/strategy/base'
+require 'unleash/strategy/default'
+require 'unleash/strategy/application_hostname'
+require 'unleash/strategy/gradual_rollout_random'
+require 'unleash/strategy/gradual_rollout_sessionid'
+require 'unleash/strategy/gradual_rollout_userid'
+require 'unleash/strategy/remote_address'
+require 'unleash/strategy/user_with_id'
+require 'unleash/strategy/unknown'
+
+module Unleash
+  STRATEGIES = {
+    applicationHostname: Unleash::Strategy::ApplicationHostname.new,
+    gradualRolloutRandom: Unleash::Strategy::GradualRolloutRandom.new,
+    gradualRolloutSessionId: Unleash::Strategy::GradualRolloutSessionId.new,
+    gradualRolloutUserId: Unleash::Strategy::GradualRolloutUserId.new,
+    remoteAddress: Unleash::Strategy::RemoteAddress.new,
+    userWithId: Unleash::Strategy::UserWithId.new,
+    unknown: Unleash::Strategy::Unknown.new,
+    default: Unleash::Strategy::Default.new,
+  }
+
+
+  class FeatureToggle
+    attr_accessor :name, :enabled, :strategies, :choices, :choices_lock
+
+    def initialize(params={})
+      self.name = params['name'] || nil
+      self.enabled = params['enabled'] || false
+
+      self.strategies = params['strategies']
+        .select{|s| ( s.key?('name') && Unleash::STRATEGIES.key?(s['name'].to_sym) ) }
+        .map{|s| ActivationStrategy.new(s['name'], s['parameters'])} || []
+
+      # Unleash.logger.debug "FeatureToggle params: #{params}"
+      # Unleash.logger.debug "strategies: #{self.strategies}"
+    end
+
+    def to_s
+      "<FeatureToggle: name=#{self.name},enabled=#{self.enabled},choices=#{self.choices},strategies=#{self.strategies}>"
+    end
+
+    def is_enabled?(context, default_result)
+      if not ['NilClass', 'Unleash::Context'].include? context.class.name
+        Unleash.logger.error "Provided context is not of the correct type #{context.class.name}, please use Unleash::Context"
+        context = nil
+      end
+
+      result = self.enabled && self.strategies.select{ |s|
+        strategy = Unleash::STRATEGIES.fetch(s.name.to_sym, :unknown)
+        r = strategy.is_enabled?(s.params, context)
+        Unleash.logger.debug "Strategy #{s.name} returned #{r} with context: #{context}" #"for params #{s.params} "
+        r
+      }.any?
+      result ||= default_result
+
+      Unleash.logger.debug "FeatureToggle (enabled:#{self.enabled} default_result:#{default_result} and Strategies combined returned #{result})"
+
+      choice = result ? :yes : :no
+      Unleash.toggle_metrics.increment(name, choice) unless Unleash.configuration.disable_metrics
+
+      return result
+    end
+
+  end
+end

data/lib/unleash/metrics.rb

@@ -0,0 +1,25 @@
+module Unleash
+
+  class Metrics
+    attr_accessor :features
+
+    def initialize
+      self.features = {}
+    end
+
+    def to_s
+      self.features.to_json
+    end
+
+    def increment(feature, choice)
+      raise "InvalidArgument choice must be :yes or :no" unless [:yes, :no].include? choice
+
+      self.features[feature] = {yes: 0, no: 0} unless self.features.include? feature
+      self.features[feature][choice] += 1
+    end
+
+    def reset
+      self.features = {}
+    end
+  end
+end

data/lib/unleash/metrics_reporter.rb

@@ -0,0 +1,61 @@
+require 'unleash/configuration'
+require 'unleash/metrics'
+require 'net/http'
+require 'json'
+require 'time'
+
+module Unleash
+
+  class MetricsReporter
+    attr_accessor :last_time, :client
+
+    def initialize
+      self.last_time = Time.now
+    end
+
+    def build_hash
+    end
+
+    def generate_report
+      now = Time.now
+      start, stop, self.last_time = self.last_time, now, now
+      report = {
+        '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
+        }
+      }
+
+      Unleash.toggle_metrics.reset
+      return report
+    end
+
+    def send
+      Unleash.logger.debug "send() Report"
+
+      generated_report = self.generate_report()
+
+      uri = URI(Unleash.configuration.client_metrics_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = Unleash.configuration.timeout # in seconds
+      http.read_timeout = Unleash.configuration.timeout # in seconds
+      headers = {'Content-Type' => 'application/json'}
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+      request.body = generated_report.to_json
+
+      Unleash.logger.debug "Report to send: #{request.body}"
+
+      response = http.request(request)
+
+      if ['200','202'].include? response.code
+        Unleash.logger.debug "Report sent to unleash server sucessfully. Server responded with http code #{response.code}"
+      else
+        Unleash.logger.error "Error when sending report to unleash server. Server responded with http code #{response.code}."
+      end
+
+    end
+  end
+end

data/lib/unleash/scheduled_executor.rb

@@ -0,0 +1,35 @@
+module Unleash
+
+  class ScheduledExecutor
+    attr_accessor :name, :interval, :max_exceptions, :retry_count
+
+    def initialize(name, interval, max_exceptions = 5)
+      self.name = name || ''
+      self.interval = interval
+      self.max_exceptions = max_exceptions
+      self.retry_count = 0
+    end
+
+    def run(&blk)
+      thread = Thread.new do
+        Thread.current[:name] = self.name
+
+        loop do
+          Unleash.logger.debug "thread #{name} sleeping for #{interval} seconds"
+          sleep interval
+
+          Unleash.logger.debug "thread #{name} started"
+          begin
+            yield
+            self.retry_count = 0
+          rescue Exception => e
+            self.retry_count += 1
+            Unleash.logger.error "thread #{name} throwing exception (#{self.retry_count} of #{self.max_exceptions})", e
+          end
+
+          break if self.retry_count > self.max_exceptions
+        end
+      end
+    end
+  end
+end