launchdarkly-server-sdk 6.3.1 → 6.3.4

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

@@ -0,0 +1,63 @@
+require "ldclient-rb/impl/event_types"
+
+module LaunchDarkly
+  module Impl
+    EventSummary = Struct.new(:start_date, :end_date, :counters)
+
+    EventSummaryFlagInfo = Struct.new(:default, :versions)
+
+    EventSummaryFlagVariationCounter = Struct.new(:value, :count)
+
+    # Manages the state of summarizable information for the EventProcessor, including the
+    # event counters and user deduplication. Note that the methods of this class are
+    # deliberately not thread-safe; the EventProcessor is responsible for enforcing
+    # synchronization across both the summarizer and the event queue.
+    class EventSummarizer
+      class Counter
+      end
+
+      def initialize
+        clear
+      end
+
+      # Adds this event to our counters, if it is a type of event we need to count.
+      def summarize_event(event)
+        return if !event.is_a?(LaunchDarkly::Impl::EvalEvent)
+
+        counters_for_flag = @counters[event.key]
+        if counters_for_flag.nil?
+          counters_for_flag = EventSummaryFlagInfo.new(event.default, Hash.new)
+          @counters[event.key] = counters_for_flag
+        end
+        counters_for_flag_version = counters_for_flag.versions[event.version]
+        if counters_for_flag_version.nil?
+          counters_for_flag_version = Hash.new
+          counters_for_flag.versions[event.version] = counters_for_flag_version
+        end
+        variation_counter = counters_for_flag_version[event.variation]
+        if variation_counter.nil?
+          counters_for_flag_version[event.variation] = EventSummaryFlagVariationCounter.new(event.value, 1)
+        else
+          variation_counter.count = variation_counter.count + 1
+        end
+        time = event.timestamp
+        if !time.nil?
+          @start_date = time if @start_date == 0 || time < @start_date
+          @end_date = time if time > @end_date
+        end
+      end
+
+      # Returns a snapshot of the current summarized event data, and resets this state.
+      def snapshot
+        ret = EventSummary.new(@start_date, @end_date, @counters)
+        ret
+      end
+
+      def clear
+        @start_date = 0
+        @end_date = 0
+        @counters = {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module LaunchDarkly
+  module Impl
+    class Event
+      def initialize(timestamp, user)
+        @timestamp = timestamp
+        @user = user
+      end
+
+      attr_reader :timestamp
+      attr_reader :kind
+      attr_reader :user
+    end
+
+    class EvalEvent < Event
+      def initialize(timestamp, user, key, version = nil, variation = nil, value = nil, reason = nil, default = nil,
+        track_events = false, debug_until = nil, prereq_of = nil)
+        super(timestamp, user)
+        @key = key
+        @version = version
+        @variation = variation
+        @value = value
+        @reason = reason
+        @default = default
+        # avoid setting rarely-used attributes if they have no value - this saves a little space per instance
+        @track_events = track_events if track_events
+        @debug_until = debug_until if debug_until
+        @prereq_of = prereq_of if prereq_of
+      end
+
+      attr_reader :key
+      attr_reader :version
+      attr_reader :variation
+      attr_reader :value
+      attr_reader :reason
+      attr_reader :default
+      attr_reader :track_events
+      attr_reader :debug_until
+      attr_reader :prereq_of
+    end
+
+    class IdentifyEvent < Event
+      def initialize(timestamp, user)
+        super(timestamp, user)
+      end
+    end
+
+    class CustomEvent < Event
+      def initialize(timestamp, user, key, data = nil, metric_value = nil)
+        super(timestamp, user)
+        @key = key
+        @data = data if !data.nil?
+        @metric_value = metric_value if !metric_value.nil?
+      end
+
+      attr_reader :key
+      attr_reader :data
+      attr_reader :metric_value
+    end
+
+    class AliasEvent < Event
+      def initialize(timestamp, key, context_kind, previous_key, previous_context_kind)
+        super(timestamp, nil)
+        @key = key
+        @context_kind = context_kind
+        @previous_key = previous_key
+        @previous_context_kind = previous_context_kind
+      end
+
+      attr_reader :key
+      attr_reader :context_kind
+      attr_reader :previous_key
+      attr_reader :previous_context_kind
+    end
+
+    class IndexEvent < Event
+      def initialize(timestamp, user)
+        super(timestamp, user)
+      end
+    end
+
+    class DebugEvent < Event
+      def initialize(eval_event)
+        super(eval_event.timestamp, eval_event.user)
+        @eval_event = eval_event
+      end
+
+      attr_reader :eval_event
+    end
+  end
+end

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

@@ -35,7 +35,7 @@ module LaunchDarkly
               @client = Aws::DynamoDB::Client.new(opts[:dynamodb_opts] || {})
             end
   
-            @logger.info("${description}: using DynamoDB table \"#{table_name}\"")
+            @logger.info("#{description}: using DynamoDB table \"#{table_name}\"")
           end
   
           def stop

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

@@ -36,7 +36,7 @@ module LaunchDarkly
       # @option opts [Integer] :capacity (1000)  maximum number of items in the cache
       # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
       #
-      def self.new_feature_store(opts, &block)
+      def self.new_feature_store(opts = {})
         core = LaunchDarkly::Impl::Integrations::Consul::ConsulFeatureStoreCore.new(opts)
         return LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
       end

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

@@ -46,7 +46,7 @@ module LaunchDarkly
       # @option opts [Integer] :capacity (1000)  maximum number of items in the cache
       # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
       #
-      def self.new_feature_store(table_name, opts)
+      def self.new_feature_store(table_name, opts = {})
         core = LaunchDarkly::Impl::Integrations::DynamoDB::DynamoDBFeatureStoreCore.new(table_name, opts)
         LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
       end

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

@@ -58,7 +58,7 @@ module LaunchDarkly
       #   lifecycle to be independent of the SDK client
       # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
       #
-      def self.new_feature_store(opts)
+      def self.new_feature_store(opts = {})
         return RedisFeatureStore.new(opts)
       end
 

data/lib/ldclient-rb/ldclient.rb

@@ -1,7 +1,6 @@
 require "ldclient-rb/impl/big_segments"
 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"
 require "digest/sha1"
@@ -46,9 +45,6 @@ module LaunchDarkly
 
       @sdk_key = sdk_key
 
-      @event_factory_default = EventFactory.new(false)
-      @event_factory_with_reasons = EventFactory.new(true)
-
       # We need to wrap the feature store object with a FeatureStoreClientWrapper in order to add
       # some necessary logic around updates. Unfortunately, we have code elsewhere that accesses
       # the feature store through the Config object, so we need to make a new Config that uses
@@ -65,7 +61,7 @@ module LaunchDarkly
       get_segment = lambda { |key| @store.get(SEGMENTS, key) }
       get_big_segments_membership = lambda { |key| @big_segment_store_manager.get_user_membership(key) }
       @evaluator = LaunchDarkly::Impl::Evaluator.new(get_flag, get_segment, get_big_segments_membership, @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
@@ -178,7 +174,7 @@ module LaunchDarkly
     # Other supported user attributes include IP address, country code, and an arbitrary hash of
     # custom attributes. For more about the supported user properties and how they work in
     # LaunchDarkly, see [Targeting users](https://docs.launchdarkly.com/home/flags/targeting-users).
-    # 
+    #
     # The optional `:privateAttributeNames` user property allows you to specify a list of
     # attribute names that should not be sent back to LaunchDarkly.
     # [Private attributes](https://docs.launchdarkly.com/home/users/attributes#creating-private-user-attributes)
@@ -202,7 +198,7 @@ module LaunchDarkly
     # @return the variation to show the user, or the default value if there's an an error
     #
     def variation(key, user, default)
-      evaluate_internal(key, user, default, @event_factory_default).value
+      evaluate_internal(key, user, default, false).value
     end
 
     #
@@ -229,7 +225,7 @@ module LaunchDarkly
     # @return [EvaluationDetail] an object describing the result
     #
     def variation_detail(key, user, default)
-      evaluate_internal(key, user, default, @event_factory_with_reasons)
+      evaluate_internal(key, user, default, true)
     end
 
     #
@@ -248,12 +244,12 @@ module LaunchDarkly
     # @return [void]
     #
     def identify(user)
-      if !user || user[:key].nil?
-        @config.logger.warn("Identify called with nil user or nil user key!")
+      if !user || user[:key].nil? || user[:key].empty?
+        @config.logger.warn("Identify called with nil user or empty user key!")
         return
       end
       sanitize_user(user)
-      @event_processor.add_event(@event_factory_default.new_identify_event(user))
+      @event_processor.record_identify_event(user)
     end
 
     #
@@ -284,7 +280,7 @@ module LaunchDarkly
         return
       end
       sanitize_user(user)
-      @event_processor.add_event(@event_factory_default.new_custom_event(event_name, user, data, metric_value))
+      @event_processor.record_custom_event(user, event_name, data, metric_value)
     end
 
     #
@@ -301,7 +297,7 @@ module LaunchDarkly
       end
       sanitize_user(current_context)
       sanitize_user(previous_context)
-      @event_processor.add_event(@event_factory_default.new_alias_event(current_context, previous_context))
+      @event_processor.record_alias_event(current_context, previous_context)
     end
 
     #
@@ -338,6 +334,15 @@ module LaunchDarkly
     def all_flags_state(user, options={})
       return FeatureFlagsState.new(false) if @config.offline?
 
+      if !initialized?
+        if @store.initialized?
+            @config.logger.warn { "Called all_flags_state before client initialization; using last known values from data store" }
+        else
+            @config.logger.warn { "Called all_flags_state before client initialization. Data store not available; returning empty state" }
+            return FeatureFlagsState.new(false)
+        end
+      end
+
       unless user && !user[:key].nil?
         @config.logger.error { "[LDClient] User and user key must be specified in all_flags_state" }
         return FeatureFlagsState.new(false)
@@ -359,14 +364,25 @@ module LaunchDarkly
           next
         end
         begin
-          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)
+          detail = @evaluator.evaluate(f, user).detail
         rescue => exn
+          detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_EXCEPTION))
           Util.log_exception(@config.logger, "Error evaluating flag \"#{k}\" in all_flags_state", exn)
