prefab-cloud-ruby 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c153ee6c00aefaa6e938e7828a4be27acd769f32fd4a557b9f084429e76d373
-  data.tar.gz: fd098eeefbf1a6b01dac20d37a3cb2cdfddf29933e798aabb36d6781bf2859a7
+  metadata.gz: 55134a75669f459bbb12d50cfa6e221937a5c00f53ca365e609f0cb436b24aff
+  data.tar.gz: f3507032152e1dfe7b48156e5b8795d3bfd9262e077fab18923fef7cbeb78e34
 SHA512:
-  metadata.gz: 395fec34b4358ef5dd7b5dd39b29d1781485afd931fdc1030b796c4c45ef1a5ef62344164f0420af30504986775479188103c4a744ef0bcbbd768ec32ef80e55
-  data.tar.gz: ed5859c38fa2743d95fb3550d9f850460c3174ba4c6b4d861a4cbd81ee6f64c4b328ae714af451a20fbbba69249e16b1a4da831472c52e66a8d3e1235829bdbe
+  metadata.gz: 839db6777d5e6c3a76d34b7812787e8241779b2ede48d4ffddbf5e96bb493494e8d30e980582a5d06518e8f64f789287417ac5e6abc66c7789e17082992c83fb
+  data.tar.gz: fd26b0d5ceb02a17724ede1a3329bda2a1ca7ee1c8d49e0776c61498bfe7e1b41ca81158e395192c4c73c35970824e5eb2d319b241a9489e0e215febe9ea2bb6

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+## 1.3.0 - 2023-11-13
+- Less logging when wifi is off and we load from cache (#157)
+- Alpha: Add Provided & Secret Support (#152)
+- Alpha: x_datafile (#156)
+- Add single line action-controller output under rails.controller (#158)
+
 ## 1.2.1 - 2023-11-01
 - Update protobuf definitions (#154)
 

data/Gemfile

@@ -7,6 +7,8 @@ gem 'google-protobuf', platforms: :ruby
 gem 'ld-eventsource'
 gem 'uuid'
 
+gem 'activesupport',  '>= 4'
+
 group :development do
   gem 'benchmark-ips'
   gem 'bundler'

data/Gemfile.lock

@@ -1,17 +1,32 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
     addressable (2.8.0)
       public_suffix (>= 2.0.2, < 5.0)
     ansi (1.5.0)
+    base64 (0.2.0)
     benchmark-ips (2.10.0)
+    bigdecimal (3.1.4)
     builder (3.2.4)
     concurrent-ruby (1.1.10)
+    connection_pool (2.4.1)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
     docile (1.3.5)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
+    drb (2.2.0)
+      ruby2_keywords
     faraday (1.3.0)
       faraday-net_http (~> 1.0)
       multipart-post (>= 1.2, < 3)
@@ -43,6 +58,8 @@ GEM
     http-cookie (1.0.4)
       domain_name (~> 0.5)
     http-form_data (2.3.0)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
     juwelier (2.4.9)
       builder
       bundler
@@ -78,6 +95,7 @@ GEM
     multi_json (1.15.0)
     multi_xml (0.6.0)
     multipart-post (2.1.1)
+    mutex_m (0.2.0)
     nokogiri (1.15.2)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
@@ -104,6 +122,8 @@ GEM
     systemu (2.6.5)
     thread_safe (0.3.6)
     timecop (0.9.4)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.8)
@@ -114,6 +134,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport (>= 4)
   benchmark-ips
   bundler
   concurrent-ruby (~> 1.0, >= 1.0.5)

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2017 Jeff Dwyer
+Copyright (c) 2023 Prefab, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION

@@ -1 +1 @@
-1.2.1
+1.3.0

data/lib/prefab/client.rb

@@ -22,6 +22,8 @@ module Prefab
 
       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
@@ -96,6 +98,8 @@ module Prefab
       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)

data/lib/prefab/config_client.rb

@@ -31,6 +31,8 @@ module Prefab
 
       if @options.local_only?
         finish_init!(:local_only, nil)
+      elsif @options.datafile?
+        load_json_file(@options.datafile)
       else
         load_checkpoint
         start_checkpointing_thread
@@ -141,8 +143,16 @@ module Prefab
         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
 
@@ -156,7 +166,7 @@ module Prefab
         [
           context.type,
           context.values.keys.map do |k|
-            [k, Prefab::ConfigValueUnwrapper.new(context.values[k]).unwrap]
+            [k, Prefab::ConfigValueUnwrapper.new(context.values[k], @config_resolver).unwrap]
           end.to_h
         ]
       end.to_h
@@ -210,12 +220,21 @@ module Prefab
         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

data/lib/prefab/config_loader.rb

@@ -54,6 +54,7 @@ module Prefab
     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|
@@ -63,6 +64,7 @@ module Prefab
     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|

data/lib/prefab/config_value_unwrapper.rb

@@ -3,37 +3,115 @@
 module Prefab
   class ConfigValueUnwrapper
     LOG = Prefab::InternalLogger.new(ConfigValueUnwrapper)
-    attr_reader :value, :weighted_value_index
+    CONFIDENTIAL_PREFIX = "*****"
+    attr_reader :weighted_value_index
 
-    def initialize(value, weighted_value_index = nil)
-      @value = value
+    def initialize(config_value, resolver, weighted_value_index = nil)
+      @config_value = config_value
+      @resolver = resolver
       @weighted_value_index = weighted_value_index
     end
 
-    def unwrap
-      case value.type
-      when :int, :string, :double, :bool, :log_level
-        value.public_send(value.type)
-      when :string_list
-        value.string_list.values
+    def reportable_wrapped_value
+      if @config_value.confidential
+        # Unique hash for differentiation
+        Prefab::ConfigValueWrapper.wrap("#{CONFIDENTIAL_PREFIX}#{Digest::MD5.hexdigest(unwrap)[0,5]}")
       else
-        LOG.error "Unknown type: #{config_value.type}"
-        raise "Unknown type: #{config_value.type}"
+        @config_value
+      end
+    end
+
+    def reportable_value
+      Prefab::ConfigValueUnwrapper.new(reportable_wrapped_value, @resolver, @weighted_value_index).unwrap
+    end
+
+    def raw_config_value
+      @config_value
+    end
+
+    # this will return the actual value of confidential, use reportable_value unless you need it
+    def unwrap
+      raw = case @config_value.type
+            when :int, :string, :double, :bool, :log_level
+              @config_value.public_send(@config_value.type)
+            when :string_list
+              @config_value.string_list.values
+            else
+              LOG.error "Unknown type: #{@config_value.type}"
+              raise "Unknown type: #{@config_value.type}"
+            end
+      if @config_value.has_decrypt_with?
+        decryption_key = @resolver.get(@config_value.decrypt_with)&.unwrapped_value
+        if decryption_key.nil?
+          LOG.warn "No value for decryption key #{@config_value.decrypt_with} found."
+          return ""
+        else
+          unencrypted = Prefab::Encryption.new(decryption_key).decrypt(raw)
+          return unencrypted
+        end
       end
+
+      raw
+
     end
 
-    def self.deepest_value(config_value, config_key, context)
+    def self.deepest_value(config_value, config, context, resolver)
       if config_value&.type == :weighted_values
         value, index = Prefab::WeightedValueResolver.new(
           config_value.weighted_values.weighted_values,
-          config_key,
+          config.key,
           context.get(config_value.weighted_values.hash_by_property_name)
         ).resolve
 
-        new(deepest_value(value.value, config_key, context).value, index)
+        new(deepest_value(value.value, config, context, resolver).raw_config_value, resolver, index)
+
+      elsif config_value&.type == :provided
+        if :ENV_VAR == config_value.provided.source
+          raw = ENV[config_value.provided.lookup]
+          if raw.nil?
+            LOG.warn "ENV Variable #{config_value.provided.lookup} not found. Using empty string."
+            new(Prefab::ConfigValueWrapper.wrap(""), resolver)
+          else
+            coerced = coerce_into_type(raw, config, config_value.provided.lookup)
+            new(Prefab::ConfigValueWrapper.wrap(coerced, confidential: config_value.confidential), resolver)
+          end
+        else
+          raise "Unknown Provided Source #{config_value.provided.source}"
+        end
+      else
+        new(config_value, resolver)
+      end
+    end
+
+    # Don't allow env vars to resolve to a value_type other than the config's value_type
+    def self.coerce_into_type(value_string, config, env_var_name)
+      case config.value_type
+      when :INT then Integer(value_string)
+      when :DOUBLE then Float(value_string)
+      when :STRING then String(value_string)
+      when :STRING_LIST then
+        maybe_string_list = YAML.load(value_string)
+        case maybe_string_list
+        when Array
+          maybe_string_list
+        else
+          raise raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
+        end
+      when :BOOL then
+        maybe_bool = YAML.load(value_string)
+        case maybe_bool
+        when TrueClass,FalseClass
+          maybe_bool
+        else
+          raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
+        end
+      when :NOT_SET_VALUE_TYPE
+        YAML.load(value_string)
       else
-        new(config_value)
+        raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
       end
+    rescue ArgumentError
+      raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
     end
   end
 end

data/lib/prefab/config_value_wrapper.rb

@@ -1,17 +1,17 @@
 module Prefab
   class ConfigValueWrapper
-    def self.wrap(value)
+    def self.wrap(value, confidential: nil)
       case value
       when Integer
-        PrefabProto::ConfigValue.new(int: value)
+        PrefabProto::ConfigValue.new(int: value, confidential: confidential)
       when Float
-        PrefabProto::ConfigValue.new(double: value)
+        PrefabProto::ConfigValue.new(double: value, confidential: confidential)
       when TrueClass, FalseClass
-        PrefabProto::ConfigValue.new(bool: value)
+        PrefabProto::ConfigValue.new(bool: value, confidential: confidential)
       when Array
-        PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: value.map(&:to_s)))
+        PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: value.map(&:to_s)), confidential: confidential)
       else
