launchdarkly-server-sdk 6.2.5 → 7.0.0

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

@@ -0,0 +1,117 @@
+require "ldclient-rb/config"
+require "ldclient-rb/expiring_cache"
+require "ldclient-rb/impl/repeating_task"
+require "ldclient-rb/interfaces"
+require "ldclient-rb/util"
+
+require "digest"
+
+module LaunchDarkly
+  module Impl
+    BigSegmentMembershipResult = Struct.new(:membership, :status)
+
+    class BigSegmentStoreManager
+      # use this as a singleton whenever a membership query returns nil; it's safe to reuse it because
+      # we will never modify the membership properties after they're queried
+      EMPTY_MEMBERSHIP = {}
+
+      def initialize(big_segments_config, logger)
+        @store = big_segments_config.store
+        @stale_after_millis = big_segments_config.stale_after * 1000
+        @status_provider = BigSegmentStoreStatusProviderImpl.new(-> { get_status })
+        @logger = logger
+        @last_status = nil
+
+        unless @store.nil?
+          @cache = ExpiringCache.new(big_segments_config.user_cache_size, big_segments_config.user_cache_time)
+          @poll_worker = RepeatingTask.new(big_segments_config.status_poll_interval, 0, -> { poll_store_and_update_status }, logger)
+          @poll_worker.start
+        end
+      end
+
+      attr_reader :status_provider
+
+      def stop
+        @poll_worker.stop unless @poll_worker.nil?
+        @store.stop unless @store.nil?
+      end
+
+      def get_context_membership(context_key)
+        return nil unless @store
+        membership = @cache[context_key]
+        unless membership
+          begin
+            membership = @store.get_membership(BigSegmentStoreManager.hash_for_context_key(context_key))
+            membership = EMPTY_MEMBERSHIP if membership.nil?
+            @cache[context_key] = membership
+          rescue => e
+            LaunchDarkly::Util.log_exception(@logger, "Big Segment store membership query returned error", e)
+            return BigSegmentMembershipResult.new(nil, BigSegmentsStatus::STORE_ERROR)
+          end
+        end
+        poll_store_and_update_status unless @last_status
+        unless @last_status.available
+          return BigSegmentMembershipResult.new(membership, BigSegmentsStatus::STORE_ERROR)
+        end
+        BigSegmentMembershipResult.new(membership, @last_status.stale ? BigSegmentsStatus::STALE : BigSegmentsStatus::HEALTHY)
+      end
+
+      def get_status
+        @last_status || poll_store_and_update_status
+      end
+
+      def poll_store_and_update_status
+        new_status = Interfaces::BigSegmentStoreStatus.new(false, false) # default to "unavailable" if we don't get a new status below
+        unless @store.nil?
+          begin
+            metadata = @store.get_metadata
+            new_status = Interfaces::BigSegmentStoreStatus.new(true, !metadata || stale?(metadata.last_up_to_date))
+          rescue => e
+            LaunchDarkly::Util.log_exception(@logger, "Big Segment store status query returned error", e)
+          end
+        end
+        @last_status = new_status
+        @status_provider.update_status(new_status)
+
+        new_status
+      end
+
+      def stale?(timestamp)
+        !timestamp || ((Impl::Util.current_time_millis - timestamp) >= @stale_after_millis)
+      end
+
+      def self.hash_for_context_key(context_key)
+        Digest::SHA256.base64digest(context_key)
+      end
+    end
+
+    #
+    # Default implementation of the BigSegmentStoreStatusProvider interface.
+    #
+    # There isn't much to this because the real implementation is in BigSegmentStoreManager - we pass in a lambda
+    # that allows us to get the current status from that class. Also, the standard Observer methods such as
+    # add_observer are provided for us because BigSegmentStoreStatusProvider mixes in Observer, so all we need to
+    # to do make notifications happen is to call the Observer methods "changed" and "notify_observers".
+    #
+    class BigSegmentStoreStatusProviderImpl
+      include LaunchDarkly::Interfaces::BigSegmentStoreStatusProvider
+
+      def initialize(status_fn)
+        @status_fn = status_fn
+        @last_status = nil
+      end
+
+      def status
+        @status_fn.call
+      end
+
+      def update_status(new_status)
+        if !@last_status || new_status != @last_status
+          @last_status = new_status
+          changed
+          notify_observers(new_status)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require "erb"
+
+module LaunchDarkly
+  module Impl
+    module Context
+      ERR_KIND_NON_STRING = 'context kind must be a string'
+      ERR_KIND_CANNOT_BE_KIND = '"kind" is not a valid context kind'
+      ERR_KIND_CANNOT_BE_MULTI = '"multi" is not a valid context kind'
+      ERR_KIND_INVALID_CHARS = 'context kind contains disallowed characters'
+
+      ERR_KEY_NON_STRING = 'context key must be a string'
+      ERR_KEY_EMPTY = 'context key must not be empty'
+
+      ERR_NAME_NON_STRING = 'context name must be a string'
+
+      ERR_ANONYMOUS_NON_BOOLEAN = 'context anonymous must be a boolean'
+
+      #
+      # We allow consumers of this SDK to provide us with either a Hash or an
+      # instance of an LDContext. This is convenient for them but not as much
+      # for us. To make the conversion slightly more convenient for us, we have
+      # created this method.
+      #
+      # @param context [Hash, LDContext]
+      # @return [LDContext]
+      #
+      def self.make_context(context)
+        return context if context.is_a?(LDContext)
+
+        LDContext.create(context)
+      end
+
+      #
+      # Returns an error message if the kind is invalid; nil otherwise.
+      #
+      # @param kind [any]
+      # @return [String, nil]
+      #
+      def self.validate_kind(kind)
+        return ERR_KIND_NON_STRING unless kind.is_a?(String)
+        return ERR_KIND_CANNOT_BE_KIND if kind == "kind"
+        return ERR_KIND_CANNOT_BE_MULTI if kind == "multi"
+        return ERR_KIND_INVALID_CHARS unless kind.match?(/^[\w.-]+$/)
+      end
+
+      #
+      # Returns an error message if the key is invalid; nil otherwise.
+      #
+      # @param key [any]
+      # @return [String, nil]
+      #
+      def self.validate_key(key)
+        return ERR_KEY_NON_STRING unless key.is_a?(String)
+        return ERR_KEY_EMPTY if key == ""
+      end
+
+      #
+      # Returns an error message if the name is invalid; nil otherwise.
+      #
+      # @param name [any]
+      # @return [String, nil]
+      #
+      def self.validate_name(name)
+        return ERR_NAME_NON_STRING unless name.nil? || name.is_a?(String)
+      end
+
+      #
+      # Returns an error message if anonymous is invalid; nil otherwise.
+      #
+      # @param anonymous [any]
+      # @param allow_nil [Boolean]
+      # @return [String, nil]
+      #
+      def self.validate_anonymous(anonymous, allow_nil)
+        return nil if anonymous.nil? && allow_nil
+        return nil if [true, false].include? anonymous
+
+        ERR_ANONYMOUS_NON_BOOLEAN
+      end
+
+      #
+      # @param kind [String]
+      # @param key [String]
+      # @return [String]
+      #
+      def self.canonicalize_key_for_kind(kind, key)
+        # When building a FullyQualifiedKey, ':' and '%' are percent-escaped;
+        # we do not use a full URL-encoding function because implementations of
+        # this are inconsistent across platforms.
+        encoded = key.gsub("%", "%25").gsub(":", "%3A")
+
+        "#{kind}:#{encoded}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+module LaunchDarkly
+  module Impl
+    class ContextFilter
+      #
+      # @param all_attributes_private [Boolean]
+      # @param private_attributes [Array<String>]
+      #
+      def initialize(all_attributes_private, private_attributes)
+        @all_attributes_private = all_attributes_private
+
+        @private_attributes = []
+        private_attributes.each do |attribute|
+          reference = LaunchDarkly::Reference.create(attribute)
+          @private_attributes << reference if reference.error.nil?
+        end
+      end
+
+      #
+      # Return a hash representation of the provided context with attribute
+      # redaction applied.
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @return [Hash]
+      #
+      def filter(context)
+        return filter_single_context(context, true) unless context.multi_kind?
+
+        filtered = {kind: 'multi'}
+        (0...context.individual_context_count).each do |i|
+          c = context.individual_context(i)
+          next if c.nil?
+
+          filtered[c.kind] = filter_single_context(c, false)
+        end
+
+        filtered
+      end
+
+      #
+      # Apply redaction rules for a single context.
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @param include_kind [Boolean]
+      # @return [Hash]
+      #
+      private def filter_single_context(context, include_kind)
+        filtered = {key: context.key}
+
+        filtered[:kind] = context.kind if include_kind
+        filtered[:anonymous] = true if context.get_value(:anonymous)
+
+        redacted = []
+        private_attributes = @private_attributes.concat(context.private_attributes)
+
+        name = context.get_value(:name)
+        if !name.nil? && !check_whole_attribute_private(:name, private_attributes, redacted)
+          filtered[:name] = name
+        end
+
+        context.get_custom_attribute_names.each do |attribute|
+          unless check_whole_attribute_private(attribute, private_attributes, redacted)
+            value = context.get_value(attribute)
+            filtered[attribute] = redact_json_value(nil, attribute, value, private_attributes, redacted)
+          end
+        end
+
+        filtered[:_meta] = {redactedAttributes: redacted} unless redacted.empty?
+
+        filtered
+      end
+
+      #
+      # Check if an entire attribute should be redacted.
+      #
+      # @param attribute [Symbol]
+      # @param private_attributes [Array<Reference>]
+      # @param redacted [Array<Symbol>]
+      # @return [Boolean]
+      #
+      private def check_whole_attribute_private(attribute, private_attributes, redacted)
+        if @all_attributes_private
+          redacted << attribute
+          return true
+        end
+
+        private_attributes.each do |private_attribute|
+          if private_attribute.component(0) == attribute && private_attribute.depth == 1
+            redacted << attribute
+            return true
+          end
+        end
+
+        false
+      end
+
+      #
+      # Apply redaction rules to the provided value.
+      #
+      # @param parent_path [Array<String>, nil]
+      # @param name [String]
+      # @param value [any]
+      # @param private_attributes [Array<Reference>]
+      # @param redacted [Array<Symbol>]
+      # @return [any]
+      #
+      private def redact_json_value(parent_path, name, value, private_attributes, redacted)
+        return value unless value.is_a?(Hash)
+
+        ret = {}
+        current_path = parent_path.clone || []
+        current_path << name
+
+        value.each do |k, v|
+          was_redacted = false
+          private_attributes.each do |private_attribute|
+            next unless private_attribute.depth == (current_path.count + 1)
+
+            component = private_attribute.component(current_path.count)
+            next unless component == k
+
+            match = true
+            (0...current_path.count).each do |i|
+              unless private_attribute.component(i) == current_path[i]
+                match = false
+                break
+              end
+            end
+
+            if match
+              redacted << private_attribute.raw_path.to_sym
+              was_redacted = true
+              break
+            end
+          end
+
+          unless was_redacted
+            ret[k] = redact_json_value(current_path, k, v, private_attributes, redacted)
+          end
+        end
+
+        ret
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module LaunchDarkly
       def self.create_diagnostic_id(sdk_key)
         {
           diagnosticId: SecureRandom.uuid,
-          sdkKeySuffix: sdk_key[-6..-1] || sdk_key
+          sdkKeySuffix: sdk_key[-6..-1] || sdk_key,
         }
       end
 