-          state.add_flag(f, nil, nil, with_reasons ? EvaluationReason::error(EvaluationReason::ERROR_EXCEPTION) : nil,
-            details_only_if_tracked)
         end
+
+        requires_experiment_data = is_experiment(f, detail.reason)
+        flag_state = {
+          key: f[:key],
+          value: detail.value,
+          variation: detail.variation_index,
+          reason: detail.reason,
+          version: f[:version],
+          trackEvents: f[:trackEvents] || requires_experiment_data,
+          trackReason: requires_experiment_data,
+          debugEventsUntilDate: f[:debugEventsUntilDate],
+        }
+
+        state.add_flag(flag_state, with_reasons, details_only_if_tracked)
       end
 
       state
@@ -410,7 +426,7 @@ module LaunchDarkly
     end
 
     # @return [EvaluationDetail]
-    def evaluate_internal(key, user, default, event_factory)
+    def evaluate_internal(key, user, default, with_reasons)
       if @config.offline?
         return Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default)
       end
@@ -433,7 +449,7 @@ module LaunchDarkly
         else
           @config.logger.error { "[LDClient] Client has not finished initializing; feature store unavailable, returning default value" }
           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))
+          record_unknown_flag_eval(key, user, default, detail.reason, with_reasons)
           return  detail
         end
       end
