prefab-cloud-ruby 0.20.0 → 0.22.0

data/lib/prefab/config_client.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
+
 module Prefab
   class ConfigClient
-    include Prefab::ConfigHelper
-
     RECONNECT_WAIT = 5
     DEFAULT_CHECKPOINT_FREQ_SEC = 60
     SSE_READ_TIMEOUT = 300
-    AUTH_USER = "authuser"
+    AUTH_USER = 'authuser'
 
     def initialize(base_client, timeout)
       @base_client = base_client
       @options = base_client.options
-      @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient"
+      @base_client.log_internal ::Logger::DEBUG, 'Initialize ConfigClient'
       @timeout = timeout
 
       @stream_lock = Concurrent::ReadWriteLock.new
@@ -22,9 +21,9 @@ module Prefab
       @config_resolver = Prefab::ConfigResolver.new(@base_client, @config_loader)
 
       @initialization_lock = Concurrent::ReadWriteLock.new
-      @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient: AcquireWriteLock"
+      @base_client.log_internal ::Logger::DEBUG, 'Initialize ConfigClient: AcquireWriteLock'
       @initialization_lock.acquire_write_lock
-      @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient: AcquiredWriteLock"
+      @base_client.log_internal ::Logger::DEBUG, 'Initialize ConfigClient: AcquiredWriteLock'
       @initialized_future = Concurrent::Future.execute { @initialization_lock.acquire_read_lock }
 
       @cancellable_interceptor = Prefab::CancellableInterceptor.new(@base_client)
@@ -45,14 +44,15 @@ module Prefab
     end
 
     def upsert(key, config_value, namespace = nil, previous_key = nil)
-      raise "Key must not contain ':' set namespaces separately" if key.include? ":"
-      raise "Namespace must not contain ':'" if namespace&.include?(":")
+      raise "Key must not contain ':' set namespaces separately" if key.include? ':'
+      raise "Namespace must not contain ':'" if namespace&.include?(':')
+
       config_delta = Prefab::ConfigClient.value_to_delta(key, config_value, namespace)
       upsert_req = Prefab::UpsertRequest.new(config_delta: config_delta)
       upsert_req.previous_key = previous_key if previous_key&.present?
 
       @base_client.request Prefab::ConfigService, :upsert, req_options: { timeout: @timeout }, params: upsert_req
-      @base_client.stats.increment("prefab.config.upsert")
+      @base_client.stats.increment('prefab.config.upsert')
       @config_loader.set(config_delta, :upsert)
       @config_loader.rm(previous_key) if previous_key&.present?
       @config_resolver.update
@@ -68,46 +68,43 @@ module Prefab
     end
 
     def self.value_to_delta(key, config_value, namespace = nil)
-      Prefab::Config.new(key: [namespace, key].compact.join(":"),
+      Prefab::Config.new(key: [namespace, key].compact.join(':'),
                          rows: [Prefab::ConfigRow.new(value: config_value)])
     end
 
-    def get(key, default=Prefab::Client::NO_DEFAULT_PROVIDED)
-      config = _get(key)
-      config ? value_of(config[:value]) : handle_default(key, default)
-    end
-
-    def get_config_obj(key)
-      config = _get(key)
-      config ? config[:config] : nil
+    def get(key, default = Prefab::Client::NO_DEFAULT_PROVIDED, properties = {}, lookup_key = nil)
+      value = _get(key, lookup_key, properties)
+      value ? Prefab::ConfigValueUnwrapper.unwrap(value, key, properties) : handle_default(key, default)
     end
 
     private
 
+    def raw(key)
+      @config_resolver.raw(key)
+    end
+
     def handle_default(key, default)
-      if default != Prefab::Client::NO_DEFAULT_PROVIDED
-        return default
-      end
+      return default if default != Prefab::Client::NO_DEFAULT_PROVIDED
 
-      if @options.on_no_default == Prefab::Options::ON_NO_DEFAULT::RAISE
-        raise Prefab::Errors::MissingDefaultError.new(key)
-      end
+      raise Prefab::Errors::MissingDefaultError, key if @options.on_no_default == Prefab::Options::ON_NO_DEFAULT::RAISE
 
       nil
     end
 
-    def _get(key)
+    def _get(key, lookup_key, properties)
       # wait timeout sec for the initalization to be complete
       @initialized_future.value(@options.initialization_timeout_sec)
       if @initialized_future.incomplete?
-        if @options.on_init_failure == Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN
-          @base_client.log_internal Logger::WARN, "Couldn't Initialize In #{@options.initialization_timeout_sec}. Key #{key}. Returning what we have"
-          @initialization_lock.release_write_lock
-        else
+        unless @options.on_init_failure == Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN
           raise Prefab::Errors::InitializationTimeoutError.new(@options.initialization_timeout_sec, key)
         end
+
+        @base_client.log_internal ::Logger::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)
+      @config_resolver.get(key, lookup_key, properties)
     end
 
     def stub
