launchdarkly-server-sdk 5.7.3 → 6.0.0

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

@@ -33,6 +33,8 @@ module LaunchDarkly
             @pool = opts[:pool] || ConnectionPool.new(size: max_connections) do
               ::Redis.new(@redis_opts)
             end
+            # shutdown pool on close unless the client passed a custom pool and specified not to shutdown
+            @pool_shutdown_on_close = (!opts[:pool] || opts.fetch(:pool_shutdown_on_close, true))
             @prefix = opts[:prefix] || LaunchDarkly::Integrations::Redis::default_prefix
             @logger = opts[:logger] || Config.default_logger
             @test_hook = opts[:test_hook]  # used for unit tests, deliberately undocumented
@@ -53,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)
@@ -73,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
@@ -93,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" }
@@ -113,11 +114,12 @@ module LaunchDarkly
           end
 
           def initialized_internal?
-            with_connection { |redis| redis.exists(inited_key) }
+            with_connection { |redis| redis.exists?(inited_key) }
           end
 
           def stop
             if @stopped.make_true
+              return unless @pool_shutdown_on_close
               @pool.shutdown { |redis| redis.close }
             end
           end
@@ -145,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

data/lib/ldclient-rb/impl/model/serialization.rb

@@ -0,0 +1,62 @@
+
+module LaunchDarkly
+  module Impl
+    module Model
+      # Abstraction of deserializing a feature flag or segment that was read from a data store or
+      # received from LaunchDarkly.
+      def self.deserialize(kind, json)
+        return nil if json.nil?
+        item = JSON.parse(json, symbolize_names: true)
+        postprocess_item_after_deserializing!(kind, item)
+        item
+      end
+
+      # Abstraction of serializing a feature flag or segment that will be written to a data store.
+      # Currently we just call to_json.
+      def self.serialize(kind, item)
+        item.to_json
+      end
+
+      # Translates a { flags: ..., segments: ... } object received from LaunchDarkly to the data store format.
+      def self.make_all_store_data(received_data)
+        flags = received_data[:flags]
+        postprocess_items_after_deserializing!(FEATURES, flags)
+        segments = received_data[:segments]
+        postprocess_items_after_deserializing!(SEGMENTS, segments)
+        { FEATURES => flags, SEGMENTS => segments }
+      end
+
+      # Called after we have deserialized a model item from JSON (because we received it from LaunchDarkly,
+      # or read it from a persistent data store). This allows us to precompute some derived attributes that
+      # will never change during the lifetime of that item.
+      def self.postprocess_item_after_deserializing!(kind, item)
+        return if !item
+        # Currently we are special-casing this for FEATURES; eventually it will be handled by delegating
+        # to the "kind" object or the item class.
+        if kind.eql? FEATURES
+          # For feature flags, we precompute all possible parameterized EvaluationReason instances.
+          prereqs = item[:prerequisites]
+          if !prereqs.nil?
+            prereqs.each do |prereq|
+              prereq[:_reason] = EvaluationReason::prerequisite_failed(prereq[:key])
+            end
+          end
+          rules = item[:rules]
+          if !rules.nil?
+            rules.each_index do |i|
+              rule = rules[i]
+              rule[:_reason] = EvaluationReason::rule_match(i, rule[:id])
+            end
+          end
+        end
+      end
+
+      def self.postprocess_items_after_deserializing!(kind, items_map)
+        return items_map if !items_map
+        items_map.each do |key, item|
+          postprocess_item_after_deserializing!(kind, item)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module LaunchDarkly
+  module Impl
+    # A simple thread safe generic unbounded resource pool abstraction
+    class UnboundedPool
+      def initialize(instance_creator, instance_destructor)
+        @pool = Array.new
+        @lock = Mutex.new
+        @instance_creator = instance_creator
+        @instance_destructor = instance_destructor
+      end
+
+      def acquire
+        @lock.synchronize {
+          if @pool.length == 0
+            @instance_creator.call()
+          else
+            @pool.pop()
+          end
+        }
+      end
+
+      def release(instance)
+        @lock.synchronize { @pool.push(instance) }
+      end
+
+      def dispose_all
+        @lock.synchronize {
+          @pool.map { |instance| @instance_destructor.call(instance) } if !@instance_destructor.nil?
+          @pool.clear()
+        }
+      end
+    end
+  end
+end

data/lib/ldclient-rb/integrations/redis.rb

@@ -45,6 +45,9 @@ module LaunchDarkly
       # @option opts [Integer] :expiration (15)  expiration time for the in-memory cache, in seconds; 0 for no local caching
       # @option opts [Integer] :capacity (1000)  maximum number of items in the cache
       # @option opts [Object] :pool  custom connection pool, if desired
+      # @option opts [Boolean] :pool_shutdown_on_close whether calling `close` should shutdown the custom connection pool;
+      #   this is true by default, and should be set to false only if you are managing the pool yourself and want its
+      #   lifecycle to be independent of the SDK client
       # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
       #
       def self.new_feature_store(opts)

data/lib/ldclient-rb/ldclient.rb

