featureflow 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 14f14953f195ceeb742c570f0bf89c40436dc068
-  data.tar.gz: 4036b8cc67e22251bfcaf7d83d2cc412f0e50dbb
+SHA256:
+  metadata.gz: 2865ebc3fed1dfffb613a9a459ce6e0ac8d6e5cd05d758b4e93944cbc8d8d372
+  data.tar.gz: 1b5a7d4b01a2ff98501ca2818e3d00a4d4523525e9e71cd4cda1a847ef009867
 SHA512:
-  metadata.gz: d75e26abe09444b7ecdc9e35a281be54fa14bf4398a358a99d32e94774d8b25abd81a558425c584532e0431942863e64c223bfd553680ee869a11802c6786bb5
-  data.tar.gz: 7238f9574262b630d372f97ddf1d18b6d7ec01e000f3d4fd27a7191ca8969d09036484c3bed01bce690dcad32296d82f14739a1e973cb741e91c996ed105358a
+  metadata.gz: 8c1fb252dcd6beac50457f7d8328198b7512d4bad761824d665490dc0a8fa59026aa55901adf0555dbfce12599ecbf1b611695801d150b29a76ee747abb1aadd
+  data.tar.gz: 712e342d59b58327b4ec1bf98770946ef255f39dbecc2093dc50fa786252b82f6aed33b06a1faacbd5c7e9f60aa65f750a37e454c4ec6f03f8a8cb9f96bb87c2

data/CHANGELOG.md

@@ -1,4 +1,30 @@
 # Change log
+## [0.7.0] - 2026-08-11
+### Fixed
+- Condition operators fail closed instead of raising into the host application: an
+  invalid `matches` regex, a non-string attribute against a string operator, or a
+  string/number type mismatch on a comparison operator is now a no-match, never an
+  exception.
+- `before`/`after` compare parsed instants rather than strings, so rule values with
+  arbitrary UTC offsets compare correctly; date-only values are read as UTC midnight
+  on every host, not local midnight.
+- Rollout bucketing hashed every user to the same bucket (`user['id']` vs
+  `user[:id]`); percentage splits now distribute correctly.
+- `RailsClient#evaluate` and `UserBuilder#with_attributes` were broken; both work
+  again, and the Rails generator accepts current `sdk-srv-env-` keys.
+### Added
+- `Featureflow::Client.new(api_key: '...')` accepts a configuration Hash; unknown
+  options raise rather than being silently dropped.
+- Implicit `featureflow.date` / `featureflow.hourofday` attributes are injected at
+  evaluation time, matching the other server SDKs.
+### Changed
+- Requires Ruby >= 3.1 (excon ~> 1.5).
+- The packaged gem now contains only `lib/`, README, CHANGELOG and LICENSE.
+
+## [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/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,25 @@ 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
+```
+
+## Manual test harness (example server)
+
+To try the SDK against a real Featureflow environment without writing any code, run the small local harness in [examples/harness](examples/harness):
+
+```
+FEATUREFLOW_SERVER_KEY=sdk-srv-env-<your_key> bundle exec ruby examples/harness/server.rb
+```
+
+Then open `http://127.0.0.1:3456/` to evaluate features in the browser, or hit `GET /api/evaluate?feature=<key>&userId=<id>` directly. See [examples/harness/README.md](examples/harness/README.md) for all endpoints and environment variables (including pointing at staging via `FEATUREFLOW_BASE_URL`).

data/lib/featureflow/client.rb

@@ -1,83 +1,107 @@
-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 = build_configuration(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 reload
+      @polling_client.finish if @polling_client
+      @polling_client = build_polling_client
+    end
+
+    def build_polling_client
+      PollingClient.new(
+        @configuration.endpoint,
+        @configuration.api_key,
+        poll_interval: 10,
+        timeout: 30
+      )
+    end
+
     def feature(key)
-      @features[key]
+      @polling_client.feature(key)
     end
 
-    def evaluate(key, context)
+    def failover_variant(key)
+      @failover_variants[key]
+    end
+
+    def evaluate(key, user)
       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)'
+      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
 
-      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)
+      user = UserBuilder.new(user).build if user.is_a?(String)
 