@@ -120,19 +117,15 @@ module Prefab
     def load_checkpoint
       success = load_checkpoint_api_cdn
 
-      if success
-        return
-      else
-        @base_client.log_internal Logger::INFO, "LoadCheckpoint: Fallback to GRPC API"
-      end
+      return if success
+
+      @base_client.log_internal ::Logger::INFO, 'LoadCheckpoint: Fallback to GRPC API'
 
       success = load_checkpoint_from_grpc_api
 
-      if success
-        return
-      else
-        @base_client.log_internal Logger::WARN, "No success loading checkpoints"
-      end
+      return if success
+
+      @base_client.log_internal ::Logger::WARN, 'No success loading checkpoints'
     end
 
     def load_checkpoint_from_grpc_api
@@ -142,9 +135,9 @@ module Prefab
       load_configs(resp, :remote_api_grpc)
       true
     rescue GRPC::Unauthenticated
-      @base_client.log_internal Logger::WARN, "Unauthenticated"
-    rescue => e
-      @base_client.log_internal Logger::WARN, "Unexpected grpc_api problem loading checkpoint #{e}"
+      @base_client.log_internal ::Logger::WARN, 'Unauthenticated'
+    rescue StandardError => e
+      @base_client.log_internal ::Logger::WARN, "Unexpected grpc_api problem loading checkpoint #{e}"
       false
     end
 
@@ -169,11 +162,11 @@ module Prefab
         load_configs(configs, source)
         true
       else
-        @base_client.log_internal Logger::INFO, "Checkpoint #{source} failed to load. Response #{resp.status}"
+        @base_client.log_internal ::Logger::INFO, "Checkpoint #{source} failed to load. Response #{resp.status}"
         false
       end
-    rescue => e
-      @base_client.log_internal Logger::WARN, "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
+    rescue StandardError => e
+      @base_client.log_internal ::Logger::WARN, "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
       false
     end
 
@@ -187,42 +180,39 @@ module Prefab
         @config_loader.set(config, source)
       end
       if @config_loader.highwater_mark > starting_highwater_mark
-        @base_client.log_internal Logger::INFO, "Found new checkpoint with highwater id #{@config_loader.highwater_mark} from #{source} in project #{project_id} environment: #{project_env_id} and namespace: '#{@namespace}'"
+        @base_client.log_internal ::Logger::INFO,
+                                  "Found new checkpoint with highwater id #{@config_loader.highwater_mark} from #{source} in project #{project_id} environment: #{project_env_id} and namespace: '#{@namespace}'"
       else
-        @base_client.log_internal Logger::DEBUG, "Checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}. No changes.", "load_configs"
+        @base_client.log_internal ::Logger::DEBUG,
+                                  "Checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}. No changes.", 'load_configs'
       end
-      @base_client.stats.increment("prefab.config.checkpoint.load")
+      @base_client.stats.increment('prefab.config.checkpoint.load')
       @config_resolver.update
       finish_init!(source)
     end
 
     # A thread that checks for a checkpoint
     def start_checkpointing_thread
-
       Thread.new do
         loop do
-          begin
-            load_checkpoint
-
-            started_at = Time.now
-            delta = @checkpoint_freq_secs - (Time.now - started_at)
-            if delta > 0
-              sleep(delta)
-            end
-          rescue StandardError => exn
-            @base_client.log_internal Logger::INFO, "Issue Checkpointing #{exn.message}"
-          end
+          load_checkpoint
+
+          started_at = Time.now
+          delta = @checkpoint_freq_secs - (Time.now - started_at)
+          sleep(delta) if delta > 0
+        rescue StandardError => e
+          @base_client.log_internal ::Logger::INFO, "Issue Checkpointing #{e.message}"
         end
       end
     end
 
     def finish_init!(source)
-      if @initialization_lock.write_locked?
-        @base_client.log_internal Logger::INFO, "Unlocked Config via #{source}"
-        @initialization_lock.release_write_lock
-        @base_client.log.set_config_client(self)
-        @base_client.log_internal Logger::INFO, to_s
-      end
+      return unless @initialization_lock.write_locked?
+
+      @base_client.log_internal ::Logger::INFO, "Unlocked Config via #{source}"
+      @initialization_lock.release_write_lock
+      @base_client.log.set_config_client(self)
+      @base_client.log_internal ::Logger::INFO, to_s
     end
 
     def start_sse_streaming_connection_thread(start_at_id)
