prefab-cloud-ruby 0.21.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a34b06515d401b7e73fd8b6adf77294187d94ea3a1d1909d159ebfd63b4046ad
-  data.tar.gz: 6ba449742b1a75517b35a47151452dbdf94c0a8aef0e58a639ae5b2481262d43
+  metadata.gz: 2cd914702e6efb141278bbf12bf120342c0de3d788e8e6399a3baefd8f11a102
+  data.tar.gz: d7ba7ad4210bbf2f89005479e970f33b6486a67fbef125502c86455830381797
 SHA512:
-  metadata.gz: 0a32e0ac965c54d634c579de66927d2982cca26d7098daaf3cdfd2dda88bf04bd33265c1e9f85e303d75fc9360f6df202cee256e59a91012b94f0adcf29252aa
-  data.tar.gz: 2c37b2cfeef43f44d2dcbe8835ff8ea130393ad98dd9dd61328371972bf1818ab12d932f6bec319a52ec2423f9204762c6305ab3643023a3aa5ea4bfd18974bf
+  metadata.gz: a797285f8e5ecffc90b5861f87af50c5aae93f6dc3ba1803b79232823ee4ff2fa4fdf4017c04712aa89fa5f607496eb99376dbc6595bcfad69e2df2ae0aa0324
+  data.tar.gz: 965bc69143e55822b5a53d691eb50ee5a883b50e85dfe3ecf868ab58b947efc717b752d287d636636846418539c2ce602451b12b4a29f596a41a41be2839ef7e

data/.github/workflows/ruby.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
+        ruby-version: ['2.6', '2.7', '3.0', '3.1']
 
     steps:
     - uses: actions/checkout@v3

data/Gemfile

@@ -6,6 +6,7 @@ gem 'googleapis-common-protos-types', platforms: :ruby
 gem 'google-protobuf', platforms: :ruby
 gem 'grpc', platforms: :ruby
 gem 'ld-eventsource'
+gem 'uuid'
 
 group :development do
   gem 'benchmark-ips'
@@ -20,4 +21,5 @@ group :test do
   gem 'minitest'
   gem 'minitest-focus'
   gem 'minitest-reporters'
+  gem 'timecop'
 end

data/Gemfile.lock

@@ -68,6 +68,8 @@ GEM
     llhttp-ffi (0.3.1)
       ffi-compiler (~> 1.0)
       rake (~> 13.0)
+    macaddr (1.7.2)
+      systemu (~> 2.6.5)
     mini_portile2 (2.8.0)
     minitest (5.16.2)
     minitest-focus (1.3.1)
@@ -92,7 +94,7 @@ GEM
     psych (3.3.1)
     public_suffix (4.0.6)
     racc (1.6.1)
-    rack (3.0.4.1)
+    rack (3.0.6.1)
     rake (13.0.6)
     rchardet (1.8.0)
     rdoc (6.3.3)
@@ -103,10 +105,14 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.3)
+    systemu (2.6.5)
     thread_safe (0.3.6)
+    timecop (0.9.4)
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.8)
+    uuid (2.3.9)
+      macaddr (~> 1.0)
 
 PLATFORMS
   ruby
@@ -127,6 +133,8 @@ DEPENDENCIES
   minitest-reporters
   rdoc
   simplecov
+  timecop
+  uuid
 
 BUNDLED WITH
    2.3.5

data/README.md

@@ -3,18 +3,20 @@ Ruby Client for Prefab FeatureFlags, Config as a Service: https://www.prefab.clo
 
 ```ruby
 client = Prefab::Client.new
-@feature_flags = client.feature_flag_client
 
-# Create a flag that is on for 10% of traffic, the entire beta group and user:1
-@feature_flags.upsert(Prefab::FeatureFlag.new(feature: "MyFeature", pct: 0.1, whitelisted: ["betas", "user:1"]))
+lookup_key = "user-123"
+identity_attributes = {
+  team_id: 432,
+  user_id: 123,
+  subscription_level: 'pro',
+  email: "alice@example.com"
+}
 
-# Use Flags By Themselves
-puts @feature_flags.feature_is_on? "MyFeature"  # returns yes 10 pct of the time
+result = client.enabled? "my-first-feature-flag", lookup_key, identity_attributes
 
-# A single user should get the same result each time
-puts @feature_flags.feature_is_on? "MyFeature", "user:1123"
+puts "my-first-feature-flag is: #{result} for #{lookup_key}"
 ```
