launchdarkly-server-sdk 8.8.3-java

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

@@ -0,0 +1,131 @@
+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 context_value the value of the context attribute that is referenced in the current clause (left-hand
+      #   side of the expression)
+      # @param clause_value the constant value that `context_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, context_value, clause_value)
+        case op
+        when :in
+          context_value == clause_value
+        when :startsWith
+          string_op(context_value, clause_value, lambda { |a, b| a.start_with? b })
+        when :endsWith
+          string_op(context_value, clause_value, lambda { |a, b| a.end_with? b })
+        when :contains
+          string_op(context_value, clause_value, lambda { |a, b| a.include? b })
+        when :matches
+          string_op(context_value, clause_value, lambda { |a, b|
+            begin
+              re = Regexp.new b
+              !re.match(a).nil?
+            rescue
+              false
+            end
+          })
+        when :lessThan
+          numeric_op(context_value, clause_value, lambda { |a, b| a < b })
+        when :lessThanOrEqual
+          numeric_op(context_value, clause_value, lambda { |a, b| a <= b })
+        when :greaterThan
+          numeric_op(context_value, clause_value, lambda { |a, b| a > b })
+        when :greaterThanOrEqual
+          numeric_op(context_value, clause_value, lambda { |a, b| a >= b })
+        when :before
+          date_op(context_value, clause_value, lambda { |a, b| a < b })
+        when :after
+          date_op(context_value, clause_value, lambda { |a, b| a > b })
+        when :semVerEqual
+          semver_op(context_value, clause_value, lambda { |a, b| a == b })
+        when :semVerLessThan
+          semver_op(context_value, clause_value, lambda { |a, b| a < b })
+        when :semVerGreaterThan
+          semver_op(context_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_context.
+          false
+        else
+          false
+        end
+      end
+
+      private
+
+      NUMERIC_VERSION_COMPONENTS_REGEX = Regexp.new("^[0-9.]*")
+      private_constant :NUMERIC_VERSION_COMPONENTS_REGEX
+
+      def self.string_op(context_value, clause_value, fn)
+        (context_value.is_a? String) && (clause_value.is_a? String) && fn.call(context_value, clause_value)
+      end
+
+      def self.numeric_op(context_value, clause_value, fn)
+        (context_value.is_a? Numeric) && (clause_value.is_a? Numeric) && fn.call(context_value, clause_value)
+      end
+
+      def self.date_op(context_value, clause_value, fn)
+        ud = to_date(context_value)
+        if !ud.nil?
+          cd = to_date(clause_value)
+          !cd.nil? && fn.call(ud, cd)
+        else
+          false
+        end
+      end
+
+      def self.semver_op(context_value, clause_value, fn)
+        uv = to_semver(context_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

@@ -0,0 +1,100 @@
+require "ldclient-rb/impl/unbounded_pool"
+
+require "securerandom"
+require "http"
+require "stringio"
+require "zlib"
+
+module LaunchDarkly
+  module Impl
+    EventSenderResult = Struct.new(:success, :must_shutdown, :time_from_server)
+
+    class EventSender
+      CURRENT_SCHEMA_VERSION = 4
+      DEFAULT_RETRY_INTERVAL = 1
+
+      def initialize(sdk_key, config, http_client = nil, retry_interval = DEFAULT_RETRY_INTERVAL)
+        @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
+        begin
+          http_client = @http_client_pool.acquire()
+          response = nil
+          2.times do |attempt|
+            if attempt > 0
+              @logger.warn { "[LDClient] Will retry posting events after #{@retry_interval} second" }
+              sleep(@retry_interval)
+            end
+            begin
+              @logger.debug { "[LDClient] sending #{description}: #{event_data}" }
+              headers = {}
+              headers["content-type"] = "application/json"
+              headers["content-encoding"] = "gzip" if @config.compress_events
+              Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| headers[k] = v }
+              unless is_diagnostic
+                headers["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
+                headers["X-LaunchDarkly-Payload-ID"] = payload_id
+              end
+
+              body = event_data
+              if @config.compress_events
+                gzip = Zlib::GzipWriter.new(StringIO.new)
+                gzip << event_data
+
+                body = gzip.close.string
+              end
+
+              response = http_client.request("POST", uri, {
+                headers: headers,
+                body: body,
+              })
+            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
+              unless response.headers["date"].nil?
+                begin
+                  res_time = Time.httpdate(response.headers["date"])
+                rescue ArgumentError
+                  # Ignored
+                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
+          end
+          # used up our retries
+          EventSenderResult.new(false, false, nil)
+        ensure
+          @http_client_pool.release(http_client)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require "ldclient-rb/impl/event_types"
+require "set"
+
+module LaunchDarkly
+  module Impl
+    EventSummary = Struct.new(:start_date, :end_date, :counters)
+
+    EventSummaryFlagInfo = Struct.new(:default, :versions, :context_kinds)
+
+    EventSummaryFlagVariationCounter = Struct.new(:value, :count)
+
+    # Manages the state of summarizable information for the EventProcessor, including the
+    # event counters and context 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 unless 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, Set.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
+
+        counters_for_flag.context_kinds.merge(event.context.kinds)
+
+        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
+        unless 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
+        EventSummary.new(@start_date, @end_date, @counters)
+      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,136 @@
+require 'set'
+
+module LaunchDarkly
+  module Impl
+    class Event
+      # @param timestamp [Integer]
+      # @param context [LaunchDarkly::LDContext]
+      # @param sampling_ratio [Integer, nil]
+      # @param exclude_from_summaries [Boolean]
+      def initialize(timestamp, context, sampling_ratio = nil, exclude_from_summaries = false)
+        @timestamp = timestamp
+        @context = context
+        @sampling_ratio = sampling_ratio
+        @exclude_from_summaries = exclude_from_summaries
+      end
+
+      # @return [Integer]
+      attr_reader :timestamp
+      # @return [LaunchDarkly::LDContext]
+      attr_reader :context
+      # @return [Integer, nil]
+      attr_reader :sampling_ratio
+      # @return [Boolean]
+      attr_reader :exclude_from_summaries
+    end
+
+    class EvalEvent < Event
+      def initialize(timestamp, context, key, version = nil, variation = nil, value = nil, reason = nil, default = nil,
+        track_events = false, debug_until = nil, prereq_of = nil, sampling_ratio = nil, exclude_from_summaries = false)
+        super(timestamp, context, sampling_ratio, exclude_from_summaries)
+        @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 MigrationOpEvent < Event
+      #
+      # A migration op event represents the results of a migration-assisted read or write operation.
+      #
+      # The event includes optional measurements reporting on consistency checks, error reporting, and operation latency
+      # values.
+      #
+      # @param timestamp [Integer]
+      # @param context [LaunchDarkly::LDContext]
+      # @param key [string]
+      # @param flag [LaunchDarkly::Impl::Model::FeatureFlag, nil]
+      # @param operation [Symbol]
+      # @param default_stage [Symbol]
+      # @param evaluation [LaunchDarkly::EvaluationDetail]
+      # @param invoked [Set]
+      # @param consistency_check [Boolean, nil]
+      # @param consistency_check_ratio [Integer, nil]
+      # @param errors [Set]
+      # @param latencies [Hash<Symbol, Float>]
+      #
+      def initialize(timestamp, context, key, flag, operation, default_stage, evaluation, invoked, consistency_check, consistency_check_ratio, errors, latencies)
+        super(timestamp, context)
+        @operation = operation
+        @key = key
+        @version = flag&.version
+        @sampling_ratio = flag&.sampling_ratio
+        @default = default_stage
+        @evaluation = evaluation
+        @consistency_check = consistency_check
+        @consistency_check_ratio = consistency_check.nil? ? nil : consistency_check_ratio
+        @invoked = invoked
+        @errors = errors
+        @latencies = latencies
+      end
+
+      attr_reader :operation
+      attr_reader :key
+      attr_reader :version
+      attr_reader :sampling_ratio
+      attr_reader :default
+      attr_reader :evaluation
+      attr_reader :consistency_check
+      attr_reader :consistency_check_ratio
+      attr_reader :invoked
+      attr_reader :errors
+      attr_reader :latencies
+    end
+
+    class IdentifyEvent < Event
+      def initialize(timestamp, context)
+        super(timestamp, context)
+      end
+    end
+
+    class CustomEvent < Event
+      def initialize(timestamp, context, key, data = nil, metric_value = nil)
+        super(timestamp, context)
+        @key = key
+        @data = data unless data.nil?
+        @metric_value = metric_value unless metric_value.nil?
+      end
+
+      attr_reader :key
+      attr_reader :data
+      attr_reader :metric_value
+    end
+
+    class IndexEvent < Event
+      def initialize(timestamp, context)
+        super(timestamp, context)
+      end
+    end
+
+    class DebugEvent < Event
+      def initialize(eval_event)
+        super(eval_event.timestamp, eval_event.context)
+        @eval_event = eval_event
+      end
+
+      attr_reader :eval_event
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "concurrent"
+require "ldclient-rb/interfaces"
+require "forwardable"
+
+module LaunchDarkly
+  module Impl
+    class FlagTracker
+      include LaunchDarkly::Interfaces::FlagTracker
+
+      extend Forwardable
+      def_delegators :@broadcaster, :add_listener, :remove_listener
+
+      def initialize(broadcaster, eval_fn)
+        @broadcaster = broadcaster
+        @eval_fn = eval_fn
+      end
+
+      def add_flag_value_change_listener(key, context, listener)
+        flag_change_listener = FlagValueChangeAdapter.new(key, context, listener, @eval_fn)
+        add_listener(flag_change_listener)
+
+        flag_change_listener
+      end
+
+      #
+      # An adapter which turns a normal flag change listener into a flag value change listener.
+      #
+      class FlagValueChangeAdapter
+        # @param [Symbol] flag_key
+        # @param [LaunchDarkly::LDContext] context
+        # @param [#update] listener
+        # @param [#call] eval_fn
+        def initialize(flag_key, context, listener, eval_fn)
+          @flag_key = flag_key
+          @context = context
+          @listener = listener
+          @eval_fn = eval_fn
+          @value = Concurrent::AtomicReference.new(@eval_fn.call(@flag_key, @context))
+        end
+
+        #
+        # @param [LaunchDarkly::Interfaces::FlagChange] flag_change
+        #
+        def update(flag_change)
+          return unless flag_change.key == @flag_key
+
+          new_eval = @eval_fn.call(@flag_key, @context)
+          old_eval = @value.get_and_set(new_eval)
+
+          return if new_eval == old_eval
+
+          @listener.update(
+            LaunchDarkly::Interfaces::FlagValueChange.new(@flag_key, old_eval, new_eval))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+require "json"
+
+module LaunchDarkly
+  module Impl
+    module Integrations
+      module Consul
+        #
+        # Internal implementation of the Consul feature store, intended to be used with CachingStoreWrapper.
+        #
+        class ConsulFeatureStoreCore
+          begin
+            require "diplomat"
+            CONSUL_ENABLED = true
+          rescue ScriptError, StandardError
+            CONSUL_ENABLED = false
+          end
+
+          def initialize(opts)
+            unless CONSUL_ENABLED
+              raise RuntimeError.new("can't use Consul feature store without the 'diplomat' gem")
+            end
+
+            @prefix = (opts[:prefix] || LaunchDarkly::Integrations::Consul.default_prefix) + '/'
+            @logger = opts[:logger] || Config.default_logger
+            Diplomat.configuration = opts[:consul_config] unless opts[:consul_config].nil?
+            Diplomat.configuration.url = opts[:url] unless opts[:url].nil?
+            @logger.info("ConsulFeatureStore: using Consul host at #{Diplomat.configuration.url}")
+          end
+
+          def init_internal(all_data)
+            # Start by reading the existing keys; we will later delete any of these that weren't in all_data.
+            unused_old_keys = Set.new
+            keys = Diplomat::Kv.get(@prefix, { keys: true, recurse: true }, :return)
+            unused_old_keys.merge(keys) if keys != ""
+
+            ops = []
+            num_items = 0
+
+            # Insert or update every provided item
+            all_data.each do |kind, items|
+              items.values.each do |item|
+                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)
+                num_items = num_items + 1
+              end
+            end
+
+            # Now delete any previously existing items whose keys were not in the current data
+            unused_old_keys.each do |key|
+              ops.push({ 'KV' => { 'Verb' => 'delete', 'Key' => key } })
+            end
+
+            # Now set the special key that we check in initialized_internal?
+            ops.push({ 'KV' => { 'Verb' => 'set', 'Key' => inited_key, 'Value' => '' } })
+
+            ConsulUtil.batch_operations(ops)
+
+            @logger.info { "Initialized database with #{num_items} items" }
+          end
+
+          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 : Model.deserialize(kind, value)
+          end
+
+          def get_all_internal(kind)
+            items_out = {}
+            results = Diplomat::Kv.get(kind_key(kind), { recurse: true }, :return)
+            (results == "" ? [] : results).each do |result|
+              value = result[:value]
+              unless value.nil?
+                item = Model.deserialize(kind, value)
+                items_out[item[:key].to_sym] = item
+              end
+            end
+            items_out
+          end
+
+          def upsert_internal(kind, new_item)
+            key = item_key(kind, new_item[:key])
+            json = Model.serialize(kind, new_item)
+
+            # We will potentially keep retrying indefinitely until someone's write succeeds
+            while true
+              old_value = Diplomat::Kv.get(key, { decode_values: true }, :return)
+              if old_value.nil? || old_value == ""
+                mod_index = 0
+              else
+                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]
+                  return old_item
+                end
+                mod_index = old_value[0]["ModifyIndex"]
+              end
+
+              # Otherwise, try to write. We will do a compare-and-set operation, so the write will only succeed if
+              # the key's ModifyIndex is still equal to the previous value. If the previous ModifyIndex was zero,
+              # it means the key did not previously exist and the write will only succeed if it still doesn't exist.
+              success = Diplomat::Kv.put(key, json, cas: mod_index)
+              return new_item if success
+
+              # If we failed, retry the whole shebang
+              @logger.debug { "Concurrent modification detected, retrying" }
+            end
+          end
+
+          def initialized_internal?
+            # Unfortunately we need to use exceptions here, instead of the :return parameter, because with
+            # :return there's no way to distinguish between a missing value and an empty string.
+            begin
+              Diplomat::Kv.get(inited_key, {})
+              true
+            rescue Diplomat::KeyNotFound
+              false
+            end
+          end
+
+          def available?
+            # Most implementations use the initialized_internal? method as a
+            # proxy for this check. However, since `initialized_internal?`
+            # catches a KeyNotFound exception, and that exception can be raised
+            # when the server goes away, we have to modify our behavior
+            # slightly.
+            Diplomat::Kv.get(inited_key, {}, :return, :return)
+            true
+          rescue
+            false
+          end
+
+          def stop
+            # There's no Consul client instance to dispose of
+          end
+
+          private
+
+          def item_key(kind, key)
+            kind_key(kind) + key.to_s
+          end
+
+          def kind_key(kind)
+            @prefix + kind[:namespace] + '/'
+          end
+
+          def inited_key
+            @prefix + '$inited'
+          end
+        end
+
+        class ConsulUtil
+          #
+          # Submits as many transactions as necessary to submit all of the given operations.
+          # The ops array is consumed.
+          #
+          def self.batch_operations(ops)
+            batch_size = 64  # Consul can only do this many at a time
+            while true
+              chunk = ops.shift(batch_size)
+              break if chunk.empty?
+              Diplomat::Kv.txn(chunk)
+            end
+          end
+        end
+      end
+    end
+  end
+end