launchdarkly-server-sdk 5.8.2 → 6.0.0

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/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
 
@@ -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

data/lib/ldclient-rb/polling.rb

@@ -37,10 +37,7 @@ module LaunchDarkly
     def poll
       all_data = @requestor.request_all_data
       if all_data
-        @config.feature_store.init({
-          FEATURES => all_data[:flags],
-          SEGMENTS => all_data[:segments]
-        })
+        @config.feature_store.init(all_data)
         if @initialized.make_true
           @config.logger.info { "[LDClient] Polling connection initialized" }
           @ready.set

data/lib/ldclient-rb/requestor.rb

@@ -1,6 +1,9 @@
+require "ldclient-rb/impl/model/serialization"
+
 require "concurrent/atomics"
 require "json"
 require "uri"
+require "http"
 
 module LaunchDarkly
   # @private
@@ -22,37 +25,44 @@ module LaunchDarkly
     def initialize(sdk_key, config)
       @sdk_key = sdk_key
       @config = config
-      @client = Util.new_http_client(@config.base_uri, @config)
+      @http_client = LaunchDarkly::Util.new_http_client(config.base_uri, config)
       @cache = @config.cache_store
     end
 
     def request_all_data()
-      make_request("/sdk/latest-all")
+      all_data = JSON.parse(make_request("/sdk/latest-all"), symbolize_names: true)
+      Impl::Model.make_all_store_data(all_data)
     end
     
     def stop
       begin
-        @client.finish
+        @http_client.close
       rescue
       end
     end
 
     private
 
+    def request_single_item(kind, path)
+      Impl::Model.deserialize(kind, make_request(path))
+    end
+
     def make_request(path)
-      @client.start if !@client.started?
       uri = URI(@config.base_uri + path)
-      req = Net::HTTP::Get.new(uri)
-      Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| req[k] = v }
-      req["Connection"] = "keep-alive"
+      headers = {}
+      Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| headers[k] = v }
+      headers["Connection"] = "keep-alive"
       cached = @cache.read(uri)
       if !cached.nil?
-        req["If-None-Match"] = cached.etag
+        headers["If-None-Match"] = cached.etag
       end
-      res = @client.request(req)
-      status = res.code.to_i
-      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{res.to_hash}\n\tbody: #{res.body}" }
-
+      response = @http_client.request("GET", uri, {
+        headers: headers
+      })
+      status = response.status.code
+      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{response.headers}\n\tbody: #{res.to_s}" }
+      # must fully read body for persistent connections
+      body = response.to_s
       if status == 304 && !cached.nil?
         body = cached.body
       else
@@ -60,11 +70,11 @@ module LaunchDarkly
         if status < 200 || status >= 300
           raise UnexpectedResponseError.new(status)
         end
-        body = fix_encoding(res.body, res["content-type"])
-        etag = res["etag"]
+        body = fix_encoding(body, response.headers["content-type"])
+        etag = response.headers["etag"]
         @cache.write(uri, CacheEntry.new(etag, body)) if !etag.nil?
       end
-      JSON.parse(body, symbolize_names: true)
+      body
     end
 
     def fix_encoding(body, content_type)

data/lib/ldclient-rb/stream.rb

@@ -1,3 +1,5 @@
+require "ldclient-rb/impl/model/serialization"
+
 require "concurrent/atomics"
 require "json"
 require "ld-eventsource"
@@ -44,7 +46,8 @@ module LaunchDarkly
       opts = {
         headers: headers,
         read_timeout: READ_TIMEOUT_SECONDS,
-        logger: @config.logger
+        logger: @config.logger,
+        socket_factory: @config.socket_factory
       }
       log_connection_started
       @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|
@@ -82,10 +85,8 @@ module LaunchDarkly
       @config.logger.debug { "[LDClient] Stream received #{method} message: #{message.data}" }
       if method == PUT
         message = JSON.parse(message.data, symbolize_names: true)
-        @feature_store.init({
-          FEATURES => message[:data][:flags],
-          SEGMENTS => message[:data][:segments]
-        })
+        all_data = Impl::Model.make_all_store_data(message[:data])
+        @feature_store.init(all_data)
         @initialized.make_true
         @config.logger.info { "[LDClient] Stream initialized" }
         @ready.set
