launchdarkly-server-sdk 5.8.2 → 6.0.0

data/lib/ldclient-rb/impl/evaluator_bucketing.rb

@@ -0,0 +1,74 @@
+
+module LaunchDarkly
+  module Impl
+    # Encapsulates the logic for percentage rollouts.
+    module EvaluatorBucketing
+      # Applies either a fixed variation or a rollout for a rule (or the fallthrough rule).
+      #
+      # @param flag [Object] the feature flag
+      # @param rule [Object] the rule
+      # @param user [Object] the user properties
+      # @return [Number] the variation index, or nil if there is an error
+      def self.variation_index_for_user(flag, rule, user)
+        variation = rule[:variation]
+        return variation if !variation.nil? # fixed variation
+        rollout = rule[:rollout]
+        return nil if rollout.nil?
+        variations = rollout[:variations]
+        if !variations.nil? && variations.length > 0 # 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;
+          variations.each do |variate|
+            sum += variate[:weight].to_f / 100000.0
+            if bucket < sum
+              return variate[:variation]
+            end
+          end
+          # The user's bucket value was greater than or equal to the end of the last bucket. This could happen due
+          # to a rounding error, or due to the fact that we are scaling to 100000 rather than 99999, or the flag
+          # data could contain buckets that don't actually add up to 100000. Rather than returning an error in
+          # this case (or changing the scaling, which would potentially change the results for *all* users), we
+          # will simply put the user in the last bucket.
+          variations[-1][:variation]
+        else # the rule isn't well-formed
+          nil
+        end
+      end
+
+      # Returns a user's bucket value as a floating-point value in `[0, 1)`.
+      #
+      # @param user [Object] the user properties
+      # @param key [String] the feature flag key (or segment key, if this is for a segment rule)
+      # @param bucket_by [String|Symbol] the name of the user attribute to be used for bucketing
+      # @param salt [String] the feature flag's or segment's salt value
+      # @return [Number] the bucket value, from 0 inclusive to 1 exclusive
+      def self.bucket_user(user, key, bucket_by, salt)
+        return nil unless user[:key]
+
+        id_hash = bucketable_string_value(EvaluatorOperators.user_value(user, bucket_by))
+        if id_hash.nil?
+          return 0.0
+        end
+
+        if user[:secondary]
+          id_hash += "." + user[:secondary].to_s
+        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
+
+      private
+
+      def self.bucketable_string_value(value)
+        return value if value.is_a? String
+        return value.to_s if value.is_a? Integer
+        nil
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/evaluator_operators.rb

