launchdarkly-server-sdk 6.3.4 → 7.0.0

data/lib/ldclient-rb/impl/model/segment.rb

@@ -0,0 +1,126 @@
+require "ldclient-rb/impl/model/clause"
+require "ldclient-rb/impl/model/preprocessed_data"
+require "set"
+
+# See serialization.rb for implementation notes on the data model classes.
+
+module LaunchDarkly
+  module Impl
+    module Model
+      class Segment
+        # @param data [Hash]
+        # @param logger [Logger|nil]
+        def initialize(data, logger = nil)
+          raise ArgumentError, "expected hash but got #{data.class}" unless data.is_a?(Hash)
+          @data = data
+          @key = data[:key]
+          @version = data[:version]
+          @deleted = !!data[:deleted]
+          return if @deleted
+          @included = data[:included] || []
+          @excluded = data[:excluded] || []
+          @included_contexts = (data[:includedContexts] || []).map do |target_data|
+            SegmentTarget.new(target_data)
+          end
+          @excluded_contexts = (data[:excludedContexts] || []).map do |target_data|
+            SegmentTarget.new(target_data)
+          end
+          @rules = (data[:rules] || []).map do |rule_data|
+            SegmentRule.new(rule_data, logger)
+          end
+          @unbounded = !!data[:unbounded]
+          @unbounded_context_kind = data[:unboundedContextKind] || LDContext::KIND_DEFAULT
+          @generation = data[:generation]
+          @salt = data[:salt]
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [String]
+        attr_reader :key
+        # @return [Integer]
+        attr_reader :version
+        # @return [Boolean]
+        attr_reader :deleted
+        # @return [Array<String>]
+        attr_reader :included
+        # @return [Array<String>]
+        attr_reader :excluded
+        # @return [Array<LaunchDarkly::Impl::Model::SegmentTarget>]
+        attr_reader :included_contexts
+        # @return [Array<LaunchDarkly::Impl::Model::SegmentTarget>]
+        attr_reader :excluded_contexts
+        # @return [Array<SegmentRule>]
+        attr_reader :rules
+        # @return [Boolean]
+        attr_reader :unbounded
+        # @return [String]
+        attr_reader :unbounded_context_kind
+        # @return [Integer|nil]
+        attr_reader :generation
+        # @return [String]
+        attr_reader :salt
+
+        # This method allows us to read properties of the object as if it's just a hash. Currently this is
+        # necessary because some data store logic is still written to expect hashes; we can remove it once
+        # we migrate entirely to using attributes of the class.
+        def [](key)
+          @data[key]
+        end
+
+        def ==(other)
+          other.is_a?(Segment) && other.data == self.data
+        end
+
+        def as_json(*) # parameter is unused, but may be passed if we're using the json gem
+          @data
+        end
+
+        # Same as as_json, but converts the JSON structure into a string.
+        def to_json(*a)
+          as_json.to_json(a)
+        end
+      end
+
+      class SegmentTarget
+        def initialize(data)
+          @data = data
+          @context_kind = data[:contextKind]
+          @values = Set.new(data[:values] || [])
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [String]
+        attr_reader :context_kind
+        # @return [Set]
+        attr_reader :values
+      end
+
+      class SegmentRule
+        def initialize(data, logger)
+          @data = data
+          @clauses = (data[:clauses] || []).map do |clause_data|
+            Clause.new(clause_data, logger)
+          end
+          @weight = data[:weight]
+          @bucket_by = data[:bucketBy]
+          @rollout_context_kind = data[:rolloutContextKind]
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [Array<LaunchDarkly::Impl::Model::Clause>]
+        attr_reader :clauses
+        # @return [Integer|nil]
+        attr_reader :weight
+        # @return [String|nil]
+        attr_reader :bucket_by
+        # @return [String|nil]
+        attr_reader :rollout_context_kind
+      end
+
+      # Clause is defined in its own file because clauses are used by both flags and segments
+    end
+  end
+end

data/lib/ldclient-rb/impl/model/serialization.rb

