launchdarkly-server-sdk 6.2.5 → 7.0.0

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

data/lib/ldclient-rb/file_data_source.rb

@@ -1,314 +0,0 @@
-require 'concurrent/atomics'
-require 'json'
-require 'yaml'
-require 'pathname'
-
-module LaunchDarkly
-  # To avoid pulling in 'listen' and its transitive dependencies for people who aren't using the
-  # file data source or who don't need auto-updating, we only enable auto-update if the 'listen'
-  # gem has been provided by the host app.
-  # @private
-  @@have_listen = false
-  begin
-    require 'listen'
-    @@have_listen = true
-  rescue LoadError
-  end
-
-  # @private
-  def self.have_listen?
-    @@have_listen
-  end
-
-  #
-  # Provides a way to use local files as a source of feature flag state. This allows using a
-  # predetermined feature flag state without an actual LaunchDarkly connection.
-  #
-  # Reading flags from a file is only intended for pre-production environments. Production
-  # environments should always be configured to receive flag updates from LaunchDarkly.
-  #
-  # To use this component, call {FileDataSource#factory}, and store its return value in the
-  # {Config#data_source} property of your LaunchDarkly client configuration. In the options
-  # to `factory`, set `paths` to the file path(s) of your data file(s):
-  #
-  #     file_source = FileDataSource.factory(paths: [ myFilePath ])
-  #     config = LaunchDarkly::Config.new(data_source: file_source)
-  #
-  # This will cause the client not to connect to LaunchDarkly to get feature flags. The
-  # client may still make network connections to send analytics events, unless you have disabled
-  # this with {Config#send_events} or {Config#offline?}.
-  #
-  # Flag data files can be either JSON or YAML. They contain an object with three possible
-  # properties:
-  #
-  # - `flags`: Feature flag definitions.
-  # - `flagValues`: Simplified feature flags that contain only a value.
-  # - `segments`: User 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
-  # to request existing flags directly from the LaunchDarkly server in JSON format, and use this
-  # output as the starting point for your file. In Linux you would do this:
-  #
-  # ```
-  #     curl -H "Authorization: YOUR_SDK_KEY" https://sdk.launchdarkly.com/sdk/latest-all
-  # ```
-  #
-  # The output will look something like this (but with many more properties):
-  #
-  #     {
-  #       "flags": {
-  #         "flag-key-1": {
-  #           "key": "flag-key-1",
-  #           "on": true,
-  #           "variations": [ "a", "b" ]
-  #         }
-  #       },
-  #       "segments": {
-  #         "segment-key-1": {
-  #           "key": "segment-key-1",
-  #           "includes": [ "user-key-1" ]
-  #         }
-  #       }
-  #     }
-  #
-  # Data in this format allows the SDK to exactly duplicate all the kinds of flag behavior supported
-  # by LaunchDarkly. However, in many cases you will not need this complexity, but will just want to
-  # set specific flag keys to specific values. For that, you can use a much simpler format:
-  #
-  #     {
-  #       "flagValues": {
-  #         "my-string-flag-key": "value-1",
-  #         "my-boolean-flag-key": true,
-  #         "my-integer-flag-key": 3
-  #       }
-  #     }
-  #
-  # Or, in YAML:
-  #
-  #     flagValues:
-  #       my-string-flag-key: "value-1"
-  #       my-boolean-flag-key: true
-  #       my-integer-flag-key: 1
-  #
-  # It is also possible to specify both "flags" and "flagValues", if you want some flags
-  # to have simple values and others to have complex behavior. However, it is an error to use the
-  # 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.      
-  #
-  class FileDataSource
-    #
-    # Returns a factory for the file data source component.
-    #
-    # @param options [Hash] the configuration options
-    # @option options [Array] :paths  The paths of the source files for loading flag data. These
-    #   may be absolute paths or relative to the current working directory.
-    # @option options [Boolean] :auto_update  True if the data source should watch for changes to
-    #   the source file(s) and reload flags whenever there is a change. Auto-updating will only
-    #   work if all of the files you specified have valid directory paths at startup time.
-    #   Note that the default implementation of this feature is based on polling the filesystem,
-    #   which may not perform well. If you install the 'listen' gem (not included by default, to
-    #   avoid adding unwanted dependencies to the SDK), its native file watching mechanism will be
-    #   used instead. However, 'listen' will not be used in JRuby 9.1 due to a known instability.
-    # @option options [Float] :poll_interval  The minimum interval, in seconds, between checks for
-    #   file modifications - used only if auto_update is true, and if the native file-watching
-    #   mechanism from 'listen' is not being used. The default value is 1 second.
-    # @return an object that can be stored in {Config#data_source}
-    #
-    def self.factory(options={})
-      return lambda { |sdk_key, config| FileDataSourceImpl.new(config.feature_store, config.logger, options) }
-    end
-  end
-
-  # @private
-  class FileDataSourceImpl
-    def initialize(feature_store, logger, options={})
-      @feature_store = feature_store
-      @logger = logger
-      @paths = options[:paths] || []
-      if @paths.is_a? String
-        @paths = [ @paths ]
-      end
-      @auto_update = options[:auto_update]
-      if @auto_update && LaunchDarkly.have_listen? && !options[:force_polling] # force_polling is used only for tests
-        # We have seen unreliable behavior in the 'listen' gem in JRuby 9.1 (https://github.com/guard/listen/issues/449).
-        # Therefore, on that platform we'll fall back to file polling instead.
-        if defined?(JRUBY_VERSION) && JRUBY_VERSION.start_with?("9.1.")
-          @use_listen = false
-        else
-          @use_listen = true
-        end
-      end
-      @poll_interval = options[:poll_interval] || 1
-      @initialized = Concurrent::AtomicBoolean.new(false)
-      @ready = Concurrent::Event.new
-    end
-
-    def initialized?
-      @initialized.value
-    end
-
-    def start
-      ready = Concurrent::Event.new
-      
-      # We will return immediately regardless of whether the file load succeeded or failed -
-      # the difference can be detected by checking "initialized?"
-      ready.set
-
-      load_all
-
-      if @auto_update
-        # If we're going to watch files, then the start event will be set the first time we get
-        # a successful load.
-        @listener = start_listener
-      end
-
-      ready
-    end
-    
-    def stop
-      @listener.stop if !@listener.nil?
-    end
-
-    private
-
-    def load_all
-      all_data = {
-        FEATURES => {},
-        SEGMENTS => {}
-      }
-      @paths.each do |path|
-        begin
-          load_file(path, all_data)
-        rescue => exn
-          Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
-          return
-        end
-      end
-      @feature_store.init(all_data)
-      @initialized.make_true
-    end
-
-    def load_file(path, all_data)
-      parsed = parse_content(IO.read(path))
-      (parsed[:flags] || {}).each do |key, flag|
-        add_item(all_data, FEATURES, flag)
-      end
-      (parsed[:flagValues] || {}).each do |key, value|
-        add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value))
-      end
-      (parsed[:segments] || {}).each do |key, segment|
-        add_item(all_data, SEGMENTS, segment)
-      end
-    end
-
-    def parse_content(content)
-      # We can use the Ruby YAML parser for both YAML and JSON (JSON is a subset of YAML and while
-      # not all YAML parsers handle it correctly, we have verified that the Ruby one does, at least
-      # for all the samples of actual flag data that we've tested).
-      symbolize_all_keys(YAML.safe_load(content))
-    end
-
-    def symbolize_all_keys(value)
-      # This is necessary because YAML.load doesn't have an option for parsing keys as symbols, and
-      # the SDK expects all objects to be formatted that way.
-      if value.is_a?(Hash)
-        value.map{ |k, v| [k.to_sym, symbolize_all_keys(v)] }.to_h
-      elsif value.is_a?(Array)
-        value.map{ |v| symbolize_all_keys(v) }
-      else
-        value
-      end
-    end
-
-    def add_item(all_data, kind, item)
-      items = all_data[kind]
-      raise ArgumentError, "Received unknown item kind #{kind} in add_data" if items.nil? # shouldn't be possible since we preinitialize the hash
-      key = item[:key].to_sym
-      if !items[key].nil?
-        raise ArgumentError, "#{kind[:namespace]} key \"#{item[:key]}\" was used more than once"
-      end
-      items[key] = item
-    end
-
-    def make_flag_with_value(key, value)
-      {
-        key: key,
-        on: true,
-        fallthrough: { variation: 0 },
-        variations: [ value ]
-      }
-    end
-
-    def start_listener
-      resolved_paths = @paths.map { |p| Pathname.new(File.absolute_path(p)).realpath.to_s }
-      if @use_listen
-        start_listener_with_listen_gem(resolved_paths)
-      else
-        FileDataSourcePoller.new(resolved_paths, @poll_interval, self.method(:load_all), @logger)
-      end
-    end
-
-    def start_listener_with_listen_gem(resolved_paths)
-      path_set = resolved_paths.to_set
-      dir_paths = resolved_paths.map{ |p| File.dirname(p) }.uniq
-      opts = { latency: @poll_interval }
-      l = Listen.to(*dir_paths, opts) do |modified, added, removed|
-        paths = modified + added + removed
-        if paths.any? { |p| path_set.include?(p) }
-          load_all
-        end
-      end
-      l.start
-      l
-    end
-
-    #
-    # Used internally by FileDataSource to track data file changes if the 'listen' gem is not available.
-    #
-    class FileDataSourcePoller
-      def initialize(resolved_paths, interval, reloader, logger)
-        @stopped = Concurrent::AtomicBoolean.new(false)
-        get_file_times = Proc.new do
-          ret = {}
-          resolved_paths.each do |path|
-            begin
-              ret[path] = File.mtime(path)
-            rescue Errno::ENOENT
-              ret[path] = nil
-            end
-          end
-          ret
-        end
-        last_times = get_file_times.call
-        @thread = Thread.new do
-          while true
-            sleep interval
-            break if @stopped.value
-            begin
-              new_times = get_file_times.call
-              changed = false
-              last_times.each do |path, old_time|
-                new_time = new_times[path]
-                if !new_time.nil? && new_time != old_time
-                  changed = true
-                  break
-                end
-              end
-              reloader.call if changed
-            rescue => exn
-              Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
-            end
-          end
-        end
-      end
-
-      def stop
-        @stopped.make_true
-        @thread.run  # wakes it up if it's sleeping
-      end
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-
-module LaunchDarkly
-  module Impl
-    # Event constructors are centralized here to avoid mistakes and repetitive logic.
-    # The LDClient owns two instances of EventFactory: one that always embeds evaluation reasons
-    # in the events (for when variation_detail is called) and one that doesn't.
-    #
-    # Note that these methods do not set the "creationDate" property, because in the Ruby client,
-    # that is done by EventProcessor.add_event().
-    class EventFactory
-      def initialize(with_reasons)
-        @with_reasons = with_reasons
-      end
-
-      def new_eval_event(flag, user, detail, default_value, prereq_of_flag = nil)
-        add_experiment_data = is_experiment(flag, detail.reason)
-        e = {
-          kind: 'feature',
-          key: flag[:key],
-          user: user,
-          variation: detail.variation_index,
-          value: detail.value,
-          default: default_value,
-          version: flag[:version]
-        }
-        # the following properties are handled separately so we don't waste bandwidth on unused keys
-        e[:trackEvents] = true if add_experiment_data || flag[:trackEvents]
-        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
-        e[:prereqOf] = prereq_of_flag[:key] if !prereq_of_flag.nil?
-        e[:reason] = detail.reason if add_experiment_data || @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_default_event(flag, user, default_value, reason)
-        e = {
-          kind: 'feature',
-          key: flag[:key],
-          user: user,
-          value: default_value,
-          default: default_value,
-          version: flag[:version]
-        }
-        e[:trackEvents] = true if flag[:trackEvents]
-        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
-        e[:reason] = reason if @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_unknown_flag_event(key, user, default_value, reason)
-        e = {
-          kind: 'feature',
-          key: key,
-          user: user,
-          value: default_value,
-          default: default_value
-        }
-        e[:reason] = reason if @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_identify_event(user)
-        {
-          kind: 'identify',
-          key: user[:key],
-          user: user
-        }
-      end
-
-      def new_alias_event(current_context, previous_context)
-        {
-          kind: 'alias',
-          key: current_context[:key],
-          contextKind: context_to_context_kind(current_context),
-          previousKey: previous_context[:key],
-          previousContextKind: context_to_context_kind(previous_context)
-        }
-      end
-
-      def new_custom_event(event_name, user, data, metric_value)
-        e = {
-          kind: 'custom',
-          key: event_name,
-          user: user
-        }
-        e[:data] = data if !data.nil?
-        e[:metricValue] = metric_value if !metric_value.nil?
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      private
-
-      def context_to_context_kind(user)
-          if !user.nil? && user[:anonymous]
-            return "anonymousUser"
-          else
-            return "user"
-          end
-      end
-
-      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
-
-    end
-  end
-end