-      Evaluate.new key, feature(key), failover_variant(key), context, '1', @events_client
-    end
+      user = user.dup
+      # Implicit attributes injected at evaluation time (matching the Node SDK's
+      # EvaluateHelpers): featureflow.date/hourofday let rules target the current
+      # moment; sdk-server's partial evaluation defers these to the JS client, but
+      # server SDKs evaluate them locally against "now".
+      now = Time.now
+      user[:attributes] = user[:attributes].merge(
+        'featureflow.user.id' => user[:id],
+        'featureflow.date' => now.utc.iso8601,
+        'featureflow.hourofday' => now.hour
+      )
 
-    private def failover_variant(key)
-      @failover_variants[key]
+      Evaluate.new(
+        feature_key: key,
+        feature: feature(key),
+        failover_variant: failover_variant(key),
+        user: user,
+        salt: '1',
+        events_client: @events_client
+      )
     end
 
-    private def update_features(features)
-      Featureflow.logger.info "updating features"
-      @features = features
-    end
+    # Accepts either a Featureflow::Configuration, or a Hash of configuration
+    # options — `Featureflow::Client.new(api_key: '...')` is the form the README
+    # leads with and the natural Ruby idiom. Passing nothing keeps using the
+    # process-wide Featureflow.configuration (which reads FEATUREFLOW_SERVER_KEY).
+    private def build_configuration(configuration)
+      return Featureflow.configuration if configuration.nil?
+      return configuration unless configuration.is_a?(Hash)
 
-    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)
-      }
+      config = Configuration.new
+      configuration.each do |option, value|
+        setter = "#{option}="
+        # Fail loudly rather than silently dropping a mistyped option — a
+        # misspelt `endpoint:` would otherwise quietly poll production.
+        unless config.respond_to?(setter)
+          raise ArgumentError, "Unknown Featureflow configuration option: #{option}"
+        end
+        config.public_send(setter, value)
+      end
+      config
     end
   end
 end

data/lib/featureflow/conditions.rb

@@ -1,33 +1,104 @@
+require 'date'
+require 'time'
+
 module Featureflow
   class Conditions
+    # Mirrors the Node SDK's dateParse: dates compare by instant, not by string,
+    # so ISO values with different UTC offsets (e.g. "+04:00" vs "Z") compare correctly.
+    #
+    # A value carrying no timezone information is read as UTC, per the SDK contract
+    # ("A date-only value denotes UTC midnight"): the dashboard's date picker emits
+    # date-only values like "2026-07-03", and reading those as *local* midnight would
+    # make a scheduled rollout fire at a different instant on every host in a fleet.
+    # Values with an explicit offset or "Z" keep their instant, unshifted.
+    def self.to_epoch(value)
+      case value
+      when Time then value.to_f
+      when Numeric then value.to_f
+      when String
+        begin
+          parsed = Time.parse(value)
+          # Time.parse silently falls back to the process's timezone when the value
+          # carries no zone; adding back the offset it applied re-reads the same
+          # wall-clock components as UTC. Date._parse only reports :offset when the
+          # value actually stated a zone.
+          parsed += parsed.utc_offset unless Date._parse(value).key?(:offset)
+          parsed.to_f
+        rescue ArgumentError, TypeError, RangeError
+          nil
+        end
+      end
+    end
+
+    # Both operands must be strings for a string operator to mean anything.
+    def self.both_strings?(a, b)
+      a.is_a?(String) && b.is_a?(String)
+    end
+
+    # Numeric-to-numeric or string-to-string only. Mixing the two raises in Ruby, and
+    # coercing would answer version comparisons wrongly.
+    def self.comparable?(a, b)
+      (a.is_a?(Numeric) && b.is_a?(Numeric)) || (a.is_a?(String) && b.is_a?(String))
+    end
+
     def self.test(op, a, b)
       case op
       when 'equals'
         a.eql? b[0]
+      # The string operators assume both sides are strings. A numeric attribute against
+      # `contains` raised NoMethodError straight into the host application — the same
+      # fail-closed violation as the invalid regex below, and reachable the same way,
+      # from a rule somebody typed into the dashboard. Python already guards these with
+      # an explicit type check; this brings Ruby into line. A type mismatch is a
+      # no-match, not an exception.
       when 'contains'
-        a.include? b[0]
+        both_strings?(a, b[0]) && a.include?(b[0])
       when 'startsWith'
-        a.start_with? b[0]
+        both_strings?(a, b[0]) && a.start_with?(b[0])
       when 'endsWith'
-        a.end_with? b[0]
+        both_strings?(a, b[0]) && a.end_with?(b[0])
       when 'matches'
