ldclient-rb 0.8.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c8a2f8c558a103c5d35bac43f65bcec2547c600
-  data.tar.gz: 2d99a0b8cf0c6a8c7132bad6b44d9f7608a19221
+  metadata.gz: 3e6c80abac366d30d919bd5fe4cc1e4457adc55f
+  data.tar.gz: 6c2a232ee5f1c33ef3f86f1511e37a3f8dd34579
 SHA512:
-  metadata.gz: 76099078850fa826d91024c5d8b9909ec3b91169a4fb3718a97116bbbe89c27aa1a6dc555f45b153c739a83d11b2d62252200c7c66870ca476b9d2b0ae25df34
-  data.tar.gz: e8b0477b6e0355636b220f67fcc27e72ca14430a6c0750b0b7252ac040a362d6878854f0e78da4800102a7299bf258a6fdf0f10856cca8a4e608d79ca99fbc98
+  metadata.gz: 8d9d45ecf32ff2580a8c716646f2b685b66c2786a0e66cd93eb914044bb7a4d67add695ff8d06308d1d51e618962587ddded79cd3287b58d65ef1eec5635b23f
+  data.tar.gz: 2b28b6e04bf7ecc6ad677ffad40421c06428b3c2b15334dd996dfe21f327694c8f27406d1ee057316ea6cbbd8b9ce84831f0165d27dd5eeb4d03bada8b96e195

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Change log
+
+All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
+
+## [2.0.0] - 2016-08-08
+### Added
+- Support for multivariate feature flags. In addition to booleans, feature flags can now return numbers, strings, dictionaries, or arrays via the `variation` method.
+- New `all_flags` method returns all flag values for a specified user.
+- If streaming is disabled, the client polls for feature flag changes. If streaming is disabled, the client will default to polling LaunchDarkly every second for updates. The poll interval is configurable via `poll_interval`.
+- New `secure_mode_hash` function computes a hash suitable for the new LaunchDarkly JavaScript client's secure mode feature.
+- Support for extremely large feature flags. When a large feature flag changes, the stream will include a directive to fetch the updated flag.
+
+### Changed
+- You can now initialize the LaunchDarkly client with an optional timeout (specified in seconds). This will block initialization until the client has finished bootstrapping and is able to serve feature flags.
+- The streaming implementation (`StreamProcessor`) uses [Celluloid](https://github.com/celluloid/celluloid) under the hood instead of [EventMachine](https://github.com/eventmachine/eventmachine). The dependency on EventMachine has been removed.
+- The `store` option has been renamed to `cache_store`.
+- Offline mode can no longer be set dynamically. Instead, at configuration time, the `offline` parameter can be set to put the client in offline mode. It is no longer possible to dynamically change whether the client is online and offline (via `set_online` and `set_offline`). Call `offline?` to determine whether or not the client is offline.
+- The `debug_stream` configuration option has been removed.
+- The `log_timings` configuration option has been removed.
+
+### Deprecated
+- The `toggle` call has been deprecated in favor of `variation`.
+
+### Removed
+- `update_user_flag_setting` has been removed. To change user settings, use the LaunchDarkly REST API.

data/README.md

@@ -23,10 +23,10 @@ gem install ldclient-rb
 require 'ldclient-rb'
 ```
 
-2. Create a new LDClient with your API key:
+2. Create a new LDClient with your SDK key:
 
 ```ruby
-client = LaunchDarkly::LDClient.new("your_api_key")
+client = LaunchDarkly::LDClient.new("your_sdk_key")
 ```
 
 ### Ruby on Rails
@@ -36,7 +36,7 @@ client = LaunchDarkly::LDClient.new("your_api_key")
 1.  Initialize the launchdarkly client in `config/initializers/launchdarkly.rb`:
 
 ```ruby
-Rails.configuration.ld_client = LaunchDarkly::LDClient.new("your_api_key")
+Rails.configuration.ld_client = LaunchDarkly::LDClient.new("your_sdk_key")
 ```
 
 2.  You may want to include a function in your ApplicationController

data/ext/mkrf_conf.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+
+
+# From http://stackoverflow.com/questions/5830835/how-to-add-openssl-dependency-to-gemspec
+# the whole reason this file exists:   to return an error if openssl
+# isn't installed.
+require 'openssl'
+
+f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w")   # create dummy rakefile to indicate success
+f.write("task :default\n")
+f.close

data/ldclient-rb.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.extensions    = 'ext/mkrf_conf.rb'
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
@@ -30,5 +31,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "net-http-persistent", "~> 2.9"
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.0.0"
   spec.add_runtime_dependency "hashdiff", "~> 0.2"
-  spec.add_runtime_dependency "ld-em-eventsource", "~> 0.2" #https://github.com/launchdarkly/em-eventsource
+  spec.add_runtime_dependency "ld-celluloid-eventsource", "~> 0.5"
+  spec.add_runtime_dependency "waitutil", "0.2"
 end

data/lib/ldclient-rb.rb

@@ -1,7 +1,11 @@
 require "ldclient-rb/version"
-require "ldclient-rb/settings"
+require "ldclient-rb/evaluation"
 require "ldclient-rb/ldclient"
-require "ldclient-rb/store"
+require "ldclient-rb/cache_store"
 require "ldclient-rb/config"
 require "ldclient-rb/newrelic"
 require "ldclient-rb/stream"
+require "ldclient-rb/polling"
+require "ldclient-rb/events"
+require "ldclient-rb/feature_store"
+require "ldclient-rb/requestor"

data/lib/ldclient-rb/config.rb

@@ -31,9 +31,15 @@ module LaunchDarkly
     #   connections in seconds.
     # @option opts [Float] :connect_timeout (2) The connect timeout for network
     #   connections in seconds.
-    # @option opts [Object] :store A cache store for the Faraday HTTP caching
+    # @option opts [Object] :cache_store A cache store for the Faraday HTTP caching
     #   library. Defaults to the Rails cache in a Rails environment, or a
     #   thread-safe in-memory store otherwise.
+    # @option opts [Boolean] :offline (false) Whether the client should be initialized in 
+    #   offline mode. In offline mode, default values are returned for all flags and no 
+    #   remote network requests are made.
+    # @option opts [Float] :poll_interval (30) The number of seconds between polls for flag updates
+    #   if streaming is off.
+    # @option opts [Boolean] :stream (true) Whether or not the streaming API should be used to receive flag updates.
     #
     # @return [type] [description]
     def initialize(opts = {})
@@ -42,14 +48,14 @@ module LaunchDarkly
       @events_uri = (opts[:events_uri] || Config.default_events_uri).chomp("/")
       @capacity = opts[:capacity] || Config.default_capacity
       @logger = opts[:logger] || Config.default_logger
-      @store = opts[:store] || Config.default_store
+      @cache_store = opts[:cache_store] || Config.default_cache_store
       @flush_interval = opts[:flush_interval] || Config.default_flush_interval
       @connect_timeout = opts[:connect_timeout] || Config.default_connect_timeout
       @read_timeout = opts[:read_timeout] || Config.default_read_timeout
       @feature_store = opts[:feature_store] || Config.default_feature_store
       @stream = opts.has_key?(:stream) ? opts[:stream] : Config.default_stream
-      @log_timings = opts.has_key?(:log_timings) ? opts[:log_timings] : Config.default_log_timings
-      @debug_stream = opts.has_key?(:debug_stream) ? opts[:debug_stream] : Config.default_debug_stream
+      @offline = opts.has_key?(:offline) ? opts[:offline] : Config.default_offline
+      @poll_interval = opts.has_key?(:poll_interval) && opts[:poll_interval] > 1 ? opts[:poll_interval] : Config.default_poll_interval
     end
 
     #
@@ -79,13 +85,9 @@ module LaunchDarkly
       @stream
     end
 
-    #
-    # Whether we should debug streaming mode. If set, the client will fetch features via polling
-    # and compare the retrieved feature with the value in the feature store
-    #
-    # @return [Boolean] True if we should debug streaming mode
-    def debug_stream?
-      @debug_stream
+    # TODO docs
+    def offline?
+      @offline
     end
 
     #
@@ -95,6 +97,11 @@ module LaunchDarkly
     # @return [Float] The configured number of seconds between flushes of the event buffer.
     attr_reader :flush_interval
 
+    #
+    # The number of seconds to wait before polling for feature flag updates. This option has no
+    # effect unless streaming is disabled
+    attr_reader :poll_interval
+
     #
     # The configured logger for the LaunchDarkly client. The client library uses the log to
     # print warning and error messages.
@@ -117,7 +124,7 @@ module LaunchDarkly
     # 'read' and 'write' requests.
     #
     # @return [Object] The configured store for the Faraday HTTP caching library.
-    attr_reader :store
+    attr_reader :cache_store
 
     #
     # The read timeout for network connections in seconds.
@@ -132,16 +139,7 @@ module LaunchDarkly
     attr_reader :connect_timeout
 
     #
-    # Whether timing information should be logged. If it is logged, it will be logged to the DEBUG
-    # level on the configured logger.  This can be very verbose.
-    #
-    # @return [Boolean] True if timing information should be logged.
-    def log_timings?
-      @log_timings
-    end
-
-    #
-    # TODO docs
+    # A store for feature flag configuration rules.
     #
     attr_reader :feature_store
 
@@ -170,7 +168,7 @@ module LaunchDarkly
       "https://events.launchdarkly.com"
     end
 
-    def self.default_store
+    def self.default_cache_store
       defined?(Rails) && Rails.respond_to?(:cache) ? Rails.cache : ThreadSafeMemoryStore.new
     end
 
@@ -190,20 +188,20 @@ module LaunchDarkly
       defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : ::Logger.new($stdout)
     end
 
-    def self.default_log_timings
-      false
-    end
-
     def self.default_stream
       true
     end
 
     def self.default_feature_store
-      nil
+      InMemoryFeatureStore.new
     end
 
-    def self.default_debug_stream
+    def self.default_offline
       false
     end
+
+    def self.default_poll_interval
+      1
+    end
   end
 end

data/lib/ldclient-rb/evaluation.rb

@@ -0,0 +1,265 @@
+require "date"
+
+module LaunchDarkly
+
+  module Evaluation
+    BUILTINS = [:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name, :anonymous]
+
+    OPERATORS = {
+      in: 
+        lambda do |a, b|
+          a == b
+        end,
+      endsWith: 
+        lambda do |a, b|
+          (a.is_a? String) && (a.end_with? b)
+        end,
+      startsWith: 
+        lambda do |a, b|
+          (a.is_a? String) && (a.start_with? b)
+        end,
+      matches:
+        lambda do |a, b|
+          (b.is_a? String) && !(Regexp.new b).match(a).nil?
+        end,
+      contains:
+        lambda do |a, b|
+          (a.is_a? String) && (a.include? b)
+        end,
+      lessThan:
+        lambda do |a, b|
+          (a.is_a? Numeric) && (a < b)
+        end,
+      lessThanOrEqual:
+        lambda do |a, b|
+          (a.is_a? Numeric) && (a <= b)
+        end,
+      greaterThan:
+        lambda do |a, b|
+          (a.is_a? Numeric) && (a > b)
+        end,
+      greaterThanOrEqual:
+        lambda do |a, b|
+          (a.is_a? Numeric) && (a >= b)
+        end,
+      before:
+        lambda do |a, b|
+          begin
+            if a.is_a? String
+              a = DateTime.rfc3339(a).strftime('%Q').to_i 
+            end
+            if b.is_a? String
+              b = DateTime.rfc3339(b).strftime('%Q').to_i
+            end          
+            (a.is_a? Numeric) ? a < b : false
+          rescue => e
+            false
+          end
+        end,
+      after:
+        lambda do |a, b|
+          begin
+            if a.is_a? String
+              a = DateTime.rfc3339(a).strftime('%Q').to_i 
+            end
+            if b.is_a? String
+              b = DateTime.rfc3339(b).strftime('%Q').to_i 
+            end          
+            (a.is_a? Numeric) ? a > b : false
+          rescue => e
+            false
+          end
+        end
+    }
+
+    class EvaluationError < StandardError
+    end
+
+    # Evaluates a feature flag, returning a hash containing the evaluation result and any events
+    # generated during prerequisite evaluation. Raises EvaluationError if the flag is not well-formed
+    # Will return nil, but not raise an exception, indicating that the rules (including fallthrough) did not match
+    # In that case, the caller should return the default value.
+    def evaluate(flag, user, store)
+      if flag.nil?
+        raise EvaluationError, "Flag does not exist"
+      end
+
+      if user.nil? || user[:key].nil?
+        raise EvaluationError, "Invalid user"
+      end
+
+      events = []
+
+      if flag[:on]
+        res = eval_internal(flag, user, store, events)
+
+        return {value: res, events: events} if !res.nil?
+      end
+
+      if !flag[:offVariation].nil? && flag[:offVariation] < flag[:variations].length
+        value = flag[:variations][flag[:offVariation]]
+        return {value: value, events: events}
+      end
+
+      {value: nil, events: events}
+    end
+
+    def eval_internal(flag, user, store, events)
+      failed_prereq = false
+      # Evaluate prerequisites, if any
+      if !flag[:prerequisites].nil?
+        flag[:prerequisites].each do |prerequisite|
+
+          prereq_flag = store.get(prerequisite[:key])
+
+          if prereq_flag.nil? || !prereq_flag[:on]
+            failed_prereq = true
+          else
+            begin
+              prereq_res = eval_internal(prereq_flag, user, store, events)
+              variation = get_variation(prereq_flag, prerequisite[:variation])
+              events.push(kind: "feature", key: prereq_flag[:key], value: prereq_res, version: prereq_flag[:version], prereqOf: flag[:key])
+              if prereq_res.nil? || prereq_res!= variation
+                failed_prereq = true
+              end
+            rescue => exn
+              @config.logger.error("[LDClient] Error evaluating prerequisite: #{exn.inspect}")
+              failed_prereq = true
+            end
+          end
+        end
+
+        if failed_prereq
+          return nil
+        end
+      end
+      # The prerequisites were satisfied.
+      # Now walk through the evaluation steps and get the correct
+      # variation index
+      eval_rules(flag, user)
+    end
+
+    def eval_rules(flag, user)
+      # Check user target matches
+      if !flag[:targets].nil?
+        flag[:targets].each do |target|
+          if !target[:values].nil?
+            target[:values].each do |value|
+              return get_variation(flag, target[:variation]) if value == user[:key]
+            end
+          end
+        end
+      end  
+
+      # Check custom rules
+      if !flag[:rules].nil?
+        flag[:rules].each do |rule|
+          return variation_for_user(rule, user, flag) if rule_match_user(rule, user)
+        end
+      end
+
+      # Check the fallthrough rule
+      if !flag[:fallthrough].nil?
+        return variation_for_user(flag[:fallthrough], user, flag)
+      end
+
+      # Not even the fallthrough matched-- return the off variation or default
+      nil
+    end
+
+    def get_variation(flag, index)
+      if index >= flag[:variations].length
+        raise EvaluationError, "Invalid variation index"
+      end
+      flag[:variations][index]
+    end
+
+    def rule_match_user(rule, user)
+      return false if !rule[:clauses]
+
+      rule[:clauses].each do |clause|
+        return false if !clause_match_user(clause, user)
+      end
+
+      return true
+    end
+
+    def clause_match_user(clause, user)
+      val = user_value(user, clause[:attribute])
+      return false if val.nil?
+
+      op = OPERATORS[clause[:op].to_sym]
+
+      if op.nil?
+        raise EvaluationError, "Unsupported operator #{clause[:op]} in evaluation"
+      end
+
+      if val.is_a? Enumerable
+        val.each do |v|
+          return maybe_negate(clause, true) if match_any(op, v, clause[:values])
+        end
+        return maybe_negate(clause, false)
+      end
+
+      maybe_negate(clause, match_any(op, val, clause[:values]))
+    end    
+
+    def variation_for_user(rule, user, flag)
+      if !rule[:variation].nil? # fixed variation
+        return get_variation(flag, rule[:variation])
+      elsif !rule[:rollout].nil? # percentage rollout
+        rollout = rule[:rollout]
+        bucket_by = rollout[:bucketBy].nil? ? "key" : rollout[:bucketBy]
+        bucket = bucket_user(user, flag[:key], bucket_by, flag[:salt])
+        sum = 0;
+        rollout[:variations].each do |variate|
+          sum += variate[:weight].to_f / 100000.0
+          return get_variation(flag, variate[:variation]) if bucket < sum
+        end
+        nil
+      else # the rule isn't well-formed
+        raise EvaluationError, "Rule does not define a variation or rollout"
+      end
+    end
+
+    def bucket_user(user, key, bucket_by, salt)
+      return nil unless user[:key]
+
+      id_hash = user_value(user, bucket_by)
+
+      if user[:secondary]
+        id_hash += "." + user[:secondary]
+      end
+
+      hash_key = "%s.%s.%s" % [key, salt, id_hash]
+
+      hash_val = (Digest::SHA1.hexdigest(hash_key))[0..14]
+      hash_val.to_i(16) / Float(0xFFFFFFFFFFFFFFF)      
+    end
+
+    def user_value(user, attribute)
+      attribute = attribute.to_sym
+
+      if BUILTINS.include? attribute
+        user[attribute]
+      elsif !user[:custom].nil?
+        user[:custom][attribute]
+      else
+        nil
+      end
+    end
+
+    def maybe_negate(clause, b)
+      clause[:negate] ? !b : b
+    end
+
+    def match_any(op, value, values)
+      values.each do |v|
+        return true if op.call(value, v)
+      end
+      return false
+    end
+  end
+
+end
+