@@ -443,32 +459,94 @@ module LaunchDarkly
       if feature.nil?
         @config.logger.info { "[LDClient] Unknown feature flag \"#{key}\". Returning default value" }
         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))
+        record_unknown_flag_eval(key, user, default, detail.reason, with_reasons)
         return detail
       end
 
       begin
-        res = @evaluator.evaluate(feature, user, event_factory)
-        if !res.events.nil?
-          res.events.each do |event|
-            @event_processor.add_event(event)
+        res = @evaluator.evaluate(feature, user)
+        if !res.prereq_evals.nil?
+          res.prereq_evals.each do |prereq_eval|
+            record_prereq_flag_eval(prereq_eval.prereq_flag, prereq_eval.prereq_of_flag, user, prereq_eval.detail, with_reasons)
           end
         end
         detail = res.detail
         if detail.default_value?
           detail = EvaluationDetail.new(default, nil, detail.reason)
         end
-        @event_processor.add_event(event_factory.new_eval_event(feature, user, detail, default))
+        record_flag_eval(feature, user, detail, default, with_reasons)
         return detail
       rescue => exn
         Util.log_exception(@config.logger, "Error evaluating feature flag \"#{key}\"", exn)
         detail = Evaluator.error_result(EvaluationReason::ERROR_EXCEPTION, default)