@@ -0,0 +1,160 @@
+require "date"
+require "semantic"
+require "set"
+
+module LaunchDarkly
+  module Impl
+    # Defines the behavior of all operators that can be used in feature flag rules and segment rules.
+    module EvaluatorOperators
+      # Applies an operator to produce a boolean result.
+      #
+      # @param op [Symbol] one of the supported LaunchDarkly operators, as a symbol
+      # @param user_value the value of the user attribute that is referenced in the current clause (left-hand
+      #   side of the expression)
+      # @param clause_value the constant value that `user_value` is being compared to (right-hand side of the
+      #   expression)
+      # @return [Boolean] true if the expression should be considered a match; false if it is not a match, or
+      #   if the values cannot be compared because they are of the wrong types, or if the operator is unknown
+      def self.apply(op, user_value, clause_value)
+        case op
+        when :in
+          user_value == clause_value
+        when :startsWith
+          string_op(user_value, clause_value, lambda { |a, b| a.start_with? b })
+        when :endsWith
+          string_op(user_value, clause_value, lambda { |a, b| a.end_with? b })
+        when :contains
+          string_op(user_value, clause_value, lambda { |a, b| a.include? b })
+        when :matches
+          string_op(user_value, clause_value, lambda { |a, b|
+            begin
+              re = Regexp.new b
+              !re.match(a).nil?
+            rescue
+              false
+            end
+          })
+        when :lessThan
+          numeric_op(user_value, clause_value, lambda { |a, b| a < b })
+        when :lessThanOrEqual
+          numeric_op(user_value, clause_value, lambda { |a, b| a <= b })
+        when :greaterThan
+          numeric_op(user_value, clause_value, lambda { |a, b| a > b })
+        when :greaterThanOrEqual
+          numeric_op(user_value, clause_value, lambda { |a, b| a >= b })
+        when :before
+          date_op(user_value, clause_value, lambda { |a, b| a < b })
+        when :after
+          date_op(user_value, clause_value, lambda { |a, b| a > b })
+        when :semVerEqual
+          semver_op(user_value, clause_value, lambda { |a, b| a == b })
+        when :semVerLessThan
+          semver_op(user_value, clause_value, lambda { |a, b| a < b })
+        when :semVerGreaterThan
+          semver_op(user_value, clause_value, lambda { |a, b| a > b })
+        when :segmentMatch
+          # We should never reach this; it can't be evaluated based on just two parameters, because it requires
+          # looking up the segment from the data store. Instead, we special-case this operator in clause_match_user.
+          false
+        else
+          false
+        end
+      end
+
+      # Retrieves the value of a user attribute by name.
+      #
+      # Built-in attributes correspond to top-level properties in the user object. They are treated as strings and
+      # non-string values are coerced to strings, except for `anonymous` which is meant to be a boolean if present
+      # and is not currently coerced. This behavior is consistent with earlier versions of the Ruby SDK, but is not
+      # guaranteed to be consistent with other SDKs, since the evaluator specification is based on the strongly-typed
+      # SDKs where it is not possible for an attribute to have the wrong type.
+      #
+      # Custom attributes correspond to properties within the `custom` property, if any, and can be of any type.
+      #
+      # @param user [Object] the user properties
+      # @param attribute [String|Symbol] the attribute to get, for instance `:key` or `:name` or `:some_custom_attr`
+      # @return the attribute value, or nil if the attribute is unknown
+      def self.user_value(user, attribute)
+        attribute = attribute.to_sym
+        if BUILTINS.include? attribute
+          value = user[attribute]
+          return nil if value.nil?
+          (attribute == :anonymous) ? value : value.to_s
+        elsif !user[:custom].nil?
+          user[:custom][attribute]
+        else
+          nil
+        end
+      end
+
+      private
+
+      BUILTINS = Set[:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name, :anonymous]
+      NUMERIC_VERSION_COMPONENTS_REGEX = Regexp.new("^[0-9.]*")
+
+      private_constant :BUILTINS
+      private_constant :NUMERIC_VERSION_COMPONENTS_REGEX
+
+      def self.string_op(user_value, clause_value, fn)
+        (user_value.is_a? String) && (clause_value.is_a? String) && fn.call(user_value, clause_value)
+      end
+
+      def self.numeric_op(user_value, clause_value, fn)
+        (user_value.is_a? Numeric) && (clause_value.is_a? Numeric) && fn.call(user_value, clause_value)
+      end
+
+      def self.date_op(user_value, clause_value, fn)
+        ud = to_date(user_value)
+        if !ud.nil?
+          cd = to_date(clause_value)
+          !cd.nil? && fn.call(ud, cd)
+        else
+          false
+        end
+      end
+
+      def self.semver_op(user_value, clause_value, fn)
+        uv = to_semver(user_value)
+        if !uv.nil?
+          cv = to_semver(clause_value)
+          !cv.nil? && fn.call(uv, cv)
+        else
+          false
+        end
+      end
+
+      def self.to_date(value)
+        if value.is_a? String
+          begin
+            DateTime.rfc3339(value).strftime("%Q").to_i
+          rescue => e
+            nil
+          end
+        elsif value.is_a? Numeric
+          value
+        else
+          nil
+        end
+      end
+
+      def self.to_semver(value)
+        if value.is_a? String
+          for _ in 0..2 do
+            begin
+              return Semantic::Version.new(value)
+            rescue ArgumentError
+              value = add_zero_version_component(value)
+            end
+          end
+        end
+        nil
+      end
+
+      def self.add_zero_version_component(v)
+        NUMERIC_VERSION_COMPONENTS_REGEX.match(v) { |m|
+          m[0] + ".0" + v[m[0].length..-1]
+        }
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/event_sender.rb

@@ -1,4 +1,7 @@
+require "ldclient-rb/impl/unbounded_pool"
+
 require "securerandom"
+require "http"
 
 module LaunchDarkly
   module Impl
@@ -9,62 +12,75 @@ module LaunchDarkly
       DEFAULT_RETRY_INTERVAL = 1
 
       def initialize(sdk_key, config, http_client = nil, retry_interval = DEFAULT_RETRY_INTERVAL)
-        @client = http_client ? http_client : LaunchDarkly::Util.new_http_client(config.events_uri, config)
         @sdk_key = sdk_key
         @config = config
         @events_uri = config.events_uri + "/bulk"
         @diagnostic_uri = config.events_uri + "/diagnostic"
         @logger = config.logger
         @retry_interval = retry_interval
