prefab-cloud-ruby 0

data/lib/prefab/client.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'uuid'
+
+module Prefab
+  class Client
+    MAX_SLEEP_SEC = 10
+    BASE_SLEEP_SEC = 0.5
+    LOG = Prefab::InternalLogger.new(Client)
+
+    attr_reader :namespace, :interceptor, :api_key, :prefab_api_url, :options, :instance_hash
+
+    def initialize(options = Prefab::Options.new)
+      @options = options.is_a?(Prefab::Options) ? options : Prefab::Options.new(options)
+      @namespace = @options.namespace
+      @stubs = {}
+      @instance_hash = UUID.new.generate
+      Prefab::LoggerClient.new(@options.logdev, formatter: @options.log_formatter,
+                                prefix: @options.log_prefix,
+                               log_path_aggregator: log_path_aggregator
+      )
+
+      if @options.local_only?
+        LOG.debug 'Prefab Running in Local Mode'
+      elsif @options.datafile?
+        LOG.debug 'Prefab Running in DataFile Mode'
+      else
+        @api_key = @options.api_key
+        raise Prefab::Errors::InvalidApiKeyError, @api_key if @api_key.nil? || @api_key.empty? || api_key.count('-') < 1
+
+        @prefab_api_url = @options.prefab_api_url
+        LOG.debug "Prefab Connecting to: #{@prefab_api_url}"
+      end
+
+      context.clear
+      # start config client
+      config_client
+    end
+
+    def with_context(properties, &block)
+      Prefab::Context.with_context(properties, &block)
+    end
+
+    def context
+      Prefab::Context.current
+    end
+
+    def config_client(timeout: 5.0)
+      @config_client ||= Prefab::ConfigClient.new(self, timeout)
+    end
+
+    def feature_flag_client
+      @feature_flag_client ||= Prefab::FeatureFlagClient.new(self)
+    end
+
+    def log_path_aggregator
+      return nil if @options.collect_max_paths <= 0
+
+      @log_path_aggregator ||= LogPathAggregator.new(client: self, max_paths: @options.collect_max_paths,
+                                                     sync_interval: @options.collect_sync_interval)
+    end
+
+    def log
+      Prefab::LoggerClient.instance
+    end
+
+    def context_shape_aggregator
+      return nil if @options.collect_max_shapes <= 0
+
+      @context_shape_aggregator ||= ContextShapeAggregator.new(client: self, max_shapes: @options.collect_max_shapes,
+                                                               sync_interval: @options.collect_sync_interval)
+    end
+
+    def example_contexts_aggregator
+      return nil if @options.collect_max_example_contexts <= 0
+
+      @example_contexts_aggregator ||= ExampleContextsAggregator.new(
+        client: self,
+        max_contexts: @options.collect_max_example_contexts,
+        sync_interval: @options.collect_sync_interval
+      )
+    end
+
+    def evaluation_summary_aggregator
+      return nil if @options.collect_max_evaluation_summaries <= 0
+
+      @evaluation_summary_aggregator ||= EvaluationSummaryAggregator.new(
+        client: self,
+        max_keys: @options.collect_max_evaluation_summaries,
+        sync_interval: @options.collect_sync_interval
+      )
+    end
+
+    def set_rails_loggers
+      Rails.logger = log
+      ActionView::Base.logger = log
+      ActionController::Base.logger = log
+      ActiveJob::Base.logger = log if defined?(ActiveJob)
+      ActiveRecord::Base.logger = log
+      ActiveStorage.logger = log if defined?(ActiveStorage)
+
+      LogSubscribers::ActionControllerSubscriber.attach_to :action_controller unless @options.disable_action_controller_logging
+    end
+
+    def on_update(&block)
+      resolver.on_update(&block)
+    end
+
+    def enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
+      feature_flag_client.feature_is_on_for?(feature_name, jit_context)
+    end
+
+    def get(key, default = NO_DEFAULT_PROVIDED, jit_context = NO_DEFAULT_PROVIDED)
+      if is_ff?(key)
+        feature_flag_client.get(key, jit_context, default: default)
+      else
+        config_client.get(key, default, jit_context)
+      end
+    end
+
+    def post(path, body)
+      Prefab::HttpConnection.new(@options.prefab_api_url, @api_key).post(path, body)
+    end
+
+    def inspect
+      "#<Prefab::Client:#{object_id} namespace=#{namespace}>"
+    end
+
+    def resolver
+      config_client.resolver
+    end
+
+    # When starting a forked process, use this to re-use the options
+    # on_worker_boot do
+    #   $prefab = $prefab.fork
+    #   $prefab.set_rails_loggers
+    # end
+    def fork
+      log_options = self.log.context_keys.to_a # get keys pre-fork
+      Prefab::Client.new(@options.for_fork).tap do |client|
+        client.log.add_context_keys(*log_options)
+      end
+    end
+
+    private
+
+    def is_ff?(key)
+      raw = config_client.send(:raw, key)
+
+      raw && raw.allowable_values.any?
+    end
+  end
+end