-See full documentation https://www.prefab.cloud/documentation/installation
+See full documentation https://docs.prefab.cloud/docs/ruby-sdk/ruby
 
 ## Supports
 
@@ -74,5 +76,5 @@ REMOTE_BRANCH=main LOCAL_BRANCH=main bundle exec rake release
 
 ## Copyright
 
-Copyright (c) 2022 Jeff Dwyer. See LICENSE.txt for
+Copyright (c) 2023 Jeff Dwyer. See LICENSE.txt for
 further details.

data/VERSION

@@ -1 +1 @@
-0.21.0
+0.23.0

data/lib/prefab/cancellable_interceptor.rb

@@ -13,16 +13,16 @@ module Prefab
       i = 0
       while i < WAIT_SEC
         if @call.instance_variable_get('@wrapped').cancelled?
-          @base_client.log_internal Logger::DEBUG, 'Cancelled streaming.'
+          @base_client.log_internal ::Logger::DEBUG, 'Cancelled streaming.'
           return
         else
-          @base_client.log_internal Logger::DEBUG, 'Unable to cancel streaming. Trying again'
+          @base_client.log_internal ::Logger::DEBUG, 'Unable to cancel streaming. Trying again'
           @call.instance_variable_get('@wrapped').instance_variable_get('@call').cancel
           i += 1
           sleep(1)
         end
       end
-      @base_client.log_internal Logger::INFO, 'Unable to cancel streaming.'
+      @base_client.log_internal ::Logger::INFO, 'Unable to cancel streaming.'
     end
 
     def request_response(request:, call:, method:, metadata:, &block)

data/lib/prefab/client.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'uuid'
+
 module Prefab
   class Client
     MAX_SLEEP_SEC = 10
@@ -13,16 +15,18 @@ module Prefab
     attr_reader :api_key
     attr_reader :prefab_api_url
     attr_reader :options
+    attr_reader :instance_hash
 
     def initialize(options = Prefab::Options.new)
-      @options = options
+      @options = options.is_a?(Prefab::Options) ? options : Prefab::Options.new(options)
       @shared_cache = @options.shared_cache
       @stats = @options.stats
       @namespace = @options.namespace
       @stubs = {}
+      @instance_hash = UUID.new.generate
 
       if @options.local_only?
-        log_internal Logger::INFO, 'Prefab Running in Local Mode'
+        log_internal ::Logger::INFO, 'Prefab Running in Local Mode'
       else
         @api_key = @options.api_key
         raise Prefab::Errors::InvalidApiKeyError, @api_key if @api_key.nil? || @api_key.empty? || api_key.count('-') < 1
@@ -30,12 +34,24 @@ module Prefab
         @interceptor = Prefab::AuthInterceptor.new(@api_key)
         @prefab_api_url = @options.prefab_api_url
         @prefab_grpc_url = @options.prefab_grpc_url
-        log_internal Logger::INFO,
+        log_internal ::Logger::INFO,
                      "Prefab Connecting to: #{@prefab_api_url} and #{@prefab_grpc_url} Secure: #{http_secure?}"
         at_exit do
           channel.destroy
         end
       end
+      # start config client
+      config_client
+    end
+
+    def with_log_context(lookup_key, properties)
+      Thread.current[:prefab_log_lookup_key] = lookup_key
+      Thread.current[:prefab_log_properties] = properties
+
+      yield
+    ensure
+      Thread.current[:prefab_log_lookup_key] = nil
+      Thread.current[:prefab_log_properties] = {}
     end
 
     def channel