-        PrefabProto::ConfigValue.new(string: value.to_s)
+        PrefabProto::ConfigValue.new(string: value.to_s, confidential: confidential)
       end
     end
   end

data/lib/prefab/criteria_evaluator.rb

@@ -22,7 +22,7 @@ module Prefab
     def evaluate(properties)
       rtn = evaluate_for_env(@project_env_id, properties) ||
         evaluate_for_env(0, properties)
-      LOG.debug "Eval Key #{@config.key} Result #{rtn&.value} with #{properties.to_h}" unless @config.config_type == :LOG_LEVEL
+      LOG.debug "Eval Key #{@config.key} Result #{rtn&.reportable_value} with #{properties.to_h}" unless @config.config_type == :LOG_LEVEL
       rtn
     end
 
@@ -93,7 +93,8 @@ module Prefab
             value: conditional_value.value,
             value_index: value_index,
             config_row_index: index,
-            context: properties
+            context: properties,
+            resolver: @resolver
           )
         end
       end
@@ -111,7 +112,7 @@ module Prefab
 
     def matches?(criterion, value, properties)
       criterion_value_or_values = Prefab::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config.key,
-                                                                             properties).unwrap
+                                                                             properties, @resolver).unwrap
 
       case criterion_value_or_values
       when Google::Protobuf::RepeatedField