data/lib/prefab/config_client.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ConfigClient
+    RECONNECT_WAIT = 5
+    DEFAULT_CHECKPOINT_FREQ_SEC = 60
+    SSE_READ_TIMEOUT = 300
+    STALE_CACHE_WARN_HOURS = 5
+    AUTH_USER = 'authuser'
+    LOGGING_KEY_PREFIX = "#{Prefab::LoggerClient::BASE_KEY}#{Prefab::LoggerClient::SEP}".freeze
+    LOG = Prefab::InternalLogger.new(ConfigClient)
+
+    def initialize(base_client, timeout)
+      @base_client = base_client
+      @options = base_client.options
+      LOG.debug 'Initialize ConfigClient'
+      @timeout = timeout
+
+      @stream_lock = Concurrent::ReadWriteLock.new
+
+      @checkpoint_freq_secs = DEFAULT_CHECKPOINT_FREQ_SEC
+
+      @config_loader = Prefab::ConfigLoader.new(@base_client)
+      @config_resolver = Prefab::ConfigResolver.new(@base_client, @config_loader)
+
+      @initialization_lock = Concurrent::ReadWriteLock.new
+      LOG.debug 'Initialize ConfigClient: AcquireWriteLock'
+      @initialization_lock.acquire_write_lock
+      LOG.debug 'Initialize ConfigClient: AcquiredWriteLock'
+      @initialized_future = Concurrent::Future.execute { @initialization_lock.acquire_read_lock }
+
+      if @options.local_only?
+        finish_init!(:local_only, nil)
+      elsif @options.datafile?
+        load_json_file(@options.datafile)
+      else
+        load_checkpoint
+        start_checkpointing_thread
+        start_streaming
+      end
+    end
+
+    def start_streaming
+      @stream_lock.with_write_lock do
+        start_sse_streaming_connection_thread(@config_loader.highwater_mark) if @streaming_thread.nil?
+      end
+    end
+
+    def to_s
+      @config_resolver.to_s
+    end
+
+    def resolver
+      @config_resolver
+    end
+
+    def self.value_to_delta(key, config_value, namespace = nil)
+      PrefabProto::Config.new(key: [namespace, key].compact.join(':'),
+                              rows: [PrefabProto::ConfigRow.new(value: config_value)])
+    end
+
+    def get(key, default = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
+      context = @config_resolver.make_context(properties)
+
+      if !context.blank? && @base_client.example_contexts_aggregator
+        @base_client.example_contexts_aggregator.record(context)
+      end
+
+      evaluation = _get(key, context)
+
+      @base_client.context_shape_aggregator&.push(context)
+
+      if evaluation
+        evaluation.report_and_return(@base_client.evaluation_summary_aggregator)
+      else
+        handle_default(key, default)
+      end
+    end
+
+    private
+
+    def raw(key)
+      @config_resolver.raw(key)
+    end
+
+    def handle_default(key, default)
+      return default if default != NO_DEFAULT_PROVIDED
+
+      raise Prefab::Errors::MissingDefaultError, key if @options.on_no_default == Prefab::Options::ON_NO_DEFAULT::RAISE
+
+      nil
+    end
+
+    def _get(key, properties)
+      # wait timeout sec for the initialization to be complete
+      @initialized_future.value(@options.initialization_timeout_sec)
+      if @initialized_future.incomplete?
+        unless @options.on_init_failure == Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN
+          raise Prefab::Errors::InitializationTimeoutError.new(@options.initialization_timeout_sec, key)
+        end
+
+        LOG.warn("Couldn't Initialize In #{@options.initialization_timeout_sec}. Key #{key}. Returning what we have")
+        @initialization_lock.release_write_lock
+      end
+
+      @config_resolver.get key, properties
+    end
+
+    def load_checkpoint
+      success = load_checkpoint_api_cdn
+
+      return if success
+
+      success = load_checkpoint_api
+
+      return if success
+
+      success = load_cache
+
+      return if success
+
+      LOG.warn 'No success loading checkpoints'
+    end
+
+    def load_checkpoint_api_cdn
+      conn = Prefab::HttpConnection.new("#{@options.url_for_api_cdn}/api/v1/configs/0", @base_client.api_key)
+      load_url(conn, :remote_cdn_api)
+    end
+
+    def load_checkpoint_api
+      conn = Prefab::HttpConnection.new("#{@options.prefab_api_url}/api/v1/configs/0", @base_client.api_key)
+      load_url(conn, :remote_api)
+    end
+
+    def load_url(conn, source)
+      resp = conn.get('')
+      if resp.status == 200
+        configs = PrefabProto::Configs.decode(resp.body)
+        load_configs(configs, source)
+        cache_configs(configs)
+        true
+      else
+        LOG.info "Checkpoint #{source} failed to load. Response #{resp.status}"
+        false
+      end
+    rescue Faraday::ConnectionFailed => e
+      if @initialization_lock.write_locked?
+        LOG.warn "Connection Fail loading #{source} checkpoint."
+      else
+        LOG.debug "Connection Fail loading #{source} checkpoint."
+      end
+      false
+    rescue StandardError => e
+      LOG.warn "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
+      LOG.debug e.backtrace
+      false
+    end
+
+    def load_configs(configs, source)
+      project_id = configs.config_service_pointer.project_id
+      project_env_id = configs.config_service_pointer.project_env_id
+      @config_resolver.project_env_id = project_env_id
+      starting_highwater_mark = @config_loader.highwater_mark
+
+      default_contexts = configs.default_context&.contexts&.map do |context|
+        [
+          context.type,
+          context.values.keys.map do |k|
+            [k, Prefab::ConfigValueUnwrapper.new(context.values[k], @config_resolver).unwrap]
+          end.to_h
+        ]
+      end.to_h
+
+      @config_resolver.default_context = default_contexts || {}
+
+      configs.configs.each do |config|
+        @config_loader.set(config, source)
+      end
+      if @config_loader.highwater_mark > starting_highwater_mark
+        LOG.debug("Found new checkpoint with highwater id #{@config_loader.highwater_mark} from #{source} in project #{project_id} environment: #{project_env_id} and namespace: '#{@namespace}'")
+      else
+        LOG.debug("Checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}. No changes.")
+      end
+      @config_resolver.update
+      finish_init!(source, project_id)
+    end
+
+    def cache_path
+      return @cache_path unless @cache_path.nil?
+      @cache_path ||= calc_cache_path
+      FileUtils.mkdir_p(File.dirname(@cache_path))
+      @cache_path
+    end
+
+    def calc_cache_path
+      file_name = "prefab.cache.#{@base_client.options.api_key_id}.json"
+      dir = ENV.fetch('XDG_CACHE_HOME', File.join(Dir.home, '.cache'))
+      File.join(dir, file_name)
+    end
+
+    def cache_configs(configs)
+      return unless @options.use_local_cache && !@options.is_fork
+      File.open(cache_path, "w") do |f|
+        f.flock(File::LOCK_EX)
+        f.write(PrefabProto::Configs.encode_json(configs))
+      end
+      LOG.debug "Cached configs to #{cache_path}"
+    rescue => e
+      LOG.debug "Failed to cache configs to #{cache_path} #{e}"
+    end
+
+    def load_cache
+      return false unless @options.use_local_cache
+      File.open(cache_path) do |f|
+        f.flock(File::LOCK_SH)
+        configs = PrefabProto::Configs.decode_json(f.read)
+        load_configs(configs, :cache)
+
+        hours_old = ((Time.now - File.mtime(f)) / 60 / 60).round(2)
+        if hours_old > STALE_CACHE_WARN_HOURS
+          LOG.info "Stale Cache Load: #{hours_old} hours old"
+        end
+        true
+      end
+    rescue => e
+      LOG.debug "Failed to read cached configs at #{cache_path}. #{e}"
+      false
+    end
+
+    def load_json_file(file)
+      File.open(file) do |f|
+        f.flock(File::LOCK_SH)
+        configs = PrefabProto::Configs.decode_json(f.read)
+        load_configs(configs, :datafile)
+      end
+    end
+
+    # A thread that checks for a checkpoint
+    def start_checkpointing_thread
+      Thread.new do
+        loop do
+          started_at = Time.now
+          delta = @checkpoint_freq_secs - (Time.now - started_at)
+          sleep(delta) if delta > 0
+
+          load_checkpoint
+        rescue StandardError => e
+          LOG.debug "Issue Checkpointing #{e.message}"
+        end
+      end
+    end
+
+    def finish_init!(source, project_id)
+      return unless @initialization_lock.write_locked?
+
+      LOG.debug "Unlocked Config via #{source}"
+      @initialization_lock.release_write_lock
+
+      Prefab::LoggerClient.instance.config_client = self
+      presenter = Prefab::ConfigClientPresenter.new(
+        size: @config_resolver.local_store.size,
+        source: source,
+        project_id: project_id,
+        project_env_id: @config_resolver.project_env_id,
+        api_key_id: @base_client.options.api_key_id
+      )
+      LOG.info presenter.to_s
+      LOG.debug to_s
+    end
+
+    def start_sse_streaming_connection_thread(start_at_id)
+      auth = "#{AUTH_USER}:#{@base_client.api_key}"
+      auth_string = Base64.strict_encode64(auth)
+      headers = {
+        'x-prefab-start-at-id' => start_at_id,
+        'Authorization' => "Basic #{auth_string}",
+        'X-PrefabCloud-Client-Version' => "prefab-cloud-ruby-#{Prefab::VERSION}"
+      }
+      url = "#{@base_client.prefab_api_url}/api/v1/sse/config"
+      LOG.debug "SSE Streaming Connect to #{url} start_at #{start_at_id}"
+      @streaming_thread = SSE::Client.new(url,
+                                          headers: headers,
+                                          read_timeout: SSE_READ_TIMEOUT,
+                                          logger: Prefab::SseLogger.new) do |client|
+        client.on_event do |event|
+          configs = PrefabProto::Configs.decode(Base64.decode64(event.data))
+          load_configs(configs, :sse)
+        end
+      end
+    end
+  end
+end

data/lib/prefab/config_client_presenter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ConfigClientPresenter
+    def initialize(size:, source:, project_id:, project_env_id:, api_key_id:)
+      @size = size
+      @source = source
+      @project_id = project_id
+      @project_env_id = project_env_id
+      @api_key_id = api_key_id
+    end
+
+    def to_s
+      "Configuration Loaded count=#{@size} source=#{@source} project=#{@project_id} project-env=#{@project_env_id} prefab.api-key-id=#{@api_key_id}"
+    end
+  end
+end
+

data/lib/prefab/config_loader.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ConfigLoader
+    LOG = Prefab::InternalLogger.new(ConfigLoader)
+
+    attr_reader :highwater_mark
+
+    def initialize(base_client)
+      @base_client = base_client
+      @prefab_options = base_client.options
+      @highwater_mark = 0
+      @classpath_config = load_classpath_config
+      @local_overrides = load_local_overrides
+      @api_config = Concurrent::Map.new
+    end
+
+    def calc_config
+      rtn = @classpath_config.clone
+      @api_config.each_key do |k|
+        rtn[k] = @api_config[k]
+      end
+      rtn.merge(@local_overrides)
+    end
+
+    def set(config, source)
+      # don't overwrite newer values
+      return if @api_config[config.key] && @api_config[config.key][:config].id >= config.id
+
+      if config.rows.empty?
+        @api_config.delete(config.key)
+      else
+        if @api_config[config.key]
+          LOG.debug(
+                                    "Replace #{config.key} with value from #{source} #{@api_config[config.key][:config].id} -> #{config.id}")
+        end
+        @api_config[config.key] = { source: source, config: config }
+      end
+      @highwater_mark = [config.id, @highwater_mark].max
+    end
+
+    def rm(key)
+      @api_config.delete key
+    end
+
+    def get_api_deltas
+      configs = PrefabProto::Configs.new
+      @api_config.each_value do |config_value|
+        configs.configs << config_value[:config]
+      end
+      configs
+    end
+
+    private
+
+    def load_classpath_config
+      return {} if @prefab_options.datafile?
+      classpath_dir = @prefab_options.prefab_config_classpath_dir
+      rtn = load_glob(File.join(classpath_dir, '.prefab.default.config.yaml'))
+      @prefab_options.prefab_envs.each do |env|
+        rtn = rtn.merge load_glob(File.join(classpath_dir, ".prefab.#{env}.config.yaml"))
+      end
+      rtn
+    end
+
+    def load_local_overrides
+      return {} if @prefab_options.datafile?
+      override_dir = @prefab_options.prefab_config_override_dir
+      rtn = load_glob(File.join(override_dir, '.prefab.default.config.yaml'))
+      @prefab_options.prefab_envs.each do |env|
+        rtn = rtn.merge load_glob(File.join(override_dir, ".prefab.#{env}.config.yaml"))
+      end
+      rtn
+    end
+
+    def load_glob(glob)
+      rtn = {}
+      Dir.glob(glob).each do |file|
+        Prefab::YAMLConfigParser.new(file, @base_client).merge(rtn)
+      end
+      rtn
+    end
+  end
+end

data/lib/prefab/config_resolver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ConfigResolver
+    attr_accessor :project_env_id # this will be set by the config_client when it gets an API response
+    attr_reader :local_store
+
+    attr_accessor :default_context
+
+    def initialize(base_client, config_loader)
+      @lock = Concurrent::ReadWriteLock.new
+      @local_store = {}
+      @config_loader = config_loader
+      @project_env_id = 0 # we don't know this yet, it is set from the API results
+      @base_client = base_client
+      @on_update = nil
+      @default_context = {}
+      make_local
+    end
+
+    def to_s
+      presenter.to_s
+    end
+
+    def presenter
+      Prefab::ResolvedConfigPresenter.new(self, @lock, @local_store)
+    end
+
+    def raw(key)
+      @local_store.dig(key, :config)
+    end
+
+    def get(key, properties = NO_DEFAULT_PROVIDED)
+      @lock.with_read_lock do
+        raw_config = raw(key)
+
+        return nil unless raw_config
+
+        evaluate(raw_config, properties)
+      end
+    end
+
+    def evaluate(config, properties = NO_DEFAULT_PROVIDED)
+      Prefab::CriteriaEvaluator.new(config,
+                                    project_env_id: @project_env_id,
+                                    resolver: self,
+                                    namespace: @base_client.options.namespace,
+                                    base_client: @base_client).evaluate(make_context(properties))
+    end
+
+    def update
+      make_local
+
+      @on_update ? @on_update.call : nil
+    end
+
+    def on_update(&block)
+      @on_update = block
+    end
+
+    def make_context(properties)
+      if properties == NO_DEFAULT_PROVIDED || properties.nil?
+        Context.current
+      else
+        Context.merge_with_current(properties)
+      end.merge_default(default_context || {})
+    end
+
+    private
+
+    def make_local
+      @lock.with_write_lock do
+        @local_store = @config_loader.calc_config
+      end
+    end
+  end
+end