@@ -55,9 +71,26 @@ module Prefab
       @feature_flag_client ||= Prefab::FeatureFlagClient.new(self)
     end
 
+    def log_path_collector
+      return nil if @options.collect_max_paths <= 0
+
+      @log_path_collector ||= LogPathCollector.new(client: self, max_paths: @options.collect_max_paths,
+                                                   sync_interval: @options.collect_sync_interval)
+    end
+
     def log
       @logger_client ||= Prefab::LoggerClient.new(@options.logdev, formatter: @options.log_formatter,
-                                                                   prefix: @options.log_prefix)
+                                                                   prefix: @options.log_prefix,
+                                                                   log_path_collector: log_path_collector)
+    end
+
+    def set_rails_loggers
+      Rails.logger = log
+      ActionView::Base.logger = log
+      ActionController::Base.logger = log
+      ActiveJob::Base.logger = log
+      ActiveRecord::Base.logger = log
+      ActiveStorage.logger = log
     end
 
     def log_internal(level, msg, path = nil)
@@ -65,6 +98,9 @@ module Prefab
     end
 
     def request(service, method, req_options: {}, params: {})
+      # Future-proofing since we previously bumped into a conflict with a service with a `send` method
+      raise ArgumentError, 'Cannot call public_send on an grpc service in Ruby' if method.to_s == 'public_send'
+
       opts = { timeout: 10 }.merge(req_options)
 
       attempts = 0
@@ -72,16 +108,17 @@ module Prefab
 
       begin
         attempts += 1
-        stub_for(service, opts[:timeout]).send(method, *params)
+
+        stub_for(service, opts[:timeout]).public_send(method, *params)
       rescue StandardError => e
-        log_internal Logger::WARN, e
+        log_internal ::Logger::WARN, e
 
         raise e if Time.now - start_time > opts[:timeout]
 
         sleep_seconds = [BASE_SLEEP_SEC * (2**(attempts - 1)), MAX_SLEEP_SEC].min
         sleep_seconds *= (0.5 * (1 + rand))
         sleep_seconds = [BASE_SLEEP_SEC, sleep_seconds].max
-        log_internal Logger::INFO, "Sleep #{sleep_seconds} and Reset #{service} #{method}"
+        log_internal ::Logger::INFO, "Sleep #{sleep_seconds} and Reset #{service} #{method}"
         sleep sleep_seconds
         reset!
         retry

data/lib/prefab/config_client.rb

@@ -10,7 +10,7 @@ module Prefab
     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
@@ -21,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)
@@ -74,6 +74,7 @@ module Prefab
 
     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
 
@@ -99,7 +100,7 @@ module Prefab
           raise Prefab::Errors::InitializationTimeoutError.new(@options.initialization_timeout_sec, key)
         end
 
-        @base_client.log_internal Logger::WARN,
+        @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
 
@@ -119,13 +120,13 @@ module Prefab
 
       return if success
 
-      @base_client.log_internal Logger::INFO, 'LoadCheckpoint: Fallback to GRPC API'
+      @base_client.log_internal ::Logger::INFO, 'LoadCheckpoint: Fallback to GRPC API'
 
       success = load_checkpoint_from_grpc_api
 
       return if success
 
-      @base_client.log_internal Logger::WARN, 'No success loading checkpoints'
+      @base_client.log_internal ::Logger::WARN, 'No success loading checkpoints'
     end
 
     def load_checkpoint_from_grpc_api
@@ -135,9 +136,9 @@ module Prefab
       load_configs(resp, :remote_api_grpc)
       true
     rescue GRPC::Unauthenticated
-      @base_client.log_internal Logger::WARN, 'Unauthenticated'
+      @base_client.log_internal ::Logger::WARN, 'Unauthenticated'
     rescue StandardError => e