@@ -94,7 +95,9 @@ module LaunchDarkly
         for kind in [FEATURES, SEGMENTS]
           key = key_for_path(kind, data[:path])
           if key
-            @feature_store.upsert(kind, data[:data])
+            data = data[:data]
+            Impl::Model.postprocess_item_after_deserializing!(kind, data)
+            @feature_store.upsert(kind, data)
             break
           end
         end

data/lib/ldclient-rb/util.rb

@@ -1,5 +1,5 @@
-require "net/http"
 require "uri"
+require "http"
 
 module LaunchDarkly
   # @private
@@ -18,14 +18,18 @@ module LaunchDarkly
       end
       ret
     end
-
+    
     def self.new_http_client(uri_s, config)
-      uri = URI(uri_s)
-      client = Net::HTTP.new(uri.hostname, uri.port)
-      client.use_ssl = true if uri.scheme == "https"
-      client.open_timeout = config.connect_timeout
-      client.read_timeout = config.read_timeout
-      client
+      http_client_options = {}
+      if config.socket_factory
+        http_client_options["socket_class"] = config.socket_factory
+      end
+      return HTTP::Client.new(http_client_options)
+        .timeout({
+          read: config.read_timeout,
+          connect: config.connect_timeout
+        })
+        .persistent(uri_s)
     end
 
     def self.log_exception(logger, message, exc)

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.8.2"
+  VERSION = "6.0.0"
 end

data/spec/evaluation_detail_spec.rb

