prefab-cloud-ruby 0

data/lib/prefab/evaluation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Prefab
+  # Records the result of evaluating a config's criteria and forensics for reporting
+  class Evaluation
+    attr_reader :value
+
+    def initialize(config:, value:, value_index:, config_row_index:, context:, resolver:)
+      @config = config
+      @value = value
+      @value_index = value_index
+      @config_row_index = config_row_index
+      @context = context
+      @resolver = resolver
+    end
+
+    def unwrapped_value
+      deepest_value.unwrap
+    end
+
+    def reportable_value
+      deepest_value.reportable_value
+    end
+
+    def report_and_return(evaluation_summary_aggregator)
+      report(evaluation_summary_aggregator)
+
+      unwrapped_value
+    end
+
+    private
+
+    def report(evaluation_summary_aggregator)
+      return if @config.config_type == :LOG_LEVEL
+      evaluation_summary_aggregator&.record(
+        config_key: @config.key,
+        config_type: @config.config_type,
+        counter: {
+          config_id: @config.id,
+          config_row_index: @config_row_index,
+          conditional_value_index: @value_index,
+          selected_value: deepest_value.reportable_wrapped_value,
+          weighted_value_index: deepest_value.weighted_value_index,
+          selected_index: nil # TODO
+        })
+    end
+
+    def deepest_value
+      @deepest_value ||= Prefab::ConfigValueUnwrapper.deepest_value(@value, @config, @context, @resolver)
+    end
+  end
+end

data/lib/prefab/evaluation_summary_aggregator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  # This class aggregates the number of times each config is evaluated, and
+  # details about how the config is evaluated This data is reported to the
+  # server at a regular interval defined by `sync_interval`.
+  class EvaluationSummaryAggregator
+    include Prefab::PeriodicSync
+
+    LOG = Prefab::InternalLogger.new(EvaluationSummaryAggregator)
+
+    attr_reader :data
+
+    def initialize(client:, max_keys:, sync_interval:)
+      @client = client
+      @max_keys = max_keys
+      @name = 'evaluation_summary_aggregator'
+
+      @data = Concurrent::Hash.new
+
+      start_periodic_sync(sync_interval)
+    end
+
+    def record(config_key:, config_type:, counter:)
+      return if @data.size >= @max_keys
+
+      key = [config_key, config_type]
+      @data[key] ||= Concurrent::Hash.new
+
+      @data[key][counter] ||= 0
+      @data[key][counter] += 1
+    end
+
+    private
+
+    def counter_proto(counter, count)
+      PrefabProto::ConfigEvaluationCounter.new(
+        config_id: counter[:config_id],
+        selected_index: counter[:selected_index],
+        config_row_index: counter[:config_row_index],
+        conditional_value_index: counter[:conditional_value_index],
+        weighted_value_index: counter[:weighted_value_index],
+        selected_value: counter[:selected_value],
+        count: count
+      )
+    end
+
+    def flush(to_ship, start_at_was)
+      pool.post do
+        LOG.debug "Flushing #{to_ship.size} summaries"
+
+        summaries_proto = PrefabProto::ConfigEvaluationSummaries.new(
+          start: start_at_was,
+          end: Prefab::TimeHelpers.now_in_ms,
+          summaries: summaries(to_ship)
+        )
+
+        result = post('/api/v1/telemetry', events(summaries_proto))
+
+        LOG.debug "Uploaded #{to_ship.size} summaries: #{result.status}"
+      end
+    end
+
+    def events(summaries)
+      event = PrefabProto::TelemetryEvent.new(summaries: summaries)
+
+      PrefabProto::TelemetryEvents.new(
+        instance_hash: @client.instance_hash,
+        events: [event]
+      )
+    end
+
+    def summaries(data)
+      data.map do |(config_key, config_type), counters|
+        counter_protos = counters.map { |counter, count| counter_proto(counter, count) }
+
+        PrefabProto::ConfigEvaluationSummary.new(
+          key: config_key,
+          type: config_type,
+          counters: counter_protos
+        )
+      end
+    end
+  end
+end