@@ -1,4 +1,5 @@
 require "ldclient-rb/impl/diagnostic_events"
+require "ldclient-rb/impl/evaluator"
 require "ldclient-rb/impl/event_factory"
 require "ldclient-rb/impl/store_client_wrapper"
 require "concurrent/atomics"
@@ -14,7 +15,6 @@ module LaunchDarkly
   # should create a single client instance for the lifetime of the application.
   #
   class LDClient
-    include Evaluation
     include Impl
     #
     # Creates a new client instance that connects to LaunchDarkly. A custom
@@ -57,6 +57,10 @@ module LaunchDarkly
       updated_config.instance_variable_set(:@feature_store, @store)
       @config = updated_config
 
+      get_flag = lambda { |key| @store.get(FEATURES, key) }
+      get_segment = lambda { |key| @store.get(SEGMENTS, key) }
+      @evaluator = LaunchDarkly::Impl::Evaluator.new(get_flag, get_segment, @config.logger)
+
       if !@config.offline? && @config.send_events && !@config.diagnostic_opt_out?
         diagnostic_accumulator = Impl::DiagnosticAccumulator.new(Impl::DiagnosticAccumulator.create_diagnostic_id(sdk_key))
       else
@@ -333,12 +337,13 @@ module LaunchDarkly
           next
         end
         begin
-          result = evaluate(f, user, @store, @config.logger, @event_factory_default)
+          result = @evaluator.evaluate(f, user, @event_factory_default)
           state.add_flag(f, result.detail.value, result.detail.variation_index, with_reasons ? result.detail.reason : nil,
             details_only_if_tracked)
         rescue => exn
           Util.log_exception(@config.logger, "Error evaluating flag \"#{k}\" in all_flags_state", exn)
-          state.add_flag(f, nil, nil, with_reasons ? { kind: 'ERROR', errorKind: 'EXCEPTION' } : nil, details_only_if_tracked)
+          state.add_flag(f, nil, nil, with_reasons ? EvaluationReason::error(EvaluationReason::ERROR_EXCEPTION) : nil,
+            details_only_if_tracked)
         end
       end
 
@@ -363,12 +368,12 @@ module LaunchDarkly
         return NullUpdateProcessor.new
       end
       raise ArgumentError, "sdk_key must not be nil" if sdk_key.nil?  # see LDClient constructor comment on sdk_key
-      requestor = Requestor.new(sdk_key, config)
       if config.stream?
-        StreamProcessor.new(sdk_key, config, requestor, diagnostic_accumulator)
+        StreamProcessor.new(sdk_key, config, diagnostic_accumulator)
       else
         config.logger.info { "Disabling streaming API" }
         config.logger.warn { "You should only disable the streaming API if instructed to do so by LaunchDarkly support" }
+        requestor = Requestor.new(sdk_key, config)
         PollingProcessor.new(config, requestor)
       end
     end
@@ -376,7 +381,7 @@ module LaunchDarkly
     # @return [EvaluationDetail]
     def evaluate_internal(key, user, default, event_factory)
       if @config.offline?
-        return error_result('CLIENT_NOT_READY', default)
+        return Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default)
       end
 
       if !initialized?
@@ -384,7 +389,7 @@ module LaunchDarkly
           @config.logger.warn { "[LDClient] Client has not finished initializing; using last known values from feature store" }
         else
           @config.logger.error { "[LDClient] Client has not finished initializing; feature store unavailable, returning default value" }
-          detail = error_result('CLIENT_NOT_READY', default)
+          detail = Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default)
           @event_processor.add_event(event_factory.new_unknown_flag_event(key, user, default, detail.reason))
           return  detail
         end
@@ -394,20 +399,20 @@ module LaunchDarkly
 
       if feature.nil?
         @config.logger.info { "[LDClient] Unknown feature flag \"#{key}\". Returning default value" }
-        detail = error_result('FLAG_NOT_FOUND', default)
+        detail = Evaluator.error_result(EvaluationReason::ERROR_FLAG_NOT_FOUND, default)
         @event_processor.add_event(event_factory.new_unknown_flag_event(key, user, default, detail.reason))
         return detail
       end
 
       unless user
         @config.logger.error { "[LDClient] Must specify user" }
-        detail = error_result('USER_NOT_SPECIFIED', default)
+        detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED, default)
         @event_processor.add_event(event_factory.new_default_event(feature, user, default, detail.reason))
         return detail
       end
 
       begin
-        res = evaluate(feature, user, @store, @config.logger, event_factory)
+        res = @evaluator.evaluate(feature, user, event_factory)
         if !res.events.nil?
           res.events.each do |event|
             @event_processor.add_event(event)
@@ -421,7 +426,7 @@ module LaunchDarkly
         return detail
       rescue => exn
         Util.log_exception(@config.logger, "Error evaluating feature flag \"#{key}\"", exn)
-        detail = error_result('EXCEPTION', default)
+        detail = Evaluator.error_result(EvaluationReason::ERROR_EXCEPTION, default)
         @event_processor.add_event(event_factory.new_default_event(feature, user, default, detail.reason))
         return detail
       end