@@ -1,61 +1,71 @@
+require "ldclient-rb/impl/model/feature_flag"
+require "ldclient-rb/impl/model/preprocessed_data"
+require "ldclient-rb/impl/model/segment"
+
+# General implementation notes about the data model classes in LaunchDarkly::Impl::Model--
+#
+# As soon as we receive flag/segment JSON data from LaunchDarkly (or, read it from a database), we
+# transform it into the model classes FeatureFlag, Segment, etc. The constructor of each of these
+# classes takes a hash (the parsed JSON), and transforms it into an internal representation that
+# is more efficient for evaluations.
+#
+# Validation works as follows:
+# - A property value that is of the correct type, but is invalid for other reasons (for example,
+# if a flag rule refers to variation index 5, but there are only 2 variations in the flag), does
+# not prevent the flag from being parsed and stored. It does cause a warning to be logged, if a
+# logger was passed to the constructor.
+# - If a value is completely invalid for the schema, the constructor may throw an
+# exception, causing the whole data set to be rejected. This is consistent with the behavior of
+# the strongly-typed SDKs.
+#
+# Currently, the model classes also retain the original hash of the parsed JSON. This is because
+# we may need to re-serialize them to JSON, and building the JSON on the fly would be very
+# inefficient, so each model class has a to_json method that just returns the same Hash. If we
+# are able in the future to either use a custom streaming serializer, or pass the JSON data
+# straight through from LaunchDarkly to a database instead of re-serializing, we could stop
+# retaining this data.
 
 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
+      #
+      # SDK code outside of Impl::Model should use this method instead of calling the model class
+      # constructors directly, so as not to rely on implementation details.
+      #
+      # @param kind [Hash] normally either FEATURES or SEGMENTS
+      # @param input [object] a JSON string or a parsed hash (or a data model object, in which case
+      #  we'll just return the original object)
+      # @param logger [Logger|nil] logs warnings if there are any data validation problems
+      # @return [Object] the flag or segment (or, for an unknown data kind, the data as a hash)
+      def self.deserialize(kind, input, logger = nil)
+        return nil if input.nil?
+        return input if !input.is_a?(String) && !input.is_a?(Hash)
+        data = input.is_a?(Hash) ? input : JSON.parse(input, symbolize_names: true)
+        case kind
+        when FEATURES
+          FeatureFlag.new(data, logger)
+        when SEGMENTS
+          Segment.new(data, logger)
+        else
+          data
+        end
       end
 
       # Abstraction of serializing a feature flag or segment that will be written to a data store.
-      # Currently we just call to_json.
+      # Currently we just call to_json, but SDK code outside of Impl::Model should use this method
+      # instead of to_json, so as not to rely on implementation details.
       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
+      def self.make_all_store_data(received_data, logger = nil)
+        {
+          FEATURES => (received_data[:flags] || {}).transform_values { |data| FeatureFlag.new(data, logger) },
+          SEGMENTS => (received_data[:segments] || {}).transform_values { |data| Segment.new(data, logger) },
+        }
       end
     end
   end

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

@@ -19,7 +19,7 @@ module LaunchDarkly
           if @start_delay
             sleep(@start_delay)
           end
-          while !@stopped.value do
+          until @stopped.value do
             started_at = Time.now
             begin
               @task.call

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

@@ -33,7 +33,7 @@ module LaunchDarkly
         return input if dependency_fn.nil? || input.empty?
         remaining_items = input.clone
         items_out = {}
-        while !remaining_items.empty?
+        until remaining_items.empty?
           # pick a random item that hasn't been updated yet
           key, item = remaining_items.first
           self.add_with_dependencies_first(item, dependency_fn, remaining_items, items_out)
@@ -46,7 +46,7 @@ module LaunchDarkly
         remaining_items.delete(item_key)  # we won't need to visit this item again
         dependency_fn.call(item).each do |dep_key|
           dep_item = remaining_items[dep_key.to_sym]
-          self.add_with_dependencies_first(dep_item, dependency_fn, remaining_items, items_out) if !dep_item.nil?
+          self.add_with_dependencies_first(dep_item, dependency_fn, remaining_items, items_out) unless dep_item.nil?
         end
         items_out[item_key] = item
       end

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

@@ -25,7 +25,7 @@ module LaunchDarkly
 
       def dispose_all
         @lock.synchronize {
-          @pool.map { |instance| @instance_destructor.call(instance) } if !@instance_destructor.nil?
+          @pool.map { |instance| @instance_destructor.call(instance) } unless @instance_destructor.nil?
           @pool.clear()
         }
       end

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

@@ -1,7 +1,7 @@
 module LaunchDarkly
   module Impl
     module Util
-      def self.is_bool(aObject)
+      def self.bool?(aObject)
          [true,false].include? aObject
       end
 
@@ -15,8 +15,66 @@ module LaunchDarkly
           ret["X-LaunchDarkly-Wrapper"] = config.wrapper_name +
             (config.wrapper_version ? "/" + config.wrapper_version : "")
         end
+
+        app_value = application_header_value config.application
+        ret["X-LaunchDarkly-Tags"] = app_value unless app_value.nil? || app_value.empty?
+
         ret
       end