-      @base_client.log_internal Logger::WARN, "Unexpected grpc_api problem loading checkpoint #{e}"
+      @base_client.log_internal ::Logger::WARN, "Unexpected grpc_api problem loading checkpoint #{e}"
       false
     end
 
@@ -162,11 +163,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 StandardError => e
-      @base_client.log_internal Logger::WARN, "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
+      @base_client.log_internal ::Logger::WARN, "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
       false
     end
 
@@ -180,10 +181,10 @@ module Prefab
         @config_loader.set(config, source)
       end
       if @config_loader.highwater_mark > starting_highwater_mark
-        @base_client.log_internal Logger::INFO,
+        @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,
+        @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')
@@ -201,7 +202,7 @@ module Prefab
           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}"
+          @base_client.log_internal ::Logger::INFO, "Issue Checkpointing #{e.message}"
         end
       end
     end
@@ -209,10 +210,10 @@ module Prefab
     def finish_init!(source)
       return unless @initialization_lock.write_locked?
 
-      @base_client.log_internal Logger::INFO, "Unlocked Config via #{source}"
+      @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
+      @base_client.log_internal ::Logger::INFO, to_s
     end
 
     def start_sse_streaming_connection_thread(start_at_id)
@@ -223,7 +224,7 @@ module Prefab
         "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,

data/lib/prefab/config_loader.rb

@@ -29,7 +29,7 @@ module Prefab
         @api_config.delete(config.key)
       else
         if @api_config[config.key]
-          @base_client.log_internal Logger::DEBUG,
+          @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 }

data/lib/prefab/internal_logger.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Prefab
-  class InternalLogger < Logger
+  class InternalLogger < ::Logger
     def initialize(path, logger)
       @path = path
       @logger = logger

data/lib/prefab/log_path_collector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Prefab
+  class LogPathCollector
+    INCREMENT = ->(count) { (count || 0) + 1 }
+
+    SEVERITY_KEY = {
+      ::Logger::DEBUG => 'debugs',
+      ::Logger::INFO => 'infos',
+      ::Logger::WARN => 'warns',
+      ::Logger::ERROR => 'errors',
+      ::Logger::FATAL => 'fatals'
+    }.freeze
+
+    def initialize(client:, max_paths:, sync_interval:)
+      @max_paths = max_paths
+      @sync_interval = sync_interval
+      @client = client
+      @start_at = now
+
+      @pool = Concurrent::ThreadPoolExecutor.new(
+        fallback_policy: :discard,
+        max_queue: 5,
+        max_threads: 4,
+        min_threads: 1,
+        name: 'prefab-log-paths'
+      )
+
+      @paths = Concurrent::Map.new
+
+      start_periodic_sync
+    end
+
+    def push(path, severity)
+      return unless @paths.size < @max_paths
+
+      @paths.compute([path, severity], &INCREMENT)
+    end
+
+    private
+
+    def sync
+      return if @paths.size.zero?
+
+      log_internal "Syncing #{@paths.size} paths"
+
+      flush
+    end
+
+    def flush
+      to_ship = @paths.dup
+      @paths.clear
+
+      start_at_was = @start_at
+      @start_at = now
+
+      @pool.post do
+        log_internal "Uploading stats for #{to_ship.size} paths"
+
+        aggregate = Hash.new { |h, k| h[k] = Prefab::Logger.new }
+
+        to_ship.each do |(path, severity), count|
+          aggregate[path][SEVERITY_KEY[severity]] = count
+          aggregate[path]['logger_name'] = path
+        end
+
+        loggers = Prefab::Loggers.new(
+          loggers: aggregate.values,
+          start_at: start_at_was,
+          end_at: now,
+          instance_hash: @client.instance_hash,
+          namespace: @client.namespace
+        )
+
+        @client.request Prefab::LoggerReportingService, :send, req_options: {}, params: loggers
+      end
+    end
+
+    def start_periodic_sync
+      Thread.new do
+        log_internal "Initialized log path collector instance_hash=#{@client.instance_hash} max_paths=#{@max_paths} sync_interval=#{@sync_interval}"
+
+        loop do
+          sleep @sync_interval
+          sync
+        end
+      end
+    end
+
+    def log_internal(message)
+      @client.log.log_internal message, 'log_path_collector', nil, ::Logger::INFO
+    end
+
+    def now
+      (Time.now.utc.to_f * 1000).to_i
+    end
+  end
+end