data/lib/ldclient-rb/newrelic.rb

@@ -1,17 +0,0 @@
-module LaunchDarkly
-  # @private
-  class LDNewRelic
-    begin
-      require "newrelic_rpm"
-      NR_ENABLED = defined?(::NewRelic::Agent.add_custom_parameters)
-    rescue ScriptError, StandardError
-      NR_ENABLED = false
-    end
-
-    def self.annotate_transaction(key, value)
-      if NR_ENABLED
-        ::NewRelic::Agent.add_custom_parameters(key.to_s => value.to_s)
-      end
-    end
-  end
-end

data/lib/ldclient-rb/redis_store.rb

@@ -1,88 +0,0 @@
-require "ldclient-rb/interfaces"
-require "ldclient-rb/impl/integrations/redis_impl"
-
-module LaunchDarkly
-  #
-  # An implementation of the LaunchDarkly client's feature store that uses a Redis
-  # instance.  This object holds feature flags and related data received from the
-  # streaming API.  Feature data can also be further cached in memory to reduce overhead
-  # of calls to Redis.
-  #
-  # To use this class, you must first have the `redis` and `connection-pool` gems
-  # installed.  Then, create an instance and store it in the `feature_store` property
-  # of your client configuration.
-  #
-  # @deprecated Use the factory method in {LaunchDarkly::Integrations::Redis} instead. This specific
-  #   implementation class may be changed or removed in the future.
-  #
-  class RedisFeatureStore
-    include LaunchDarkly::Interfaces::FeatureStore
-
-    # Note that this class is now just a facade around CachingStoreWrapper, which is in turn delegating
-    # to RedisFeatureStoreCore where the actual database logic is. This class was retained for historical
-    # reasons, so that existing code can still call RedisFeatureStore.new. In the future, we will migrate
-    # away from exposing these concrete classes and use factory methods instead.
-
-    #
-    # Constructor for a RedisFeatureStore instance.
-    #
-    # @param opts [Hash] the configuration options
-    # @option opts [String] :redis_url  URL of the Redis instance (shortcut for omitting redis_opts)
-    # @option opts [Hash] :redis_opts  options to pass to the Redis constructor (if you want to specify more than just redis_url)
-    # @option opts [String] :prefix  namespace prefix to add to all hash keys used by LaunchDarkly
-    # @option opts [Logger] :logger  a `Logger` instance; defaults to `Config.default_logger`
-    # @option opts [Integer] :max_connections  size of the Redis connection pool
-    # @option opts [Integer] :expiration  expiration time for the in-memory cache, in seconds; 0 for no local caching
-    # @option opts [Integer] :capacity  maximum number of feature flags (or related objects) to cache locally
-    # @option opts [Object] :pool  custom connection pool, if desired
-    # @option opts [Boolean] :pool_shutdown_on_close whether calling `close` should shutdown the custom connection pool.
-    #
-    def initialize(opts = {})
-      core = LaunchDarkly::Impl::Integrations::Redis::RedisFeatureStoreCore.new(opts)
-      @wrapper = LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
-    end
-
-    #
-    # Default value for the `redis_url` constructor parameter; points to an instance of Redis
-    # running at `localhost` with its default port.
-    #
-    def self.default_redis_url
-      LaunchDarkly::Integrations::Redis::default_redis_url
-    end
-
-    #
-    # Default value for the `prefix` constructor parameter.
-    #
-    def self.default_prefix
-      LaunchDarkly::Integrations::Redis::default_prefix
-    end
-
-    def get(kind, key)
-      @wrapper.get(kind, key)
-    end
-
-    def all(kind)
-      @wrapper.all(kind)
-    end
-
-    def delete(kind, key, version)
-      @wrapper.delete(kind, key, version)
-    end
-
-    def init(all_data)
-      @wrapper.init(all_data)
-    end
-
-    def upsert(kind, item)
-      @wrapper.upsert(kind, item)
-    end
-
-    def initialized?
-      @wrapper.initialized?
-    end
-
-    def stop
-      @wrapper.stop
-    end
-  end
-end