data/lib/prefab/encryption.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Prefab
+  class Encryption
+    CIPHER_TYPE = "aes-256-gcm" # 32/12
+    SEPARATOR = "--"
+
+    # Hexadecimal format ensures that generated keys are representable with
+    # plain text
+    #
+    # To convert back to the original string with the desired length:
+    #   [ value ].pack("H*")
+    def self.generate_new_hex_key
+      generate_random_key.unpack("H*")[0]
+    end
+
+    def initialize(key_string_hex)
+      @key = [key_string_hex].pack("H*")
+    end
+
+    def encrypt(clear_text)
+      cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+      cipher.encrypt
+      iv = cipher.random_iv
+
+      # load them into the cipher
+      cipher.key = @key
+      cipher.iv = iv
+      cipher.auth_data = ""
+
+      # encrypt the message
+      encrypted = cipher.update(clear_text)
+      encrypted << cipher.final
+      tag = cipher.auth_tag
+
+      # pack and join
+      [encrypted, iv, tag].map { |p| p.unpack("H*")[0] }.join(SEPARATOR)
+    end
+
+    def decrypt(encrypted_string)
+      unpacked_parts = encrypted_string.split(SEPARATOR).map { |p| [p].pack("H*") }
+
+      cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+      cipher.decrypt
+      cipher.key = @key
+      cipher.iv = unpacked_parts[1]
+      cipher.auth_tag = unpacked_parts[2]
+
+      # and decrypt it
+      decrypted = cipher.update(unpacked_parts[0])
+      decrypted << cipher.final
+      decrypted
+    end
+
+    private
+
+    def self.generate_random_key
+      SecureRandom.random_bytes(key_length)
+    end
+
+    def self.key_length
+      OpenSSL::Cipher.new(CIPHER_TYPE).key_len
+    end
+  end
+end