@@ -230,10 +220,10 @@ module Prefab
       auth_string = Base64.strict_encode64(auth)
       headers = {
         "x-prefab-start-at-id": start_at_id,
-        "Authorization": "Basic #{auth_string}",
+        "Authorization": "Basic #{auth_string}"
       }
       url = "#{@base_client.prefab_api_url}/api/v1/sse/config"
-      @base_client.log_internal Logger::INFO, "SSE Streaming Connect to #{url} start_at #{start_at_id}"
+      @base_client.log_internal ::Logger::INFO, "SSE Streaming Connect to #{url} start_at #{start_at_id}"
       @streaming_thread = SSE::Client.new(url,
                                           headers: headers,
                                           read_timeout: SSE_READ_TIMEOUT,
@@ -246,4 +236,3 @@ module Prefab
     end
   end
 end
-

data/lib/prefab/config_loader.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'yaml'
 module Prefab
   class ConfigLoader
     attr_reader :highwater_mark
@@ -19,21 +18,19 @@ module Prefab
       @api_config.each_key do |k|
         rtn[k] = @api_config[k]
       end
-      rtn = rtn.merge(@local_overrides)
-      rtn
+      rtn.merge(@local_overrides)
     end
 
     def set(config, source)
       # don't overwrite newer values
-      if @api_config[config.key] && @api_config[config.key][:config].id >= config.id
-        return
-      end
+      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]
-          @base_client.log_internal Logger::DEBUG, "Replace #{config.key} with value from #{source} #{ @api_config[config.key][:config].id} -> #{config.id}"
+          @base_client.log_internal ::Logger::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
@@ -56,7 +53,7 @@ module Prefab
 
     def load_classpath_config
       classpath_dir = @prefab_options.prefab_config_classpath_dir
-      rtn = load_glob(File.join(classpath_dir, ".prefab.default.config.yaml"))
+      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
@@ -65,7 +62,7 @@ module Prefab
 
     def load_local_overrides
       override_dir = @prefab_options.prefab_config_override_dir
-      rtn = load_glob(File.join(override_dir, ".prefab.overrides.config.yaml"))
+      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
@@ -75,113 +72,9 @@ module Prefab
     def load_glob(glob)
       rtn = {}
       Dir.glob(glob).each do |file|
-        @base_client.log_internal Logger::INFO, "Load #{file}"
-        yaml = load(file)
-        yaml.each do |k, v|
-          load_kv(k, v, rtn, file)
-        end
+        Prefab::YAMLConfigParser.new(file, @base_client).merge(rtn)
       end
       rtn
     end
-
-    def load_kv(k, v, rtn, file)
-      if v.class == Hash
-        if v['feature_flag']
-          rtn[k] = feature_flag_config(file, k, v)
-        else
-          v.each do |nest_k, nest_v|
-            nested_key = "#{k}.#{nest_k}"
-            nested_key = k if nest_k == "_"
-            load_kv(nested_key, nest_v, rtn, file)
-          end
-        end
-      else
-        rtn[k] = {
-          source: file,
-          match: "default",
-          config: Prefab::Config.new(
-            key: k,
-            rows: [
-              Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(value_from(k, v)))
-            ]
-          )
-        }
-      end
-    end
-
-    def load(filename)
-      if File.exist? filename
-        @base_client.log_internal Logger::INFO, "Load #{filename}"
-        YAML.load_file(filename)
-      else
-        @base_client.log_internal Logger::INFO, "No file #{filename}"
-        {}
-      end
-    end
-
-    def value_from(key, raw)
-      case raw
-      when String
-        if key.start_with? Prefab::LoggerClient::BASE_KEY
-          prefab_log_level_resolve = Prefab::LogLevel.resolve(raw.upcase.to_sym) || Prefab::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)
-      criteria = Prefab::Criteria.new(operator: 'ALWAYS_TRUE')
-
-      if value['criteria']
-        criteria = Prefab::Criteria.new(criteria_values(value['criteria']))
-      end
-
-      row = Prefab::ConfigRow.new(
-        value: Prefab::ConfigValue.new(
-          feature_flag: Prefab::FeatureFlag.new(
-            active: true,
-            inactive_variant_idx: -1, # not supported
-            rules: [
-              Prefab::Rule.new(
-                variant_weights: [
-                  Prefab::VariantWeight.new(variant_idx: 0, weight: 1000)
-                ],
-                criteria: criteria
-              )
-            ]
-          )
-        )
-      )
-
-      unless value.has_key?('value')
-        raise Prefab::Error, "Feature flag config `#{key}` #{file} must have a `value`"
-      end
-
-      {
-        source: file,
-        match: key,
-        config: Prefab::Config.new(
-          key: key,
-          variants: [Prefab::FeatureFlagVariant.new(value_from(key, value['value']))],
-          rows: [row]
-        )
-      }
-    end
-
-    def criteria_values(criteria_hash)
-      if RUBY_VERSION < '2.7'
-        criteria_hash.transform_keys(&:to_sym)
-      else
-        criteria_hash
-      end
-    end
   end
 end