@@ -25,16 +25,16 @@ module LaunchDarkly
       end
 
       def create_init_event(config)
-        return {
+        {
           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
+          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 })
@@ -57,7 +57,7 @@ module LaunchDarkly
           droppedEvents: dropped_events,
           deduplicatedUsers: deduplicated_users,
           eventsInLastBatch: events_in_last_batch,
-          streamInits: previous_stream_inits
+          streamInits: previous_stream_inits,
         }
         @data_since_date = current_time
         event
@@ -73,12 +73,11 @@ module LaunchDarkly
           diagnosticRecordingIntervalMillis: self.seconds_to_millis(config.diagnostic_recording_interval),
           eventsCapacity: config.capacity,
           eventsFlushIntervalMillis: self.seconds_to_millis(config.flush_interval),
-          inlineUsersInEvents: config.inline_users_in_events,
           pollingIntervalMillis: self.seconds_to_millis(config.poll_interval),
           socketTimeoutMillis: self.seconds_to_millis(config.read_timeout),
           streamingDisabled: !config.stream?,
-          userKeysCapacity: config.user_keys_capacity,
-          userKeysFlushIntervalMillis: self.seconds_to_millis(config.user_keys_flush_interval),
+          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?,
         }
@@ -88,7 +87,7 @@ module LaunchDarkly
       def self.make_sdk_data(config)
         ret = {
           name: 'ruby-server-sdk',
-          version: LaunchDarkly::VERSION
+          version: LaunchDarkly::VERSION,
         }
         if config.wrapper_name
           ret[:wrapperName] = config.wrapper_name
@@ -105,7 +104,7 @@ module LaunchDarkly
           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'
+          rubyImplementation: Object.constants.include?(:RUBY_ENGINE) ? RUBY_ENGINE : 'unknown',
         }
       end