data/lib/prefab/example_contexts_aggregator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  # This class aggregates example contexts. It dedupes based on the
+  # concatenation of the keys of the contexts.
+  #
+  # It shouldn't send the same context more than once per hour.
+  class ExampleContextsAggregator
+    include Prefab::PeriodicSync
+
+    LOG = Prefab::InternalLogger.new(ExampleContextsAggregator)
+
+    attr_reader :data, :cache
+
+    ONE_HOUR = 60 * 60
+
+    def initialize(client:, max_contexts:, sync_interval:)
+      @client = client
+      @max_contexts = max_contexts
+      @name = 'example_contexts_aggregator'
+
+      @data = Concurrent::Array.new
+      @cache = Prefab::RateLimitCache.new(ONE_HOUR)
+
+      start_periodic_sync(sync_interval)
+    end
+
+    def record(contexts)
+      key = contexts.grouped_key
+
+      return unless @data.size < @max_contexts && !@cache.fresh?(key)
+
+      @cache.set(key)
+
+      @data.push(contexts)
+    end
+
+    private
+
+    def on_prepare_data
+      @cache.prune
+    end
+
+    def flush(to_ship, _)
+      pool.post do
+        LOG.debug "Flushing #{to_ship.size} examples"
+
+        result = post('/api/v1/telemetry', events(to_ship))
+
+        LOG.debug "Uploaded #{to_ship.size} examples: #{result.status}"
+      end
+    end
+
+    def example_contexts(to_ship)
+      to_ship.map do |contexts|
+        PrefabProto::ExampleContext.new(
+          timestamp: contexts.seen_at * 1000,
+          contextSet: contexts.slim_proto
+        )
+      end
+    end
+
+    def events(to_ship)
+      event = PrefabProto::TelemetryEvent.new(
+        example_contexts: PrefabProto::ExampleContexts.new(
+          examples: example_contexts(to_ship)
+        )
+      )
+
+      PrefabProto::TelemetryEvents.new(
+        instance_hash: @client.instance_hash,
+        events: [event]
+      )
+    end
+  end
+end

data/lib/prefab/exponential_backoff.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Prefab
+  # This class implements exponential backoff with a maximum delay.
+  #
+  # This is the default sync interval for aggregators.
+  class ExponentialBackoff
+    def initialize(max_delay:, initial_delay: 2, multiplier: 2)
+      @initial_delay = initial_delay
+      @max_delay = max_delay
+      @multiplier = multiplier
+      @delay = initial_delay
+    end
+
+    def call
+      delay = @delay
+      @delay = [@delay * @multiplier, @max_delay].min
+      delay
+    end
+  end
+end

data/lib/prefab/feature_flag_client.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Prefab
+  class FeatureFlagClient
+    def initialize(base_client)
+      @base_client = base_client
+    end
+
+    def feature_is_on?(feature_name)
+      feature_is_on_for?(feature_name, {})
+    end
+
+    def feature_is_on_for?(feature_name, properties)
+      variant = @base_client.config_client.get(feature_name, false, properties)
+
+      is_on?(variant)
+    end
+
+    def get(feature_name, properties, default: false)
+      value = _get(feature_name, properties)
+
+      value.nil? ? default : value
+    end
+
+    private
+
+    def _get(feature_name, properties)
+      @base_client.config_client.get(feature_name, nil, properties)
+    end
+
+    def is_on?(variant)
+      return false if variant.nil?
+
+      return variant if variant == !!variant
+
+      variant.bool
+    rescue StandardError
+      @base_client.log.info("is_on? methods only work for boolean feature flags variants. This feature flags variant is '#{variant}'. Returning false")
+      false
+    end
+  end
+end

data/lib/prefab/http_connection.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Prefab
+  class HttpConnection
+    AUTH_USER = 'authuser'
+    PROTO_HEADERS = {
+      'Content-Type' => 'application/x-protobuf',
+      'Accept' => 'application/x-protobuf',
+      'X-PrefabCloud-Client-Version' => "prefab-cloud-ruby-#{Prefab::VERSION}"
+    }.freeze
+
+    def initialize(api_root, api_key)
+      @api_root = api_root
+      @api_key = api_key
+    end
+
+    def get(path)
+      connection(PROTO_HEADERS).get(path)
+    end
+
+    def post(path, body)
+      connection(PROTO_HEADERS).post(path, body.to_proto)
+    end
+
+    def connection(headers = {})
+      if Faraday::VERSION[0].to_i >= 2
+        Faraday.new(@api_root) do |conn|
+          conn.request :authorization, :basic, AUTH_USER, @api_key
+
+          conn.headers.merge!(headers)
+        end
+      else
+        Faraday.new(@api_root) do |conn|
+          conn.request :basic_auth, AUTH_USER, @api_key
+
+          conn.headers.merge!(headers)
+        end
+      end
+    end
+  end
+end

data/lib/prefab/internal_logger.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Prefab
+  class InternalLogger < StaticLogger
+    INTERNAL_PREFIX = 'cloud.prefab.client'
+
+    def initialize(path)
+      if path.is_a?(Class)
+        path_string = path.name.split('::').last.downcase
+      else
+        path_string = path
+      end
+      super("#{INTERNAL_PREFIX}.#{path_string}")
+    end
+  end
+end