data/lib/prefab/logger_client.rb

@@ -1,33 +1,39 @@
 # frozen_string_literal: true
 
+require 'prefab/log_path_collector'
+
 module Prefab
-  class LoggerClient < Logger
+  class LoggerClient < ::Logger
     SEP = '.'
     BASE_KEY = 'log-level'
     UNKNOWN_PATH = 'unknown.'
     INTERNAL_PREFIX = 'cloud.prefab.client'
 
     LOG_LEVEL_LOOKUPS = {
-      Prefab::LogLevel::NOT_SET_LOG_LEVEL => Logger::DEBUG,
-      Prefab::LogLevel::TRACE => Logger::DEBUG,
-      Prefab::LogLevel::DEBUG => Logger::DEBUG,
-      Prefab::LogLevel::INFO => Logger::INFO,
-      Prefab::LogLevel::WARN => Logger::WARN,
-      Prefab::LogLevel::ERROR => Logger::ERROR,
-      Prefab::LogLevel::FATAL => Logger::FATAL
+      Prefab::LogLevel::NOT_SET_LOG_LEVEL => ::Logger::DEBUG,
+      Prefab::LogLevel::TRACE => ::Logger::DEBUG,
+      Prefab::LogLevel::DEBUG => ::Logger::DEBUG,
+      Prefab::LogLevel::INFO => ::Logger::INFO,
+      Prefab::LogLevel::WARN => ::Logger::WARN,
+      Prefab::LogLevel::ERROR => ::Logger::ERROR,
+      Prefab::LogLevel::FATAL => ::Logger::FATAL
     }
 
-    def initialize(logdev, formatter: nil, prefix: nil)
+    def initialize(logdev, log_path_collector: nil, formatter: nil, prefix: nil)
       super(logdev)
       self.formatter = formatter
       @config_client = BootstrappingConfigClient.new
       @silences = Concurrent::Map.new(initial_capacity: 2)
-      @prefix = prefix
+      @prefix = "#{prefix}#{prefix && '.'}"
+
+      @log_path_collector = log_path_collector
     end
 
     def add(severity, message = nil, progname = nil, loc, &block)
-      path = get_loc_path(loc)
-      path = "#{@prefix}#{@prefix && '.'}#{path}"
+      path_loc = get_loc_path(loc)
+      path = @prefix + path_loc
+
+      @log_path_collector&.push(path_loc, severity)
 
       log(message, path, progname, severity, &block)
     end
@@ -43,7 +49,8 @@ module Prefab
     end
 
     def log(message, path, progname, severity)
-      severity ||= Logger::UNKNOWN
+      severity ||= ::Logger::UNKNOWN
+
       return true if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
 
       progname = "#{path}: #{progname || @progname}"
@@ -124,14 +131,26 @@ module Prefab
 
     private
 
+    NO_DEFAULT = nil
+
     # Find the closest match to 'log_level.path' in config
     def level_of(path)
-      closest_log_level_match = @config_client.get(BASE_KEY, :WARN)
+      properties = Thread.current[:prefab_log_properties] || {}
+      lookup_key = Thread.current[:prefab_log_lookup_key] || nil
+
+      closest_log_level_match = nil
+
       path.split(SEP).each_with_object([BASE_KEY]) do |n, memo|
         memo << n
-        val = @config_client.get(memo.join(SEP), nil)
+        val = @config_client.get(memo.join(SEP), NO_DEFAULT, properties, lookup_key)
         closest_log_level_match = val unless val.nil?
       end