+
+      #
+      # Generate an HTTP Header value containing the application meta information (@see #application).
+      #
+      # @return [String]
+      #
+      def self.application_header_value(application)
+        parts = []
+        unless  application[:id].empty?
+          parts << "application-id/#{application[:id]}"
+        end
+
+        unless  application[:version].empty?
+          parts << "application-version/#{application[:version]}"
+        end
+
+        parts.join(" ")
+      end
+
+      #
+      # @param value [String]
+      # @param name [Symbol]
+      # @param logger [Logger]
+      # @return [String]
+      #
+      def self.validate_application_value(value, name, logger)
+        value = value.to_s
+
+        return "" if value.empty?
+
+        if value.length > 64
+          logger.warn { "Value of application[#{name}] was longer than 64 characters and was discarded" }
+          return ""
+        end
+
+        if /[^a-zA-Z0-9._-]/.match?(value)
+          logger.warn { "Value of application[#{name}] contained invalid characters and was discarded" }
+          return ""
+        end
+
+        value
+      end
+
+      #
+      # @param app [Hash]
+      # @param logger [Logger]
+      # @return [Hash]
+      #
+      def self.validate_application_info(app, logger)
+        {
+          id: validate_application_value(app[:id], :id, logger),
+          version: validate_application_value(app[:version], :version, logger),
+        }
+      end
     end
   end
 end

data/lib/ldclient-rb/in_memory_store.rb

@@ -14,13 +14,13 @@ module LaunchDarkly
   FEATURES = {
     namespace: "features",
     priority: 1,  # that is, features should be stored after segments
-    get_dependency_keys: lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }
+    get_dependency_keys: lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } },
   }.freeze
 
   # @private
   SEGMENTS = {
     namespace: "segments",
-    priority: 0
+    priority: 0,
   }.freeze
 
   #

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

@@ -38,7 +38,7 @@ module LaunchDarkly
       #
       def self.new_feature_store(opts = {})
         core = LaunchDarkly::Impl::Integrations::Consul::ConsulFeatureStoreCore.new(opts)
-        return LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
+        LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
       end
     end
   end

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

@@ -54,7 +54,7 @@ module LaunchDarkly
       #
       # Creates a DynamoDB-backed Big Segment store.
       #
-      # Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+      # Big Segments are a specific type of segments. For more information, read the LaunchDarkly
       # documentation: https://docs.launchdarkly.com/home/users/big-segments
       #
       # To use this method, you must first install one of the AWS SDK gems: either `aws-sdk-dynamodb`, or

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

@@ -25,7 +25,7 @@ module LaunchDarkly
     #
     # - `flags`: Feature flag definitions.
     # - `flagValues`: Simplified feature flags that contain only a value.
-    # - `segments`: User segment definitions.
+    # - `segments`: Context segment definitions.
     #
     # The format of the data in `flags` and `segments` is defined by the LaunchDarkly application
     # and is subject to change. Rather than trying to construct these objects yourself, it is simpler
@@ -78,7 +78,7 @@ module LaunchDarkly
     # same flag key or segment key more than once, either in a single file or across multiple files.
     #
     # If the data source encounters any error in any file-- malformed content, a missing file, or a
-    # duplicate key-- it will not load flags from any of the files.      
+    # duplicate key-- it will not load flags from any of the files.
     #
     module FileData
       #
@@ -100,7 +100,7 @@ module LaunchDarkly
       # @return an object that can be stored in {Config#data_source}
       #
       def self.data_source(options={})
-        return lambda { |sdk_key, config|
+        lambda { |sdk_key, config|
           Impl::Integrations::FileDataSourceImpl.new(config.feature_store, config.logger, options) }
       end
     end

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

@@ -1,4 +1,4 @@
-require "ldclient-rb/redis_store"  # eventually we will just refer to impl/integrations/redis_impl directly
+require "ldclient-rb/impl/integrations/redis_impl"
 
 module LaunchDarkly
   module Integrations
@@ -59,13 +59,13 @@ module LaunchDarkly
       # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
       #
       def self.new_feature_store(opts = {})
-        return RedisFeatureStore.new(opts)
+        LaunchDarkly::Impl::Integrations::Redis::RedisFeatureStore.new(opts)
       end
 
       #
       # Creates a Redis-backed Big Segment store.
       #
-      # Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+      # Big Segments are a specific type of segments. For more information, read the LaunchDarkly
       # documentation: https://docs.launchdarkly.com/home/users/big-segments
       #
       # To use this method, you must first have the `redis` and `connection-pool` gems installed. Then,
@@ -91,7 +91,7 @@ module LaunchDarkly
       # @return [LaunchDarkly::Interfaces::BigSegmentStore]  a Big Segment store object
       #
       def self.new_big_segment_store(opts)
-        return LaunchDarkly::Impl::Integrations::Redis::RedisBigSegmentStore.new(opts)
+        LaunchDarkly::Impl::Integrations::Redis::RedisBigSegmentStore.new(opts)
       end
     end
   end