data/lib/prefab/config_resolver.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
+
 module Prefab
   class ConfigResolver
-    include Prefab::ConfigHelper
-    NAMESPACE_DELIMITER = "."
-
     attr_accessor :project_env_id # this will be set by the config_client when it gets an API response
 
     def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @namespace = base_client.options.namespace
+      @additional_properties = { Prefab::CriteriaEvaluator::NAMESPACE_KEY => base_client.options.namespace }
       @config_loader = config_loader
-      @project_env_id = 0
+      @project_env_id = 0 # we don't know this yet, it is set from the API results
+      @base_client = base_client
       make_local
     end
 
@@ -22,82 +21,53 @@ module Prefab
           v = @local_store[k]
           elements = [k.slice(0..49).ljust(50)]
           if v.nil?
-            elements << "tombstone"
+            elements << 'tombstone'
           else
-            value = v[:value]
-            elements << value_of(value).to_s.slice(0..34).ljust(35)
-            elements << value_of(value).class.to_s.slice(0..6).ljust(7)
+            config = evaluate(v[:config], {})
+            value = Prefab::ConfigValueUnwrapper.unwrap(config, k, {})
+            elements << value.to_s.slice(0..34).ljust(35)
+            elements << value.class.to_s.slice(0..6).ljust(7)
             elements << "Match: #{v[:match]}".slice(0..29).ljust(30)
             elements << "Source: #{v[:source]}"
           end
-          str += elements.join(" | ") << "\n"
+          str += elements.join(' | ') << "\n"
         end
       end
       str
     end
 
-    def get(property)
-      config = _get(property)
-      config ? value_of(config[:value]) : nil
-    end
+    def raw(key)
+      via_key = @local_store[key]
 
-    def get_config(property)
-      config = _get(property)
-      config ? config[:config] : nil
+      via_key ? via_key[:config] : nil
     end
 
-    def _get(key)
+    def get(key, lookup_key, properties = {})
       @lock.with_read_lock do
-        @local_store[key]
+        raw_config = raw(key)
+
+        return nil unless raw_config
+
+        evaluate(raw(key), lookup_key, properties)
       end
     end
 
+    def evaluate(config, lookup_key, properties = {})
+      props = properties.merge(@additional_properties).merge(Prefab::CriteriaEvaluator::LOOKUP_KEY => lookup_key)
+
+      Prefab::CriteriaEvaluator.new(config,
+                                    project_env_id: @project_env_id, resolver: self, base_client: @base_client).evaluate(props)
+    end
+
     def update
       make_local
     end
 
     private
 
-    # Should client a.b.c see key in namespace a.b? yes
-    # Should client a.b.c see key in namespace a.b.c? yes
-    # Should client a.b.c see key in namespace a.b.d? no
-    # Should client a.b.c see key in namespace ""? yes
-    #
-    def starts_with_ns?(key_namespace, client_namespace)
-      zipped = key_namespace.split(NAMESPACE_DELIMITER).zip(client_namespace.split(NAMESPACE_DELIMITER))
-      mapped = zipped.map do |k, c|
-        (k.nil? || k.empty?) || k == c
-      end
-      [mapped.all?, mapped.size]
-    end
-
     def make_local
-      store = {}
-      @config_loader.calc_config.each do |key, config_resolver_obj|
-        config = config_resolver_obj[:config]
-        sortable = config.rows.map do |row|
-          if row.project_env_id != 0
-            if row.project_env_id == @project_env_id
-              if !row.namespace.empty?
-                (starts_with, count) = starts_with_ns?(row.namespace, @namespace)
-                # rubocop:disable BlockNesting
-                { sortable: 2 + count, match: "nm:#{row.namespace}", value: row.value, config: config} if starts_with
-              else
-                { sortable: 1, match: "env:#{row.project_env_id}", value: row.value, config: config}
-              end
-            end
-          else
-            match = config_resolver_obj[:match] || "default"
-            { sortable: 0, match: match, value: row.value, config: config}
-          end
-        end.compact
-        to_store = sortable.sort_by { |h| h[:sortable] }.last
-        to_store[:source] = config_resolver_obj[:source]
-        store[key] = to_store
-      end
-
       @lock.with_write_lock do