+
+      if closest_log_level_match.nil?
+        # get the top-level setting or default to WARN
+        closest_log_level_match = @config_client.get(BASE_KEY, :WARN, properties, lookup_key)
+      end
+
       closest_log_level_match_int = Prefab::LogLevel.resolve(closest_log_level_match)
       LOG_LEVEL_LOOKUPS[closest_log_level_match_int]
     end
@@ -158,7 +177,7 @@ module Prefab
   # StubConfigClient to be used while config client initializes
   # since it may log
   class BootstrappingConfigClient
-    def get(_key, default = nil)
+    def get(_key, default = nil, _properties = {}, _lookup_key = nil)
       ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].upcase.to_sym : default
     end
   end

data/lib/prefab/options.rb

@@ -17,6 +17,7 @@ module Prefab
     attr_reader :prefab_config_override_dir
     attr_reader :prefab_config_classpath_dir
     attr_reader :prefab_envs
+    attr_reader :collect_sync_interval
 
     DEFAULT_LOG_FORMATTER = proc { |severity, datetime, progname, msg|
       "#{severity.ljust(5)} #{datetime}:#{' ' if progname}#{progname} #{msg}\n"
@@ -37,7 +38,10 @@ module Prefab
       LOCAL_ONLY = 2
     end
 
-    def initialize(
+    DEFAULT_MAX_PATHS = 1_000
+    DEFAULT_SYNC_INTERVAL = 60
+
+    private def init(
       api_key: ENV['PREFAB_API_KEY'],
       logdev: $stdout,
       stats: NoopStats.new, # receives increment("prefab.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
@@ -55,9 +59,11 @@ module Prefab
       prefab_datasources: ENV['PREFAB_DATASOURCES'] == 'LOCAL_ONLY' ? DATASOURCES::LOCAL_ONLY : DATASOURCES::ALL,
       prefab_config_override_dir: Dir.home,
       prefab_config_classpath_dir: '.',
-      prefab_envs: ENV['PREFAB_ENVS'].nil? ? [] : ENV['PREFAB_ENVS'].split(',')
+      prefab_envs: ENV['PREFAB_ENVS'].nil? ? [] : ENV['PREFAB_ENVS'].split(','),
+      collect_logs: true,
+      collect_max_paths: DEFAULT_MAX_PATHS,
+      collect_sync_interval: DEFAULT_SYNC_INTERVAL
     )
-      # debugger
       @api_key = api_key
       @logdev = logdev
       @stats = stats
@@ -74,12 +80,25 @@ module Prefab
       @prefab_config_classpath_dir = prefab_config_classpath_dir
       @prefab_config_override_dir = prefab_config_override_dir
       @prefab_envs = Array(prefab_envs)
+      @collect_logs = collect_logs
+      @collect_max_paths = collect_max_paths
+      @collect_sync_interval = collect_sync_interval
+    end
+
+    def initialize(options = {})
+      init(**options)
     end
 
     def local_only?
       @prefab_datasources == DATASOURCES::LOCAL_ONLY
     end
 
+    def collect_max_paths
+      return 0 if !@collect_logs || local_only?
+
+      @collect_max_paths
+    end
+
     # https://api.prefab.cloud -> https://api-prefab-cloud.global.ssl.fastly.net
     def url_for_api_cdn
       ENV['PREFAB_CDN_URL'] || "#{@prefab_api_url.gsub(/\./, '-')}.global.ssl.fastly.net"

data/lib/prefab/yaml_config_parser.rb

@@ -21,10 +21,10 @@ module Prefab
 
     def load
       if File.exist?(@file)
-        @client.log_internal Logger::INFO, "Load #{@file}"
+        @client.log_internal ::Logger::INFO, "Load #{@file}"
         YAML.load_file(@file)
       else
-        @client.log_internal Logger::INFO, "No file #{@file}"
+        @client.log_internal ::Logger::INFO, "No file #{@file}"
         {}
       end
     end