data/lib/ldclient-rb/user_filter.rb

@@ -1,52 +0,0 @@
-require "json"
-require "set"
-
-module LaunchDarkly
-  # @private
-  class UserFilter
-    def initialize(config)
-      @all_attributes_private = config.all_attributes_private
-      @private_attribute_names = Set.new(config.private_attribute_names.map(&:to_sym))
-    end
-
-    def transform_user_props(user_props)
-      return nil if user_props.nil?
-      
-      user_private_attrs = Set.new((user_props[:privateAttributeNames] || []).map(&:to_sym))
-
-      filtered_user_props, removed = filter_values(user_props, user_private_attrs, ALLOWED_TOP_LEVEL_KEYS, IGNORED_TOP_LEVEL_KEYS)
-      custom = user_props[:custom]
-      if !custom.nil?
-        filtered_user_props[:custom], removed_custom = filter_values(custom, user_private_attrs)
-        removed.merge(removed_custom)
-      end
-
-      unless removed.empty?
-        # note, :privateAttributeNames is what the developer sets; :privateAttrs is what we send to the server
-        filtered_user_props[:privateAttrs] = removed.to_a.sort.map { |s| s.to_s }
-      end
-      return filtered_user_props
-    end
-
-    private
-
-    ALLOWED_TOP_LEVEL_KEYS = Set.new([:key, :secondary, :ip, :country, :email,
-                :firstName, :lastName, :avatar, :name, :anonymous, :custom])
-    IGNORED_TOP_LEVEL_KEYS = Set.new([:custom, :key, :anonymous])
-
-    def filter_values(props, user_private_attrs, allowed_keys = [], keys_to_leave_as_is = [])
-      is_valid_key = lambda { |key| allowed_keys.empty? || allowed_keys.include?(key) }
-      removed_keys = Set.new(props.keys.select { |key|
-        # Note that if is_valid_key returns false, we don't explicitly *remove* the key (which would place
-        # it in the privateAttrs list) - we just silently drop it when we calculate filtered_hash.
-        is_valid_key.call(key) && !keys_to_leave_as_is.include?(key) && private_attr?(key, user_private_attrs)
-      })
-      filtered_hash = props.select { |key, value| !removed_keys.include?(key) && is_valid_key.call(key) }
-      [filtered_hash, removed_keys]
-    end
-
-    def private_attr?(name, user_private_attrs)
-      @all_attributes_private || @private_attribute_names.include?(name) || user_private_attrs.include?(name)
-    end
-  end
-end