data/lib/prefab/errors/env_var_parse_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class EnvVarParseError < Prefab::Error
+      def initialize(env_var, config, env_var_name)
+        super("Evaluating #{config.key} couldn't coerce #{env_var_name} of #{env_var} to #{config.value_type}")
+      end
+    end
+  end
+end

data/lib/prefab/evaluation.rb

@@ -5,18 +5,23 @@ module Prefab
   class Evaluation
     attr_reader :value
 
-    def initialize(config:, value:, value_index:, config_row_index:, context:)
+    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)
 
@@ -27,7 +32,6 @@ module Prefab
 
     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,
@@ -35,14 +39,14 @@ module Prefab
           config_id: @config.id,
           config_row_index: @config_row_index,
           conditional_value_index: @value_index,
-          selected_value: deepest_value.value,
+          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.key, @context)
+      @deepest_value ||= Prefab::ConfigValueUnwrapper.deepest_value(@value, @config, @context, @resolver)
     end
   end
 end

data/lib/prefab/internal_logger.rb

@@ -1,33 +1,16 @@
 # frozen_string_literal: true
 
 module Prefab
-  class InternalLogger < ::Logger
+  class InternalLogger < StaticLogger
+    INTERNAL_PREFIX = 'cloud.prefab.client'
+
     def initialize(path)
       if path.is_a?(Class)
-        @path = path.name.split('::').last.downcase
+        path_string = path.name.split('::').last.downcase
       else
-        @path = path
+        path_string = path
       end
-    end
-
-    def debug msg
-      Prefab::LoggerClient.instance.log_internal ::Logger::DEBUG, msg, @path
-    end
-
-    def info msg
-      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, msg, @path
-    end
-
-    def warn msg
-      Prefab::LoggerClient.instance.log_internal ::Logger::WARN, msg, @path
-    end
-
-    def error msg
-      Prefab::LoggerClient.instance.log_internal ::Logger::ERROR, msg, @path
-    end
-
-    def fatal msg
-      Prefab::LoggerClient.instance.log_internal ::Logger::FATAL, msg, @path
+      super("#{INTERNAL_PREFIX}.#{path_string}")
     end
   end
 end

data/lib/prefab/local_config_parser.rb

@@ -7,6 +7,10 @@ module Prefab
         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}"
@@ -23,8 +27,8 @@ module Prefab
               key: key,
               rows: [
                 PrefabProto::ConfigRow.new(values: [
-                                             PrefabProto::ConditionalValue.new(value: value_from(key, value))
-                                           ])
+                  PrefabProto::ConditionalValue.new(value: value_from(key, value))
+                ])
               ]
             )
           }
@@ -79,6 +83,58 @@ module Prefab
         }
       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'],