featureflow 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 14f14953f195ceeb742c570f0bf89c40436dc068
-  data.tar.gz: 4036b8cc67e22251bfcaf7d83d2cc412f0e50dbb
+SHA256:
+  metadata.gz: 6e44302ab7573a1fe36b0fac9deaac9958ab96d01b73a865e3c98d00bd71ebb3
+  data.tar.gz: 8b641fa3bd07be005e7cf6f722a441da2544d2fa1141b40c35e1d3abb4df6db6
 SHA512:
-  metadata.gz: d75e26abe09444b7ecdc9e35a281be54fa14bf4398a358a99d32e94774d8b25abd81a558425c584532e0431942863e64c223bfd553680ee869a11802c6786bb5
-  data.tar.gz: 7238f9574262b630d372f97ddf1d18b6d7ec01e000f3d4fd27a7191ca8969d09036484c3bed01bce690dcad32296d82f14739a1e973cb741e91c996ed105358a
+  metadata.gz: dd22e33787e281e6a61ca62464f771c3e4d1778d6893f6689ff189c57dbdf3c433e7b49b6a881f73e113f5b5d21216c7b3a6dd67e313c8aeaf4e317ed4c858b9
+  data.tar.gz: 679d1c6f0efbefca2497da6467109c22f93bdde4a6bc165dd5e6b0d03b35daaa02888c5aeec0296dec6f962fd0aeea5a257b701e26798b15f2d394fe324aa544

data/.gitignore

@@ -1 +1,2 @@
 pkg
+.idea

data/CHANGELOG.md

@@ -1,4 +1,8 @@
 # Change log
+## [0.6.0] - 2018-12-17
+### Fixed 
+- Use User over Context matching all other SDKs
+- Use events.featureflow.io endpoint
 ## [0.5.1] - 2017-07-17
 ### Fixed 
 - Feature registration now compatible with Ruby 2.4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    featureflow (0.5.0)
+    featureflow (0.6.0)
       excon (~> 0.57.0)
 
 GEM
@@ -20,7 +20,7 @@ GEM
       gherkin (~> 4.0)
     cucumber-wire (0.0.1)
     diff-lcs (1.3)
-    excon (0.57.0)
+    excon (0.57.1)
     gherkin (4.1.3)
     multi_json (1.12.1)
     multi_test (0.1.2)
@@ -50,4 +50,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   1.15.1
+   1.15.3

data/README.md

@@ -15,7 +15,7 @@ The easiest way to get started is to follow the [Featureflow quick start guides]
 
 ## Change Log
 