data/lib/prefab/local_config_parser.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Prefab
+  class LocalConfigParser
+    class << self
+      def parse(key, value, config, file)
+        if value.instance_of?(Hash)
+          if value['feature_flag']
+            config[key] = feature_flag_config(file, key, value)
+          elsif value['type'] == 'provided'
+            config[key] = provided_config(file, key, value)
+          elsif value['decrypt_with'] || value['confidential']
+            config[key] = complex_string(file, key, value)
+          else
+            value.each do |nest_key, nest_value|
+              nested_key = "#{key}.#{nest_key}"
+              nested_key = key if nest_key == '_'
+              parse(nested_key, nest_value, config, file)
+            end
+          end
+        else
+          config[key] = {
+            source: file,
+            match: 'default',
+            config: PrefabProto::Config.new(
+              config_type: :CONFIG,
+              key: key,
+              rows: [
+                PrefabProto::ConfigRow.new(values: [
+                  PrefabProto::ConditionalValue.new(value: value_from(key, value))
+                ])
+              ]
+            )
+          }
+        end
+
+        config
+      end
+
+      def value_from(key, raw)
+        case raw
+        when String
+          if key.to_s.start_with? Prefab::LoggerClient::BASE_KEY
+            prefab_log_level_resolve = PrefabProto::LogLevel.resolve(raw.upcase.to_sym) || PrefabProto::LogLevel::NOT_SET_LOG_LEVEL
+            { log_level: prefab_log_level_resolve }
+          else
+            { string: raw }
+          end
+        when Integer
+          { int: raw }
+        when TrueClass, FalseClass
+          { bool: raw }
+        when Float
+          { double: raw }
+        end
+      end
+
+      def feature_flag_config(file, key, value)
+        criterion = (parse_criterion(value['criterion']) if value['criterion'])
+
+        variant = PrefabProto::ConfigValue.new(value_from(key, value['value']))
+
+        row = PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [criterion].compact,
+              value: variant
+            )
+          ]
+        )
+
+        raise Prefab::Error, "Feature flag config `#{key}` #{file} must have a `value`" unless value.key?('value')
+
+        {
+          source: file,
+          match: key,
+          config: PrefabProto::Config.new(
+            config_type: :FEATURE_FLAG,
+            key: key,
+            allowable_values: [variant],
+            rows: [row]
+          )
+        }
+      end
+
+      def provided_config(file, key, value_hash)
+        value = PrefabProto::ConfigValue.new(provided: PrefabProto::Provided.new(
+          source: :ENV_VAR,
+          lookup: value_hash["lookup"],
+        ),
+                                             confidential: value_hash["confidential"],
+        )
+
+        row = PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: value
+            )
+          ]
+        )
+
+        {
+          source: file,
+          match: value.provided.lookup,
+          config: PrefabProto::Config.new(
+            config_type: :CONFIG,
+            key: key,
+            rows: [row]
+          )
+        }
+      end
+
+      def complex_string(file, key, value_hash)
+        value = PrefabProto::ConfigValue.new(
+          string: value_hash["value"],
+          confidential: value_hash["confidential"],
+          decrypt_with: value_hash["decrypt_with"],
+        )
+
+        row = PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: value
+            )
+          ]
+        )
+
+        {
+          source: file,
+          config: PrefabProto::Config.new(
+            config_type: :CONFIG,
+            key: key,
+            rows: [row]
+          )
+        }
+      end
+
+      def parse_criterion(criterion)
+        PrefabProto::Criterion.new(operator: criterion['operator'],
+                                   property_name: criterion['property'],
+                                   value_to_match: parse_value_to_match(criterion['values']))
+      end
+
+      def parse_value_to_match(values)
+        raise "Can't handle #{values}" unless values.instance_of?(Array)
+
+        PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: values))
+      end
+    end
+  end
+end

data/lib/prefab/log_path_aggregator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  class LogPathAggregator
+    LOG = Prefab::InternalLogger.new(LogPathAggregator)
+
+    include Prefab::PeriodicSync
+
+    INCREMENT = ->(count) { (count || 0) + 1 }
+
+    SEVERITY_KEY = {
+      ::Logger::DEBUG => 'debugs',
+      ::Logger::INFO => 'infos',
+      ::Logger::WARN => 'warns',
+      ::Logger::ERROR => 'errors',
+      ::Logger::FATAL => 'fatals'
+    }.freeze
+
+    attr_reader :data
+
+    def initialize(client:, max_paths:, sync_interval:)
+      @max_paths = max_paths
+      @client = client
+      @name = 'log_path_aggregator'
+
+      @data = Concurrent::Map.new
+
+      @last_data_sent = nil
+      @last_request = nil
+
+      start_periodic_sync(sync_interval)
+    end
+
+    def push(path, severity)
+      return if @data.size >= @max_paths
+
+      @data.compute([path, severity], &INCREMENT)
+    end
+
+    private
+
+    def flush(to_ship, start_at_was)
+      pool.post do
+        LOG.debug "Uploading stats for #{to_ship.size} paths"
+
+        aggregate = Hash.new { |h, k| h[k] = PrefabProto::Logger.new }
+
+        to_ship.each do |(path, severity), count|
+          aggregate[path][SEVERITY_KEY[severity]] = count
+          aggregate[path]['logger_name'] = path
+        end
+
+        loggers = PrefabProto::Loggers.new(
+          loggers: aggregate.values,
+          start_at: start_at_was,
+          end_at: Prefab::TimeHelpers.now_in_ms,
+          instance_hash: @client.instance_hash,
+          namespace: @client.namespace
+        )
+
+        result = post('/api/v1/known-loggers', loggers)
+
+        LOG.debug "Uploaded #{to_ship.size} paths: #{result.status}"
+      end
+    end
+  end
+end