launchdarkly-server-sdk 8.8.3-java

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

@@ -0,0 +1,188 @@
+require "concurrent"
+require "forwardable"
+require "ldclient-rb/impl/dependency_tracker"
+require "ldclient-rb/interfaces"
+require "set"
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      class StatusProvider
+        include LaunchDarkly::Interfaces::DataSource::StatusProvider
+
+        extend Forwardable
+        def_delegators :@status_broadcaster, :add_listener, :remove_listener
+
+        def initialize(status_broadcaster, update_sink)
+          # @type [Broadcaster]
+          @status_broadcaster = status_broadcaster
+          # @type [UpdateSink]
+          @data_source_update_sink = update_sink
+        end
+
+        def status
+          @data_source_update_sink.current_status
+        end
+      end
+
+      class UpdateSink
+        include LaunchDarkly::Interfaces::DataSource::UpdateSink
+
+        # @return [LaunchDarkly::Interfaces::DataSource::Status]
+        attr_reader :current_status
+
+        def initialize(data_store, status_broadcaster, flag_change_broadcaster)
+          # @type [LaunchDarkly::Interfaces::FeatureStore]
+          @data_store = data_store
+          # @type [Broadcaster]
+          @status_broadcaster = status_broadcaster
+          # @type [Broadcaster]
+          @flag_change_broadcaster = flag_change_broadcaster
+          @dependency_tracker = LaunchDarkly::Impl::DependencyTracker.new
+
+          @mutex = Mutex.new
+          @current_status = LaunchDarkly::Interfaces::DataSource::Status.new(
+            LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING,
+            Time.now,
+            nil)
+        end
+
+        def init(all_data)
+          old_data = nil
+          monitor_store_update do
+            if @flag_change_broadcaster.has_listeners?
+              old_data = {}
+              LaunchDarkly::ALL_KINDS.each do |kind|
+                old_data[kind] = @data_store.all(kind)
+              end
+            end
+
+            @data_store.init(all_data)
+          end
+
+          update_full_dependency_tracker(all_data)
+
+          return if old_data.nil?
+
+          send_change_events(
+            compute_changed_items_for_full_data_set(old_data, all_data)
+          )
+        end
+
+        def upsert(kind, item)
+          monitor_store_update { @data_store.upsert(kind, item) }
+
+          # TODO(sc-197908): We only want to do this if the store successfully
+          # updates the record.
+          @dependency_tracker.update_dependencies_from(kind, item[:key], item)
+          if @flag_change_broadcaster.has_listeners?
+            affected_items = Set.new
+            @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: item[:key]})
+            send_change_events(affected_items)
+          end
+        end
+
+        def delete(kind, key, version)
+          monitor_store_update { @data_store.delete(kind, key, version) }
+
+          @dependency_tracker.update_dependencies_from(kind, key, nil)
+          if @flag_change_broadcaster.has_listeners?
+            affected_items = Set.new
+            @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: key})
+            send_change_events(affected_items)
+          end
+        end
+
+        def update_status(new_state, new_error)
+          return if new_state.nil?
+
+          status_to_broadcast = nil
+
+          @mutex.synchronize do
+            old_status = @current_status
+
+            if new_state == LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED && old_status.state == LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+              # See {LaunchDarkly::Interfaces::DataSource::UpdateSink#update_status} for more information
+              new_state = LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+            end
+
+            unless new_state == old_status.state && new_error.nil?
+              @current_status = LaunchDarkly::Interfaces::DataSource::Status.new(
+                new_state,
+                new_state == current_status.state ? current_status.state_since : Time.now,
+                new_error.nil? ? current_status.last_error : new_error
+              )
+              status_to_broadcast = current_status
+            end
+          end
+
+          @status_broadcaster.broadcast(status_to_broadcast) unless status_to_broadcast.nil?
+        end
+
+        private def update_full_dependency_tracker(all_data)
+          @dependency_tracker.reset
+          all_data.each do |kind, items|
+            items.each do |key, item|
+              @dependency_tracker.update_dependencies_from(kind, item.key, item)
+            end
+          end
+        end
+
+
+        #
+        # Method to monitor updates to the store. You provide a block to update
+        # the store. This mthod wraps that block, catching and re-raising all
+        # errors, and notifying all status listeners of the error.
+        #
+        private def monitor_store_update
+          begin
+            yield
+          rescue => e
+            error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::STORE_ERROR, 0, e.to_s, Time.now)
+            update_status(LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED, error_info)
+            raise
+          end
+        end
+
+
+        #
+        # @param [Hash] old_data
+        # @param [Hash] new_data
+        # @return [Set]
+        #
+        private def compute_changed_items_for_full_data_set(old_data, new_data)
+          affected_items = Set.new
+
+          LaunchDarkly::ALL_KINDS.each do |kind|
+            old_items = old_data[kind] || {}
+            new_items = new_data[kind] || {}
+
+            old_items.keys.concat(new_items.keys).each do |key|
+              old_item = old_items[key]
+              new_item = new_items[key]
+
+              next if old_item.nil? && new_item.nil?
+
+              if old_item.nil? || new_item.nil? || old_item[:version] < new_item[:version]
+                @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: key.to_s})
+              end
+            end
+          end
+
+          affected_items
+        end
+
+        #
+        # @param affected_items [Set]
+        #
+        private def send_change_events(affected_items)
+          affected_items.each do |item|
+            if item[:kind] == LaunchDarkly::FEATURES
+              @flag_change_broadcaster.broadcast(LaunchDarkly::Interfaces::FlagChange.new(item[:key]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+require 'concurrent'
+require "ldclient-rb/interfaces"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+
+      class DataKind
+        FEATURES = "features".freeze
+        SEGMENTS = "segments".freeze
+
+        FEATURE_PREREQ_FN = lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }.freeze
+
+        attr_reader :namespace
+        attr_reader :priority
+
+        #
+        # @param namespace [String]
+        # @param priority [Integer]
+        #
+        def initialize(namespace:, priority:)
+          @namespace = namespace
+          @priority = priority
+        end
+
+        #
+        # Maintain the same behavior when these data kinds were standard ruby hashes.
+        #
+        # @param key [Symbol]
+        # @return [Object]
+        #
+        def [](key)
+          return priority if key == :priority
+          return namespace if key == :namespace
+          return get_dependency_keys_fn() if key == :get_dependency_keys
+          nil
+        end
+
+        #
+        # Retrieve the dependency keys for a particular data kind. Right now, this is only defined for flags.
+        #
+        def get_dependency_keys_fn()
+          return nil unless @namespace == FEATURES
+
+          FEATURE_PREREQ_FN
+        end
+
+        def eql?(other)
+          other.is_a?(DataKind) && namespace == other.namespace && priority == other.priority
+        end
+
+        def hash
+          [namespace, priority].hash
+        end
+      end
+
+      class StatusProvider
+        include LaunchDarkly::Interfaces::DataStore::StatusProvider
+
+        def initialize(store, update_sink)
+          # @type [LaunchDarkly::Impl::FeatureStoreClientWrapper]
+          @store = store
+          # @type [UpdateSink]
+          @update_sink = update_sink
+        end
+
+        def status
+          @update_sink.last_status.get
+        end
+
+        def monitoring_enabled?
+          @store.monitoring_enabled?
+        end
+
+        def add_listener(listener)
+          @update_sink.broadcaster.add_listener(listener)
+        end
+
+        def remove_listener(listener)
+          @update_sink.broadcaster.remove_listener(listener)
+        end
+      end
+
+      class UpdateSink
+        include LaunchDarkly::Interfaces::DataStore::UpdateSink
+
+        # @return [LaunchDarkly::Impl::Broadcaster]
+        attr_reader :broadcaster
+
+        # @return [Concurrent::AtomicReference]
+        attr_reader :last_status
+
+        def initialize(broadcaster)
+          @broadcaster = broadcaster
+          @last_status = Concurrent::AtomicReference.new(
+            LaunchDarkly::Interfaces::DataStore::Status.new(true, false)
+          )
+        end
+
+        def update_status(status)
+          return if status.nil?
+
+          old_status = @last_status.get_and_set(status)
+          @broadcaster.broadcast(status) unless old_status == status
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module LaunchDarkly
+  module Impl
+    class DependencyTracker
+      def initialize
+        @from = {}
+        @to = {}
+      end
+
+      #
+      # Updates the dependency graph when an item has changed.
+      #
+      # @param from_kind [Object] the changed item's kind
+      # @param from_key [String] the changed item's key
+      # @param from_item [Object] the changed item
+      #
+      def update_dependencies_from(from_kind, from_key, from_item)
+        from_what = { kind: from_kind, key: from_key }
+        updated_dependencies = DependencyTracker.compute_dependencies_from(from_kind, from_item)
+
+        old_dependency_set = @from[from_what]
+        unless old_dependency_set.nil?
+          old_dependency_set.each do |kind_and_key|
+            deps_to_this_old_dep = @to[kind_and_key]
+            deps_to_this_old_dep&.delete(from_what)
+          end
+        end
+
+        @from[from_what] = updated_dependencies
+        updated_dependencies.each do |kind_and_key|
+          deps_to_this_new_dep = @to[kind_and_key]
+          if deps_to_this_new_dep.nil?
+            deps_to_this_new_dep = Set.new
+            @to[kind_and_key] = deps_to_this_new_dep
+          end
+          deps_to_this_new_dep.add(from_what)
+        end
+      end
+
+      def self.segment_keys_from_clauses(clauses)
+        clauses.flat_map do |clause|
+          if clause.op == :segmentMatch
+            clause.values.map { |value| {kind: LaunchDarkly::SEGMENTS, key: value }}
+          else
+            []
+          end
+        end
+      end
+
+      #
+      # @param from_kind [String]
+      # @param from_item [LaunchDarkly::Impl::Model::FeatureFlag, LaunchDarkly::Impl::Model::Segment]
+      # @return [Set]
+      #
+      def self.compute_dependencies_from(from_kind, from_item)
+        return Set.new if from_item.nil?
+
+        if from_kind == LaunchDarkly::FEATURES
+          prereq_keys = from_item.prerequisites.map { |prereq| {kind: from_kind, key: prereq.key} }
+          segment_keys = from_item.rules.flat_map { |rule| DependencyTracker.segment_keys_from_clauses(rule.clauses) }
+
+          results = Set.new(prereq_keys)
+          results.merge(segment_keys)
+        elsif from_kind == LaunchDarkly::SEGMENTS
+          kind_and_keys  = from_item.rules.flat_map do |rule|
+            DependencyTracker.segment_keys_from_clauses(rule.clauses)
+          end
+          Set.new(kind_and_keys)
+        else
+          Set.new
+        end
+      end
+
+      #
+      # Clear any tracked dependencies and reset the tracking state to a clean slate.
+      #
+      def reset
+        @from.clear
+        @to.clear
+      end
+
+      #
+      # Populates the given set with the union of the initial item and all items that directly or indirectly
+      # depend on it (based on the current state of the dependency graph).
+      #
+      # @param items_out [Set]
+      # @param initial_modified_item [Object]
+      #
+      def add_affected_items(items_out, initial_modified_item)
+        return if items_out.include? initial_modified_item
+
+        items_out.add(initial_modified_item)
+        affected_items = @to[initial_modified_item]
+
+        return if affected_items.nil?
+
+        affected_items.each do |affected_item|
+          add_affected_items(items_out, affected_item)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require "ldclient-rb/impl/util"
+
+require "rbconfig"
+require "securerandom"
+
+module LaunchDarkly
+  module Impl
+    class DiagnosticAccumulator
+      def self.create_diagnostic_id(sdk_key)
+        {
+          diagnosticId: SecureRandom.uuid,
+          sdkKeySuffix: sdk_key[-6..-1] || sdk_key,
+        }
+      end
+
+      def initialize(diagnostic_id)
+        @id = diagnostic_id
+        @lock = Mutex.new
+        self.reset(Util.current_time_millis)
+      end
+
+      def reset(time)
+        @data_since_date = time
+        @stream_inits = []
+      end
+
+      def create_init_event(config)
+        {
+          kind: 'diagnostic-init',
+          creationDate: Util.current_time_millis,
+          id: @id,
+          configuration: DiagnosticAccumulator.make_config_data(config),
+          sdk: DiagnosticAccumulator.make_sdk_data(config),
+          platform: DiagnosticAccumulator.make_platform_data,
+        }
+      end
+
+      def record_stream_init(timestamp, failed, duration_millis)
+        @lock.synchronize do
+          @stream_inits.push({ timestamp: timestamp, failed: failed, durationMillis: duration_millis })
+        end
+      end
+
+      def create_periodic_event_and_reset(dropped_events, deduplicated_users, events_in_last_batch)
+        previous_stream_inits = @lock.synchronize do
+          si = @stream_inits
+          @stream_inits = []
+          si
+        end
+
+        current_time = Util.current_time_millis
+        event = {
+          kind: 'diagnostic',
+          creationDate: current_time,
+          id: @id,
+          dataSinceDate: @data_since_date,
+          droppedEvents: dropped_events,
+          deduplicatedUsers: deduplicated_users,
+          eventsInLastBatch: events_in_last_batch,
+          streamInits: previous_stream_inits,
+        }
+        @data_since_date = current_time
+        event
+      end
+
+      def self.make_config_data(config)
+        ret = {
+          allAttributesPrivate: config.all_attributes_private,
+          connectTimeoutMillis: self.seconds_to_millis(config.connect_timeout),
+          customBaseURI: config.base_uri != Config.default_base_uri,
+          customEventsURI: config.events_uri != Config.default_events_uri,
+          customStreamURI: config.stream_uri != Config.default_stream_uri,
+          diagnosticRecordingIntervalMillis: self.seconds_to_millis(config.diagnostic_recording_interval),
+          eventsCapacity: config.capacity,
+          eventsFlushIntervalMillis: self.seconds_to_millis(config.flush_interval),
+          pollingIntervalMillis: self.seconds_to_millis(config.poll_interval),
+          socketTimeoutMillis: self.seconds_to_millis(config.read_timeout),
+          streamingDisabled: !config.stream?,
+          userKeysCapacity: config.context_keys_capacity,
+          userKeysFlushIntervalMillis: self.seconds_to_millis(config.context_keys_flush_interval),
+          usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY') || ENV.has_key?('HTTPS_PROXY'),
+          usingRelayDaemon: config.use_ldd?,
+        }
+        ret
+      end
+
+      def self.make_sdk_data(config)
+        ret = {
+          name: 'ruby-server-sdk',
+          version: LaunchDarkly::VERSION,
+        }
+        if config.wrapper_name
+          ret[:wrapperName] = config.wrapper_name
+          ret[:wrapperVersion] = config.wrapper_version
+        end
+        ret
+      end
+
+      def self.make_platform_data
+        conf = RbConfig::CONFIG
+        {
+          name: 'ruby',
+          osArch: conf['host_cpu'],
+          osName: self.normalize_os_name(conf['host_os']),
+          osVersion: 'unknown', # there seems to be no portable way to detect this in Ruby
+          rubyVersion: conf['ruby_version'],
+          rubyImplementation: Object.constants.include?(:RUBY_ENGINE) ? RUBY_ENGINE : 'unknown',
+        }
+      end
+
+      def self.normalize_os_name(name)
+        case name
+        when /linux|arch/i
+          'Linux'
+        when /darwin/i
+          'MacOS'
+        when /mswin|windows/i
+          'Windows'
+        else
+          name
+        end
+      end
+
+      def self.seconds_to_millis(s)
+        (s * 1000).to_i
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module LaunchDarkly
+  module Impl
+    #
+    # Simple helper class for returning formatted data.
+    #
+    # The variation methods make use of the new hook support. Those methods all need to return an evaluation detail, and
+    # some other unstructured bit of data.
+    #
+    class EvaluationWithHookResult
+      #
+      # Return the evaluation detail that was generated as part of the evaluation.
+      #
+      # @return [LaunchDarkly::EvaluationDetail]
+      #
+      attr_reader :evaluation_detail
+
+      #
+      # All purpose container for additional return values from the wrapping method
+      #
+      # @return [any]
+      #
+      attr_reader :results
+
+      #
+      # @param evaluation_detail [LaunchDarkly::EvaluationDetail]
+      # @param results [any]
+      #
+      def initialize(evaluation_detail, results = nil)
+        @evaluation_detail = evaluation_detail
+        @results = results
+      end
+    end
+  end
+end