@@ -0,0 +1,135 @@
+require "spec_helper"
+
+module LaunchDarkly
+  describe "EvaluationDetail" do
+    subject { EvaluationDetail }
+
+    it "sets properties" do
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).value).to eq "x"
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).variation_index).to eq 0
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).reason).to eq EvaluationReason::off
+    end
+
+    it "checks parameter types" do
+      expect { EvaluationDetail.new(nil, nil, EvaluationReason::off) }.not_to raise_error
+      expect { EvaluationDetail.new(nil, 0, EvaluationReason::off) }.not_to raise_error
+      expect { EvaluationDetail.new(nil, "x", EvaluationReason::off) }.to raise_error(ArgumentError)
+      expect { EvaluationDetail.new(nil, 0, { kind: "OFF" }) }.to raise_error(ArgumentError)
+      expect { EvaluationDetail.new(nil, 0, nil) }.to raise_error(ArgumentError)
+    end
+
+    it "equality test" do
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).to eq EvaluationDetail.new("x", 0, EvaluationReason::off)
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("y", 0, EvaluationReason::off)
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("x", 1, EvaluationReason::off)
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("x", 0, EvaluationReason::fallthrough)
+    end
+  end
+
+  describe "EvaluationReason" do
+    subject { EvaluationReason }
+
+    values = [
+      [ EvaluationReason::off, EvaluationReason::OFF, { "kind" => "OFF" }, "OFF", nil ],
+      [ EvaluationReason::fallthrough, EvaluationReason::FALLTHROUGH,
+        { "kind" => "FALLTHROUGH" }, "FALLTHROUGH", nil ],
+      [ EvaluationReason::target_match, EvaluationReason::TARGET_MATCH,
+        { "kind" => "TARGET_MATCH" }, "TARGET_MATCH", nil ],
+      [ EvaluationReason::rule_match(1, "x"), EvaluationReason::RULE_MATCH,
+        { "kind" => "RULE_MATCH", "ruleIndex" => 1, "ruleId" => "x" }, "RULE_MATCH(1,x)",
+        [ EvaluationReason::rule_match(2, "x"), EvaluationReason::rule_match(1, "y") ] ],
+      [ EvaluationReason::prerequisite_failed("x"), EvaluationReason::PREREQUISITE_FAILED,
+        { "kind" => "PREREQUISITE_FAILED", "prerequisiteKey" => "x" }, "PREREQUISITE_FAILED(x)" ],
+      [ EvaluationReason::error(EvaluationReason::ERROR_FLAG_NOT_FOUND), EvaluationReason::ERROR,
+        { "kind" => "ERROR", "errorKind" => "FLAG_NOT_FOUND" }, "ERROR(FLAG_NOT_FOUND)" ]
+    ]
+    values.each_index do |i|
+      params = values[i]
+      reason = params[0]
+      kind = params[1]
+      json_rep = params[2]
+      brief_str = params[3]
+      unequal_values = params[4]
+
+      describe "reason #{reason.kind}" do
+        it "has correct kind" do
+          expect(reason.kind).to eq kind
+        end
+
+        it "equality to self" do
+          expect(reason).to eq reason
+        end
+
+        it "inequality to others" do
+          values.each_index do |j|
+            if i != j
+              expect(reason).not_to eq values[j][0]
+            end
+          end
+          if !unequal_values.nil?
+            unequal_values.each do |v|
+              expect(reason).not_to eq v
+            end
+          end
+        end
+
+        it "JSON representation" do
+          expect(JSON.parse(reason.as_json.to_json)).to eq json_rep
+          expect(JSON.parse(reason.to_json)).to eq json_rep
+        end
+
+        it "brief representation" do
+          expect(reason.inspect).to eq brief_str
+          expect(reason.to_s).to eq brief_str
+        end
+      end
+    end
+
+    it "reuses singleton reasons" do
+      expect(EvaluationReason::off).to be EvaluationReason::off
+      expect(EvaluationReason::fallthrough).to be EvaluationReason::fallthrough
+      expect(EvaluationReason::target_match).to be EvaluationReason::target_match
+      expect(EvaluationReason::rule_match(1, 'x')).not_to be EvaluationReason::rule_match(1, 'x')
+      expect(EvaluationReason::prerequisite_failed('x')).not_to be EvaluationReason::prerequisite_failed('x')
+      errors = [ EvaluationReason::ERROR_CLIENT_NOT_READY, EvaluationReason::ERROR_FLAG_NOT_FOUND,
+        EvaluationReason::ERROR_MALFORMED_FLAG, EvaluationReason::ERROR_USER_NOT_SPECIFIED, EvaluationReason::ERROR_EXCEPTION ]
+      errors.each do |e|
+        expect(EvaluationReason::error(e)).to be EvaluationReason::error(e)
+      end
+    end
+
+    it "supports [] with JSON property names" do
+      expect(EvaluationReason::off[:kind]).to eq "OFF"
+      expect(EvaluationReason::off[:ruleIndex]).to be nil
+      expect(EvaluationReason::off[:ruleId]).to be nil
+      expect(EvaluationReason::off[:prerequisiteKey]).to be nil
+      expect(EvaluationReason::off[:errorKind]).to be nil
+      expect(EvaluationReason::rule_match(1, "x")[:ruleIndex]).to eq 1
+      expect(EvaluationReason::rule_match(1, "x")[:ruleId]).to eq "x"
+      expect(EvaluationReason::prerequisite_failed("x")[:prerequisiteKey]).to eq "x"
+      expect(EvaluationReason::error(EvaluationReason::ERROR_FLAG_NOT_FOUND)[:errorKind]).to eq "FLAG_NOT_FOUND"
+    end
+
+    it "freezes string properties" do
+      rm = EvaluationReason::rule_match(1, "x")
+      expect { rm.rule_id.upcase! }.to raise_error(RuntimeError)
+      pf = EvaluationReason::prerequisite_failed("x")
+      expect { pf.prerequisite_key.upcase! }.to raise_error(RuntimeError)
+    end
+
+    it "checks parameter types" do
+      expect { EvaluationReason::rule_match(nil, "x") }.to raise_error(ArgumentError)
+      expect { EvaluationReason::rule_match(true, "x") }.to raise_error(ArgumentError)
+      expect { EvaluationReason::rule_match(1, nil) }.not_to raise_error # we allow nil rule_id for backward compatibility
+      expect { EvaluationReason::rule_match(1, 9) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::prerequisite_failed(nil) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::prerequisite_failed(9) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::error(nil) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::error(9) }.to raise_error(ArgumentError)
+    end
+
+    it "does not allow direct access to constructor" do
+      expect { EvaluationReason.new(:off, nil, nil, nil, nil) }.to raise_error(NoMethodError)
+    end
+  end
+end