-Please see [CHANGELOG](https://github.com/featureflow/featureflow-node-sdk/blob/master/CHANGELOG.md).
+Please see [CHANGELOG](https://github.com/featureflow/featureflow-ruby-sdk/blob/master/CHANGELOG.md).
 
 ## Usage
 
@@ -30,7 +30,7 @@ gem 'featureflow'
 ```
 
 Requiring `featureflow` in your ruby application will expose the classes
- `Featureflow::Client`, `Featuerflow::ContextBuilder` and `Featureflow::Feature`.
+ `Featureflow::Client`, `Featuerflow::UserBuilder` and `Featureflow::Feature`.
 
 The usage of each class is documented below.
 
@@ -79,45 +79,45 @@ end
 
 
 
-#### Defining Context
+#### Defining a User
 
-Before evaluating a feature you must define a context for the current user.  
-Featureflow uses context to target different user groups to specific feature variants. 
-A featureflow context has a `key`, which should uniquely identify the current user, and optionally additional `values`. 
-Featureflow requires the context `key` to be unique per user for gradual rollout of features.
+Before evaluating a feature you must define a user.  
+Featureflow uses users to target different user groups to specific feature variants. 
+A featureflow user has an `id`, which should uniquely identify the current user, and optionally additional `attributes`. 
+Featureflow requires the user `id` to be unique per user for gradual rollout of features.
 
-There are two ways to define context:
+There are two ways to define a user:
 ```ruby
 require 'featureflow'
-context_key = '<unique_user_identifier>'
+user_id = '<unique_user_identifier>'
 
-# option 1, use the context builder
-context = Featureflow::ContextBuilder.new(context_key)
-                                     .with_values(country: 'US',
+# option 1, use the user builder
+user = Featureflow::UserBuilder.new(user_id)
+                                     .with_attributes(country: 'US',
                                                   roles: %w[USER_ADMIN, BETA_CUSTOMER])
                                      .build
 
 # option 2, use just a string
-context = context_key
+user = user_id
 ```
 
 #### Evaluating Features
 
 In your code, you can test the value of your feature using something similar to below
-For these examples below, assume the feature `my-feature-key` is equal to `'on'` for the current `context`
+For these examples below, assume the feature `my-feature-key` is equal to `'on'` for the current `user`
 ```ruby
-if featureflow.evaluate('my-feature-key', context).is? 'on'
-  # this code will be run because 'my-feature-key' is set to 'on' for the given context
+if featureflow.evaluate('my-feature-key', user).is? 'on'
+  # this code will be run because 'my-feature-key' is set to 'on' for the given user
 end
 ```
 Because the most common variants for a feature are `'on'` and `'off'`, we have provided two helper methods `.on?` and `.off?`
 
 ```ruby
-if featureflow.evaluate('my-feature-key', context).on?
+if featureflow.evaluate('my-feature-key', user).on?
   # this feature code will be run because 'my-feature-key' is set to 'on'
 end
 
-if featureflow.evaluate('my-feature-key', context).off?
+if featureflow.evaluate('my-feature-key', user).off?
   # this feature code won't be run because 'my-feature-key' is not set to 'off'
 end
 ```
@@ -147,9 +147,9 @@ featureflow = Featureflow::Client.new(api_key: FEATUREFLOW_SERVER_KEY,
                                       ])
 
 # ... app has been started offline
-featureflow.evaluate('key-one', context).on? # == true
-featureflow.evaluate('key-two', context).off? # == true
-featureflow.evaluate('key-three', context).is? 'custom' # == true
+featureflow.evaluate('key-one', user).on? # == true
+featureflow.evaluate('key-two', user).off? # == true
+featureflow.evaluate('key-three', user).is? 'custom' # == true
 
 ```
 
@@ -170,4 +170,15 @@ Apache-2.0
 [rubygems-img]: https://badge.fury.io/rb/featureflow.png
 
 [dependency-url]: https://www.featureflow.io
-[dependency-img]: https://www.featureflow.io/wp-content/uploads/2016/12/featureflow-web.png
+[dependency-img]: https://www.featureflow.io/wp-content/uploads/2016/12/featureflow-web.png
+
+#Developer documentation
+
+To build and test the SDK
+
+```
+rvm install 2.5.1
+rvm use --default 2.5.1
+bundle install
+ruby test.rb
+```

data/featureflow.gemspec

@@ -6,8 +6,8 @@ require 'featureflow/version'
 Gem::Specification.new do |spec|
   spec.name          = "featureflow"
   spec.version       = Featureflow::VERSION
-  spec.authors       = ["Henry Young"]
-  spec.email         = ["henry@featureflow.io"]
+  spec.authors       = ["Oliver Oldfield-Hodge"]
+  spec.email         = ["contact@featureflow.io"]
 
   spec.summary       = "Ruby SDK for Featureflow"
   spec.description   = "Connects your server with Featureflow. Create features at https://featureflow.io."

data/lib/featureflow.rb

@@ -1,16 +1,38 @@
+require 'logger'
 require 'featureflow/version'
+require 'featureflow/configuration'
 require 'featureflow/client'
-require 'featureflow/context_builder'
+require 'featureflow/user_builder'
 require 'featureflow/feature'
 
 module Featureflow
   class << self
-    attr_writer :logger
+    def configure(config_hash = nil)
+      if config_hash
+        config_hash.each do |k, v|
+          configuration.send("#{k}=", v) rescue nil if configuration.respond_to?("#{k}=")
+        end
+      end
+
+      yield(configuration) if block_given?
+    end
+
+    def configuration
+      @configuration ||= Featureflow::Configuration.new
+    end
 
     def logger
-      @logger ||= Logger.new($stderr).tap do |log|
-        log.progname = self.name
-      end
+      configuration.logger
+    end
+
+    def client
+      @client ||= Featureflow::Client.new(configuration)
+    end
+
+    alias featureflow client
+
+    def evaluate(*args)
+      client.evaluate(*args)
     end
   end
 end

data/lib/featureflow/client.rb

@@ -1,83 +1,76 @@
-require 'logger'
-require 'time'
-require 'pp'
 require 'featureflow/evaluate'
 require 'featureflow/polling_client'
 require 'featureflow/events_client'
 
 module Featureflow
   class Client
-    def initialize(config = {})
-      api_key = config[:api_key] || ENV['FEATUREFLOW_SERVER_KEY']
-      raise ArgumentError, "You have not defined either config[:api_key] or ENV[:FEATUREFLOW_SERVER_KEY]" unless api_key
-      Featureflow.logger.info 'initializing client'
+    def initialize(configuration = nil)
+      @configuration = configuration || Featureflow.configuration
+      @configuration.validate!
       @features = {}
-      @config = {
-        api_key: api_key,
-        url: 'https://app.featureflow.io',
-        path: '/api/sdk/v1/features',
-        with_features: [],
-        disable_events: false
-      }.merge(config)
 
-      unless with_features_valid? @config[:with_features]
-        raise ArgumentError, 'config[:with_features] must be an array of Feature hashes. Use Featureflow::Feature.create(key, failover_variant)'
-      end
+      Featureflow.logger.info 'initializing client'
 
       @failover_variants = {}
-      @config[:with_features].each do |feature|
+      @configuration.with_features.each do |feature|
         Featureflow.logger.info "Registering feature with key #{feature[:key]}"
         failover = feature[:failover_variant];
         @failover_variants[feature[:key]] = failover if failover.is_a?(String) && !failover.empty?
       end
 
-      unless @config[:disable_events]
-        @events_client = EventsClient.new @config[:url], @config[:api_key]
-        @events_client.register_features @config[:with_features]
+      unless @configuration.disable_events
+        @events_client = EventsClient.new @configuration.event_endpoint, @configuration.api_key
+        @events_client.register_features @configuration.with_features
       end
 
-      PollingClient.new(@config[:url] + @config[:path],
-                        @config[:api_key],
-                        delay: 30,
-                        timeout: 30) {|features| update_features(features)}
+      reload
 
       Featureflow.logger.info 'client initialized'
     end
 
-    def feature(key)
-      @features[key]
+    def reload
+      @polling_client.finish if @polling_client
+      @polling_client = build_polling_client
     end
 
-    def evaluate(key, context)
-      raise ArgumentError, 'key must be a string' unless key.is_a?(String)
-      raise ArgumentError, 'context is required' unless context
-      unless context.is_a?(String) || context.is_a?(Hash)
-        raise ArgumentError, 'context must be either a string context key,' + \
-                             ' or a Hash built using Featureflow::ContextBuilder)'
-      end
-
-      context = ContextBuilder.new(context).build if context.is_a?(String)
-
-      context = context.dup
-      context[:values] = context[:values].merge('featureflow.key' => context[:key],
-                                                'featureflow.date' => Time.now.iso8601)
+    def build_polling_client
+      PollingClient.new(
+        @configuration.endpoint,
+        @configuration.api_key,
+        poll_interval: 10,
+        timeout: 30
+      )
+    end
 
-      Evaluate.new key, feature(key), failover_variant(key), context, '1', @events_client
+    def feature(key)
+      @polling_client.feature(key)
     end
 
-    private def failover_variant(key)
+    def failover_variant(key)
       @failover_variants[key]
     end
 
-    private def update_features(features)
-      Featureflow.logger.info "updating features"
-      @features = features
-    end
+    def evaluate(key, user)
+      raise ArgumentError, 'key must be a string' unless key.is_a?(String)
+      raise ArgumentError, 'user is required' unless user
+      unless user.is_a?(String) || user.is_a?(Hash)
+        raise ArgumentError, 'user must be either a string user id,' + \
+                             ' or a Hash built using Featureflow::UserBuilder)'
+      end
+
+      user = UserBuilder.new(user).build if user.is_a?(String)
+
+      user = user.dup
+      user[:attributes] = user[:attributes].merge('featureflow.user.id' => user[:id])
 
-    private def with_features_valid?(features)
-      features.all? { |feature|
-        feature[:key].is_a?(String) && feature[:failover_variant].is_a?(String) && feature[:variants].is_a?(Array)
-      }
+      Evaluate.new(
+        feature_key: key,
+        feature: feature(key),
+        failover_variant: failover_variant(key),
+        user: user,
+        salt: '1',
+        events_client: @events_client
+      )
     end
   end
 end

data/lib/featureflow/configuration.rb

@@ -0,0 +1,36 @@
+class Featureflow::Configuration
+  attr_accessor :api_key
+  attr_accessor :endpoint
+  attr_accessor :event_endpoint
+  attr_accessor :disable_events
+  attr_accessor :with_features
+  attr_accessor :logger
+  
+  DEFAULT_ENDPOINT = 'https://app.featureflow.io'
+  DEFAULT_EVENT_ENDPOINT = 'https://events.featureflow.io'
+
+  def initialize
+    self.api_key = ENV["FEATUREFLOW_SERVER_KEY"]
+    self.endpoint = DEFAULT_ENDPOINT
+    self.event_endpoint = DEFAULT_EVENT_ENDPOINT
+    self.disable_events = false
+    self.with_features = []
+
+    self.logger = Logger.new(STDOUT)
+    self.logger.level = Logger::WARN
+  end
+
+  def validate!
+    unless with_features_valid? @with_features
+      raise ArgumentError, 'with_features must be an array of Feature hashes. Use Featureflow::Feature.create(key, failover_variant)'
+    end
+  end
+
+  private
+
+  def with_features_valid?(features)
+    features.all? do |feature|
+      feature[:key].is_a?(String) && feature[:failover_variant].is_a?(String) && feature[:variants].is_a?(Array)
+    end
+  end
+end

data/lib/featureflow/evaluate.rb

@@ -2,15 +2,22 @@ require 'featureflow/evaluate_helpers'
 
 module Featureflow
   class Evaluate
-    def initialize(feature_key, feature, failover_variant, context, salt, events_client = nil)
-      @evaluated_variant = calculate_variant feature_key, feature, failover_variant, context, salt
-      @events_client = events_client
-      @context = context
+    def initialize(feature_key:, feature:, failover_variant:, user:, salt:, events_client: nil)
       @key = feature_key
+      @feature = feature
+      @failover_variant = failover_variant
+      @user = user
+      @salt = salt
+      @events_client = events_client
+
+      @has_failover = @failover_variant.is_a?(String)
+      @failover_variant = 'off' unless @has_failover
+
+      @evaluated_variant = evaluate_variant
     end
 
     def is?(value)
-      @events_client.evaluate @key, @evaluated_variant, value, @context unless @events_client.is_a?(NilClass)
+      @events_client.evaluate(@key, @evaluated_variant, value, @user) if @events_client
       @evaluated_variant == value
     end
 
@@ -28,22 +35,23 @@ module Featureflow
       @evaluated_variant
     end
 
-    private def calculate_variant(feature_key, feature, failover_variant, context = {}, salt = '1')
-      unless feature
-        has_failover = failover_variant.is_a?(String)
-        failover_variant = 'off' unless has_failover
-        Featureflow.logger.info "Evaluating nil feature '#{feature_key}' using the "\
-          "#{has_failover ? 'provided' : 'default'} failover '#{failover_variant}'"
-        return failover_variant
+    private
+
+    def evaluate_variant
+      unless @feature
+        Featureflow.logger.info "Evaluating nil feature '#{@feature_key}' using the "\
+          "#{@has_failover ? 'provided' : 'default'} failover '#{@failover_variant}'"
+        return @failover_variant
       end
 
-      return feature['offVariantKey'] unless feature['enabled']
-      feature['rules'].each do |rule|
-        next unless EvaluateHelpers.rule_matches rule, context
-        hash = EvaluateHelpers.calculate_hash salt, feature['key'], context['key']
-        variant_value = EvaluateHelpers.get_variant_value hash
-        return EvaluateHelpers.get_variant_split_key rule['variantSplits'], variant_value
+      return @feature['offVariantKey'] unless @feature['enabled']
+
+      @feature['rules'].each do |rule|
+        next unless EvaluateHelpers.rule_matches(rule, @user)
+        hash = EvaluateHelpers.calculate_hash(@salt, @feature['key'], @user['id'])
+        variant_value = EvaluateHelpers.get_variant_value(hash)
+        return EvaluateHelpers.get_variant_split_key(rule['variantSplits'], variant_value)
       end
     end
   end
-end
+end

data/lib/featureflow/evaluate_helpers.rb

@@ -3,15 +3,15 @@ require 'digest/sha1'
 
 module Featureflow
   class EvaluateHelpers
-    def self.rule_matches(rule, context)
+    def self.rule_matches(rule, user)
       if rule['defaultRule']
         true # the default rule will always match true
       else
         rule['audience']['conditions'].all? do |condition|
-          context_values = context[:values][condition['target']]
+          user_attributes = user[:attributes][condition['target']]
           # convert to array to work with test
-          Array(context_values).any? do |value|
-            Conditions.test condition['operator'], value, condition['values']
+          Array(user_attributes).any? do |attribute|
+            Conditions.test condition['operator'], attribute, condition['values']
           end
         end
       end

data/lib/featureflow/events_client.rb

@@ -1,13 +1,31 @@
 require 'excon'
 require 'json'
+require 'thread'
+require 'time'
 
 module Featureflow
+  #LOCK = Mutex.new
+
   class EventsClient
     def initialize(url, api_key)
       @url = url
       @api_key = api_key
+      @eventsQueue = Queue.new
+      @scheduler = start_scheduler
+    end
+
+    def start_scheduler()
+      Thread.new do
+        loop do
+          begin
+            sleep 10
+            send_queue
+          end
+        end
+      end
     end
 
+    #register features are not queued and go straight out
     def register_features(with_features)
       Thread.new do
         features = []
@@ -16,28 +34,63 @@ module Featureflow
                           variants: feature[:variants],
                           failoverVariant: feature[:failover_variant])
         end
-        send_event 'Register Features', :put, 'api/sdk/v1/register', features
+        send_event 'Register Features', :put, '/api/sdk/v1/register', features
       end
     end
 
-    def evaluate(key, evaluated_variant, expected_variant, context)
+    def evaluate(key, evaluated_variant, expected_variant, user)
       Thread.new do
-        send_event 'Evaluate Variant', :post, 'api/sdk/v1/events', [{
-                                                                      featureKey: key,
-                                                                      evaluatedVariant: evaluated_variant,
-                                                                      expectedVaraint: expected_variant,
-                                                                      context: context
-                                                                    }]
+        timestamp = Time.now.iso8601
+        queue_event  ({
+             featureKey: key,
+             evaluatedVariant: evaluated_variant,
+             expectedVaraint: expected_variant,
+             user: user,
+             timestamp: timestamp
+       })
       end
     end
 
-    private def send_event(event_name, method, path, body)
+    def queue_event(event)
+      #add to queue
+
+        @eventsQueue.push(event)
+
+        if !@scheduler.alive?
+          @scheduler = start_scheduler
+        end
+
+      if @eventsQueue.length >= 10000
+        send_queue
+      end
+      #id queue = 10000 then send_queue
+    end
+
+    def send_queue()
+        events  =[]
+        begin
+          loop do
+            events << @eventsQueue.pop(true)
+          end
+        rescue ThreadError
+        end
+
+        if !events.empty?
+          send_event 'Evaluate Variant', :post, '/api/sdk/v1/events', events
+        end
+
+    end
+
+=begin
+    private def send_queue()
+
       connection = Excon.new(@url)
       response = connection.request(method: method,
                                     path: path,
                                     headers: {
                                       'Authorization' => "Bearer #{@api_key}",
-                                      'Content-Type' => 'application/json;charset=UTF-8'
+                                      'Content-Type' => 'application/json;charset=UTF-8',
+                                      'X-Featureflow-Client' => 'RubyClient/' + Featureflow::VERSION
                                     },
                                     omit_default_port: true,
                                     body: JSON.generate(body))
@@ -48,5 +101,27 @@ module Featureflow
     rescue => e
       Featureflow.logger.error e.inspect
     end
+=end
+
+    private def send_event(event_name, method, path, body)
+      connection = Excon.new(@url)
+      response = connection.request(method: method,
+                                    path: path,
+                                    headers: {
+                                        'Authorization' => "Bearer #{@api_key}",
+                                        'Content-Type' => 'application/json;charset=UTF-8',
+                                        'Accept' => 'Application/Json',
+                                        'X-Featureflow-Client' => 'RubyClient/' + Featureflow::VERSION
+                                    },
+                                    omit_default_port: true,
+                                    body: JSON.generate(body))
+      if response.status >= 400
+        Featureflow.logger.error "unable to send event #{event_name} to #{@url+path}. Failed with response status #{response.status}"
+        Featureflow.logger.error response.to_s
+      end
+    rescue => e
+      Featureflow.logger.error e.inspect
+    end
+
   end
-end
+end

data/lib/featureflow/polling_client.rb

@@ -7,15 +7,18 @@ module Featureflow
       poll_interval: 30,
       timeout: 30
     }.freeze
-    def initialize(url, api_key, options = {}, &set_features)
+    LOCK = Mutex.new
+
+    def initialize(url, api_key, options = {})
       @etag = ''
       @url = url
       @api_key = api_key
       @options = DEFAULT_OPTIONS.merge(options)
-      @set_features = set_features
+      @features = {}
 
       load_features
-      Thread.new do
+
+      @thread = Thread.new do
         loop do
           sleep @options[:poll_interval]
           load_features
@@ -23,14 +26,30 @@ module Featureflow
       end
     end
 
+    def finish
+      @thread.exit
+    end
+
+    def feature(key)
+      LOCK.synchronize { @features[key] }
+    end
+
     def load_features
-      response = Excon.get(@url, headers: {
+      response = Excon.get(@url +  + '/api/sdk/v1/features', headers: {
         'Authorization' => "Bearer #{@api_key}",
-        'If-None-Match' => @etag
+        'Accept' => 'Application/Json',
+        'If-None-Match' => @etag,
+        'X-Featureflow-Client' => 'RubyClient/' + Featureflow::VERSION
       }, omit_default_port: true, read_timeout: @options[:timeout])
+
       if response.status == 200
+        Featureflow.logger.debug "updating features"
+
         @etag = response.headers['ETag']
-        @set_features.call(JSON.parse(response.body))
+
+        features = JSON.parse(response.body)
+
+        LOCK.synchronize { @features = features }
       elsif response.status >= 400
         Featureflow.logger.error "request for features failed with response status #{response.status}"
         Featureflow.logger.error response.to_s

data/lib/featureflow/rails/rails_client.rb

@@ -5,15 +5,14 @@ module Featureflow
     def initialize(request)
       @request = request
     end
+
     def evaluate(key, context)
       request_context_values = {
         'featureflow.ip' => @request.remote_ip,
         'featureflow.url' => @request.original_url
       }
       context = {key: context, values: {}} if context.is_a?(String)
-      Featureflow.featureflow.evaluate(key,
-                                  key: context[:key],
-                                  values: request_context_values.merge(context[:values]))
+      Featureflow.evaluate(key, key: context[:key], values: request_context_values.merge(context[:values]))
     end
   end
 end

data/lib/featureflow/rails/railtie.rb

@@ -1,42 +1,12 @@
 require 'featureflow/rails/rails_client'
-module Featureflow
-  LOCK = Mutex.new
-
-  class << self
-    def configure(config_hash=nil)
-      if config_hash
-        configuration.merge!(config_hash)
-      end
-
-      yield(configuration) if block_given?
-      yield(featureflow) if block_given?
-    end
-
-    # Configuration getters
-    def configuration
-      @configuration = nil unless defined?(@configuration)
-      @configuration || LOCK.synchronize { @configuration ||= {} }
-    end
-
-    # Configuration getters
-    def featureflow
-      @featureflow = nil unless defined?(@featureflow)
-      @featureflow || LOCK.synchronize { @featureflow ||= Featureflow::Client.new(configuration) }
-    end
-  end
-
-  class FeatureflowRailtie < Rails::Railtie
-
-    config.before_initialize do
-      ActiveSupport.on_load(:action_controller) do
-        # @client =
-        ActionController::Base.class_eval do
-          def featureflow
-            Featureflow::RailsClient.new(request)
-          end
+class Featureflow::FeatureflowRailtie < Rails::Railtie
+  config.before_initialize do
+    ActiveSupport.on_load(:action_controller) do
+      ActionController::Base.class_eval do
+        def featureflow
+          @featureflow ||= Featureflow::RailsClient.new(request)
         end
       end
     end
-
   end
 end

data/lib/featureflow/{context_builder.rb → user_builder.rb}

@@ -1,32 +1,32 @@
 module Featureflow
-  class ContextBuilder
-    def initialize(key)
-      raise ArgumentError, 'Parameter key must be a String' unless key.is_a?(String) && !key.empty?
-      @context_key = key
-      @values = {}
+  class UserBuilder
+    def initialize(id)
+      raise ArgumentError, 'Parameter id must be a String' unless id.is_a?(String) && !id.empty?
+      @user_id = id
+      @attributes = {}
       self
     end
 
-    def with_values(hash)
+    def with_attributes(hash)
       raise ArgumentError, 'Parameter hash must be a Hash' unless hash.is_a?(Hash)
       hash = hash.dup
       hash.each do |k, v|
         raise ArgumentError, "Value for #{k} must be a valid 'primitive' JSON datatype" unless valid_value?(v)
         hash[k.to_s] = h.delete(k) unless k.is_a?(String)
       end
-      @values = @values.merge(hash)
+      @attributes = @attributes.merge(hash)
       self
     end
 
     def build
       {
-        key: @context_key,
-        values: @values
+        id: @user_id,
+        attributes: @attributes
       }
     end
 
-    private def valid_value?(values)
-      Array(values).all? do |v|
+    private def valid_attribute?(attributes)
+      Array(attributes).all? do |v|
         [String, Numeric, TrueClass, FalseClass].any? { |type| v.is_a?(type) }
       end
     end

data/lib/featureflow/version.rb

@@ -1,3 +1,3 @@
 module Featureflow
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/publish-gem.sh

@@ -0,0 +1 @@
+gem push

data/test.rb

@@ -2,20 +2,32 @@ $:.unshift(File.dirname(__FILE__) + "/lib/")
 
 require 'featureflow'
 with_features = [
-  Featureflow::Feature.create('default', 'variant')
+  Featureflow::Feature.create('default', 'variant'),
+  Featureflow::Feature.create('oli-f1', 'off')
 ]
 
 
 
-# api_key = 'srv-env-9b5fff890c724d119a334a64ed4d2eb2'
-api_key = 'srv-env-f472cfa8c2774ea2b3678fc5a3dbfe13'
-featureflow_client = Featureflow::Client.new(api_key: api_key, with_features: with_features, url: 'http://10.10.2.163:8081')
-context = Featureflow::ContextBuilder.new('user1').build
-puts('test-integration is on? ' + featureflow_client.evaluate('test-integration', context).on?.to_s)
-featureflow_client.evaluate('nooooo', context).on?
-featureflow_client.evaluate('default', context).on?
+api_key = 'srv-env-'
+config = Featureflow::Configuration.new
+config.api_key = api_key
+#config.endpoint = 'http://localhost:8081'
+#config.event_endpoint = 'http://localhost:8081'
+config.with_features = with_features
+
+featureflow_client = Featureflow::Client.new(config)
+=begin
+featureflow_client = Featureflow::Client.new(api_key: api_key, with_features: with_features, url: 'http://localhost:8081')
+=end
+user = Featureflow::UserBuilder.new('user1').build
+puts('test-integration is on? ' + featureflow_client.evaluate('test-integration', user).on?.to_s)
+featureflow_client.evaluate('nooooo', user).on?
+featureflow_client.evaluate('default', user).on?
 
 #
 loop do
-  sleep 1
-end
+  sleep 10
+  puts(featureflow_client.evaluate('oli-f1', user).value)
+  puts(featureflow_client.evaluate('oli-f1', user).is?('extended'))
+  puts(featureflow_client.evaluate('default', user).on?)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: featureflow
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
-- Henry Young
+- Oliver Oldfield-Hodge
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-17 00:00:00.000000000 Z
+date: 2018-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,7 +82,7 @@ dependencies:
         version: 0.57.0
 description: Connects your server with Featureflow. Create features at https://featureflow.io.
 email:
-- henry@featureflow.io
+- contact@featureflow.io
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -99,7 +99,7 @@ files:
 - lib/featureflow.rb
 - lib/featureflow/client.rb
 - lib/featureflow/conditions.rb
-- lib/featureflow/context_builder.rb
+- lib/featureflow/configuration.rb
 - lib/featureflow/evaluate.rb
 - lib/featureflow/evaluate_helpers.rb
 - lib/featureflow/events_client.rb
@@ -107,8 +107,10 @@ files:
 - lib/featureflow/polling_client.rb
 - lib/featureflow/rails/rails_client.rb
 - lib/featureflow/rails/railtie.rb
+- lib/featureflow/user_builder.rb
 - lib/featureflow/version.rb
 - lib/generators/featureflow_generator.rb
+- publish-gem.sh
 - test.rb
 homepage: https://github.com/featureflow/featureflow-ruby-sdk
 licenses:
@@ -130,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Ruby SDK for Featureflow