-        @event_processor.add_event(event_factory.new_default_event(feature, user, default, detail.reason))
+        record_flag_eval_error(feature, user, default, detail.reason, with_reasons)
         return detail
       end
     end
 
-    def sanitize_user(user)
+    private def record_flag_eval(flag, user, detail, default, with_reasons)
+      add_experiment_data = is_experiment(flag, detail.reason)
+      @event_processor.record_eval_event(
+        user,
+        flag[:key],
+        flag[:version],
+        detail.variation_index,
+        detail.value,
+        (add_experiment_data || with_reasons) ? detail.reason : nil,
+        default,
+        add_experiment_data || flag[:trackEvents] || false,
+        flag[:debugEventsUntilDate],
+        nil
+      )
+    end
+    
+    private def record_prereq_flag_eval(prereq_flag, prereq_of_flag, user, detail, with_reasons)
+      add_experiment_data = is_experiment(prereq_flag, detail.reason)
+      @event_processor.record_eval_event(
+        user,
+        prereq_flag[:key],
+        prereq_flag[:version],
+        detail.variation_index,
+        detail.value,
+        (add_experiment_data || with_reasons) ? detail.reason : nil,
+        nil,
+        add_experiment_data || prereq_flag[:trackEvents] || false,
+        prereq_flag[:debugEventsUntilDate],
+        prereq_of_flag[:key]
+      )
+    end
+    
+    private def record_flag_eval_error(flag, user, default, reason, with_reasons)
+      @event_processor.record_eval_event(user, flag[:key], flag[:version], nil, default, with_reasons ? reason : nil, default,
+        flag[:trackEvents], flag[:debugEventsUntilDate], nil)
+    end
+
+    private def record_unknown_flag_eval(flag_key, user, default, reason, with_reasons)
+      @event_processor.record_eval_event(user, flag_key, nil, nil, default, with_reasons ? reason : nil, default,
+        false, nil, nil)
+    end
+
+    private def is_experiment(flag, reason)
+      return false if !reason
+
+      if reason.in_experiment
+        return true
+      end
+
+      case reason[:kind]
+      when 'RULE_MATCH'
+        index = reason[:ruleIndex]
+        if !index.nil?
+          rules = flag[:rules] || []
+          return index >= 0 && index < rules.length && rules[index][:trackEvents]
+        end
+      when 'FALLTHROUGH'
+        return !!flag[:trackEventsFallthrough]
+      end
+      false
+    end
+
+    private def sanitize_user(user)
       if user[:key]
         user[:key] = user[:key].to_s
       end

data/lib/ldclient-rb/stream.rb

@@ -47,7 +47,8 @@ module LaunchDarkly
         headers: headers,
         read_timeout: READ_TIMEOUT_SECONDS,
         logger: @config.logger,
-        socket_factory: @config.socket_factory
+        socket_factory: @config.socket_factory,
+        reconnect_time: @config.initial_reconnect_delay
       }
       log_connection_started
       @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|

data/lib/ldclient-rb/util.rb