-        a.match? Regexp.new(b[0])
+        # The pattern is untrusted configuration, not code: it comes from a targeting
+        # rule somebody typed into the dashboard, so a malformed one like "[unclosed"
+        # is a user's mistake rather than a bug in the SDK. The contract
+        # (featureflow-client-sdk-testbed/CONTRACT.md, "Operators") therefore requires
+        # an invalid regex to return false — a flag SDK must degrade rather than take
+        # the host application down with it.
+        #
+        # Only the regex failure is rescued, never everything: RegexpError for a
+        # pattern that will not compile, TypeError for a value that is not a string at
+        # all. A genuine bug anywhere else still surfaces.
+        begin
+          a.match? Regexp.new(b[0])
+        rescue RegexpError, TypeError
+          false
+        end
       when 'in'
         b.include? a
       when 'notIn'
         !b.include? a
+      # Comparing a String with a Numeric raises ArgumentError in Ruby, so an attribute
+      # whose type does not match the rule's took the host application down. The
+      # contract requires a numeric operator to return false on non-numeric input
+      # rather than coercing — "1.10.0" > "1.9.0" must not silently succeed — so a
+      # mismatch is simply a no-match. String-to-string comparison is kept, since Ruby
+      # orders strings meaningfully and the server behaves the same way.
       when 'greaterThan'
-        a > b[0]
+        comparable?(a, b[0]) && a > b[0]
       when 'greaterThanOrEqual'
-        a >= b[0]
+        comparable?(a, b[0]) && a >= b[0]
       when 'lessThan'
-        a < b[0]
+        comparable?(a, b[0]) && a < b[0]
       when 'lessThanOrEqual'
-        a <= b[0]
+        comparable?(a, b[0]) && a <= b[0]
       when 'before'
-        a < b[0]
+        a_time = to_epoch(a)
+        b_time = to_epoch(b[0])
+        !!(a_time && b_time && a_time < b_time)
       when 'after'
-        a > b[0]
+        a_time = to_epoch(a)
+        b_time = to_epoch(b[0])
+        !!(a_time && b_time && a_time > b_time)
       else
         false
       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

@@ -1,19 +1,37 @@
 require 'featureflow/client'
+require 'featureflow/user_builder'
 
 module Featureflow
   class RailsClient
     def initialize(request)
       @request = request
     end