-        @local_store = store
+        @local_store = @config_loader.calc_config
       end
     end
   end

data/lib/prefab/config_value_unwrapper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ConfigValueUnwrapper
+    def self.unwrap(config_value, config_key, properties)
+      return nil unless config_value
+
+      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
+      when :weighted_values
+        lookup_key = properties[Prefab::CriteriaEvaluator::LOOKUP_KEY]
+        weights = config_value.weighted_values.weighted_values
+        value = Prefab::WeightedValueResolver.new(weights, config_key, lookup_key).resolve
+        unwrap(value.value, config_key, properties)
+      else
+        raise "Unknown type: #{config_value.type}"
+      end
+    end
+  end
+end

data/lib/prefab/criteria_evaluator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Prefab
+  class CriteriaEvaluator
+    LOOKUP_KEY = 'LOOKUP'
+    NAMESPACE_KEY = 'NAMESPACE'
+    NO_MATCHING_ROWS = [].freeze
+
+    def initialize(config, project_env_id:, resolver:, base_client:)
+      @config = config
+      @project_env_id = project_env_id
+      @resolver = resolver
+      @base_client = base_client
+    end
+
+    def evaluate(properties)
+      # TODO: optimize this and perhaps do it elsewhere
+      props = properties.transform_keys(&:to_s)
+
+      matching_environment_row_values.each do |conditional_value|
+        return conditional_value.value if all_criteria_match?(conditional_value, props)
+      end
+
+      default_row_values.each do |conditional_value|
+        return conditional_value.value if all_criteria_match?(conditional_value, props)
+      end
+
+      nil
+    end
+
+    def all_criteria_match?(conditional_value, props)
+      conditional_value.criteria.all? do |criterion|
+        evaluate_criteron(criterion, props)
+      end
+    end
+
+    def evaluate_criteron(criterion, properties)
+      value_from_properties = properties[criterion.property_name]
+
+      case criterion.operator
+      when :LOOKUP_KEY_IN, :PROP_IS_ONE_OF
+        matches?(criterion, value_from_properties, properties)
+      when :LOOKUP_KEY_NOT_IN, :PROP_IS_NOT_ONE_OF
+        !matches?(criterion, value_from_properties, properties)
+      when :IN_SEG
+        in_segment?(criterion, properties)
+      when :NOT_IN_SEG
+        !in_segment?(criterion, properties)
+      when :PROP_ENDS_WITH_ONE_OF
+        return false unless value_from_properties
+
+        criterion.value_to_match.string_list.values.any? do |ending|
+          value_from_properties.end_with?(ending)
+        end
+      when :PROP_DOES_NOT_END_WITH_ONE_OF
+        return true unless value_from_properties
+
+        criterion.value_to_match.string_list.values.none? do |ending|
+          value_from_properties.end_with?(ending)
+        end
+      when :HIERARCHICAL_MATCH
+        value_from_properties.start_with?(criterion.value_to_match.string)
+      when :ALWAYS_TRUE
+        true
+      else
+        @base_client.log.info("Unknown Operator: #{criterion.operator}")
+        false
+      end
+    end
+
+    private
+
+    def matching_environment_row_values
+      @config.rows.find { |row| row.project_env_id == @project_env_id }&.values || NO_MATCHING_ROWS
+    end
+
+    def default_row_values
+      @config.rows.find { |row| row.project_env_id != @project_env_id }&.values || NO_MATCHING_ROWS
+    end
+
+    def in_segment?(criterion, properties)
+      @resolver.get(criterion.value_to_match.string, properties[LOOKUP_KEY], properties).bool
+    end
+
+    def matches?(criterion, value_from_properties, properties)
+      criterion_value_or_values = Prefab::ConfigValueUnwrapper.unwrap(criterion.value_to_match, @config.key, properties)
+
+      case criterion_value_or_values
+      when Google::Protobuf::RepeatedField
+        criterion_value_or_values.include?(value_from_properties)
+      else
+        criterion_value_or_values == value_from_properties
+      end
+    end
+  end
+end

data/lib/prefab/errors/invalid_api_key_error.rb

@@ -5,7 +5,7 @@ module Prefab
     class InvalidApiKeyError < Prefab::Error
       def initialize(key)
         if key.nil? || key.empty?
-          message = "No API key. Set PREFAB_API_KEY env var or use PREFAB_DATASOURCES=LOCAL_ONLY"
+          message = 'No API key. Set PREFAB_API_KEY env var or use PREFAB_DATASOURCES=LOCAL_ONLY'
 
           super(message)
         else