@@ -24,6 +24,15 @@ module LaunchDarkly
       if config.socket_factory
         http_client_options["socket_class"] = config.socket_factory
       end
+      proxy = URI.parse(uri_s).find_proxy
+      if !proxy.nil?
+        http_client_options["proxy"] = {
+          proxy_address: proxy.host,
+          proxy_port: proxy.port,
+          proxy_username: proxy.user,
+          proxy_password: proxy.password
+        }
+      end
       return HTTP::Client.new(http_client_options)
         .timeout({
           read: config.read_timeout,

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "6.3.1"
+  VERSION = "6.3.4"
 end

data/lib/ldclient-rb.rb

@@ -21,7 +21,6 @@ require "ldclient-rb/polling"
 require "ldclient-rb/user_filter"
 require "ldclient-rb/simple_lru_cache"
 require "ldclient-rb/non_blocking_thread_pool"
-require "ldclient-rb/event_summarizer"
 require "ldclient-rb/events"
 require "ldclient-rb/requestor"
 require "ldclient-rb/file_data_source"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 6.3.1
+  version: 6.3.4
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-31 00:00:00.000000000 Z
+date: 2022-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.2.33
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.2.33
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.2.1
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -254,7 +254,6 @@ files:
 - lib/ldclient-rb/cache_store.rb
 - lib/ldclient-rb/config.rb
 - lib/ldclient-rb/evaluation_detail.rb
-- lib/ldclient-rb/event_summarizer.rb
 - lib/ldclient-rb/events.rb
 - lib/ldclient-rb/expiring_cache.rb
 - lib/ldclient-rb/file_data_source.rb
@@ -265,8 +264,9 @@ files:
 - lib/ldclient-rb/impl/evaluator.rb
 - lib/ldclient-rb/impl/evaluator_bucketing.rb
 - lib/ldclient-rb/impl/evaluator_operators.rb
-- lib/ldclient-rb/impl/event_factory.rb
 - lib/ldclient-rb/impl/event_sender.rb
+- lib/ldclient-rb/impl/event_summarizer.rb
+- lib/ldclient-rb/impl/event_types.rb
 - lib/ldclient-rb/impl/integrations/consul_impl.rb
 - lib/ldclient-rb/impl/integrations/dynamodb_impl.rb
 - lib/ldclient-rb/impl/integrations/file_data_source.rb
@@ -319,7 +319,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.4
+rubygems_version: 3.3.17
 signing_key: 
 specification_version: 4
 summary: LaunchDarkly SDK for Ruby

data/lib/ldclient-rb/event_summarizer.rb

@@ -1,55 +0,0 @@
-
-module LaunchDarkly
-  # @private
-  EventSummary = Struct.new(:start_date, :end_date, :counters)
-
-  # Manages the state of summarizable information for the EventProcessor, including the
-  # event counters and user deduplication. Note that the methods of this class are
-  # deliberately not thread-safe; the EventProcessor is responsible for enforcing
-  # synchronization across both the summarizer and the event queue.
-  #
-  # @private
-  class EventSummarizer
-    def initialize
-      clear
-    end
-
-    # Adds this event to our counters, if it is a type of event we need to count.
-    def summarize_event(event)
-      if event[:kind] == "feature"
-        counter_key = {
-          key: event[:key],
-          version: event[:version],
-          variation: event[:variation]
-        }
-        c = @counters[counter_key]
-        if c.nil?
-          @counters[counter_key] = {
-            value: event[:value],
-            default: event[:default],
-            count: 1
-          }
-        else
-          c[:count] = c[:count] + 1
-        end
-        time = event[:creationDate]
-        if !time.nil?
-          @start_date = time if @start_date == 0 || time < @start_date
-          @end_date = time if time > @end_date
-        end
-      end
-    end
-
-    # Returns a snapshot of the current summarized event data, and resets this state.
-    def snapshot
-      ret = EventSummary.new(@start_date, @end_date, @counters)
-      ret
-    end
-
-    def clear
-      @start_date = 0
-      @end_date = 0
-      @counters = {}
-    end
-  end
-end