-    def evaluate(key, context)
-      request_context_values = {
+
+    # `user` is whatever Client#evaluate accepts: a String user id, or a user
+    # Hash built with Featureflow::UserBuilder ({id:, attributes:}). The current
+    # request's ip and url are merged in as implicit attributes so targeting
+    # rules can match on them; anything the caller set explicitly wins.
+    def evaluate(key, user)
+      Featureflow.evaluate(key, with_request_attributes(user))
+    end
+
+    private
+
+    def with_request_attributes(user)
+      user = UserBuilder.new(user).build if user.is_a?(String)
+      # Anything else is left alone so Client#evaluate raises its own ArgumentError.
+      return user unless user.is_a?(Hash)
+
+      user.merge(attributes: request_attributes.merge(user[:attributes] || {}))
+    end
+
+    # Attribute keys are Strings throughout the evaluation path (UserBuilder
+    # normalises them), so the request attributes are keyed as Strings too.
+    def request_attributes
+      {
         '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]))
     end
   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/user_builder.rb

@@ -0,0 +1,34 @@
+module Featureflow
+  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_attributes(hash)
+      raise ArgumentError, 'Parameter hash must be a Hash' unless hash.is_a?(Hash)
+      normalized = {}
+      hash.each do |k, v|
+        raise ArgumentError, "Value for #{k} must be a valid 'primitive' JSON datatype" unless valid_attribute?(v)
+        normalized[k.to_s] = v
+      end
+      @attributes = @attributes.merge(normalized)
+      self
+    end
+
+    def build
+      {
+        id: @user_id,
+        attributes: @attributes
+      }
+    end
+
+    private def valid_attribute?(attributes)
+      Array(attributes).all? do |v|
+        [String, Numeric, TrueClass, FalseClass].any? { |type| v.is_a?(type) }
+      end
+    end
+  end
+end

data/lib/featureflow/version.rb

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

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/generators/featureflow_generator.rb

@@ -9,7 +9,7 @@ class FeatureflowGenerator < Rails::Generators::Base
   desc "Configures the featureflow with your API key"
 
   def create_initializer_file
-    unless /^srv-env-[a-f0-9]{32}$/ =~ api_key
+    unless /^sdk-srv-env-[a-f0-9]{32}$/ =~ api_key
       raise Thor::Error, "Invalid featureflow environment api key #{api_key.inspect}\nYou can find your environment api key on your featureflow dashboard at https://[APP-NAME].featureflow.io/"
     end
 

metadata

@@ -1,105 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: featureflow
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
-- Henry Young
-autorequire: 
+- Oliver Oldfield-Hodge
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2017-07-17 00:00:00.000000000 Z
+date: 2026-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '11.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
-  name: cucumber
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: '1.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: excon
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.57.0
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.57.0
+        version: '1.5'
 description: Connects your server with Featureflow. Create features at https://featureflow.io.
 email:
-- henry@featureflow.io
+- contact@featureflow.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rubocop.yml"
 - CHANGELOG.md
-- Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
-- Rakefile
-- featureflow.gemspec
 - 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,14 +115,18 @@ 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
-- test.rb
 homepage: https://github.com/featureflow/featureflow-ruby-sdk
 licenses:
-- MIT
-metadata: {}
-post_install_message: 
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/featureflow/featureflow-ruby-sdk
+  source_code_uri: https://github.com/featureflow/featureflow-ruby-sdk
+  changelog_uri: https://github.com/featureflow/featureflow-ruby-sdk/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/featureflow/featureflow-ruby-sdk/issues
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -122,16 +134,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Ruby SDK for Featureflow
 test_files: []

data/.gitignore

@@ -1 +0,0 @@
-pkg

data/.rubocop.yml

@@ -1,5 +0,0 @@
-Metrics/LineLength:
-  Max: 120
-  
-Metrics/MethodLength:
-  Max: 20

data/Gemfile

@@ -1,4 +0,0 @@
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in featureflow.gemspec
-gemspec

data/Gemfile.lock

@@ -1,53 +0,0 @@
-PATH
-  remote: .
-  specs:
-    featureflow (0.5.0)
-      excon (~> 0.57.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    builder (3.2.3)
-    cucumber (2.4.0)
-      builder (>= 2.1.2)
-      cucumber-core (~> 1.5.0)
-      cucumber-wire (~> 0.0.1)
-      diff-lcs (>= 1.1.3)
-      gherkin (~> 4.0)
-      multi_json (>= 1.7.5, < 2.0)
-      multi_test (>= 0.1.2)
-    cucumber-core (1.5.0)
-      gherkin (~> 4.0)
-    cucumber-wire (0.0.1)
-    diff-lcs (1.3)
-    excon (0.57.0)
-    gherkin (4.1.3)
-    multi_json (1.12.1)
-    multi_test (0.1.2)
-    rake (10.5.0)
-    rspec (3.6.0)
-      rspec-core (~> 3.6.0)
-      rspec-expectations (~> 3.6.0)
-      rspec-mocks (~> 3.6.0)
-    rspec-core (3.6.0)
-      rspec-support (~> 3.6.0)
-    rspec-expectations (3.6.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-mocks (3.6.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-support (3.6.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.15)
-  cucumber (~> 2.4.0)
-  featureflow!
-  rake (~> 10.0)
-  rspec (~> 3.0)
-
-BUNDLED WITH
-   1.15.1

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/featureflow.gemspec

@@ -1,38 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-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.summary       = "Ruby SDK for Featureflow"
-  spec.description   = "Connects your server with Featureflow. Create features at https://featureflow.io."
-  spec.homepage      = "https://github.com/featureflow/featureflow-ruby-sdk"
-  spec.license       = "MIT"
-
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  # if spec.respond_to?(:metadata)
-  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-  # else
-  #   raise "RubyGems 2.0 or newer is required to protect against " \
-  #     "public gem pushes."
-  # end
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "cucumber", "~> 2.4.0"
-  spec.add_dependency "excon", "~> 0.57.0"
-end

data/lib/featureflow/context_builder.rb

@@ -1,34 +0,0 @@
-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 = {}
-      self
-    end
-
-    def with_values(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)
-      self
-    end
-
-    def build
-      {
-        key: @context_key,
-        values: @values
-      }
-    end
-
-    private def valid_value?(values)
-      Array(values).all? do |v|
-        [String, Numeric, TrueClass, FalseClass].any? { |type| v.is_a?(type) }
-      end
-    end
-  end
-end

data/test.rb

@@ -1,21 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + "/lib/")
-
-require 'featureflow'
-with_features = [
-  Featureflow::Feature.create('default', 'variant')
-]
-
-
-
-# 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?
-
-#
-loop do
-  sleep 1
-end