+        @http_client_pool = UnboundedPool.new(
+          lambda { LaunchDarkly::Util.new_http_client(@config.events_uri, @config) },
+          lambda { |client| client.close })
+      end
+
+      def stop
+        @http_client_pool.dispose_all()
       end
 
       def send_event_data(event_data, description, is_diagnostic)
         uri = is_diagnostic ? @diagnostic_uri : @events_uri
         payload_id = is_diagnostic ? nil : SecureRandom.uuid
-        res = nil
-        (0..1).each do |attempt|
-          if attempt > 0
-            @logger.warn { "[LDClient] Will retry posting events after #{@retry_interval} second" }
-            sleep(@retry_interval)
-          end
-          begin
-            @client.start if !@client.started?
-            @logger.debug { "[LDClient] sending #{description}: #{event_data}" }
-            req = Net::HTTP::Post.new(uri)
-            req.content_type = "application/json"
-            req.body = event_data
-            Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| req[k] = v }
-            if !is_diagnostic
-              req["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
-              req["X-LaunchDarkly-Payload-ID"] = payload_id
+        begin
+          http_client = @http_client_pool.acquire()
+          response = nil
+          (0..1).each do |attempt|
+            if attempt > 0
+              @logger.warn { "[LDClient] Will retry posting events after #{@retry_interval} second" }
+              sleep(@retry_interval)
             end
-            req["Connection"] = "keep-alive"
-            res = @client.request(req)
-          rescue StandardError => exn
-            @logger.warn { "[LDClient] Error sending events: #{exn.inspect}." }
-            next
-          end
-          status = res.code.to_i
-          if status >= 200 && status < 300
-            res_time = nil
-            if !res["date"].nil?
-              begin
-                res_time = Time.httpdate(res["date"])
-              rescue ArgumentError
+            begin
+              @logger.debug { "[LDClient] sending #{description}: #{event_data}" }
+              headers = {}
+              headers["content-type"] = "application/json"
+              Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| headers[k] = v }
+              if !is_diagnostic
+                headers["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
+                headers["X-LaunchDarkly-Payload-ID"] = payload_id
               end
+              response = http_client.request("POST", uri, {
+                headers: headers,
+                body: event_data
+              })
+            rescue StandardError => exn
+              @logger.warn { "[LDClient] Error sending events: #{exn.inspect}." }
+              next
+            end
+            status = response.status.code
+            # must fully read body for persistent connections
+            body = response.to_s
+            if status >= 200 && status < 300
+              res_time = nil
+              if !response.headers["date"].nil?
+                begin
+                  res_time = Time.httpdate(response.headers["date"])
+                rescue ArgumentError
+                end
+              end
+              return EventSenderResult.new(true, false, res_time)
+            end
+            must_shutdown = !LaunchDarkly::Util.http_error_recoverable?(status)
+            can_retry = !must_shutdown && attempt == 0
+            message = LaunchDarkly::Util.http_error_message(status, "event delivery", can_retry ? "will retry" : "some events were dropped")
+            @logger.error { "[LDClient] #{message}" }
+            if must_shutdown
+              return EventSenderResult.new(false, true, nil)
             end
-            return EventSenderResult.new(true, false, res_time)
-          end
-          must_shutdown = !LaunchDarkly::Util.http_error_recoverable?(status)
-          can_retry = !must_shutdown && attempt == 0
-          message = LaunchDarkly::Util.http_error_message(status, "event delivery", can_retry ? "will retry" : "some events were dropped")
-          @logger.error { "[LDClient] #{message}" }
-          if must_shutdown
-            return EventSenderResult.new(false, true, nil)
           end
+          # used up our retries
+          return EventSenderResult.new(false, false, nil)
+        ensure
+          @http_client_pool.release(http_client)
         end
-        # used up our retries
-        return EventSenderResult.new(false, false, nil)
       end
     end
   end

data/lib/ldclient-rb/impl/integrations/consul_impl.rb

@@ -39,7 +39,7 @@ module LaunchDarkly
             # Insert or update every provided item
             all_data.each do |kind, items|
               items.values.each do |item|
-                value = item.to_json
+                value = Model.serialize(kind, item)
                 key = item_key(kind, item[:key])
                 ops.push({ 'KV' => { 'Verb' => 'set', 'Key' => key, 'Value' => value } })
                 unused_old_keys.delete(key)
@@ -62,7 +62,7 @@ module LaunchDarkly
 
           def get_internal(kind, key)
             value = Diplomat::Kv.get(item_key(kind, key), {}, :return)  # :return means "don't throw an error if not found"
-            (value.nil? || value == "") ? nil : JSON.parse(value, symbolize_names: true)
+            (value.nil? || value == "") ? nil : Model.deserialize(kind, value)
           end
 
           def get_all_internal(kind)
@@ -71,7 +71,7 @@ module LaunchDarkly
             (results == "" ? [] : results).each do |result|
               value = result[:value]
               if !value.nil?
-                item = JSON.parse(value, symbolize_names: true)
+                item = Model.deserialize(kind, value)
                 items_out[item[:key].to_sym] = item
               end
             end
@@ -80,7 +80,7 @@ module LaunchDarkly
 
           def upsert_internal(kind, new_item)
             key = item_key(kind, new_item[:key])
-            json = new_item.to_json
+            json = Model.serialize(kind, new_item)
 
             # We will potentially keep retrying indefinitely until someone's write succeeds
             while true
@@ -88,7 +88,7 @@ module LaunchDarkly
               if old_value.nil? || old_value == ""
                 mod_index = 0
               else
-                old_item = JSON.parse(old_value[0]["Value"], symbolize_names: true)
+                old_item = Model.deserialize(kind, old_value[0]["Value"])
                 # Check whether the item is stale. If so, don't do the update (and return the existing item to
                 # FeatureStoreWrapper so it can be cached)
                 if old_item[:version] >= new_item[:version]

data/lib/ldclient-rb/impl/integrations/dynamodb_impl.rb

@@ -77,7 +77,7 @@ module LaunchDarkly
 
           def get_internal(kind, key)
             resp = get_item_by_keys(namespace_for_kind(kind), key)
-            unmarshal_item(resp.item)
+            unmarshal_item(kind, resp.item)
           end
 
           def get_all_internal(kind)
@@ -86,7 +86,7 @@ module LaunchDarkly
             while true
               resp = @client.query(req)
               resp.items.each do |item|
-                item_out = unmarshal_item(item)
+                item_out = unmarshal_item(kind, item)
                 items_out[item_out[:key].to_sym] = item_out
               end
               break if resp.last_evaluated_key.nil? || resp.last_evaluated_key.length == 0
@@ -196,15 +196,15 @@ module LaunchDarkly
           def marshal_item(kind, item)
             make_keys_hash(namespace_for_kind(kind), item[:key]).merge({
               VERSION_ATTRIBUTE => item[:version],
-              ITEM_JSON_ATTRIBUTE => item.to_json
+              ITEM_JSON_ATTRIBUTE => Model.serialize(kind, item)
             })
           end
 
-          def unmarshal_item(item)
+          def unmarshal_item(kind, item)
             return nil if item.nil? || item.length == 0
             json_attr = item[ITEM_JSON_ATTRIBUTE]
             raise RuntimeError.new("DynamoDB map did not contain expected item string") if json_attr.nil?
-            JSON.parse(json_attr, symbolize_names: true)
+            Model.deserialize(kind, json_attr)
           end
         end
 

data/lib/ldclient-rb/impl/integrations/redis_impl.rb

@@ -55,7 +55,7 @@ module LaunchDarkly
                   multi.del(items_key(kind))
                   count = count + items.count
                   items.each do |key, item|
-                    multi.hset(items_key(kind), key, item.to_json)
+                    multi.hset(items_key(kind), key, Model.serialize(kind,item))
                   end
                 end
                 multi.set(inited_key, inited_key)
@@ -75,8 +75,7 @@ module LaunchDarkly
             with_connection do |redis|
               hashfs = redis.hgetall(items_key(kind))
               hashfs.each do |k, json_item|
-                f = JSON.parse(json_item, symbolize_names: true)
-                fs[k.to_sym] = f
+                fs[k.to_sym] = Model.deserialize(kind, json_item)
               end
             end
             fs
@@ -95,7 +94,7 @@ module LaunchDarkly
                   before_update_transaction(base_key, key)
                   if old_item.nil? || old_item[:version] < new_item[:version]
                     result = redis.multi do |multi|
-                      multi.hset(base_key, key, new_item.to_json)
+                      multi.hset(base_key, key, Model.serialize(kind, new_item))
                     end
                     if result.nil?
                       @logger.debug { "RedisFeatureStore: concurrent modification detected, retrying" }
@@ -115,9 +114,7 @@ module LaunchDarkly
           end
 
           def initialized_internal?
-            with_connection do |redis|
-              redis.respond_to?(:exists?) ? redis.exists?(inited_key) : redis.exists(inited_key)
-            end
+            with_connection { |redis| redis.exists?(inited_key) }
           end
 
           def stop
@@ -150,8 +147,7 @@ module LaunchDarkly
           end
 
           def get_redis(redis, kind, key)
-            json_item = redis.hget(items_key(kind), key)
-            json_item.nil? ? nil : JSON.parse(json_item, symbolize_names: true)
+            Model.deserialize(kind, redis.hget(items_key(kind), key))
           end
         end
       end